Merge branch 'revert-server-iface-sources' into release-3.13

Merge-request: !2495

4 files changed, 40 insertions, 189 deletions

diff --git a/Help/manual/cmake-server.7.rst b/Help/manual/cmake-server.7.rst
index b4c1436..25d364c 100644
--- a/Help/manual/cmake-server.7.rst
+++ b/Help/manual/cmake-server.7.rst
@@ -308,9 +308,6 @@ which will result in a response type "reply"::
 
 indicating that the server is ready for action.
 
-Protocol version 1.3 introduces an optional flag on the target filegroup
-that indicates if the filegroup represents :prop_tgt:`INTERFACE_SOURCES`.
-
 
 Type "globalSettings"
 ^^^^^^^^^^^^^^^^^^^^^
@@ -527,8 +524,6 @@ FileGroups are used to group sources using similar settings together.
 
 Each fileGroup object may contain the following keys:
 
-"isInterfaceSources"
-  true if the fileGroup represents :prop_tgt:`INTERFACE_SOURCES`.
 "language"
   contains the programming language used by all files in the group.
 "compileFlags"
@@ -543,8 +538,6 @@ Each fileGroup object may contain the following keys:
 "defines"
   with a list of defines in the form "SOMEVALUE" or "SOMEVALUE=42". This
   value is encoded in the system's native shell format.
-"isGenerated"
-  true if the files were generated.
 "sources"
   with a list of source files.
 
diff --git a/Source/cmJsonObjectDictionary.h b/Source/cmJsonObjectDictionary.h
index a4d41f3..8a2b529 100644
--- a/Source/cmJsonObjectDictionary.h
+++ b/Source/cmJsonObjectDictionary.h
@@ -43,4 +43,3 @@ static const std::string kCTEST_COMMAND = "ctestCommand";
 static const std::string kCTEST_INFO = "ctestInfo";
 static const std::string kMINIMUM_CMAKE_VERSION = "minimumCMakeVersion";
 static const std::string kIS_GENERATOR_PROVIDED_KEY = "isGeneratorProvided";
-static const std::string kIS_INTERFACE_SOURCES_KEY = "isInterfaceSources";
diff --git a/Source/cmJsonObjects.cxx b/Source/cmJsonObjects.cxx
index a7db75f..4148894 100644
--- a/Source/cmJsonObjects.cxx
+++ b/Source/cmJsonObjects.cxx
@@ -150,8 +150,6 @@ Json::Value cmDumpCMakeInputs(const cmake* cm)
   return array;
 }
 
-const std::string kInterfaceSourcesLanguageDataKey =
-  "INTERFACE_SOURCES_LD_KEY";
 class LanguageData
 {
 public:
@@ -184,12 +182,6 @@ void LanguageData::SetDefines(const std::set<std::string>& defines)
   Defines = std::move(result);
 }
 
-struct FileGroupSources
-{
-  bool IsInterfaceSources;
-  std::vector<std::string> Files;
-};
-
 namespace std {
 
 template <>
@@ -217,35 +209,31 @@ struct hash<LanguageData>
 } // namespace std
 
 static Json::Value DumpSourceFileGroup(const LanguageData& data,
-                                       bool isInterfaceSource,
                                        const std::vector<std::string>& files,
                                        const std::string& baseDir)
 {
   Json::Value result = Json::objectValue;
 
-  if (isInterfaceSource) {
-    result[kIS_INTERFACE_SOURCES_KEY] = true;
-  }
   if (!data.Language.empty()) {
     result[kLANGUAGE_KEY] = data.Language;
-  }
-  if (!data.Flags.empty()) {
-    result[kCOMPILE_FLAGS_KEY] = data.Flags;
-  }
-  if (!data.IncludePathList.empty()) {
-    Json::Value includes = Json::arrayValue;
-    for (auto const& i : data.IncludePathList) {
-      Json::Value tmp = Json::objectValue;
-      tmp[kPATH_KEY] = i.first;
-      if (i.second) {
-        tmp[kIS_SYSTEM_KEY] = i.second;
+    if (!data.Flags.empty()) {
+      result[kCOMPILE_FLAGS_KEY] = data.Flags;
+    }
+    if (!data.IncludePathList.empty()) {
+      Json::Value includes = Json::arrayValue;
+      for (auto const& i : data.IncludePathList) {
+        Json::Value tmp = Json::objectValue;
+        tmp[kPATH_KEY] = i.first;
+        if (i.second) {
+          tmp[kIS_SYSTEM_KEY] = i.second;
+        }
+        includes.append(tmp);
       }
-      includes.append(tmp);
+      result[kINCLUDE_PATH_KEY] = includes;
+    }
+    if (!data.Defines.empty()) {
+      result[kDEFINES_KEY] = fromStringList(data.Defines);
     }
-    result[kINCLUDE_PATH_KEY] = includes;
-  }
-  if (!data.Defines.empty()) {
-    result[kDEFINES_KEY] = fromStringList(data.Defines);
   }
 
   result[kIS_GENERATED_KEY] = data.IsGenerated;
@@ -260,19 +248,21 @@ static Json::Value DumpSourceFileGroup(const LanguageData& data,
   return result;
 }
 
-static void PopulateFileGroupData(
-  cmGeneratorTarget* target, bool isInterfaceSources,
-  const std::vector<cmSourceFile*>& files, const std::string& config,
-  const std::map<std::string, LanguageData>& languageDataMap,
-  std::unordered_map<LanguageData, FileGroupSources>& fileGroups)
+static Json::Value DumpSourceFilesList(
+  cmGeneratorTarget* target, const std::string& config,
+  const std::map<std::string, LanguageData>& languageDataMap)
 {
+  // Collect sourcefile groups:
+
+  std::vector<cmSourceFile*> files;
+  target->GetSourceFiles(files, config);
+
+  std::unordered_map<LanguageData, std::vector<std::string>> fileGroups;
   for (cmSourceFile* file : files) {
     LanguageData fileData;
     fileData.Language = file->GetLanguage();
-    if (!fileData.Language.empty() || isInterfaceSources) {
-      const LanguageData& ld = isInterfaceSources
-        ? languageDataMap.at(kInterfaceSourcesLanguageDataKey)
-        : languageDataMap.at(fileData.Language);
+    if (!fileData.Language.empty()) {
+      const LanguageData& ld = languageDataMap.at(fileData.Language);
       cmLocalGenerator* lg = target->GetLocalGenerator();
       cmGeneratorExpressionInterpreter genexInterpreter(lg, config, target,
                                                         fileData.Language);
@@ -300,14 +290,10 @@ static void PopulateFileGroupData(
         lg->AppendIncludeDirectories(includes, evaluatedIncludes, *file);
 
         for (const auto& include : includes) {
-          // INTERFACE_LIBRARY targets do not support the
-          // IsSystemIncludeDirectory call so just set it to false.
-          const bool isSystemInclude = isInterfaceSources
-            ? false
-            : target->IsSystemIncludeDirectory(include, config,
-                                               fileData.Language);
           fileData.IncludePathList.push_back(
-            std::make_pair(include, isSystemInclude));
+            std::make_pair(include,
+                           target->IsSystemIncludeDirectory(
+                             include, config, fileData.Language)));
         }
       }
 
@@ -336,71 +322,14 @@ static void PopulateFileGroupData(
     }
 
     fileData.IsGenerated = file->GetPropertyAsBool("GENERATED");
-    FileGroupSources& groupFileList = fileGroups[fileData];
-    groupFileList.IsInterfaceSources = isInterfaceSources;
-    groupFileList.Files.push_back(file->GetFullPath());
-  }
-}
-
-static Json::Value DumpSourceFilesList(
-  cmGeneratorTarget* target, const std::string& config,
-  const std::map<std::string, LanguageData>& languageDataMap)
-{
-  const cmStateEnums::TargetType type = target->GetType();
-  std::unordered_map<LanguageData, FileGroupSources> fileGroups;
-
-  // Collect sourcefile groups:
-
-  std::vector<cmSourceFile*> files;
-  if (type == cmStateEnums::INTERFACE_LIBRARY) {
-    // INTERFACE_LIBRARY targets do not create all the data structures
-    // associated with regular targets. If properties are explicitly specified
-    // for files in INTERFACE_SOURCES then we can get them through the Makefile
-    // rather than the target.
-    files = target->Makefile->GetSourceFiles();
-  } else {
-    target->GetSourceFiles(files, config);
-    PopulateFileGroupData(target, false /* isInterfaceSources */, files,
-                          config, languageDataMap, fileGroups);
-  }
-
-  // Collect interface sourcefile groups:
-
-  auto targetProp = target->Target->GetProperty("INTERFACE_SOURCES");
-  if (targetProp != nullptr) {
-    cmGeneratorExpressionInterpreter genexInterpreter(
-      target->GetLocalGenerator(), config, target);
-
-    auto evaluatedSources = cmsys::SystemTools::SplitString(
-      genexInterpreter.Evaluate(targetProp, "INTERFACE_SOURCES"), ';');
-
-    std::map<std::string, cmSourceFile*> filesMap;
-    for (auto file : files) {
-      filesMap[file->GetFullPath()] = file;
-    }
-
-    std::vector<cmSourceFile*> interfaceSourceFiles;
-    for (const std::string& interfaceSourceFilePath : evaluatedSources) {
-      auto entry = filesMap.find(interfaceSourceFilePath);
-      if (entry != filesMap.end()) {
-        // use what we have since it has all the associated properties
-        interfaceSourceFiles.push_back(entry->second);
-      } else {
-        interfaceSourceFiles.push_back(
-          new cmSourceFile(target->Makefile, interfaceSourceFilePath));
-      }
-    }
-
-    PopulateFileGroupData(target, true /* isInterfaceSources */,
-                          interfaceSourceFiles, config, languageDataMap,
-                          fileGroups);
+    std::vector<std::string>& groupFileList = fileGroups[fileData];
+    groupFileList.push_back(file->GetFullPath());
   }
 
   const std::string& baseDir = target->Makefile->GetCurrentSourceDirectory();
   Json::Value result = Json::arrayValue;
   for (auto const& it : fileGroups) {
-    Json::Value group = DumpSourceFileGroup(
-      it.first, it.second.IsInterfaceSources, it.second.Files, baseDir);
+    Json::Value group = DumpSourceFileGroup(it.first, it.second, baseDir);
     if (!group.isNull()) {
       result.append(group);
     }
@@ -517,58 +446,6 @@ Json::Value cmDumpCTestInfo(const cmake* cm)
   return result;
 }
 
-static void GetTargetProperty(
-  cmGeneratorExpressionInterpreter& genexInterpreter,
-  cmGeneratorTarget* target, const char* propertyName,
-  std::vector<std::string>& propertyValue)
-{
-  auto targetProp = target->Target->GetProperty(propertyName);
-  if (targetProp != nullptr) {
-    propertyValue = cmsys::SystemTools::SplitString(
-      genexInterpreter.Evaluate(targetProp, propertyName), ';');
-  }
-}
-
-static void CreateInterfaceSourcesEntry(
-  cmLocalGenerator* lg, cmGeneratorTarget* target, const std::string& config,
-  std::map<std::string, LanguageData>& languageDataMap)
-{
-  LanguageData& ld = languageDataMap[kInterfaceSourcesLanguageDataKey];
-  ld.Language = "";
-
-  cmGeneratorExpressionInterpreter genexInterpreter(lg, config, target);
-  std::vector<std::string> propertyValue;
-  GetTargetProperty(genexInterpreter, target, "INTERFACE_INCLUDE_DIRECTORIES",
-                    propertyValue);
-  for (std::string const& i : propertyValue) {
-    ld.IncludePathList.push_back(
-      std::make_pair(i, false /* isSystemInclude */));
-  }
-
-  propertyValue.clear();
-  GetTargetProperty(genexInterpreter, target,
-                    "INTERFACE_SYSTEM_INCLUDE_DIRECTORIES", propertyValue);
-  for (std::string const& i : propertyValue) {
-    ld.IncludePathList.push_back(
-      std::make_pair(i, true /* isSystemInclude */));
-  }
-
-  propertyValue.clear();
-  GetTargetProperty(genexInterpreter, target, "INTERFACE_COMPILE_OPTIONS",
-                    propertyValue);
-  for (const auto& s : propertyValue) {
-    ld.Flags += " " + s;
-  }
-
-  propertyValue.clear();
-  GetTargetProperty(genexInterpreter, target, "INTERFACE_COMPILE_DEFINITIONS",
-                    propertyValue);
-  if (!propertyValue.empty()) {
-    std::set<std::string> defines(propertyValue.begin(), propertyValue.end());
-    ld.SetDefines(defines);
-  }
-}
-
 static Json::Value DumpTarget(cmGeneratorTarget* target,
                               const std::string& config)
 {
@@ -598,6 +475,11 @@ static Json::Value DumpTarget(cmGeneratorTarget* target,
   result[kTYPE_KEY] = typeName;
   result[kSOURCE_DIRECTORY_KEY] = lg->GetCurrentSourceDirectory();
   result[kBUILD_DIRECTORY_KEY] = lg->GetCurrentBinaryDirectory();
+
+  if (type == cmStateEnums::INTERFACE_LIBRARY) {
+    return result;
+  }
+
   result[kFULL_NAME_KEY] = target->GetFullName(config);
 
   if (target->Target->GetHaveInstallRule()) {
@@ -684,21 +566,8 @@ static Json::Value DumpTarget(cmGeneratorTarget* target,
   }
 
   std::set<std::string> languages;
+  target->GetLanguages(languages, config);
   std::map<std::string, LanguageData> languageDataMap;
-  if (type == cmStateEnums::INTERFACE_LIBRARY) {
-    // INTERFACE_LIBRARY targets do not create all the data structures
-    // associated with regular targets. If properties are explicitly specified
-    // for files in INTERFACE_SOURCES then we can get them through the Makefile
-    // rather than the target.
-    for (auto file : target->Makefile->GetSourceFiles()) {
-      const std::string& language = file->GetLanguage();
-      if (!language.empty()) {
-        languages.insert(language);
-      }
-    }
-  } else {
-    target->GetLanguages(languages, config);
-  }
 
   for (std::string const& lang : languages) {
     LanguageData& ld = languageDataMap[lang];
@@ -715,11 +584,6 @@ static Json::Value DumpTarget(cmGeneratorTarget* target,
     }
   }
 
-  if (target->Target->GetProperty("INTERFACE_SOURCES") != nullptr) {
-    // Create an entry in the languageDataMap for interface sources.
-    CreateInterfaceSourcesEntry(lg, target, config, languageDataMap);
-  }
-
   Json::Value sourceGroupsValue =
     DumpSourceFilesList(target, config, languageDataMap);
   if (!sourceGroupsValue.empty()) {
diff --git a/Source/cmServerProtocol.cxx b/Source/cmServerProtocol.cxx
index f75a5ce..f051fd9 100644
--- a/Source/cmServerProtocol.cxx
+++ b/Source/cmServerProtocol.cxx
@@ -164,12 +164,7 @@ bool cmServerProtocol::DoActivate(const cmServerRequest& /*request*/,
 
 std::pair<int, int> cmServerProtocol1::ProtocolVersion() const
 {
-  // Revision history
-  // 1, 1 - Report backtraces in codemodel response
-  // 1, 2 - Add target install destinations to codemodel
-  // 1, 3 - Add a flag to target filegroups indicating whether or not the
-  // filegroup is for INTERFACE_SOURCES
-  return std::make_pair(1, 3);
+  return std::make_pair(1, 2);
 }
 
 static void setErrorMessage(std::string* errorMessage, const std::string& text)