Merge topic 'autogen-optimize-cleanup'

8e452e67 Remove AUTOGEN variables from cmSourceFile and cmMakefile
0f2e178f Autogen: Don't use cmMakefile::GetQtUiFilesWithOptions
13bb716f Autogen: Fix and extend SKIP_AUTOMOC test
727247c3 Autogen: Read skip files from makefile
1eb1b409 Autogen: Remove VS specific code exclusion
54ec2a8b Autogen: Initializer file type scanning optimizations
cf7b3b96 Autogen: Initializer optimizations and cleanups

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !1171

12 files changed, 445 insertions, 372 deletions

diff --git a/Modules/AutogenInfo.cmake.in b/Modules/AutogenInfo.cmake.in
index e1a9c39..60ceebc 100644
--- a/Modules/AutogenInfo.cmake.in
+++ b/Modules/AutogenInfo.cmake.in
@@ -4,7 +4,7 @@ set(AM_CMAKE_SOURCE_DIR "@CMAKE_SOURCE_DIR@/")
 set(AM_CMAKE_CURRENT_SOURCE_DIR "@CMAKE_CURRENT_SOURCE_DIR@/")
 set(AM_CMAKE_CURRENT_BINARY_DIR "@CMAKE_CURRENT_BINARY_DIR@/")
 set(AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE "@CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE@")
-set(AM_BUILD_DIR @_autogen_build_dir@)
+set(AM_BUILD_DIR @_build_dir@)
 set(AM_SOURCES @_sources@)
 set(AM_HEADERS @_headers@)
 # Qt environment
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index cb6cf2d..29999e9 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -3902,16 +3902,6 @@ bool cmMakefile::EnforceUniqueDir(const std::string& srcPath,
   return false;
 }
 
-void cmMakefile::AddQtUiFileWithOptions(cmSourceFile* sf)
-{
-  this->QtUiFilesWithOptions.push_back(sf);
-}
-
-std::vector<cmSourceFile*> cmMakefile::GetQtUiFilesWithOptions() const
-{
-  return this->QtUiFilesWithOptions;
-}
-
 static std::string const matchVariables[] = {
   "CMAKE_MATCH_0", "CMAKE_MATCH_1", "CMAKE_MATCH_2", "CMAKE_MATCH_3",
   "CMAKE_MATCH_4", "CMAKE_MATCH_5", "CMAKE_MATCH_6", "CMAKE_MATCH_7",
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 35cda6d..059a4e7 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -736,9 +736,6 @@ public:
   cmStringRange GetCompileDefinitionsEntries() const;
   cmBacktraceRange GetCompileDefinitionsBacktraces() const;
 
-  void AddQtUiFileWithOptions(cmSourceFile* sf);
-  std::vector<cmSourceFile*> GetQtUiFilesWithOptions() const;
-
   std::set<std::string> const& GetSystemIncludeDirectories() const
   {
     return this->SystemIncludeDirectories;
@@ -917,8 +914,6 @@ private:
   void UpdateOutputToSourceMap(std::string const& output,
                                cmSourceFile* source);
 
-  std::vector<cmSourceFile*> QtUiFilesWithOptions;
-
   bool AddRequiredTargetCFeature(cmTarget* target, const std::string& feature,
                                  std::string* error = CM_NULLPTR) const;
 
diff --git a/Source/cmQtAutoGeneratorInitializer.cxx b/Source/cmQtAutoGeneratorInitializer.cxx
index 6ae101f..a8e2bca 100644
--- a/Source/cmQtAutoGeneratorInitializer.cxx
+++ b/Source/cmQtAutoGeneratorInitializer.cxx
@@ -4,6 +4,8 @@
 #include "cmQtAutoGeneratorCommon.h"
 
 #include "cmAlgorithms.h"
+#include "cmConfigure.h"
+#include "cmCustomCommand.h"
 #include "cmCustomCommandLines.h"
 #include "cmFilePathChecksum.h"
 #include "cmGeneratorTarget.h"
@@ -19,13 +21,8 @@
 #include "cmTarget.h"
 #include "cm_sys_stat.h"
 #include "cmake.h"
-
-#if defined(_WIN32) && !defined(__CYGWIN__)
-#include "cmGlobalVisualStudioGenerator.h"
-#endif
-
-#include "cmConfigure.h"
 #include "cmsys/FStream.hxx"
+
 #include <algorithm>
 #include <map>
 #include <set>
@@ -34,26 +31,20 @@
 #include <utility>
 #include <vector>
 
-static void utilCopyTargetProperty(cmTarget* destinationTarget,
-                                   cmTarget* sourceTarget,
-                                   const std::string& propertyName)
+inline static const char* SafeString(const char* value)
 {
-  const char* propertyValue = sourceTarget->GetProperty(propertyName);
-  if (propertyValue) {
-    destinationTarget->SetProperty(propertyName, propertyValue);
-  }
+  return (value != CM_NULLPTR) ? value : "";
 }
 
-inline static bool PropertyEnabled(cmSourceFile* sourceFile, const char* key)
+static std::string GetSafeProperty(cmGeneratorTarget const* target,
+                                   const char* key)
 {
-  return cmSystemTools::IsOn(sourceFile->GetPropertyForUser(key));
+  return std::string(SafeString(target->GetProperty(key)));
 }
 
-static std::string GetSafeProperty(cmGeneratorTarget const* target,
-                                   const char* key)
+inline static bool AutogenMultiConfig(cmGlobalGenerator* globalGen)
 {
-  const char* tmp = target->GetProperty(key);
-  return std::string((tmp != CM_NULLPTR) ? tmp : "");
+  return globalGen->IsMultiConfig();
 }
 
 static std::string GetAutogenTargetName(cmGeneratorTarget const* target)
@@ -156,11 +147,6 @@ static void GetCompileDefinitionsAndDirectories(
   }
 }
 
-static bool IsMultiConfig(cmGlobalGenerator* globalGen)
-{
-  return globalGen->IsMultiConfig();
-}
-
 static std::vector<std::string> GetConfigurations(
   cmMakefile* makefile, std::string* config = CM_NULLPTR)
 {
@@ -181,7 +167,7 @@ static std::vector<std::string> GetConfigurations(
 static std::vector<std::string> GetConfigurationSuffixes(cmMakefile* makefile)
 {
   std::vector<std::string> suffixes;
-  if (IsMultiConfig(makefile->GetGlobalGenerator())) {
+  if (AutogenMultiConfig(makefile->GetGlobalGenerator())) {
     makefile->GetConfigurations(suffixes);
     for (std::vector<std::string>::iterator it = suffixes.begin();
          it != suffixes.end(); ++it) {
@@ -208,6 +194,13 @@ static void AddDefinitionEscaped(cmMakefile* makefile, const char* key,
     key, cmOutputConverter::EscapeForCMake(cmJoin(values, ";")).c_str());
 }
 
+static void AddDefinitionEscaped(cmMakefile* makefile, const char* key,
+                                 const std::set<std::string>& values)
+{
+  makefile->AddDefinition(
+    key, cmOutputConverter::EscapeForCMake(cmJoin(values, ";")).c_str());
+}
+
 static bool AddToSourceGroup(cmMakefile* makefile, const std::string& fileName,
                              cmQtAutoGeneratorCommon::GeneratorType genType)
 {
@@ -263,6 +256,12 @@ static bool AddToSourceGroup(cmMakefile* makefile, const std::string& fileName,
   return true;
 }
 
+static void AddCleanFile(cmMakefile* makefile, const std::string& fileName)
+{
+  makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", fileName.c_str(),
+                           false);
+}
+
 static void AddGeneratedSource(cmGeneratorTarget* target,
                                const std::string& filename,
                                cmQtAutoGeneratorCommon::GeneratorType genType)
@@ -278,39 +277,81 @@ static void AddGeneratedSource(cmGeneratorTarget* target,
   AddToSourceGroup(makefile, filename, genType);
 }
 
-static void AcquireScanFiles(cmGeneratorTarget const* target,
-                             std::vector<std::string>& mocUicSources,
-                             std::vector<std::string>& mocUicHeaders,
-                             std::vector<std::string>& mocSkipList,
-                             std::vector<std::string>& uicSkipList)
+struct AutogenSetup
+{
+  std::vector<std::string> sources;
+  std::vector<std::string> headers;
+
+  std::set<std::string> mocSkip;
+  std::set<std::string> uicSkip;
+
+  std::map<std::string, std::string> configSuffix;
+  std::map<std::string, std::string> configMocIncludes;
+  std::map<std::string, std::string> configMocDefines;
+  std::map<std::string, std::string> configUicOptions;
+};
+
+static void SetupAcquireScanFiles(cmGeneratorTarget const* target,
+                                  bool mocEnabled, bool uicEnabled,
+                                  const std::vector<cmSourceFile*>& srcFiles,
+                                  AutogenSetup& setup)
 {
-  const bool mocTarget = target->GetPropertyAsBool("AUTOMOC");
-  const bool uicTarget = target->GetPropertyAsBool("AUTOUIC");
+  // Read skip files from makefile sources
+  {
+    const std::vector<cmSourceFile*>& allSources =
+      target->Makefile->GetSourceFiles();
+    for (std::vector<cmSourceFile*>::const_iterator fit = allSources.begin();
+         fit != allSources.end(); ++fit) {
+      cmSourceFile* sf = *fit;
+      // sf->GetExtension() is only valid after sf->GetFullPath() ...
+      const std::string& fPath = sf->GetFullPath();
+      const cmSystemTools::FileFormat fileType =
+        cmSystemTools::GetFileFormat(sf->GetExtension().c_str());
+      if (!(fileType == cmSystemTools::CXX_FILE_FORMAT) &&
+          !(fileType == cmSystemTools::HEADER_FILE_FORMAT)) {
+        continue;
+      }
+      const bool skipAll = sf->GetPropertyAsBool("SKIP_AUTOGEN");
+      const bool mocSkip =
+        mocEnabled && (skipAll || sf->GetPropertyAsBool("SKIP_AUTOMOC"));
+      const bool uicSkip =
+        uicEnabled && (skipAll || sf->GetPropertyAsBool("SKIP_AUTOUIC"));
+      if (mocSkip || uicSkip) {
+        const std::string absFile = cmsys::SystemTools::GetRealPath(fPath);
+        if (mocSkip) {
+          setup.mocSkip.insert(absFile);
+        }
+        if (uicSkip) {
+          setup.uicSkip.insert(absFile);
+        }
+      }
+    }
+  }
+
   const cmPolicies::PolicyStatus CMP0071_status =
     target->Makefile->GetPolicyStatus(cmPolicies::CMP0071);
-
-  std::vector<cmSourceFile*> srcFiles;
-  target->GetConfigCommonSourceFiles(srcFiles);
   for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
        fileIt != srcFiles.end(); ++fileIt) {
     cmSourceFile* sf = *fileIt;
+    // sf->GetExtension() is only valid after sf->GetFullPath() ...
+    const std::string& fPath = sf->GetFullPath();
     const cmSystemTools::FileFormat fileType =
       cmSystemTools::GetFileFormat(sf->GetExtension().c_str());
     if (!(fileType == cmSystemTools::CXX_FILE_FORMAT) &&
         !(fileType == cmSystemTools::HEADER_FILE_FORMAT)) {
       continue;
     }
-
-    const std::string absFile =
-      cmsys::SystemTools::GetRealPath(sf->GetFullPath());
-    // Skip flags
-    const bool skipAll = PropertyEnabled(sf, "SKIP_AUTOGEN");
-    const bool mocSkip = skipAll || PropertyEnabled(sf, "SKIP_AUTOMOC");
-    const bool uicSkip = skipAll || PropertyEnabled(sf, "SKIP_AUTOUIC");
-    const bool accept = (mocTarget && !mocSkip) || (uicTarget && !uicSkip);
+    // Real file path
+    const std::string absFile = cmsys::SystemTools::GetRealPath(fPath);
+    // Skip test
+    const bool mocSkip = !mocEnabled || (setup.mocSkip.count(absFile) != 0);
+    const bool uicSkip = !uicEnabled || (setup.uicSkip.count(absFile) != 0);
+    if (mocSkip && uicSkip) {
+      continue;
+    }
 
     // For GENERATED files check status of policy CMP0071
-    if (accept && PropertyEnabled(sf, "GENERATED")) {
+    if (sf->GetPropertyAsBool("GENERATED")) {
       bool policyAccept = false;
       switch (CMP0071_status) {
         case cmPolicies::WARN: {
@@ -336,47 +377,32 @@ static void AcquireScanFiles(cmGeneratorTarget const* target,
       }
     }
 
-    // Add file name to skip lists.
-    // Do this even when the file is not added to the sources/headers lists
-    // because the file name may be extracted from an other file when
-    // processing
-    if (mocSkip) {
-      mocSkipList.push_back(absFile);
-    }
-    if (uicSkip) {
-      uicSkipList.push_back(absFile);
-    }
-
-    if (accept) {
-      // Add file name to sources or headers list
-      switch (fileType) {
-        case cmSystemTools::CXX_FILE_FORMAT:
-          mocUicSources.push_back(absFile);
-          break;
-        case cmSystemTools::HEADER_FILE_FORMAT:
-          mocUicHeaders.push_back(absFile);
-          break;
-        default:
-          break;
-      }
+    // Add file name to sources or headers list
+    switch (fileType) {
+      case cmSystemTools::CXX_FILE_FORMAT:
+        setup.sources.push_back(absFile);
+        break;
+      case cmSystemTools::HEADER_FILE_FORMAT:
+        setup.headers.push_back(absFile);
+        break;
+      default:
+        break;
     }
   }
 }
 
-static void MocSetupAutoTarget(
-  cmGeneratorTarget const* target, const std::string& autogenTargetName,
-  std::string const& qtMajorVersion, std::string const& config,
-  std::vector<std::string> const& configs,
-  std::vector<std::string> const& mocSkipList,
-  std::map<std::string, std::string>& configMocIncludes,
-  std::map<std::string, std::string>& configMocDefines)
+static void SetupAutoTargetMoc(cmGeneratorTarget const* target,
+                               std::string const& qtMajorVersion,
+                               std::string const& config,
+                               std::vector<std::string> const& configs,
+                               AutogenSetup& setup)
 {
-  cmLocalGenerator* lg = target->GetLocalGenerator();
+  cmLocalGenerator* localGen = target->GetLocalGenerator();
   cmMakefile* makefile = target->Target->GetMakefile();
 
+  AddDefinitionEscaped(makefile, "_moc_skip", setup.mocSkip);
   AddDefinitionEscaped(makefile, "_moc_options",
                        GetSafeProperty(target, "AUTOMOC_MOC_OPTIONS"));
-  AddDefinitionEscaped(makefile, "_moc_skip", mocSkipList);
   AddDefinitionEscaped(makefile, "_moc_relaxed_mode",
                        makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE") ? "TRUE"
                                                                     : "FALSE");
@@ -408,42 +434,41 @@ static void MocSetupAutoTarget(
       GetCompileDefinitionsAndDirectories(target, *li, configIncs,
                                           configCompileDefs);
       if (configIncs != incs) {
-        configMocIncludes[*li] = cmOutputConverter::EscapeForCMake(configIncs);
+        setup.configMocIncludes[*li] = configIncs;
       }
       if (configCompileDefs != compileDefs) {
-        configMocDefines[*li] =
-          cmOutputConverter::EscapeForCMake(configCompileDefs);
+        setup.configMocDefines[*li] = configCompileDefs;
       }
     }
   }
 
   // Moc executable
   {
+    std::string mocExec;
     std::string err;
-    const char* mocExec = CM_NULLPTR;
+
     if (qtMajorVersion == "5") {
-      cmGeneratorTarget* qt5Moc = lg->FindGeneratorTargetToUse("Qt5::moc");
-      if (qt5Moc != CM_NULLPTR) {
-        mocExec = qt5Moc->ImportedGetLocation("");
+      cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt5::moc");
+      if (tgt != CM_NULLPTR) {
+        mocExec = SafeString(tgt->ImportedGetLocation(""));
       } else {
-        err = "Qt5::moc target not found " + autogenTargetName;
+        err = "AUTOMOC: Qt5::moc target not found";
       }
     } else if (qtMajorVersion == "4") {
-      cmGeneratorTarget* qt4Moc = lg->FindGeneratorTargetToUse("Qt4::moc");
-      if (qt4Moc != CM_NULLPTR) {
-        mocExec = qt4Moc->ImportedGetLocation("");
+      cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt4::moc");
+      if (tgt != CM_NULLPTR) {
+        mocExec = SafeString(tgt->ImportedGetLocation(""));
       } else {
-        err = "Qt4::moc target not found " + autogenTargetName;
+        err = "AUTOMOC: Qt4::moc target not found";
       }
     } else {
-      err = "The CMAKE_AUTOMOC feature supports only Qt 4 and Qt 5 ";
-      err += autogenTargetName;
+      err = "The AUTOMOC feature supports only Qt 4 and Qt 5";
     }
-    // Add definition or error
+
     if (err.empty()) {
-      AddDefinitionEscaped(makefile, "_qt_moc_executable",
-                           mocExec ? mocExec : "");
+      AddDefinitionEscaped(makefile, "_qt_moc_executable", mocExec);
     } else {
+      err += " (" + target->GetName() + ")";
       cmSystemTools::Error(err.c_str());
     }
   }
@@ -457,26 +482,30 @@ static void UicGetOpts(cmGeneratorTarget const* target,
   optString = cmJoin(opts, ";");
 }
 
-static void UicSetupAutoTarget(
-  cmGeneratorTarget const* target, std::string const& qtMajorVersion,
-  std::string const& config, std::vector<std::string> const& configs,
-  std::vector<std::string> const& uicSkipList,
-  std::map<std::string, std::string>& configUicOptions)
+static void SetupAutoTargetUic(cmGeneratorTarget const* target,
+                               std::string const& qtMajorVersion,
+                               std::string const& config,
+                               std::vector<std::string> const& configs,
+                               AutogenSetup& setup)
 {
-  cmLocalGenerator* lg = target->GetLocalGenerator();
+  cmLocalGenerator* localGen = target->GetLocalGenerator();
   cmMakefile* makefile = target->Target->GetMakefile();
 
-  AddDefinitionEscaped(makefile, "_uic_skip", uicSkipList);
+  AddDefinitionEscaped(makefile, "_uic_skip", setup.uicSkip);
 
   // Uic search paths
   {
     std::vector<std::string> uicSearchPaths;
-    cmSystemTools::ExpandListArgument(
-      GetSafeProperty(target, "AUTOUIC_SEARCH_PATHS"), uicSearchPaths);
-    const std::string srcDir = makefile->GetCurrentSourceDirectory();
-    for (std::vector<std::string>::iterator it = uicSearchPaths.begin();
-         it != uicSearchPaths.end(); ++it) {
-      *it = cmSystemTools::CollapseFullPath(*it, srcDir);
+    {
+      const std::string usp = GetSafeProperty(target, "AUTOUIC_SEARCH_PATHS");
+      if (!usp.empty()) {
+        cmSystemTools::ExpandListArgument(usp, uicSearchPaths);
+        const std::string srcDir = makefile->GetCurrentSourceDirectory();
+        for (std::vector<std::string>::iterator it = uicSearchPaths.begin();
+             it != uicSearchPaths.end(); ++it) {
+          *it = cmSystemTools::CollapseFullPath(*it, srcDir);
+        }
+      }
     }
     AddDefinitionEscaped(makefile, "_uic_search_paths", uicSearchPaths);
   }
@@ -493,8 +522,7 @@ static void UicSetupAutoTarget(
       std::string configUicOpts;
       UicGetOpts(target, *li, configUicOpts);
       if (configUicOpts != uicOpts) {
-        configUicOptions[*li] =
-          cmOutputConverter::EscapeForCMake(configUicOpts);
+        setup.configUicOptions[*li] = configUicOpts;
       }
     }
   }
@@ -503,25 +531,25 @@ static void UicSetupAutoTarget(
     std::vector<std::string> uiFileFiles;
     std::vector<std::string> uiFileOptions;
     {
-      std::set<std::string> skipped;
-      skipped.insert(uicSkipList.begin(), uicSkipList.end());
-
-      const std::vector<cmSourceFile*> uiFilesWithOptions =
-        makefile->GetQtUiFilesWithOptions();
-      for (std::vector<cmSourceFile*>::const_iterator fileIt =
-             uiFilesWithOptions.begin();
-           fileIt != uiFilesWithOptions.end(); ++fileIt) {
-        cmSourceFile* sf = *fileIt;
-        const std::string absFile =
-          cmsys::SystemTools::GetRealPath(sf->GetFullPath());
-        if (skipped.insert(absFile).second) {
-          // The file wasn't skipped
-          uiFileFiles.push_back(absFile);
-          {
-            std::string opts = sf->GetProperty("AUTOUIC_OPTIONS");
-            cmSystemTools::ReplaceString(opts, ";",
-                                         cmQtAutoGeneratorCommon::listSep);
-            uiFileOptions.push_back(opts);
+      const std::string uiExt = "ui";
+      const std::vector<cmSourceFile*>& srcFiles = makefile->GetSourceFiles();
+      for (std::vector<cmSourceFile*>::const_iterator fit = srcFiles.begin();
+           fit != srcFiles.end(); ++fit) {
+        cmSourceFile* sf = *fit;
+        // sf->GetExtension() is only valid after sf->GetFullPath() ...
+        const std::string& fPath = sf->GetFullPath();
+        if (sf->GetExtension() == uiExt) {
+          // Check if the files has uic options
+          std::string uicOpts = sf->GetProperty("AUTOUIC_OPTIONS");
+          if (!uicOpts.empty()) {
+            const std::string absFile = cmsys::SystemTools::GetRealPath(fPath);
+            // Check if file isn't skipped
+            if (setup.uicSkip.count(absFile) == 0) {
+              uiFileFiles.push_back(absFile);
+              cmSystemTools::ReplaceString(uicOpts, ";",
+                                           cmQtAutoGeneratorCommon::listSep);
+              uiFileOptions.push_back(uicOpts);
+            }
           }
         }
       }
@@ -533,30 +561,30 @@ static void UicSetupAutoTarget(
   // Uic executable
   {
     std::string err;
-    const char* uicExec = CM_NULLPTR;
+    std::string uicExec;
+
     if (qtMajorVersion == "5") {
-      cmGeneratorTarget* qt5Uic = lg->FindGeneratorTargetToUse("Qt5::uic");
-      if (qt5Uic != CM_NULLPTR) {
-        uicExec = qt5Uic->ImportedGetLocation("");
+      cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt5::uic");
+      if (tgt != CM_NULLPTR) {
+        uicExec = SafeString(tgt->ImportedGetLocation(""));
       } else {
         // Project does not use Qt5Widgets, but has AUTOUIC ON anyway
       }
     } else if (qtMajorVersion == "4") {
-      cmGeneratorTarget* qt4Uic = lg->FindGeneratorTargetToUse("Qt4::uic");
-      if (qt4Uic != CM_NULLPTR) {
-        uicExec = qt4Uic->ImportedGetLocation("");
+      cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt4::uic");
+      if (tgt != CM_NULLPTR) {
+        uicExec = SafeString(tgt->ImportedGetLocation(""));
       } else {
-        err = "Qt4::uic target not found " + target->GetName();
+        err = "AUTOUIC: Qt4::uic target not found";
       }
     } else {
-      err = "The CMAKE_AUTOUIC feature supports only Qt 4 and Qt 5 ";
-      err += target->GetName();
+      err = "The AUTOUIC feature supports only Qt 4 and Qt 5";
     }
-    // Add definition or error
+
     if (err.empty()) {
-      AddDefinitionEscaped(makefile, "_qt_uic_executable",
-                           uicExec ? uicExec : "");
+      AddDefinitionEscaped(makefile, "_qt_uic_executable", uicExec);
     } else {
+      err += " (" + target->GetName() + ")";
       cmSystemTools::Error(err.c_str());
     }
   }
@@ -566,27 +594,30 @@ static std::string RccGetExecutable(cmGeneratorTarget const* target,
                                     const std::string& qtMajorVersion)
 {
   std::string rccExec;
-  cmLocalGenerator* lg = target->GetLocalGenerator();
+  std::string err;
+
+  cmLocalGenerator* localGen = target->GetLocalGenerator();
   if (qtMajorVersion == "5") {
-    cmGeneratorTarget* qt5Rcc = lg->FindGeneratorTargetToUse("Qt5::rcc");
-    if (qt5Rcc != CM_NULLPTR) {
-      rccExec = qt5Rcc->ImportedGetLocation("");
+    cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt5::rcc");
+    if (tgt != CM_NULLPTR) {
+      rccExec = SafeString(tgt->ImportedGetLocation(""));
     } else {
-      cmSystemTools::Error("Qt5::rcc target not found ",
-                           target->GetName().c_str());
+      err = "AUTORCC: Qt5::rcc target not found";
     }
   } else if (qtMajorVersion == "4") {
-    cmGeneratorTarget* qt4Rcc = lg->FindGeneratorTargetToUse("Qt4::rcc");
-    if (qt4Rcc != CM_NULLPTR) {
-      rccExec = qt4Rcc->ImportedGetLocation("");
+    cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse("Qt4::rcc");
+    if (tgt != CM_NULLPTR) {
+      rccExec = SafeString(tgt->ImportedGetLocation(""));
     } else {
-      cmSystemTools::Error("Qt4::rcc target not found ",
-                           target->GetName().c_str());
+      err = "AUTORCC: Qt4::rcc target not found";
     }
   } else {
-    cmSystemTools::Error(
-      "The CMAKE_AUTORCC feature supports only Qt 4 and Qt 5 ",
-      target->GetName().c_str());
+    err = "The AUTORCC feature supports only Qt 4 and Qt 5";
+  }
+
+  if (!err.empty()) {
+    err += " (" + target->GetName() + ")";
+    cmSystemTools::Error(err.c_str());
   }
   return rccExec;
 }
@@ -628,38 +659,38 @@ static void RccMergeOptions(std::vector<std::string>& opts,
   opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
 }
 
-static void RccSetupAutoTarget(cmGeneratorTarget const* target,
-                               const std::string& qtMajorVersion)
+static void SetupAutoTargetRcc(cmGeneratorTarget const* target,
+                               const std::string& qtMajorVersion,
+                               const std::vector<cmSourceFile*>& srcFiles)
 {
   cmMakefile* makefile = target->Target->GetMakefile();
   const bool qtMajorVersion5 = (qtMajorVersion == "5");
   const std::string rccCommand = RccGetExecutable(target, qtMajorVersion);
-  std::vector<std::string> _rcc_files;
-  std::vector<std::string> _rcc_inputs;
+  std::vector<std::string> rccFiles;
+  std::vector<std::string> rccInputs;
   std::vector<std::string> rccFileFiles;
   std::vector<std::string> rccFileOptions;
   std::vector<std::string> rccOptionsTarget;
-  if (const char* opts = target->GetProperty("AUTORCC_OPTIONS")) {
-    cmSystemTools::ExpandListArgument(opts, rccOptionsTarget);
-  }
 
-  std::vector<cmSourceFile*> srcFiles;
-  target->GetConfigCommonSourceFiles(srcFiles);
+  cmSystemTools::ExpandListArgument(GetSafeProperty(target, "AUTORCC_OPTIONS"),
+                                    rccOptionsTarget);
+
   for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
        fileIt != srcFiles.end(); ++fileIt) {
     cmSourceFile* sf = *fileIt;
+    // sf->GetExtension() is only valid after sf->GetFullPath() ...
+    const std::string& fPath = sf->GetFullPath();
     if ((sf->GetExtension() == "qrc") &&
-        !PropertyEnabled(sf, "SKIP_AUTOGEN") &&
-        !PropertyEnabled(sf, "SKIP_AUTORCC")) {
-      const std::string absFile =
-        cmsys::SystemTools::GetRealPath(sf->GetFullPath());
+        !sf->GetPropertyAsBool("SKIP_AUTOGEN") &&
+        !sf->GetPropertyAsBool("SKIP_AUTORCC")) {
+      const std::string absFile = cmsys::SystemTools::GetRealPath(fPath);
       // qrc file
-      _rcc_files.push_back(absFile);
+      rccFiles.push_back(absFile);
       // qrc file entries
       {
         std::string entriesList = "{";
         // Read input file list only for non generated .qrc files.
-        if (!PropertyEnabled(sf, "GENERATED")) {
+        if (!sf->GetPropertyAsBool("GENERATED")) {
           std::string error;
           std::vector<std::string> files;
           if (cmQtAutoGeneratorCommon::RccListInputs(
@@ -670,7 +701,7 @@ static void RccSetupAutoTarget(cmGeneratorTarget const* target,
           }
         }
         entriesList += "}";
-        _rcc_inputs.push_back(entriesList);
+        rccInputs.push_back(entriesList);
       }
       // rcc options for this qrc file
       {
@@ -692,44 +723,50 @@ static void RccSetupAutoTarget(cmGeneratorTarget const* target,
   }
 
   AddDefinitionEscaped(makefile, "_qt_rcc_executable", rccCommand);
-  AddDefinitionEscaped(makefile, "_rcc_files", _rcc_files);
-  AddDefinitionEscaped(makefile, "_rcc_inputs", _rcc_inputs);
+  AddDefinitionEscaped(makefile, "_rcc_files", rccFiles);
+  AddDefinitionEscaped(makefile, "_rcc_inputs", rccInputs);
   AddDefinitionEscaped(makefile, "_rcc_options_files", rccFileFiles);
   AddDefinitionEscaped(makefile, "_rcc_options_options", rccFileOptions);
 }
 
 void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
-  cmLocalGenerator* lg, cmGeneratorTarget* target)
+  cmLocalGenerator* localGen, cmGeneratorTarget* target)
 {
   cmMakefile* makefile = target->Target->GetMakefile();
+  cmGlobalGenerator* globalGen = localGen->GetGlobalGenerator();
 
   // Create a custom target for running generators at buildtime
   const bool mocEnabled = target->GetPropertyAsBool("AUTOMOC");
   const bool uicEnabled = target->GetPropertyAsBool("AUTOUIC");
   const bool rccEnabled = target->GetPropertyAsBool("AUTORCC");
-  const bool multiConfig = IsMultiConfig(target->GetGlobalGenerator());
+  const bool multiConfig = AutogenMultiConfig(globalGen);
   const std::string autogenTargetName = GetAutogenTargetName(target);
   const std::string autogenBuildDir = GetAutogenTargetBuildDir(target);
   const std::string workingDirectory =
     cmSystemTools::CollapseFullPath("", makefile->GetCurrentBinaryDirectory());
-  const std::string qtMajorVersion = GetQtMajorVersion(target);
-  const std::string rccCommand = RccGetExecutable(target, qtMajorVersion);
   const std::vector<std::string> suffixes = GetConfigurationSuffixes(makefile);
   std::set<std::string> autogenDependsSet;
   std::vector<std::string> autogenProvides;
 
+  bool usePRE_BUILD = false;
+  if (globalGen->GetName().find("Visual Studio") != std::string::npos) {
+    // Under VS use a PRE_BUILD event instead of a separate target to
+    // reduce the number of targets loaded into the IDE.
+    // This also works around a VS 11 bug that may skip updating the target:
+    //  https://connect.microsoft.com/VisualStudio/feedback/details/769495
+    usePRE_BUILD = true;
+  }
+
   // Remove build directories on cleanup
-  makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES",
-                           autogenBuildDir.c_str(), false);
+  AddCleanFile(makefile, autogenBuildDir);
 
   // Remove old settings on cleanup
   {
     std::string base = GetAutogenTargetFilesDir(target);
+    base += "/AutogenOldSettings";
     for (std::vector<std::string>::const_iterator it = suffixes.begin();
          it != suffixes.end(); ++it) {
-      std::string fname = base + "/AutogenOldSettings" + *it + ".cmake";
-      makefile->AppendProperty("ADDITIONAL_MAKE_CLEAN_FILES", fname.c_str(),
-                               false);
+      AddCleanFile(makefile, base + *it + ".cmake");
     }
   }
 
@@ -787,25 +824,16 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
     target->AddIncludeDirectory(includeDir, true);
   }
 
-#if defined(_WIN32) && !defined(__CYGWIN__)
-  bool usePRE_BUILD = false;
-  cmGlobalGenerator* gg = lg->GetGlobalGenerator();
-  if (gg->GetName().find("Visual Studio") != std::string::npos) {
-    // Under VS use a PRE_BUILD event instead of a separate target to
-    // reduce the number of targets loaded into the IDE.
-    // This also works around a VS 11 bug that may skip updating the target:
-    //  https://connect.microsoft.com/VisualStudio/feedback/details/769495
-    usePRE_BUILD = true;
-  }
-#endif
-
-  // Initialize autogen target dependencies
-  if (const char* deps = target->GetProperty("AUTOGEN_TARGET_DEPENDS")) {
-    std::vector<std::string> extraDepends;
-    cmSystemTools::ExpandListArgument(deps, extraDepends);
-    autogenDependsSet.insert(extraDepends.begin(), extraDepends.end());
+  // Add user defined autogen target dependencies
+  {
+    const std::string deps = GetSafeProperty(target, "AUTOGEN_TARGET_DEPENDS");
+    if (!deps.empty()) {
+      std::vector<std::string> extraDepends;
+      cmSystemTools::ExpandListArgument(deps, extraDepends);
+      autogenDependsSet.insert(extraDepends.begin(), extraDepends.end());
+    }
   }
-  // Add other target dependencies autogen dependencies
+  // Add utility target dependencies to the autogen dependencies
   {
     const std::set<std::string>& utils = target->Target->GetUtilities();
     for (std::set<std::string>::const_iterator it = utils.begin();
@@ -816,7 +844,7 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
       }
     }
   }
-  // Add link library targets to the autogen dependencies
+  // Add link library target dependencies to the autogen dependencies
   {
     const cmTarget::LinkLibraryVectorType& libVec =
       target->Target->GetOriginalLinkLibraries();
@@ -828,106 +856,127 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
       }
     }
   }
+
+  // Extract relevant source files
+  std::vector<std::string> generatedSources;
+  std::vector<std::pair<std::string, bool> > qrcSources;
   {
-    cmFilePathChecksum fpathCheckSum(makefile);
-    // Iterate over all source files
+    const std::string qrcExt = "qrc";
     std::vector<cmSourceFile*> srcFiles;
     target->GetConfigCommonSourceFiles(srcFiles);
     for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
          fileIt != srcFiles.end(); ++fileIt) {
       cmSourceFile* sf = *fileIt;
-      if (!PropertyEnabled(sf, "SKIP_AUTOGEN")) {
-        std::string const& ext = sf->GetExtension();
-        // Add generated file that will be scanned by moc or uic to
-        // the dependencies
-        if (mocEnabled || uicEnabled) {
-          const cmSystemTools::FileFormat fileType =
-            cmSystemTools::GetFileFormat(ext.c_str());
-          if ((fileType == cmSystemTools::CXX_FILE_FORMAT) ||
-              (fileType == cmSystemTools::HEADER_FILE_FORMAT)) {
-            if (PropertyEnabled(sf, "GENERATED")) {
-              if ((mocEnabled && !PropertyEnabled(sf, "SKIP_AUTOMOC")) ||
-                  (uicEnabled && !PropertyEnabled(sf, "SKIP_AUTOUIC"))) {
-                autogenDependsSet.insert(
-                  cmsys::SystemTools::GetRealPath(sf->GetFullPath()));
-#if defined(_WIN32) && !defined(__CYGWIN__)
-                // Cannot use PRE_BUILD with generated files
-                usePRE_BUILD = false;
-#endif
-              }
+      if (sf->GetPropertyAsBool("SKIP_AUTOGEN")) {
+        continue;
+      }
+      // sf->GetExtension() is only valid after sf->GetFullPath() ...
+      const std::string& fPath = sf->GetFullPath();
+      const std::string& ext = sf->GetExtension();
+      // Register generated files that will be scanned by moc or uic
+      if (mocEnabled || uicEnabled) {
+        const cmSystemTools::FileFormat fileType =
+          cmSystemTools::GetFileFormat(ext.c_str());
+        if ((fileType == cmSystemTools::CXX_FILE_FORMAT) ||
+            (fileType == cmSystemTools::HEADER_FILE_FORMAT)) {
+          if (sf->GetPropertyAsBool("GENERATED")) {
+            if ((mocEnabled && !sf->GetPropertyAsBool("SKIP_AUTOMOC")) ||
+                (uicEnabled && !sf->GetPropertyAsBool("SKIP_AUTOUIC"))) {
+              generatedSources.push_back(
+                cmsys::SystemTools::GetRealPath(fPath));
             }
           }
         }
-        // Process rcc enabled files
-        if (rccEnabled && (ext == "qrc") &&
-            !PropertyEnabled(sf, "SKIP_AUTORCC")) {
-          const std::string absFile =
-            cmsys::SystemTools::GetRealPath(sf->GetFullPath());
-
-          // Compose rcc output file name
-          {
-            std::string rccBuildFile = autogenBuildDir + "/";
-            rccBuildFile += fpathCheckSum.getPart(absFile);
-            rccBuildFile += "/qrc_";
-            rccBuildFile +=
-              cmsys::SystemTools::GetFilenameWithoutLastExtension(absFile);
-            rccBuildFile += ".cpp";
-
-            // Register rcc ouput file as generated
-            AddGeneratedSource(target, rccBuildFile,
-                               cmQtAutoGeneratorCommon::RCC);
-            // Register rcc ouput file as generated by the _autogen target
-            autogenProvides.push_back(rccBuildFile);
-          }
+      }
+      // Register rcc enabled files
+      if (rccEnabled && (ext == qrcExt) &&
+          !sf->GetPropertyAsBool("SKIP_AUTORCC")) {
+        qrcSources.push_back(
+          std::pair<std::string, bool>(cmsys::SystemTools::GetRealPath(fPath),
+                                       sf->GetPropertyAsBool("GENERATED")));
+      }
+    }
+    // cmGeneratorTarget::GetConfigCommonSourceFiles computes the target's
+    // sources meta data cache. Clear it so that OBJECT library targets that
+    // are AUTOGEN initialized after this target get their added
+    // mocs_compilation.cpp source acknowledged by this target.
+    target->ClearSourcesCache();
+  }
+
+  if (!generatedSources.empty()) {
+    for (std::vector<std::string>::const_iterator it =
+           generatedSources.begin();
+         it != generatedSources.end(); ++it) {
+      autogenDependsSet.insert(*it);
+    }
+  }
+
+  if (!qrcSources.empty()) {
+    const std::string qtMajorVersion = GetQtMajorVersion(target);
+    const std::string rccCommand = RccGetExecutable(target, qtMajorVersion);
+    const cmFilePathChecksum fpathCheckSum(makefile);
+    for (std::vector<std::pair<std::string, bool> >::const_iterator it =
+           qrcSources.begin();
+         it != qrcSources.end(); ++it) {
+      const std::string& absFile = it->first;
+
+      // Compose rcc output file name
+      {
+        std::string rccBuildFile = autogenBuildDir + "/";
+        rccBuildFile += fpathCheckSum.getPart(absFile);
+        rccBuildFile += "/qrc_";
+        rccBuildFile +=
+          cmsys::SystemTools::GetFilenameWithoutLastExtension(absFile);
+        rccBuildFile += ".cpp";
+
+        // Register rcc ouput file as generated
+        AddGeneratedSource(target, rccBuildFile, cmQtAutoGeneratorCommon::RCC);
+        // Register rcc ouput file as generated by the _autogen target
+        autogenProvides.push_back(rccBuildFile);
+      }
 
-          if (PropertyEnabled(sf, "GENERATED")) {
-            // Add generated qrc file to the dependencies
-            autogenDependsSet.insert(absFile);
+      if (it->second) {
+        // Add generated qrc file to the dependencies
+        autogenDependsSet.insert(absFile);
+      } else {
+        // Run cmake again when .qrc file changes
+        makefile->AddCMakeDependFile(absFile);
+        // Add the qrc input files to the dependencies
+        {
+          std::string error;
+          std::vector<std::string> extraDepends;
+          if (cmQtAutoGeneratorCommon::RccListInputs(
+                qtMajorVersion, rccCommand, absFile, extraDepends, &error)) {
+            autogenDependsSet.insert(extraDepends.begin(), extraDepends.end());
           } else {
-            // Run cmake again when .qrc file changes
-            makefile->AddCMakeDependFile(absFile);
-            // Add the qrc input files to the dependencies
-            {
-              std::string error;
-              std::vector<std::string> extraDepends;
-              if (cmQtAutoGeneratorCommon::RccListInputs(
-                    qtMajorVersion, rccCommand, absFile, extraDepends,
-                    &error)) {
-                autogenDependsSet.insert(extraDepends.begin(),
-                                         extraDepends.end());
-              } else {
-                cmSystemTools::Error(error.c_str());
-              }
-            }
+            cmSystemTools::Error(error.c_str());
           }
-#if defined(_WIN32) && !defined(__CYGWIN__)
-          // Cannot use PRE_BUILD because the resource files themselves
-          // may not be sources within the target so VS may not know the
-          // target needs to re-build at all.
-          usePRE_BUILD = false;
-#endif
         }
       }
     }
   }
 
-  // cmGeneratorTarget::GetConfigCommonSourceFiles computes the target's
-  // sources meta data cache. Clear it so that OBJECT library targets that
-  // are AUTOGEN initialized after this target get their added
-  // mocs_compilation.cpp source acknowledged by this target.
-  target->ClearSourcesCache();
-
   // Convert std::set to std::vector
   const std::vector<std::string> autogenDepends(autogenDependsSet.begin(),
                                                 autogenDependsSet.end());
-#if defined(_WIN32) && !defined(__CYGWIN__)
+  // Disable PRE_BUILD on demand
   if (usePRE_BUILD) {
-    // If the autogen target depends on an other target don't use PRE_BUILD
-    for (std::vector<std::string>::const_iterator it = autogenDepends.begin();
-         it != autogenDepends.end(); ++it) {
-      if (makefile->FindTargetToUse(*it) != CM_NULLPTR) {
-        usePRE_BUILD = false;
-        break;
+    if (!generatedSources.empty() || !qrcSources.empty()) {
+      // - Cannot use PRE_BUILD with generated files
+      // - Cannot use PRE_BUILD because the resource files themselves
+      // may not be sources within the target so VS may not know the
+      // target needs to re-build at all.
+      usePRE_BUILD = false;
+    }
+    if (usePRE_BUILD) {
+      // If the autogen target depends on an other target don't use PRE_BUILD
+      for (std::vector<std::string>::const_iterator it =
+             autogenDepends.begin();
+           it != autogenDepends.end(); ++it) {
+        if (makefile->FindTargetToUse(*it) != CM_NULLPTR) {
+          usePRE_BUILD = false;
+          break;
+        }
       }
     }
   }
@@ -942,31 +991,33 @@ void cmQtAutoGeneratorInitializer::InitializeAutogenTarget(
     cc.SetEscapeOldStyle(false);
     cc.SetEscapeAllowMakeVars(true);
     target->Target->AddPreBuildCommand(cc);
-  } else
-#endif
-  {
+  } else {
     cmTarget* autogenTarget = makefile->AddUtilityCommand(
       autogenTargetName, true, workingDirectory.c_str(),
       /*byproducts=*/autogenProvides, autogenDepends, commandLines, false,
       autogenComment.c_str());
 
-    cmGeneratorTarget* gt = new cmGeneratorTarget(autogenTarget, lg);
-    lg->AddGeneratorTarget(gt);
+    localGen->AddGeneratorTarget(
+      new cmGeneratorTarget(autogenTarget, localGen));
 
-    // Set target folder
-    const char* autogenFolder =
-      makefile->GetState()->GetGlobalProperty("AUTOMOC_TARGETS_FOLDER");
-    if (!autogenFolder) {
-      autogenFolder =
-        makefile->GetState()->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER");
-    }
-    if (autogenFolder && *autogenFolder) {
-      autogenTarget->SetProperty("FOLDER", autogenFolder);
-    } else {
-      // inherit FOLDER property from target (#13688)
-      utilCopyTargetProperty(gt->Target, target->Target, "FOLDER");
+    // Set autogen target FOLDER
+    {
+      const char* autogenFolder =
+        makefile->GetState()->GetGlobalProperty("AUTOMOC_TARGETS_FOLDER");
+      if (autogenFolder == CM_NULLPTR) {
+        autogenFolder =
+          makefile->GetState()->GetGlobalProperty("AUTOGEN_TARGETS_FOLDER");
+      }
+      // Inherit FOLDER property from target (#13688)
+      if (autogenFolder == CM_NULLPTR) {
+        autogenFolder = target->Target->GetProperty("FOLDER");
+      }
+      if ((autogenFolder != CM_NULLPTR) && (*autogenFolder != '\0')) {
+        autogenTarget->SetProperty("FOLDER", autogenFolder);
+      }
     }
 
+    // Add autogen target to the origin target dependencies
     target->Target->AddUtility(autogenTargetName);
   }
 }
@@ -984,54 +1035,46 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
   std::string config;
   const std::vector<std::string> configs(GetConfigurations(makefile, &config));
 
-  // Configurations settings buffers
+  // Configuration suffixes
   std::map<std::string, std::string> configSuffix;
-  std::map<std::string, std::string> configMocIncludes;
-  std::map<std::string, std::string> configMocDefines;
-  std::map<std::string, std::string> configUicOptions;
-
-  // Configuration suffix
-  if (IsMultiConfig(target->GetGlobalGenerator())) {
+  if (AutogenMultiConfig(target->GetGlobalGenerator())) {
     for (std::vector<std::string>::const_iterator it = configs.begin();
          it != configs.end(); ++it) {
-      configSuffix[*it] = cmOutputConverter::EscapeForCMake("_" + *it);
+      configSuffix[*it] = "_" + *it;
     }
   }
 
+  // Configurations settings buffers
+  AutogenSetup setup;
+
   // Basic setup
   {
     const bool mocEnabled = target->GetPropertyAsBool("AUTOMOC");
     const bool uicEnabled = target->GetPropertyAsBool("AUTOUIC");
     const bool rccEnabled = target->GetPropertyAsBool("AUTORCC");
-    const std::string autogenTargetName = GetAutogenTargetName(target);
     const std::string qtMajorVersion = GetQtMajorVersion(target);
-
-    std::vector<std::string> sources;
-    std::vector<std::string> headers;
-
-    if (mocEnabled || uicEnabled || rccEnabled) {
-      std::vector<std::string> mocSkipList;
-      std::vector<std::string> uicSkipList;
-      AcquireScanFiles(target, sources, headers, mocSkipList, uicSkipList);
-      if (mocEnabled) {
-        MocSetupAutoTarget(target, autogenTargetName, qtMajorVersion, config,
-                           configs, mocSkipList, configMocIncludes,
-                           configMocDefines);
-      }
-      if (uicEnabled) {
-        UicSetupAutoTarget(target, qtMajorVersion, config, configs,
-                           uicSkipList, configUicOptions);
+    {
+      std::vector<cmSourceFile*> srcFiles;
+      target->GetConfigCommonSourceFiles(srcFiles);
+      if (mocEnabled || uicEnabled) {
+        SetupAcquireScanFiles(target, mocEnabled, uicEnabled, srcFiles, setup);
+        if (mocEnabled) {
+          SetupAutoTargetMoc(target, qtMajorVersion, config, configs, setup);
+        }
+        if (uicEnabled) {
+          SetupAutoTargetUic(target, qtMajorVersion, config, configs, setup);
+        }
       }
       if (rccEnabled) {
-        RccSetupAutoTarget(target, qtMajorVersion);
+        SetupAutoTargetRcc(target, qtMajorVersion, srcFiles);
       }
     }
 
-    AddDefinitionEscaped(makefile, "_autogen_build_dir",
+    AddDefinitionEscaped(makefile, "_build_dir",
                          GetAutogenTargetBuildDir(target));
     AddDefinitionEscaped(makefile, "_qt_version_major", qtMajorVersion);
-    AddDefinitionEscaped(makefile, "_sources", sources);
-    AddDefinitionEscaped(makefile, "_headers", headers);
+    AddDefinitionEscaped(makefile, "_sources", setup.sources);
+    AddDefinitionEscaped(makefile, "_headers", setup.headers);
   }
 
   // Generate info file
@@ -1044,8 +1087,8 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
   }
 
   // Append custom definitions to info file on demand
-  if (!configSuffix.empty() || !configMocDefines.empty() ||
-      !configMocIncludes.empty() || !configUicOptions.empty()) {
+  if (!configSuffix.empty() || !setup.configMocDefines.empty() ||
+      !setup.configMocIncludes.empty() || !setup.configUicOptions.empty()) {
 
     // Ensure we have write permission in case .in was read-only.
     mode_t perm = 0;
@@ -1067,29 +1110,29 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
              it = configSuffix.begin(),
              end = configSuffix.end();
            it != end; ++it) {
-        ofs << "set(AM_CONFIG_SUFFIX_" << it->first << " " << it->second
-            << ")\n";
+        ofs << "set(AM_CONFIG_SUFFIX_" << it->first << " "
+            << cmOutputConverter::EscapeForCMake(it->second) << ")\n";
       }
       for (std::map<std::string, std::string>::iterator
-             it = configMocDefines.begin(),
-             end = configMocDefines.end();
+             it = setup.configMocDefines.begin(),
+             end = setup.configMocDefines.end();
            it != end; ++it) {
-        ofs << "set(AM_MOC_DEFINITIONS_" << it->first << " " << it->second
-            << ")\n";
+        ofs << "set(AM_MOC_DEFINITIONS_" << it->first << " "
+            << cmOutputConverter::EscapeForCMake(it->second) << ")\n";
       }
       for (std::map<std::string, std::string>::iterator
-             it = configMocIncludes.begin(),
-             end = configMocIncludes.end();
+             it = setup.configMocIncludes.begin(),
+             end = setup.configMocIncludes.end();
            it != end; ++it) {
-        ofs << "set(AM_MOC_INCLUDES_" << it->first << " " << it->second
-            << ")\n";
+        ofs << "set(AM_MOC_INCLUDES_" << it->first << " "
+            << cmOutputConverter::EscapeForCMake(it->second) << ")\n";
       }
       for (std::map<std::string, std::string>::iterator
-             it = configUicOptions.begin(),
-             end = configUicOptions.end();
+             it = setup.configUicOptions.begin(),
+             end = setup.configUicOptions.end();
            it != end; ++it) {
-        ofs << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " " << it->second
-            << ")\n";
+        ofs << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " "
+            << cmOutputConverter::EscapeForCMake(it->second) << ")\n";
       }
     } else {
       // File open error
diff --git a/Source/cmQtAutoGeneratorInitializer.h b/Source/cmQtAutoGeneratorInitializer.h
index 11f6e1e..48ae70e 100644
--- a/Source/cmQtAutoGeneratorInitializer.h
+++ b/Source/cmQtAutoGeneratorInitializer.h
@@ -11,7 +11,7 @@ class cmLocalGenerator;
 class cmQtAutoGeneratorInitializer
 {
 public:
-  static void InitializeAutogenTarget(cmLocalGenerator* lg,
+  static void InitializeAutogenTarget(cmLocalGenerator* localGen,
                                       cmGeneratorTarget* target);
   static void SetupAutoGenerateTarget(cmGeneratorTarget const* target);
 };
diff --git a/Source/cmSourceFile.cxx b/Source/cmSourceFile.cxx
index 5c4f18b..baf95c5 100644
--- a/Source/cmSourceFile.cxx
+++ b/Source/cmSourceFile.cxx
@@ -17,8 +17,6 @@ cmSourceFile::cmSourceFile(cmMakefile* mf, const std::string& name)
 {
   this->CustomCommand = CM_NULLPTR;
   this->FindFullPathFailed = false;
-  this->IsUiFile = (".ui" == cmSystemTools::GetFilenameLastExtension(
-                               this->Location.GetName()));
 }
 
 cmSourceFile::~cmSourceFile()
@@ -245,13 +243,6 @@ bool cmSourceFile::Matches(cmSourceFileLocation const& loc)
 void cmSourceFile::SetProperty(const std::string& prop, const char* value)
 {
   this->Properties.SetProperty(prop, value);
-
-  if (this->IsUiFile) {
-    cmMakefile const* mf = this->Location.GetMakefile();
-    if (prop == "AUTOUIC_OPTIONS") {
-      const_cast<cmMakefile*>(mf)->AddQtUiFileWithOptions(this);
-    }
-  }
 }
 
 void cmSourceFile::AppendProperty(const std::string& prop, const char* value,
diff --git a/Source/cmSourceFile.h b/Source/cmSourceFile.h
index e739d18..91f783d 100644
--- a/Source/cmSourceFile.h
+++ b/Source/cmSourceFile.h
@@ -107,7 +107,6 @@ private:
   std::string ObjectLibrary;
   std::vector<std::string> Depends;
   bool FindFullPathFailed;
-  bool IsUiFile;
 
   bool FindFullPath(std::string* error);
   bool TryFullPath(const std::string& path, const std::string& ext);
diff --git a/Tests/QtAutogen/CMakeLists.txt b/Tests/QtAutogen/CMakeLists.txt
index be864c3..81ab734 100644
--- a/Tests/QtAutogen/CMakeLists.txt
+++ b/Tests/QtAutogen/CMakeLists.txt
@@ -114,16 +114,27 @@ target_compile_features(empty PRIVATE ${QT_COMPILE_FEATURES})
 # -- Test
 # Test for SKIP_AUTOMOC and SKIP_AUTOGEN on an AUTOMOC enabled target
 if(ALLOW_WRAP_CPP)
+  # Generate header mocs manually
   qtx_wrap_cpp(skipMocWrapMoc
     skipSource/qItemA.hpp
-    skipSource/qItemB.hpp)
+    skipSource/qItemB.hpp
+    skipSource/qItemC.hpp
+    skipSource/qItemD.hpp
+    )
   set(skipMocSources
     skipMoc.cpp
     skipSource/qItemA.cpp
     skipSource/qItemB.cpp
-    skipSource/qItemC.cpp)
+    skipSource/qItemC.cpp
+    skipSource/qItemD.cpp
+    )
+  # When cpp files are skipped, the hpp won't be processed either,
+  # unless they are mentioned in the sources - which they aren't.
   set_property(SOURCE skipSource/qItemA.cpp PROPERTY SKIP_AUTOMOC ON)
   set_property(SOURCE skipSource/qItemB.cpp PROPERTY SKIP_AUTOGEN ON)
+  # When hpp files are skipped, the cpp still get processed.
+  set_property(SOURCE skipSource/qItemC.hpp PROPERTY SKIP_AUTOMOC ON)
+  set_property(SOURCE skipSource/qItemD.hpp PROPERTY SKIP_AUTOGEN ON)
   # AUTOMOC enabled only
   add_executable(skipMocA ${skipMocSources} ${skipMocWrapMoc})
   set_property(TARGET skipMocA PROPERTY AUTOMOC ON)
diff --git a/Tests/QtAutogen/skipMoc.cpp b/Tests/QtAutogen/skipMoc.cpp
index 85305f5..d6b292f 100644
--- a/Tests/QtAutogen/skipMoc.cpp
+++ b/Tests/QtAutogen/skipMoc.cpp
@@ -2,12 +2,14 @@
 #include "skipSource/qItemA.hpp"
 #include "skipSource/qItemB.hpp"
 #include "skipSource/qItemC.hpp"
+#include "skipSource/qItemD.hpp"
 
 int main(int, char**)
 {
   QItemA itemA;
-  QItemA itemB;
-  QItemA itemC;
+  QItemB itemB;
+  QItemC itemC;
+  QItemD itemD;
 
   // Fails to link if the symbol is not present.
   return 0;
diff --git a/Tests/QtAutogen/skipSource/qItemC.cpp b/Tests/QtAutogen/skipSource/qItemC.cpp
index 700abd6..622f282 100644
--- a/Tests/QtAutogen/skipSource/qItemC.cpp
+++ b/Tests/QtAutogen/skipSource/qItemC.cpp
@@ -1,5 +1,17 @@
 #include "qItemC.hpp"
 
+class QItemC_Local : public QObject
+{
+  Q_OBJECT
+public:
+  QItemC_Local(){};
+  ~QItemC_Local(){};
+};
+
 void QItemC::go()
 {
+  QItemC_Local localObject;
 }
+
+// We need AUTOMOC processing
+#include "qItemC.moc"
diff --git a/Tests/QtAutogen/skipSource/qItemD.cpp b/Tests/QtAutogen/skipSource/qItemD.cpp
new file mode 100644
index 0000000..fe0f4e4
--- /dev/null
+++ b/Tests/QtAutogen/skipSource/qItemD.cpp
@@ -0,0 +1,17 @@
+#include "qItemD.hpp"
+
+class QItemD_Local : public QObject
+{
+  Q_OBJECT
+public:
+  QItemD_Local(){};
+  ~QItemD_Local(){};
+};
+
+void QItemD::go()
+{
+  QItemD_Local localObject;
+}
+
+// We need AUTOMOC processing
+#include "qItemD.moc"
diff --git a/Tests/QtAutogen/skipSource/qItemD.hpp b/Tests/QtAutogen/skipSource/qItemD.hpp
new file mode 100644
index 0000000..99e0acb
--- /dev/null
+++ b/Tests/QtAutogen/skipSource/qItemD.hpp
@@ -0,0 +1,13 @@
+#ifndef QITEMD_HPP
+#define QITEMD_HPP
+
+#include <QObject>
+
+class QItemD : public QObject
+{
+  Q_OBJECT
+  Q_SLOT
+  void go();
+};
+
+#endif