Add Parsing Completed function for Rust (#7084)

include/flatbuffers/flatc.h

@@ -49,6 +49,8 @@ class FlatCompiler {
     typedef std::string (*MakeRuleFn)(const flatbuffers::Parser &parser,
                                       const std::string &path,
                                       const std::string &file_name);
+    typedef bool (*ParsingCompletedFn)(const flatbuffers::Parser &parser,
+                                       const std::string &output_path);
 
     GenerateFn generate;
     const char *lang_name;
@@ -58,6 +60,7 @@ class FlatCompiler {
     FlatCOption option;
     MakeRuleFn make_rule;
     BfbsGenerator *bfbs_generator;
+    ParsingCompletedFn parsing_completed;
   };
 
   typedef void (*WarnFn)(const FlatCompiler *flatc, const std::string &warn,

src/flatc.cpp

@@ -19,7 +19,6 @@
 #include <list>
 #include <sstream>
 
-#include "bfbs_gen_lua.h"
 #include "flatbuffers/util.h"
 
 namespace flatbuffers {
@@ -767,9 +766,19 @@ int FlatCompiler::Compile(int argc, const char **argv) {
     // in any files coming up next.
     parser->MarkGenerated();
   }
-  if (opts.lang_to_generate & IDLOptions::kRust && !parser->opts.one_file) {
-    GenerateRustModuleRootFile(*parser, output_path);
+
+  // Once all the files have been parsed, run any generators Parsing Completed
+  // function for final generation.
+  for (size_t i = 0; i < params_.num_generators; ++i) {
+    if (generator_enabled[i] &&
+        params_.generators[i].parsing_completed != nullptr) {
+      if (!params_.generators[i].parsing_completed(*parser, output_path)) {
+        Error("failed running parsing completed for " +
+              std::string(params_.generators[i].lang_name));
+      }
+    }
   }
+
   return 0;
 }
 

src/flatc_main.cpp

@@ -68,82 +68,83 @@ int main(int argc, const char *argv[]) {
       flatbuffers::FlatCOption{
           "b", "binary", "",
           "Generate wire format binaries for any data definitions" },
-      flatbuffers::BinaryMakeRule, nullptr },
+      flatbuffers::BinaryMakeRule, nullptr, nullptr },
     { flatbuffers::GenerateTextFile, "text", false, nullptr,
       flatbuffers::IDLOptions::kJson,
       flatbuffers::FlatCOption{
           "t", "json", "", "Generate text output for any data definitions" },
 
-      flatbuffers::TextMakeRule, nullptr },
+      flatbuffers::TextMakeRule, nullptr, nullptr },
     { flatbuffers::GenerateCPP, "C++", true, flatbuffers::GenerateCppGRPC,
       flatbuffers::IDLOptions::kCpp,
       flatbuffers::FlatCOption{ "c", "cpp", "",
                                 "Generate C++ headers for tables/structs" },
-      flatbuffers::CPPMakeRule, nullptr },
+      flatbuffers::CPPMakeRule, nullptr, nullptr },
     { flatbuffers::GenerateGo, "Go", true, flatbuffers::GenerateGoGRPC,
       flatbuffers::IDLOptions::kGo,
       flatbuffers::FlatCOption{ "g", "go", "",
                                 "Generate Go files for tables/structs" },
-      nullptr, nullptr },
+      nullptr, nullptr, nullptr },
     { flatbuffers::GenerateJava, "Java", true, flatbuffers::GenerateJavaGRPC,
       flatbuffers::IDLOptions::kJava,
       flatbuffers::FlatCOption{ "j", "java", "",
                                 "Generate Java classes for tables/structs" },
-      flatbuffers::JavaMakeRule, nullptr },
+      flatbuffers::JavaMakeRule, nullptr, nullptr },
     { flatbuffers::GenerateDart, "Dart", true, nullptr,
       flatbuffers::IDLOptions::kDart,
       flatbuffers::FlatCOption{ "d", "dart", "",
                                 "Generate Dart classes for tables/structs" },
-      flatbuffers::DartMakeRule, nullptr },
+      flatbuffers::DartMakeRule, nullptr, nullptr },
     { flatbuffers::GenerateTS, "TypeScript", true, flatbuffers::GenerateTSGRPC,
       flatbuffers::IDLOptions::kTs,
       flatbuffers::FlatCOption{ "T", "ts", "",
                                 "Generate TypeScript code for tables/structs" },
-      flatbuffers::TSMakeRule, nullptr },
+      flatbuffers::TSMakeRule, nullptr, nullptr },
     { flatbuffers::GenerateCSharp, "C#", true, nullptr,
       flatbuffers::IDLOptions::kCSharp,
       flatbuffers::FlatCOption{ "n", "csharp", "",
                                 "Generate C# classes for tables/structs" },
-      flatbuffers::CSharpMakeRule, nullptr },
+      flatbuffers::CSharpMakeRule, nullptr, nullptr },
     { flatbuffers::GeneratePython, "Python", true,
       flatbuffers::GeneratePythonGRPC, flatbuffers::IDLOptions::kPython,
       flatbuffers::FlatCOption{ "p", "python", "",
                                 "Generate Python files for tables/structs" },
-      nullptr, nullptr },
+      nullptr, nullptr, nullptr },
     { flatbuffers::GenerateLobster, "Lobster", true, nullptr,
       flatbuffers::IDLOptions::kLobster,
       flatbuffers::FlatCOption{ "", "lobster", "",
                                 "Generate Lobster files for tables/structs" },
-      nullptr, nullptr },
+      nullptr, nullptr, nullptr },
     { flatbuffers::GenerateLua, "Lua", true, nullptr,
       flatbuffers::IDLOptions::kLua,
       flatbuffers::FlatCOption{ "l", "lua", "",
                                 "Generate Lua files for tables/structs" },
-      nullptr, bfbs_gen_lua.get() },
+      nullptr, bfbs_gen_lua.get(), nullptr },
     { flatbuffers::GenerateRust, "Rust", true, nullptr,
       flatbuffers::IDLOptions::kRust,
       flatbuffers::FlatCOption{ "r", "rust", "",
                                 "Generate Rust files for tables/structs" },
-      flatbuffers::RustMakeRule, nullptr },
+      flatbuffers::RustMakeRule, nullptr,
+      flatbuffers::GenerateRustModuleRootFile },
     { flatbuffers::GeneratePhp, "PHP", true, nullptr,
       flatbuffers::IDLOptions::kPhp,
       flatbuffers::FlatCOption{ "", "php", "",
                                 "Generate PHP files for tables/structs" },
-      nullptr, nullptr },
+      nullptr, nullptr, nullptr },
     { flatbuffers::GenerateKotlin, "Kotlin", true, nullptr,
       flatbuffers::IDLOptions::kKotlin,
       flatbuffers::FlatCOption{ "", "kotlin", "",
                                 "Generate Kotlin classes for tables/structs" },
-      nullptr, nullptr },
+      nullptr, nullptr, nullptr },
     { flatbuffers::GenerateJsonSchema, "JsonSchema", true, nullptr,
       flatbuffers::IDLOptions::kJsonSchema,
       flatbuffers::FlatCOption{ "", "jsonschema", "", "Generate Json schema" },
-      nullptr, nullptr },
+      nullptr, nullptr, nullptr },
     { flatbuffers::GenerateSwift, "swift", true, flatbuffers::GenerateSwiftGRPC,
       flatbuffers::IDLOptions::kSwift,
       flatbuffers::FlatCOption{ "", "swift", "",
                                 "Generate Swift files for tables/structs" },
-      nullptr, nullptr },
+      nullptr, nullptr, nullptr },
   };
 
   flatbuffers::FlatCompiler::InitParams params;

src/idl_gen_rust.cpp

@@ -194,6 +194,11 @@ bool IsOptionalToBuilder(const FieldDef &field) {
 
 bool GenerateRustModuleRootFile(const Parser &parser,
                                 const std::string &output_dir) {
+  if (parser.opts.one_file) {
+    // Don't generate a root file when generating one file. This isn't an error
+    // so return true.
+    return true;
+  }
   // We gather the symbols into a tree of namespaces (which are rust mods) and
   // generate a file that gathers them all.
   struct Module {