Factor an <INCLUDES> placeholder out of <FLAGS> in rule variables

Teach the Makefile and Ninja generators to substitute for an <INCLUDES>
placeholder instead of putting -I in <FLAGS>.  Update our values for

  CMAKE_<LANG>_COMPILE_OBJECT,
  CMAKE_<LANG>_CREATE_ASSEMBLY_SOURCE, and
  CMAKE_<LANG>_CREATE_PREPROCESSED_SOURCE

to place <INCLUDES> just before <FLAGS>.

6 files changed, 32 insertions, 3 deletions

diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx
index ce351ee..2225fdc 100644
--- a/Source/cmCommonTargetGenerator.cxx
+++ b/Source/cmCommonTargetGenerator.cxx
@@ -312,9 +312,6 @@ std::string cmCommonTargetGenerator::GetFlags(const std::string &l)
     this->LocalGenerator->AddVisibilityPresetFlags(flags, this->Target,
                                                    lang);
 
-    // Add include directory flags.
-    this->AddIncludeFlags(flags, lang);
-
     // Append old-style preprocessor definition flags.
     this->LocalGenerator->
       AppendFlags(flags, this->Makefile->GetDefineFlags());
@@ -358,3 +355,16 @@ std::string cmCommonTargetGenerator::GetDefines(const std::string &l)
     }
   return i->second;
 }
+
+std::string cmCommonTargetGenerator::GetIncludes(std::string const& l)
+{
+  ByLanguageMap::iterator i = this->IncludesByLanguage.find(l);
+  if (i == this->IncludesByLanguage.end())
+    {
+    std::string includes;
+    this->AddIncludeFlags(includes, l);
+    ByLanguageMap::value_type entry(l, includes);
+    i = this->IncludesByLanguage.insert(entry).first;
+    }
+  return i->second;
+}
diff --git a/Source/cmCommonTargetGenerator.h b/Source/cmCommonTargetGenerator.h
index e184dba..5451a5a 100644
--- a/Source/cmCommonTargetGenerator.h
+++ b/Source/cmCommonTargetGenerator.h
@@ -83,6 +83,8 @@ protected:
   ByLanguageMap FlagsByLanguage;
   std::string GetDefines(const std::string &l);
   ByLanguageMap DefinesByLanguage;
+  std::string GetIncludes(std::string const& l);
+  ByLanguageMap IncludesByLanguage;
 };
 
 #endif
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index e170253..5c9ee0e 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -766,6 +766,10 @@ cmLocalGenerator::ExpandRuleVariable(std::string const& variable,
     {
     return replaceValues.Defines;
     }
+  if(replaceValues.Includes && variable == "INCLUDES")
+    {
+    return replaceValues.Includes;
+    }
   if(replaceValues.TargetPDB )
     {
     if(variable == "TARGET_PDB")
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 98f4d3a..2dfe825 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -230,6 +230,7 @@ public:
     const char* LinkFlags;
     const char* LanguageCompileFlags;
     const char* Defines;
+    const char* Includes;
     const char* RuleLauncher;
     const char* DependencyFile;
     const char* FilterPrefix;
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index ef4bbbe..9cac5bd 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -295,11 +295,14 @@ void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
     {
     std::string flags = this->GetFlags(*l);
     std::string defines = this->GetDefines(*l);
+    std::string includes = this->GetIncludes(*l);
     // Escape comment characters so they do not terminate assignment.
     cmSystemTools::ReplaceString(flags, "#", "\\#");
     cmSystemTools::ReplaceString(defines, "#", "\\#");
+    cmSystemTools::ReplaceString(includes, "#", "\\#");
     *this->FlagFileStream << *l << "_FLAGS = " << flags << "\n\n";
     *this->FlagFileStream << *l << "_DEFINES = " << defines << "\n\n";
+    *this->FlagFileStream << *l << "_INCLUDES = " << includes << "\n\n";
     }
 }
 
@@ -611,6 +614,9 @@ cmMakefileTargetGenerator
 
   vars.Defines = definesString.c_str();
 
+  std::string const includesString = "$(" + lang + "_INCLUDES)";
+  vars.Includes = includesString.c_str();
+
   // At the moment, it is assumed that C, C++, and Fortran have both
   // assembly and preprocessor capabilities. The same is true for the
   // ability to export compile commands
@@ -643,6 +649,9 @@ cmMakefileTargetGenerator
     std::string langDefines = std::string("$(") + lang + "_DEFINES)";
     compileCommand.replace(compileCommand.find(langDefines),
                            langDefines.size(), this->GetDefines(lang));
+    std::string langIncludes = std::string("$(") + lang + "_INCLUDES)";
+    compileCommand.replace(compileCommand.find(langIncludes),
+                           langIncludes.size(), this->GetIncludes(lang));
     this->GlobalGenerator->AddCXXCompileCommand(
       source.GetFullPath(), workingDirectory, compileCommand);
     }
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index a72bc72..3441149 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -315,6 +315,7 @@ cmNinjaTargetGenerator
   vars.Source = "$in";
   vars.Object = "$out";
   vars.Defines = "$DEFINES";
+  vars.Includes = "$INCLUDES";
   vars.TargetPDB = "$TARGET_PDB";
   vars.TargetCompilePDB = "$TARGET_COMPILE_PDB";
   vars.ObjectDir = "$OBJECT_DIR";
@@ -592,6 +593,7 @@ cmNinjaTargetGenerator
   cmNinjaVars vars;
   vars["FLAGS"] = this->ComputeFlagsForObject(source, language);
   vars["DEFINES"] = this->ComputeDefines(source, language);
+  vars["INCLUDES"] = this->GetIncludes(language);
   if (!this->NeedDepTypeMSVC(language)) {
     vars["DEP_FILE"] =
             cmGlobalNinjaGenerator::EncodeDepfileSpace(objectFileName + ".d");
@@ -637,6 +639,7 @@ cmNinjaTargetGenerator
     compileObjectVars.ObjectFileDir = objectFileDir.c_str();
     compileObjectVars.Flags = vars["FLAGS"].c_str();
     compileObjectVars.Defines = vars["DEFINES"].c_str();
+    compileObjectVars.Includes = vars["INCLUDES"].c_str();
 
     // Rule for compiling object file.
     std::string compileCmdVar = "CMAKE_";