Ninja: GlobalNinjaGenerator WriteBuild and WritePhonyBuild non static

To properly track the usage of dependencies that are generated at
compile time as the side effect of other build steps we need
to make the WriteBuild and WritePhonyBuild commands non static

Source/cmGlobalNinjaGenerator.cxx

@@ -208,14 +208,14 @@ void cmGlobalNinjaGenerator::WritePhonyBuild(std::ostream& os,
                                              const cmNinjaDeps& orderOnlyDeps,
                                              const cmNinjaVars& variables)
 {
-  cmGlobalNinjaGenerator::WriteBuild(os,
-                                     comment,
-                                     "phony",
-                                     outputs,
-                                     explicitDeps,
-                                     implicitDeps,
-                                     orderOnlyDeps,
-                                     variables);
+  this->WriteBuild(os,
+                   comment,
+                   "phony",
+                   outputs,
+                   explicitDeps,
+                   implicitDeps,
+                   orderOnlyDeps,
+                   variables);
 }
 
 void cmGlobalNinjaGenerator::AddCustomCommandRule()
@@ -251,14 +251,14 @@ cmGlobalNinjaGenerator::WriteCustomCommandBuild(const std::string& command,
   vars["COMMAND"] = cmd;
   vars["DESC"] = EncodeLiteral(description);
 
-  cmGlobalNinjaGenerator::WriteBuild(*this->BuildFileStream,
-                                     comment,
-                                     "CUSTOM_COMMAND",
-                                     outputs,
-                                     deps,
-                                     cmNinjaDeps(),
-                                     orderOnlyDeps,
-                                     vars);
+  this->WriteBuild(*this->BuildFileStream,
+                   comment,
+                   "CUSTOM_COMMAND",
+                   outputs,
+                   deps,
+                   cmNinjaDeps(),
+                   orderOnlyDeps,
+                   vars);
 }
 
 void
@@ -293,14 +293,14 @@ cmGlobalNinjaGenerator::WriteMacOSXContentBuild(const std::string& input,
   deps.push_back(input);
   cmNinjaVars vars;
 
-  cmGlobalNinjaGenerator::WriteBuild(*this->BuildFileStream,
-                                     "",
-                                     "COPY_OSX_CONTENT",
-                                     outputs,
-                                     deps,
-                                     cmNinjaDeps(),
-                                     cmNinjaDeps(),
-                                     cmNinjaVars());
+  this->WriteBuild(*this->BuildFileStream,
+                   "",
+                   "COPY_OSX_CONTENT",
+                   outputs,
+                   deps,
+                   cmNinjaDeps(),
+                   cmNinjaDeps(),
+                   cmNinjaVars());
 }
 
 void cmGlobalNinjaGenerator::WriteRule(std::ostream& os,
@@ -896,10 +896,10 @@ void cmGlobalNinjaGenerator::WriteTargetAliases(std::ostream& os)
     cmNinjaDeps deps;
     this->AppendTargetOutputs(i->second, deps);
 
-    cmGlobalNinjaGenerator::WritePhonyBuild(os,
-                                            "",
-                                            cmNinjaDeps(1, i->first),
-                                            deps);
+    this->WritePhonyBuild(os,
+                          "",
+                          cmNinjaDeps(1, i->first),
+                          deps);
   }
 }
 
@@ -920,10 +920,10 @@ void cmGlobalNinjaGenerator::WriteTargetAll(std::ostream& os)
   cmNinjaDeps outputs;
   outputs.push_back("all");
 
-  cmGlobalNinjaGenerator::WritePhonyBuild(os,
-                                          "The main all target.",
-                                          outputs,
-                                          this->AllDependencies);
+  this->WritePhonyBuild(os,
+                        "The main all target.",
+                        outputs,
+                        this->AllDependencies);
 
   cmGlobalNinjaGenerator::WriteDefault(os,
                                        outputs,
@@ -970,19 +970,19 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
                      implicitDeps.end());
   implicitDeps.push_back("CMakeCache.txt");
 
-  WriteBuild(os,
-             "Re-run CMake if any of its inputs changed.",
-             "RERUN_CMAKE",
-             /*outputs=*/ cmNinjaDeps(1, NINJA_BUILD_FILE),
-             /*explicitDeps=*/ cmNinjaDeps(),
-             implicitDeps,
-             /*orderOnlyDeps=*/ cmNinjaDeps(),
-             /*variables=*/ cmNinjaVars());
-
-  WritePhonyBuild(os,
-                  "A missing CMake input file is not an error.",
-                  implicitDeps,
-                  cmNinjaDeps());
+  this->WriteBuild(os,
+                   "Re-run CMake if any of its inputs changed.",
+                   "RERUN_CMAKE",
+                   /*outputs=*/ cmNinjaDeps(1, NINJA_BUILD_FILE),
+                   /*explicitDeps=*/ cmNinjaDeps(),
+                   implicitDeps,
+                   /*orderOnlyDeps=*/ cmNinjaDeps(),
+                   /*variables=*/ cmNinjaVars());
+
+  this->WritePhonyBuild(os,
+                        "A missing CMake input file is not an error.",
+                        implicitDeps,
+                        cmNinjaDeps());
 }
 
 std::string cmGlobalNinjaGenerator::ninjaCmd() const

Source/cmGlobalNinjaGenerator.h

@@ -77,27 +77,27 @@ public:
    * It also writes the variables bound to this build statement.
    * @warning no escaping of any kind is done here.
    */
-  static void WriteBuild(std::ostream& os,
-                         const std::string& comment,
-                         const std::string& rule,
-                         const cmNinjaDeps& outputs,
-                         const cmNinjaDeps& explicitDeps,
-                         const cmNinjaDeps& implicitDeps,
-                         const cmNinjaDeps& orderOnlyDeps,
-                         const cmNinjaVars& variables,
-                         const std::string& rspfile = std::string(),
-                         int cmdLineLimit = -1);
+  void WriteBuild(std::ostream& os,
+                  const std::string& comment,
+                  const std::string& rule,
+                  const cmNinjaDeps& outputs,
+                  const cmNinjaDeps& explicitDeps,
+                  const cmNinjaDeps& implicitDeps,
+                  const cmNinjaDeps& orderOnlyDeps,
+                  const cmNinjaVars& variables,
+                  const std::string& rspfile = std::string(),
+                  int cmdLineLimit = -1);
 
   /**
    * Helper to write a build statement with the special 'phony' rule.
    */
-  static void WritePhonyBuild(std::ostream& os,
-                              const std::string& comment,
-                              const cmNinjaDeps& outputs,
-                              const cmNinjaDeps& explicitDeps,
-                              const cmNinjaDeps& implicitDeps = cmNinjaDeps(),
-                              const cmNinjaDeps& orderOnlyDeps = cmNinjaDeps(),
-                              const cmNinjaVars& variables = cmNinjaVars());
+  void WritePhonyBuild(std::ostream& os,
+                       const std::string& comment,
+                       const cmNinjaDeps& outputs,
+                       const cmNinjaDeps& explicitDeps,
+                       const cmNinjaDeps& implicitDeps = cmNinjaDeps(),
+                       const cmNinjaDeps& orderOnlyDeps = cmNinjaDeps(),
+                       const cmNinjaVars& variables = cmNinjaVars());
 
   void WriteCustomCommandBuild(const std::string& command,
                                const std::string& description,

Source/cmLocalNinjaGenerator.cxx

@@ -340,14 +340,15 @@ cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
   this->AppendCustomCommandLines(cc, cmdLines);
 
   if (cmdLines.empty()) {
-    cmGlobalNinjaGenerator::WritePhonyBuild(this->GetBuildFileStream(),
-                                            "Phony custom command for " +
-                                              ninjaOutputs[0],
-                                            ninjaOutputs,
-                                            ninjaDeps,
-                                            cmNinjaDeps(),
-                                            orderOnlyDeps,
-                                            cmNinjaVars());
+    this->GetGlobalNinjaGenerator()->WritePhonyBuild(
+      this->GetBuildFileStream(),
+      "Phony custom command for " +
+      ninjaOutputs[0],
+      ninjaOutputs,
+      ninjaDeps,
+      cmNinjaDeps(),
+      orderOnlyDeps,
+      cmNinjaVars());
   } else {
     this->GetGlobalNinjaGenerator()->WriteCustomCommandBuild(
       this->BuildCommandLine(cmdLines),

Source/cmNinjaNormalTargetGenerator.cxx

@@ -598,32 +598,37 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
 #endif
   }
 
+  //Get the global generator as we are going to be call WriteBuild numerous
+  //times in the following section
+  cmGlobalNinjaGenerator* globalGenerator = this->GetGlobalGenerator();
+
+
   const std::string rspfile = std::string
                               (cmake::GetCMakeFilesDirectoryPostSlash()) +
                               this->GetTarget()->GetName() + ".rsp";
 
   // Write the build statement for this target.
-  cmGlobalNinjaGenerator::WriteBuild(this->GetBuildFileStream(),
-                                     comment.str(),
-                                     this->LanguageLinkerRule(),
-                                     outputs,
-                                     explicitDeps,
-                                     implicitDeps,
-                                     emptyDeps,
-                                     vars,
-                                     rspfile,
-                                     commandLineLengthLimit);
+  globalGenerator->WriteBuild(this->GetBuildFileStream(),
+                              comment.str(),
+                              this->LanguageLinkerRule(),
+                              outputs,
+                              explicitDeps,
+                              implicitDeps,
+                              emptyDeps,
+                              vars,
+                              rspfile,
+                              commandLineLengthLimit);
 
   if (targetOutput != targetOutputReal) {
     if (targetType == cmTarget::EXECUTABLE) {
-      cmGlobalNinjaGenerator::WriteBuild(this->GetBuildFileStream(),
+      globalGenerator->WriteBuild(this->GetBuildFileStream(),
                                   "Create executable symlink " + targetOutput,
-                                         "CMAKE_SYMLINK_EXECUTABLE",
-                                         cmNinjaDeps(1, targetOutput),
-                                         cmNinjaDeps(1, targetOutputReal),
-                                         emptyDeps,
-                                         emptyDeps,
-                                         symlinkVars);
+                                  "CMAKE_SYMLINK_EXECUTABLE",
+                                  cmNinjaDeps(1, targetOutput),
+                                  cmNinjaDeps(1, targetOutputReal),
+                                  emptyDeps,
+                                  emptyDeps,
+                                  symlinkVars);
     } else {
       cmNinjaDeps symlinks;
       const std::string soName = this->GetTargetFilePath(this->TargetNameSO);
@@ -635,30 +640,30 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
         symlinks.push_back(soName);
       }
       symlinks.push_back(targetOutput);
-      cmGlobalNinjaGenerator::WriteBuild(this->GetBuildFileStream(),
-                                      "Create library symlink " + targetOutput,
-                                         "CMAKE_SYMLINK_LIBRARY",
-                                         symlinks,
-                                         cmNinjaDeps(1, targetOutputReal),
-                                         emptyDeps,
-                                         emptyDeps,
-                                         symlinkVars);
+      globalGenerator->WriteBuild(this->GetBuildFileStream(),
+                                  "Create library symlink " + targetOutput,
+                                     "CMAKE_SYMLINK_LIBRARY",
+                                  symlinks,
+                                  cmNinjaDeps(1, targetOutputReal),
+                                  emptyDeps,
+                                  emptyDeps,
+                                  symlinkVars);
     }
   }
 
   if (!this->TargetNameImport.empty()) {
     // Since using multiple outputs would mess up the $out variable, use an
     // alias for the import library.
-    cmGlobalNinjaGenerator::WritePhonyBuild(this->GetBuildFileStream(),
-                                            "Alias for import library.",
-                                            cmNinjaDeps(1, targetOutputImplib),
-                                            cmNinjaDeps(1, targetOutputReal));
+    globalGenerator->WritePhonyBuild(this->GetBuildFileStream(),
+                                     "Alias for import library.",
+                                     cmNinjaDeps(1, targetOutputImplib),
+                                     cmNinjaDeps(1, targetOutputReal));
   }
 
   // Add aliases for the file name and the target name.
-  this->GetGlobalGenerator()->AddTargetAlias(this->TargetNameOut,
+  globalGenerator->AddTargetAlias(this->TargetNameOut,
                                              this->GetTarget());
-  this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(),
+  globalGenerator->AddTargetAlias(this->GetTargetName(),
                                              this->GetTarget());
 }
 
@@ -669,11 +674,11 @@ void cmNinjaNormalTargetGenerator::WriteObjectLibStatement()
   cmNinjaDeps outputs;
   this->GetLocalGenerator()->AppendTargetOutputs(this->GetTarget(), outputs);
   cmNinjaDeps depends = this->GetObjects();
-  cmGlobalNinjaGenerator::WritePhonyBuild(this->GetBuildFileStream(),
-                                          "Object library "
-                                          + this->GetTargetName(),
-                                          outputs,
-                                          depends);
+  this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
+                                              "Object library "
+                                                + this->GetTargetName(),
+                                              outputs,
+                                              depends);
 
   // Add aliases for the target name.
   this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(),

Source/cmNinjaTargetGenerator.cxx

@@ -642,24 +642,24 @@ cmNinjaTargetGenerator
                                                      sourceFileName);
     }
 
-  cmGlobalNinjaGenerator::WriteBuild(this->GetBuildFileStream(),
-                                     comment,
-                                     rule,
-                                     outputs,
-                                     explicitDeps,
-                                     implicitDeps,
-                                     orderOnlyDeps,
-                                     vars);
+  this->GetGlobalGenerator()->WriteBuild(this->GetBuildFileStream(),
+                                         comment,
+                                         rule,
+                                         outputs,
+                                         explicitDeps,
+                                         implicitDeps,
+                                         orderOnlyDeps,
+                                         vars);
 
   if(const char* objectOutputs = source->GetProperty("OBJECT_OUTPUTS")) {
     std::vector<std::string> outputList;
     cmSystemTools::ExpandListArgument(objectOutputs, outputList);
     std::transform(outputList.begin(), outputList.end(), outputList.begin(),
                    MapToNinjaPath());
-    cmGlobalNinjaGenerator::WritePhonyBuild(this->GetBuildFileStream(),
-                                            "Additional output files.",
-                                            outputList,
-                                            outputs);
+    this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
+                                                "Additional output files.",
+                                                outputList,
+                                                outputs);
   }
 }
 

Source/cmNinjaUtilityTargetGenerator.cxx

@@ -61,11 +61,11 @@ void cmNinjaUtilityTargetGenerator::Generate()
   this->GetLocalGenerator()->AppendTargetDepends(this->GetTarget(), deps);
 
   if (commands.empty()) {
-    cmGlobalNinjaGenerator::WritePhonyBuild(this->GetBuildFileStream(),
-                                            "Utility command for "
-                                            + this->GetTargetName(),
-                                            outputs,
-                                            deps);
+    this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
+                                                "Utility command for "
+                                                  + this->GetTargetName(),
+                                                outputs,
+                                                deps);
   } else {
     std::string command =
       this->GetLocalGenerator()->BuildCommandLine(commands);
@@ -105,10 +105,11 @@ void cmNinjaUtilityTargetGenerator::Generate()
       cmNinjaDeps(1, utilCommandName),
       deps);
 
-    cmGlobalNinjaGenerator::WritePhonyBuild(this->GetBuildFileStream(),
-                                            "",
-                                            outputs,
-                                            cmNinjaDeps(1, utilCommandName));
+    this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
+                                                "",
+                                                outputs,
+                                                cmNinjaDeps(1, utilCommandName)
+                                                );
   }
 
   this->GetGlobalGenerator()->AddTargetAlias(this->GetTargetName(),