Merge topic 'tid-system-argument'

9cf3547 Add the INTERFACE_SYSTEM_INCLUDE_DIRECTORIES target property.
1925cff Add a SYSTEM parameter to target_include_directories (#14180)
286f227 Extend the cmTargetPropCommandBase interface property handling.
83498d4 Store system include directories in the cmTarget.
f1fcbe3 Add Target API to determine if an include is a system include.
2679a34 Remove unused variable.

Source/cmExportInstallFileGenerator.cxx

@@ -127,6 +127,10 @@ bool cmExportInstallFileGenerator::GenerateMainFile(std::ostream& os)
     this->PopulateIncludeDirectoriesInterface(te,
                                   cmGeneratorExpression::InstallInterface,
                                   properties, missingTargets);
+    this->PopulateInterfaceProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES",
+                                  te,
+                                  cmGeneratorExpression::InstallInterface,
+                                  properties, missingTargets);
     this->PopulateInterfaceProperty("INTERFACE_COMPILE_DEFINITIONS",
                                   te,
                                   cmGeneratorExpression::InstallInterface,

Source/cmExtraSublimeTextGenerator.cxx

@@ -421,7 +421,7 @@ cmExtraSublimeTextGenerator::ComputeFlagsForObject(cmSourceFile* source,
   std::vector<std::string> includes;
   lg->GetIncludeDirectories(includes, gtgt, language, config);
   std::string includeFlags =
-    lg->GetIncludeFlags(includes, language, true); // full include paths
+    lg->GetIncludeFlags(includes, gtgt, language, true); // full include paths
   lg->AppendFlags(flags, includeFlags.c_str());
   }
 

Source/cmGeneratorExpressionDAGChecker.cxx

@@ -186,6 +186,14 @@ bool cmGeneratorExpressionDAGChecker::EvaluatingIncludeDirectories() const
        || strcmp(prop, "INTERFACE_INCLUDE_DIRECTORIES") == 0 );
 }
 
+//----------------------------------------------------------------------------
+bool
+cmGeneratorExpressionDAGChecker::EvaluatingSystemIncludeDirectories() const
+{
+  const char *prop = this->Property.c_str();
+  return strcmp(prop, "INTERFACE_SYSTEM_INCLUDE_DIRECTORIES") == 0;
+}
+
 //----------------------------------------------------------------------------
 bool cmGeneratorExpressionDAGChecker::EvaluatingCompileDefinitions() const
 {

Source/cmGeneratorExpressionDAGChecker.h

@@ -18,11 +18,13 @@
 
 #define CM_FOR_EACH_TRANSITIVE_PROPERTY_METHOD(F) \
   F(EvaluatingIncludeDirectories) \
+  F(EvaluatingSystemIncludeDirectories) \
   F(EvaluatingCompileDefinitions) \
   F(EvaluatingCompileOptions)
 
 #define CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(F) \
   F(INTERFACE_INCLUDE_DIRECTORIES) \
+  F(INTERFACE_SYSTEM_INCLUDE_DIRECTORIES) \
   F(INTERFACE_COMPILE_DEFINITIONS) \
   F(INTERFACE_COMPILE_OPTIONS)
 

Source/cmGeneratorExpressionEvaluator.cxx

@@ -897,6 +897,10 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode
       {
       interfacePropertyName = "INTERFACE_INCLUDE_DIRECTORIES";
       }
+    else if (propertyName == "INTERFACE_SYSTEM_INCLUDE_DIRECTORIES")
+      {
+      interfacePropertyName = "INTERFACE_SYSTEM_INCLUDE_DIRECTORIES";
+      }
     else if (propertyName == "INTERFACE_COMPILE_DEFINITIONS"
         || propertyName == "COMPILE_DEFINITIONS"
         || strncmp(propertyName.c_str(), "COMPILE_DEFINITIONS_", 20) == 0)

Source/cmGeneratorTarget.cxx

@@ -47,6 +47,51 @@ const char *cmGeneratorTarget::GetProperty(const char *prop)
   return this->Target->GetProperty(prop);
 }
 
+//----------------------------------------------------------------------------
+bool cmGeneratorTarget::IsSystemIncludeDirectory(const char *dir,
+                                                 const char *config)
+{
+  std::string config_upper;
+  if(config && *config)
+    {
+    config_upper = cmSystemTools::UpperCase(config);
+    }
+
+  typedef std::map<std::string, std::vector<std::string> > IncludeCacheType;
+  IncludeCacheType::iterator iter =
+      this->SystemIncludesCache.find(config_upper);
+
+  if (iter == this->SystemIncludesCache.end())
+    {
+    std::vector<std::string> result;
+    for (std::set<cmStdString>::const_iterator
+        it = this->Target->GetSystemIncludeDirectories().begin();
+        it != this->Target->GetSystemIncludeDirectories().end(); ++it)
+      {
+      cmListFileBacktrace lfbt;
+      cmGeneratorExpression ge(lfbt);
+
+      cmGeneratorExpressionDAGChecker dagChecker(lfbt,
+                                                this->GetName(),
+                                "INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", 0, 0);
+
+      cmSystemTools::ExpandListArgument(ge.Parse(*it)
+                                        ->Evaluate(this->Makefile,
+                                        config, false, this->Target,
+                                        &dagChecker), result);
+      }
+    IncludeCacheType::value_type entry(config_upper, result);
+    iter = this->SystemIncludesCache.insert(entry).first;
+    }
+
+  if (std::find(iter->second.begin(),
+                iter->second.end(), dir) != iter->second.end())
+    {
+    return true;
+    }
+  return false;
+}
+
 //----------------------------------------------------------------------------
 bool cmGeneratorTarget::GetPropertyAsBool(const char *prop)
 {

Source/cmGeneratorTarget.h

@@ -72,10 +72,14 @@ public:
   /** Get the include directories for this target.  */
   std::vector<std::string> GetIncludeDirectories(const char *config);
 
+  bool IsSystemIncludeDirectory(const char *dir, const char *config);
+
 private:
   void ClassifySources();
   void LookupObjectLibraries();
 
+  std::map<std::string, std::vector<std::string> > SystemIncludesCache;
+
   cmGeneratorTarget(cmGeneratorTarget const&);
   void operator=(cmGeneratorTarget const&);
 };

Source/cmGlobalGenerator.cxx

@@ -1017,6 +1017,17 @@ void cmGlobalGenerator::Generate()
   // it builds by default.
   this->FillLocalGeneratorToTargetMap();
 
+  for (i = 0; i < this->LocalGenerators.size(); ++i)
+    {
+    cmMakefile* mf = this->LocalGenerators[i]->GetMakefile();
+    cmTargets* targets = &(mf->GetTargets());
+    for ( cmTargets::iterator it = targets->begin();
+        it != targets->end(); ++ it )
+      {
+      it->second.FinalizeSystemIncludeDirectories();
+      }
+    }
+
   // Generate project files
   for (i = 0; i < this->LocalGenerators.size(); ++i)
     {

Source/cmLocalGenerator.cxx

@@ -577,7 +577,7 @@ void cmLocalGenerator::AddCustomCommandToCreateObject(const char* ofname,
     {
     std::vector<std::string> includes;
     this->GetIncludeDirectories(includes, &target, lang);
-    flags += this->GetIncludeFlags(includes, lang);
+    flags += this->GetIncludeFlags(includes, &target, lang);
     }
   flags += this->Makefile->GetDefineFlags();
 
@@ -1224,6 +1224,7 @@ cmLocalGenerator::ConvertToIncludeReference(std::string const& path)
 //----------------------------------------------------------------------------
 std::string cmLocalGenerator::GetIncludeFlags(
                                      const std::vector<std::string> &includes,
+                                     cmGeneratorTarget* target,
                                      const char* lang, bool forResponseFile,
                                      const char *config)
 {
@@ -1294,11 +1295,10 @@ std::string cmLocalGenerator::GetIncludeFlags(
       continue;
       }
 
-    std::string include = *i;
     if(!flagUsed || repeatFlag)
       {
-      if(sysIncludeFlag &&
-         this->Makefile->IsSystemIncludeDirectory(i->c_str(), config))
+      if(sysIncludeFlag && target &&
+         target->IsSystemIncludeDirectory(i->c_str(), config))
         {
         includeFlags << sysIncludeFlag;
         }

Source/cmLocalGenerator.h

@@ -152,6 +152,7 @@ public:
   virtual void AppendFlagEscape(std::string& flags, const char* rawFlag);
   ///! Get the include flags for the current makefile and language
   std::string GetIncludeFlags(const std::vector<std::string> &includes,
+                              cmGeneratorTarget* target,
                               const char* lang, bool forResponseFile = false,
                               const char *config = 0);
 

Source/cmMakefile.cxx

@@ -1681,28 +1681,14 @@ cmMakefile::AddSystemIncludeDirectories(const std::set<cmStdString> &incs)
     {
     this->SystemIncludeDirectories.insert(*li);
     }
-}
 
-//----------------------------------------------------------------------------
-bool cmMakefile::IsSystemIncludeDirectory(const char* dir, const char *config)
+  for (cmTargets::iterator l = this->Targets.begin();
+       l != this->Targets.end(); ++l)
     {
-  for (std::set<cmStdString>::const_iterator
-      it = this->SystemIncludeDirectories.begin();
-      it != this->SystemIncludeDirectories.end(); ++it)
-    {
-    cmListFileBacktrace lfbt;
-    cmGeneratorExpression ge(lfbt);
-
-    std::vector<std::string> incs;
-    cmSystemTools::ExpandListArgument(ge.Parse(*it)
-                                       ->Evaluate(this, config, false), incs);
-    if (std::find(incs.begin(), incs.end(), dir) != incs.end())
-      {
-      return true;
+    cmTarget &t = l->second;
+    t.AddSystemIncludeDirectories(incs);
     }
 }
-  return false;
-}
 
 void cmMakefile::AddDefinition(const char* name, const char* value)
 {

Source/cmMakefile.h

@@ -879,6 +879,9 @@ public:
   bool IsGeneratingBuildSystem(){ return this->GeneratingBuildSystem; }
   void SetGeneratingBuildSystem(){ this->GeneratingBuildSystem = true; }
 
+  std::set<cmStdString> const & GetSystemIncludeDirectories() const
+    { return this->SystemIncludeDirectories; }
+
 protected:
   // add link libraries and directories to the target
   void AddGlobalLinkInformation(const char* name, cmTarget& target);

Source/cmMakefileTargetGenerator.cxx

@@ -1835,7 +1835,8 @@ void cmMakefileTargetGenerator::AddIncludeFlags(std::string& flags,
                                               lang, config);
 
   std::string includeFlags =
-    this->LocalGenerator->GetIncludeFlags(includes, lang, useResponseFile);
+    this->LocalGenerator->GetIncludeFlags(includes, this->GeneratorTarget,
+                                          lang, useResponseFile);
   if(includeFlags.empty())
     {
     return;

Source/cmNinjaTargetGenerator.cxx

@@ -161,7 +161,8 @@ cmNinjaTargetGenerator::ComputeFlagsForObject(cmSourceFile *source,
                                               this->GeneratorTarget,
                                               language.c_str(), config);
   std::string includeFlags =
-    this->LocalGenerator->GetIncludeFlags(includes, language.c_str(),
+    this->LocalGenerator->GetIncludeFlags(includes, this->GeneratorTarget,
+                                          language.c_str(),
     language == "RC" ? true : false); // full include paths for RC
                                       // needed by cmcldeps
   if(cmGlobalNinjaGenerator::IsMinGW())

Source/cmTarget.cxx

@@ -873,6 +873,17 @@ void cmTarget::DefineProperties(cmake *cm)
      CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
      CM_DOCUMENT_LANGUAGE_GENERATOR_EXPRESSIONS);
 
+  cm->DefineProperty
+    ("SYSTEM_INTERFACE_INCLUDE_DIRECTORIES", cmProperty::TARGET,
+     "List of public system include directories for a library.",
+     "Targets may populate this property to publish the include directories "
+     "which contain system headers, and therefore should not result in "
+     "compiler warnings.  Consuming targets will then mark the same include "
+     "directories as system headers."
+     "\n"
+     CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
+     CM_DOCUMENT_LANGUAGE_GENERATOR_EXPRESSIONS);
+
   cm->DefineProperty
     ("INTERFACE_COMPILE_DEFINITIONS", cmProperty::TARGET,
      "List of public compile definitions for a library.",
@@ -1678,6 +1689,17 @@ void cmTarget::SetMakefile(cmMakefile* mf)
     {
     this->InsertInclude(*it);
     }
+
+  const std::set<cmStdString> parentSystemIncludes =
+                              this->Makefile->GetSystemIncludeDirectories();
+
+  for (std::set<cmStdString>::const_iterator it
+        = parentSystemIncludes.begin();
+        it != parentSystemIncludes.end(); ++it)
+    {
+    this->SystemIncludeDirectories.insert(*it);
+    }
+
   const std::vector<cmValueWithOrigin> parentOptions =
                               this->Makefile->GetCompileOptionsEntries();
 
@@ -2558,6 +2580,61 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
 
 }
 
+//----------------------------------------------------------------------------
+void
+cmTarget::AddSystemIncludeDirectories(const std::set<cmStdString> &incs)
+{
+  for(std::set<cmStdString>::const_iterator li = incs.begin();
+      li != incs.end(); ++li)
+    {
+    this->SystemIncludeDirectories.insert(*li);
+    }
+}
+
+//----------------------------------------------------------------------------
+void
+cmTarget::AddSystemIncludeDirectories(const std::vector<std::string> &incs)
+{
+  for(std::vector<std::string>::const_iterator li = incs.begin();
+      li != incs.end(); ++li)
+    {
+    this->SystemIncludeDirectories.insert(*li);
+    }
+}
+
+//----------------------------------------------------------------------------
+void cmTarget::FinalizeSystemIncludeDirectories()
+{
+  for (std::vector<cmValueWithOrigin>::const_iterator
+      it = this->Internal->LinkInterfacePropertyEntries.begin(),
+      end = this->Internal->LinkInterfacePropertyEntries.end();
+      it != end; ++it)
+    {
+    {
+    cmListFileBacktrace lfbt;
+    cmGeneratorExpression ge(lfbt);
+    cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
+                                                      ge.Parse(it->Value);
+    std::string targetName = cge->Evaluate(this->Makefile, 0,
+                                      false, this, 0, 0);
+    if (!this->Makefile->FindTargetToUse(targetName.c_str()))
+      {
+      continue;
+      }
+    }
+    std::string includeGenex = "$<TARGET_PROPERTY:" +
+                        it->Value + ",INTERFACE_SYSTEM_INCLUDE_DIRECTORIES>";
+    if (cmGeneratorExpression::Find(it->Value) != std::string::npos)
+      {
+      // Because it->Value is a generator expression, ensure that it
+      // evaluates to the non-empty string before being used in the
+      // TARGET_PROPERTY expression.
+      includeGenex = "$<$<BOOL:" + it->Value + ">:" + includeGenex + ">";
+      }
+    this->SystemIncludeDirectories.insert(includeGenex);
+    }
+}
+
 //----------------------------------------------------------------------------
 void
 cmTarget::AnalyzeLibDependencies( const cmMakefile& mf )

Source/cmTarget.h

@@ -535,7 +535,19 @@ public:
 
   std::string GetDebugGeneratorExpressions(const std::string &value,
                                   cmTarget::LinkLibraryType llt);
+
+  void AddSystemIncludeDirectories(const std::set<cmStdString> &incs);
+  void AddSystemIncludeDirectories(const std::vector<std::string> &incs);
+  std::set<cmStdString> const & GetSystemIncludeDirectories() const
+    { return this->SystemIncludeDirectories; }
+
+  void FinalizeSystemIncludeDirectories();
+
 private:
+  // The set of include directories that are marked as system include
+  // directories.
+  std::set<cmStdString> SystemIncludeDirectories;
+
   /**
    * A list of direct dependencies. Use in conjunction with DependencyMap.
    */

Source/cmTargetCompileDefinitionsCommand.cxx

@@ -60,7 +60,7 @@ std::string cmTargetCompileDefinitionsCommand
 //----------------------------------------------------------------------------
 void cmTargetCompileDefinitionsCommand
 ::HandleDirectContent(cmTarget *tgt, const std::vector<std::string> &content,
-                                   bool)
+                                   bool, bool)
 {
   tgt->AppendProperty("COMPILE_DEFINITIONS", this->Join(content).c_str());
 }

Source/cmTargetCompileDefinitionsCommand.h

@@ -82,7 +82,7 @@ private:
 
   virtual void HandleDirectContent(cmTarget *tgt,
                                    const std::vector<std::string> &content,
-                                   bool prepend);
+                                   bool prepend, bool system);
   virtual std::string Join(const std::vector<std::string> &content);
 };
 

Source/cmTargetCompileOptionsCommand.cxx

@@ -53,7 +53,7 @@ std::string cmTargetCompileOptionsCommand
 //----------------------------------------------------------------------------
 void cmTargetCompileOptionsCommand
 ::HandleDirectContent(cmTarget *tgt, const std::vector<std::string> &content,
-                                   bool)
+                                   bool, bool)
 {
   cmListFileBacktrace lfbt;
   this->Makefile->GetBacktrace(lfbt);

Source/cmTargetCompileOptionsCommand.h

@@ -83,7 +83,7 @@ private:
 
   virtual void HandleDirectContent(cmTarget *tgt,
                                    const std::vector<std::string> &content,
-                                   bool prepend);
+                                   bool prepend, bool system);
   virtual std::string Join(const std::vector<std::string> &content);
 };
 

Source/cmTargetIncludeDirectoriesCommand.cxx

@@ -15,7 +15,8 @@
 bool cmTargetIncludeDirectoriesCommand
 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 {
-  return this->HandleArguments(args, "INCLUDE_DIRECTORIES", PROCESS_BEFORE);
+  return this->HandleArguments(args, "INCLUDE_DIRECTORIES",
+                               ArgumentFlags(PROCESS_BEFORE | PROCESS_SYSTEM));
 }
 
 //----------------------------------------------------------------------------
@@ -65,10 +66,39 @@ std::string cmTargetIncludeDirectoriesCommand
 //----------------------------------------------------------------------------
 void cmTargetIncludeDirectoriesCommand
 ::HandleDirectContent(cmTarget *tgt, const std::vector<std::string> &content,
-                      bool prepend)
+                      bool prepend, bool system)
 {
   cmListFileBacktrace lfbt;
   this->Makefile->GetBacktrace(lfbt);
   cmValueWithOrigin entry(this->Join(content), lfbt);
   tgt->InsertInclude(entry, prepend);
+  if (system)
+    {
+    tgt->AddSystemIncludeDirectories(content);
+    }
+}
+
+//----------------------------------------------------------------------------
+void cmTargetIncludeDirectoriesCommand
+::HandleInterfaceContent(cmTarget *tgt,
+                         const std::vector<std::string> &content,
+                         bool prepend, bool system)
+{
+  cmTargetPropCommandBase::HandleInterfaceContent(tgt, content,
+                                                  prepend, system);
+
+  if (system)
+    {
+    std::string joined;
+    std::string sep;
+    for(std::vector<std::string>::const_iterator it = content.begin();
+      it != content.end(); ++it)
+      {
+      joined += sep;
+      sep = ";";
+      joined += *it;
+      }
+    tgt->AppendProperty("INTERFACE_SYSTEM_INCLUDE_DIRECTORIES",
+                        joined.c_str());
+    }
 }

Source/cmTargetIncludeDirectoriesCommand.h

@@ -54,7 +54,7 @@ public:
   virtual const char* GetFullDocumentation() const
     {
     return
-      "  target_include_directories(<target> [BEFORE] "
+      "  target_include_directories(<target> [SYSTEM] [BEFORE] "
       "<INTERFACE|PUBLIC|PRIVATE> [items1...]\n"
       "    [<INTERFACE|PUBLIC|PRIVATE> [items2...] ...])\n"
       "Specify include directories or targets to use when compiling a given "
@@ -71,6 +71,14 @@ public:
       "The following arguments specify include directories.  Specified "
       "include directories may be absolute paths or relative paths.  "
       "Repeated calls for the same <target> append items in the order called."
+      "If SYSTEM is specified, the compiler will be told the "
+      "directories are meant as system include directories on some "
+      "platforms (signalling this setting might achieve effects such as "
+      "the compiler skipping warnings, or these fixed-install system files "
+      "not being considered in dependency calculations - see compiler "
+      "docs).  If SYSTEM is used together with PUBLIC or INTERFACE, the "
+      "INTERFACE_SYSTEM_INCLUDE_DIRECTORIES target property will be "
+      "populated with the specified directories."
       "\n"
       "Arguments to target_include_directories may use \"generator "
       "expressions\" with the syntax \"$<...>\".  "
@@ -87,7 +95,11 @@ private:
 
   virtual void HandleDirectContent(cmTarget *tgt,
                                    const std::vector<std::string> &content,
-                                   bool prepend);
+                                   bool prepend, bool system);
+  virtual void HandleInterfaceContent(cmTarget *tgt,
+                                   const std::vector<std::string> &content,
+                                   bool prepend, bool system);
+
   virtual std::string Join(const std::vector<std::string> &content);
 };
 

Source/cmTargetPropCommandBase.cxx

@@ -48,8 +48,20 @@ bool cmTargetPropCommandBase
     return false;
     }
 
+  bool system = false;
   unsigned int argIndex = 1;
 
+  if ((flags & PROCESS_SYSTEM) && args[argIndex] == "SYSTEM")
+    {
+    if (args.size() < 4)
+      {
+      this->SetError("called with incorrect number of arguments");
+      return false;
+      }
+    system = true;
+    ++argIndex;
+    }
+
   bool prepend = false;
   if ((flags & PROCESS_BEFORE) && args[argIndex] == "BEFORE")
     {
@@ -66,7 +78,7 @@ bool cmTargetPropCommandBase
 
   while (argIndex < args.size())
     {
-    if (!this->ProcessContentArgs(args, argIndex, prepend))
+    if (!this->ProcessContentArgs(args, argIndex, prepend, system))
       {
       return false;
       }
@@ -77,7 +89,7 @@ bool cmTargetPropCommandBase
 //----------------------------------------------------------------------------
 bool cmTargetPropCommandBase
 ::ProcessContentArgs(std::vector<std::string> const& args,
-                     unsigned int &argIndex, bool prepend)
+                     unsigned int &argIndex, bool prepend, bool system)
 {
   const std::string scope = args[argIndex];
 
@@ -105,12 +117,12 @@ bool cmTargetPropCommandBase
         || args[i] == "PRIVATE"
         || args[i] == "INTERFACE" )
       {
-      this->PopulateTargetProperies(scope, content, prepend);
+      this->PopulateTargetProperies(scope, content, prepend, system);
       return true;
       }
     content.push_back(args[i]);
     }
-  this->PopulateTargetProperies(scope, content, prepend);
+  this->PopulateTargetProperies(scope, content, prepend, system);
   return true;
 }
 
@@ -118,27 +130,35 @@ bool cmTargetPropCommandBase
 void cmTargetPropCommandBase
 ::PopulateTargetProperies(const std::string &scope,
                           const std::vector<std::string> &content,
-                          bool prepend)
+                          bool prepend, bool system)
 {
   if (scope == "PRIVATE" || scope == "PUBLIC")
     {
-    this->HandleDirectContent(this->Target, content, prepend);
+    this->HandleDirectContent(this->Target, content, prepend, system);
     }
   if (scope == "INTERFACE" || scope == "PUBLIC")
+    {
+    this->HandleInterfaceContent(this->Target, content, prepend, system);
+    }
+}
+
+//----------------------------------------------------------------------------
+void cmTargetPropCommandBase::HandleInterfaceContent(cmTarget *tgt,
+                                  const std::vector<std::string> &content,
+                                  bool prepend, bool)
 {
   if (prepend)
     {
     const std::string propName = std::string("INTERFACE_") + this->Property;
-      const char *propValue = this->Target->GetProperty(propName.c_str());
+    const char *propValue = tgt->GetProperty(propName.c_str());
     const std::string totalContent = this->Join(content) + (propValue
                                               ? std::string(";") + propValue
                                               : std::string());
-      this->Target->SetProperty(propName.c_str(), totalContent.c_str());
+    tgt->SetProperty(propName.c_str(), totalContent.c_str());
     }
   else
     {
-      this->Target->AppendProperty(("INTERFACE_" + this->Property).c_str(),
+    tgt->AppendProperty(("INTERFACE_" + this->Property).c_str(),
                           this->Join(content).c_str());
     }
 }
-}

Source/cmTargetPropCommandBase.h

@@ -25,7 +25,8 @@ public:
 
   enum ArgumentFlags {
     NO_FLAGS = 0,
-    PROCESS_BEFORE = 1
+    PROCESS_BEFORE = 1,
+    PROCESS_SYSTEM = 2
   };
 
   bool HandleArguments(std::vector<std::string> const& args,
@@ -36,20 +37,24 @@ protected:
   std::string Property;
   cmTarget *Target;
 
+  virtual void HandleInterfaceContent(cmTarget *tgt,
+                                   const std::vector<std::string> &content,
+                                   bool prepend, bool system);
 private:
   virtual void HandleImportedTarget(const std::string &tgt) = 0;
   virtual void HandleMissingTarget(const std::string &name) = 0;
 
   virtual void HandleDirectContent(cmTarget *tgt,
                                    const std::vector<std::string> &content,
-                                   bool prepend) = 0;
+                                   bool prepend, bool system) = 0;
+
   virtual std::string Join(const std::vector<std::string> &content) = 0;
 
   bool ProcessContentArgs(std::vector<std::string> const& args,
-                          unsigned int &argIndex, bool prepend);
+                          unsigned int &argIndex, bool prepend, bool system);
   void PopulateTargetProperies(const std::string &scope,
                                const std::vector<std::string> &content,
-                               bool prepend);
+                               bool prepend, bool system);
 };
 
 #endif

Source/cmake.cxx

@@ -612,7 +612,7 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
     std::vector<std::string> includeDirs;
     cmSystemTools::ExpandListArgument(includes, includeDirs);
 
-    std::string includeFlags = lg->GetIncludeFlags(includeDirs,
+    std::string includeFlags = lg->GetIncludeFlags(includeDirs, 0,
                                                    language.c_str(), false);
 
     std::string definitions = mf->GetSafeDefinition("PACKAGE_DEFINITIONS");

Tests/IncludeDirectories/CMakeLists.txt

@@ -1,6 +1,23 @@
 cmake_minimum_required (VERSION 2.6)
 project(IncludeDirectories)
 
+if (((CMAKE_C_COMPILER_ID STREQUAL GNU AND CMAKE_C_COMPILER_VERSION VERSION_GREATER 4.4)
+    OR CMAKE_C_COMPILER_ID STREQUAL Clang)
+    AND (CMAKE_GENERATOR STREQUAL "Unix Makefiles" OR CMAKE_GENERATOR STREQUAL "Ninja"))
+  include(CheckCXXCompilerFlag)
+  check_cxx_compiler_flag(-Wunused-variable run_sys_includes_test)
+  if(run_sys_includes_test)
+    # The Bullseye wrapper appears to break the -isystem effect.
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version OUTPUT_VARIABLE out ERROR_VARIABLE out)
+    if("x${out}" MATCHES "Bullseye")
+      set(run_sys_includes_test 0)
+    endif()
+  endif()
+  if (run_sys_includes_test)
+    add_subdirectory(SystemIncludeDirectories)
+  endif()
+endif()
+
 file(WRITE ${CMAKE_BINARY_DIR}/Flags/Flags.h
 "//Flags.h
 ")

Tests/IncludeDirectories/SystemIncludeDirectories/CMakeLists.txt

@@ -0,0 +1,19 @@
+
+cmake_minimum_required(VERSION 2.8)
+
+project(SystemIncludeDirectories)
+
+add_library(systemlib systemlib.cpp)
+target_include_directories(systemlib PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/systemlib")
+
+add_library(upstream upstream.cpp)
+target_link_libraries(upstream LINK_PUBLIC systemlib)
+target_compile_options(upstream PRIVATE -Werror=unused-variable)
+
+target_include_directories(upstream SYSTEM PUBLIC
+  $<TARGET_PROPERTY:systemlib,INTERFACE_INCLUDE_DIRECTORIES>
+)
+
+add_library(consumer consumer.cpp)
+target_link_libraries(consumer upstream)
+target_compile_options(consumer PRIVATE -Werror=unused-variable)

Tests/IncludeDirectories/SystemIncludeDirectories/consumer.cpp

@@ -0,0 +1,7 @@
+
+#include "upstream.h"
+
+int consumer()
+{
+  return upstream();
+}

Tests/IncludeDirectories/SystemIncludeDirectories/systemlib.cpp

@@ -0,0 +1,4 @@
+
+#include "systemlib.h"
+
+int systemlib() { return 0; }

Tests/IncludeDirectories/SystemIncludeDirectories/systemlib/systemlib.h

@@ -0,0 +1,19 @@
+
+#ifndef SYSTEMLIB_H
+#define SYSTEMLIB_H
+
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+int systemlib();
+
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+int unusedFunc()
+{
+  int unused;
+  return systemlib();
+}
+
+#endif

Tests/IncludeDirectories/SystemIncludeDirectories/upstream.cpp

@@ -0,0 +1,4 @@
+
+#include "upstream.h"
+
+int upstream() { return systemlib(); }

Tests/IncludeDirectories/SystemIncludeDirectories/upstream.h

@@ -0,0 +1,12 @@
+
+#ifndef UPSTREAM_H
+#define UPSTREAM_H
+
+#include "systemlib.h"
+
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+int upstream();
+
+#endif