Merge topic 'autogen_json'

29d96633 Autogen: Don't use .moc include in Q_PLUGIN_METADATA test
d60f1ddc Autogen: Documentation update
cdb72127 Autogen: Add release notes for Q_PLUGIN_METADATA support
8b13a52c Autogen: Tests: Set different compression levels in rcc test
9d1db7d7 Autogen: Overhaul and simplify AutogenInfo.cmake file generation
0ab817fa Autogen: Optimize GetCompileDefinitionsAndDirectories function
754d4318 Autogen: Sort AutogenInfo.cmake.in
cd74daf0 Autogen: Tests: Add Q_PLUGIN_METADATA test
39c4819e Autogen: Tests: Add moc include tests
50805693 Autogen: Tests: Clean comments
c23206b6 Autogen: Log simplifications
347572cf Autogen: Only touch an unchanged moc_compilation.cpp
03df033b Autogen: Rebuild moc when Q_PLUGIN_METADATA json file changes
3ec230de Autogen: Use GetRealPath in central places only
41fb64e7 Autogen: Search moc includes in include directories
175c8900 Autogen: Sort includes before composing include options
...

Help/manual/cmake-qt.7.rst

@@ -63,20 +63,24 @@ If a ``Q_OBJECT`` or ``Q_GADGET`` macro is found in a header file, ``moc``
 will be run on the file.  The result will be put into a file named according
 to ``moc_<basename>.cpp``.  If the macro is found in a C++ implementation
 file, the moc output will be put into a file named according to
-``<basename>.moc``, following the Qt conventions.  The ``moc file`` may be
-included by the user in the C++ implementation file with a preprocessor
-``#include``.  If it is not so included, it will be added to a separate file
-which is compiled into the target.
+``<basename>.moc``, following the Qt conventions.  The ``<basename>.moc`` must
+be included by the user in the C++ implementation file with a preprocessor
+``#include``.
 
-The ``moc`` command line will consume the :prop_tgt:`COMPILE_DEFINITIONS` and
-:prop_tgt:`INCLUDE_DIRECTORIES` target properties from the target it is being
-invoked for, and for the appropriate build configuration.
-
-The generated ``moc_*.cpp`` and ``*.moc`` files are placed in the
+Included ``moc_*.cpp`` and ``*.moc`` files will be generated in the
 ``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/include`` directory which is
 automatically added to the target's :prop_tgt:`INCLUDE_DIRECTORIES`.
 (This differs from CMake 3.7 and below; see their documentation for details.)
 
+Not included ``moc_<basename>.cpp`` files will be generated in custom
+folders to avoid name collisions and included in a separate
+``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/moc_compilation.cpp``
+file which is compiled into the target.
+
+The ``moc`` command line will consume the :prop_tgt:`COMPILE_DEFINITIONS` and
+:prop_tgt:`INCLUDE_DIRECTORIES` target properties from the target it is being
+invoked for, and for the appropriate build configuration.
+
 The :prop_tgt:`AUTOMOC` target property may be pre-set for all
 following targets by setting the :variable:`CMAKE_AUTOMOC` variable.  The
 :prop_tgt:`AUTOMOC_MOC_OPTIONS` target property may be populated to set

Help/prop_tgt/AUTOMOC.rst

@@ -8,31 +8,41 @@ preprocessor automatically, i.e.  without having to use the
 :module:`QT4_WRAP_CPP() <FindQt4>` or QT5_WRAP_CPP() macro.  Currently Qt4 and Qt5 are
 supported.
 
-When this property is set ``ON``, CMake will scan the
+When this property is set ``ON``, CMake will scan the header and
 source files at build time and invoke moc accordingly.
 
-* If an ``#include`` statement like ``#include "moc_foo.cpp"`` is found,
-  the ``Q_OBJECT`` class declaration is expected in the header, and
-  ``moc`` is run on the header file.  A ``moc_foo.cpp`` file will be
-  generated from the source's header into the
-  ``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/include``
-  directory which is automatically added to the target's
+* If an ``#include`` statement like ``#include "moc_<basename>.cpp"`` is found,
+  the ``Q_OBJECT`` or ``Q_GADGET`` macros are expected in an otherwise empty
+  line of the ``<basename>.h(xx)`` header file. ``moc`` is run on the header file to
+  generate ``moc_<basename>.cpp`` in the
+  ``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/include`` directory
+  which is automatically added to the target's
   :prop_tgt:`INCLUDE_DIRECTORIES`.  This allows the compiler to find the
-  included ``moc_foo.cpp`` file regardless of the location the original source.
-  However, if multiple source files in different directories do this then their
-  generated moc files would collide.  In this case a diagnostic will be issued.
-
-* If an ``#include`` statement like ``#include "foo.moc"`` is found,
-  then a ``Q_OBJECT`` is expected in the current source file and ``moc``
-  is run on the file itself.  Additionally, header files with the same
-  base name (like ``foo.h``) or ``_p`` appended to the base name (like
-  ``foo_p.h``) are parsed for ``Q_OBJECT`` macros, and if found, ``moc``
-  is also executed on those files.  ``AUTOMOC`` checks multiple header
-  alternative extensions, such as ``hpp``, ``hxx`` etc when searching
-  for headers.  The resulting moc files, which are not included as shown
-  above in any of the source files are included in a generated
-  ``moc_compilation.cpp`` file, which is compiled as part of the
-  target.
+  included ``moc_<basename>.cpp`` file regardless of the location the
+  original source.
+
+* If an ``#include`` statement like ``#include "<basename>.moc"`` is found,
+  then ``Q_OBJECT`` or ``Q_GADGET`` macros are expected in the current source
+  file and ``moc`` is run on the source file itself.
+
+* Header files that are not included by an ``#include "moc_<basename>.cpp"``
+  statement are nonetheless scanned for ``Q_OBJECT`` or ``Q_GADGET`` macros.
+  The resulting ``moc_<basename>.cpp`` files are generated in custom
+  directories and automatically included in the generated
+  ``<CMAKE_CURRENT_BINARY_DIR>/<TARGETNAME>_autogen/moc_compilation.cpp`` file,
+  which is compiled as part of the target. The custom directories help to
+  avoid name collisions for moc files with the same ``<basename>``.
+
+* Additionally, header files with the same base name as a source file,
+  (like ``<basename>.h``) or ``_p`` appended to the base name (like
+  ``<basename>_p.h``), are parsed for ``Q_OBJECT`` or ``Q_GADGET`` macros,
+  and if found, ``moc`` is also executed on those files.
+
+* ``AUTOMOC`` always checks multiple header alternative extensions,
+  such as ``hpp``, ``hxx``, etc. when searching for headers.
+
+* ``AUTOMOC`` looks for the ``Q_PLUGIN_METADATA`` macro and reruns the
+  ``moc`` when the file addressed by the ``FILE`` argument of the macro changes.
 
 This property is initialized by the value of the :variable:`CMAKE_AUTOMOC`
 variable if it is set when a target is created.

Help/release/dev/Autogen_json.rst

@@ -0,0 +1,10 @@
+AutoGen json
+------------
+
+* When using :prop_tgt:`AUTOMOC`, CMake scans for the presence of the
+  ``Q_PLUGIN_METADATA`` macro and reruns moc when the file from the
+  macro's ``FILE`` argument changes.
+
+* When :prop_tgt:`AUTOMOC` detects an include statement of the form
+  ``#include "moc_<basename>.cpp"`` the respective header file is searched
+  for in the :prop_tgt:`INCLUDE_DIRECTORIES` of the target as well.

Modules/AutogenInfo.cmake.in

@@ -1,25 +1,31 @@
-set(AM_SOURCES @_moc_uic_sources@)
-set(AM_HEADERS @_moc_uic_headers@)
-set(AM_SKIP_MOC @_skip_moc@)
-set(AM_SKIP_UIC @_skip_uic@)
-set(AM_MOC_COMPILE_DEFINITIONS @_moc_compile_defs@)
-set(AM_MOC_INCLUDES @_moc_incs@)
-set(AM_MOC_OPTIONS @_moc_options@)
-set(AM_MOC_RELAXED_MODE "@_moc_relaxed_mode@")
-set(AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE "@CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE@")
+# Target names
+set(AM_TARGET_NAME @_autogen_target_name@)
+set(AM_ORIGIN_TARGET_NAME @_origin_target_name@)
+# Directories and files
 set(AM_CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@/")
 set(AM_CMAKE_SOURCE_DIR "@CMAKE_SOURCE_DIR@/")
-set(AM_QT_MOC_EXECUTABLE "@_qt_moc_executable@")
-set(AM_QT_UIC_EXECUTABLE "@_qt_uic_executable@")
-set(AM_QT_RCC_EXECUTABLE "@_qt_rcc_executable@")
 set(AM_CMAKE_CURRENT_SOURCE_DIR "@CMAKE_CURRENT_SOURCE_DIR@/")
 set(AM_CMAKE_CURRENT_BINARY_DIR "@CMAKE_CURRENT_BINARY_DIR@/")
-set(AM_QT_VERSION_MAJOR "@_target_qt_version@")
-set(AM_TARGET_NAME @_moc_target_name@)
-set(AM_ORIGIN_TARGET_NAME @_origin_target_name@)
+set(AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE "@CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE@")
+set(AM_SOURCES @_sources@)
+set(AM_HEADERS @_headers@)
+# Qt environment
+set(AM_QT_VERSION_MAJOR @_qt_version_major@)
+set(AM_QT_MOC_EXECUTABLE @_qt_moc_executable@)
+set(AM_QT_UIC_EXECUTABLE @_qt_uic_executable@)
+set(AM_QT_RCC_EXECUTABLE @_qt_rcc_executable@)
+# MOC settings
+set(AM_MOC_SKIP @_moc_skip@)
+set(AM_MOC_COMPILE_DEFINITIONS @_moc_compile_defs@)
+set(AM_MOC_INCLUDES @_moc_incs@)
+set(AM_MOC_OPTIONS @_moc_options@)
+set(AM_MOC_RELAXED_MODE @_moc_relaxed_mode@)
+# UIC settings
+set(AM_UIC_SKIP @_uic_skip@)
 set(AM_UIC_TARGET_OPTIONS @_uic_target_options@)
 set(AM_UIC_OPTIONS_FILES @_qt_uic_options_files@)
 set(AM_UIC_OPTIONS_OPTIONS @_qt_uic_options_options@)
+# RCC settings
 set(AM_RCC_SOURCES @_rcc_files@ )
 set(AM_RCC_INPUTS @_rcc_inputs@)
 set(AM_RCC_OPTIONS_FILES @_rcc_options_files@)

Source/cmFilePathChecksum.cxx

@@ -45,7 +45,7 @@ void cmFilePathChecksum::setupParentDirs(const std::string& currentSrcDir,
   parentDirs[3].second = "ProjectBinary";
 }
 
-std::string cmFilePathChecksum::get(const std::string& filePath)
+std::string cmFilePathChecksum::get(const std::string& filePath) const
 {
   std::string relPath;
   std::string relSeed;
@@ -82,7 +82,7 @@ std::string cmFilePathChecksum::get(const std::string& filePath)
 }
 
 std::string cmFilePathChecksum::getPart(const std::string& filePath,
-                                        size_t length)
+                                        size_t length) const
 {
   return get(filePath).substr(0, length);
 }

Source/cmFilePathChecksum.h

@@ -47,13 +47,13 @@ public:
   /* @brief Calculates the path checksum for the parent directory of a file
    *
    */
-  std::string get(const std::string& filePath);
+  std::string get(const std::string& filePath) const;
 
   /* @brief Same as get() but returns only the first length characters
    *
    */
   std::string getPart(const std::string& filePath,
-                      size_t length = partLengthDefault);
+                      size_t length = partLengthDefault) const;
 
 private:
   /// Size of the parent directory list

Source/cmQtAutoGeneratorInitializer.cxx

@@ -22,7 +22,6 @@
 #endif
 
 #include <algorithm>
-#include <assert.h>
 #include <cmConfigure.h>
 #include <cmsys/FStream.hxx>
 #include <cmsys/RegularExpression.hxx>
@@ -55,6 +54,13 @@ static std::string utilStripCR(std::string const& line)
   return line;
 }
 
+static std::string GetSafeProperty(cmGeneratorTarget const* target,
+                                   const char* key)
+{
+  const char* tmp = target->GetProperty(key);
+  return std::string((tmp != CM_NULLPTR) ? tmp : "");
+}
+
 static std::string GetAutogenTargetName(cmGeneratorTarget const* target)
 {
   std::string autogenTargetName = target->GetName();
@@ -98,19 +104,53 @@ static std::string GetQtMajorVersion(cmGeneratorTarget const* target)
   return qtMajorVersion;
 }
 
+static void GetCompileDefinitionsAndDirectories(
+  cmGeneratorTarget const* target, const std::string& config,
+  std::string& incs, std::string& defs)
+{
+  cmLocalGenerator* localGen = target->GetLocalGenerator();
+  {
+    std::vector<std::string> includeDirs;
+    // Get the include dirs for this target, without stripping the implicit
+    // include dirs off, see
+    // https://gitlab.kitware.com/cmake/cmake/issues/13667
+    localGen->GetIncludeDirectories(includeDirs, target, "CXX", config, false);
+    incs = cmJoin(includeDirs, ";");
+  }
+  {
+    std::set<std::string> defines;
+    localGen->AddCompileDefinitions(defines, target, config, "CXX");
+    defs += cmJoin(defines, ";");
+  }
+}
+
+static void AddDefinitionEscaped(cmMakefile* makefile, const char* key,
+                                 const std::string& value)
+{
+  makefile->AddDefinition(key,
+                          cmOutputConverter::EscapeForCMake(value).c_str());
+}
+
+static void AddDefinitionEscaped(cmMakefile* makefile, const char* key,
+                                 const std::vector<std::string>& values)
+{
+  makefile->AddDefinition(
+    key, cmOutputConverter::EscapeForCMake(cmJoin(values, ";")).c_str());
+}
+
 static void SetupSourceFiles(cmGeneratorTarget const* target,
                              std::vector<std::string>& mocUicSources,
                              std::vector<std::string>& mocUicHeaders,
-                             std::vector<std::string>& skipMocList,
-                             std::vector<std::string>& skipUicList)
+                             std::vector<std::string>& mocSkipList,
+                             std::vector<std::string>& uicSkipList)
 {
   cmMakefile* makefile = target->Target->GetMakefile();
 
   std::vector<cmSourceFile*> srcFiles;
   target->GetConfigCommonSourceFiles(srcFiles);
 
-  const bool targetMoc = target->GetPropertyAsBool("AUTOMOC");
-  const bool targetUic = target->GetPropertyAsBool("AUTOUIC");
+  const bool mocTarget = target->GetPropertyAsBool("AUTOMOC");
+  const bool uicTarget = target->GetPropertyAsBool("AUTOUIC");
 
   cmFilePathChecksum fpathCheckSum(makefile);
   for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
@@ -131,22 +171,22 @@ static void SetupSourceFiles(cmGeneratorTarget const* target,
     // Skip flags
     const bool skipAll =
       cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOGEN"));
-    const bool skipMoc =
+    const bool mocSkip =
       skipAll || cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOMOC"));
-    const bool skipUic =
+    const bool uicSkip =
       skipAll || cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOUIC"));
     // 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 (skipMoc) {
-      skipMocList.push_back(absFile);
+    if (mocSkip) {
+      mocSkipList.push_back(absFile);
     }
-    if (skipUic) {
-      skipUicList.push_back(absFile);
+    if (uicSkip) {
+      uicSkipList.push_back(absFile);
     }
 
-    if ((targetMoc && !skipMoc) || (targetUic && !skipUic)) {
+    if ((mocTarget && !mocSkip) || (uicTarget && !uicSkip)) {
       // Add file name to sources or headers list
       switch (fileType) {
         case cmSystemTools::CXX_FILE_FORMAT:
@@ -162,100 +202,87 @@ static void SetupSourceFiles(cmGeneratorTarget const* target,
   }
 }
 
-static void GetCompileDefinitionsAndDirectories(
-  cmGeneratorTarget const* target, const std::string& config,
-  std::string& incs, std::string& defs)
-{
-  std::vector<std::string> includeDirs;
-  cmLocalGenerator* localGen = target->GetLocalGenerator();
-  // Get the include dirs for this target, without stripping the implicit
-  // include dirs off, see https://gitlab.kitware.com/cmake/cmake/issues/13667
-  localGen->GetIncludeDirectories(includeDirs, target, "CXX", config, false);
-
-  incs = cmJoin(includeDirs, ";");
-
-  std::set<std::string> defines;
-  localGen->AddCompileDefinitions(defines, target, config, "CXX");
-
-  defs += cmJoin(defines, ";");
-}
-
 static void MocSetupAutoTarget(
   cmGeneratorTarget const* target, const std::string& autogenTargetName,
-  std::vector<std::string> const& skipMoc,
+  const std::string& qtMajorVersion,
+  std::vector<std::string> const& mocSkipList,
   std::map<std::string, std::string>& configIncludes,
   std::map<std::string, std::string>& configDefines)
 {
   cmLocalGenerator* lg = target->GetLocalGenerator();
   cmMakefile* makefile = target->Target->GetMakefile();
 
-  const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS");
-  std::string _moc_options = (tmp != CM_NULLPTR ? tmp : "");
-  makefile->AddDefinition(
-    "_moc_options", cmOutputConverter::EscapeForCMake(_moc_options).c_str());
-  makefile->AddDefinition(
-    "_skip_moc",
-    cmOutputConverter::EscapeForCMake(cmJoin(skipMoc, ";")).c_str());
-  bool relaxedMode = makefile->IsOn("CMAKE_AUTOMOC_RELAXED_MODE");
-  makefile->AddDefinition("_moc_relaxed_mode", relaxedMode ? "TRUE" : "FALSE");
-
-  std::string _moc_incs;
-  std::string _moc_compile_defs;
-  std::vector<std::string> configs;
-  const std::string& config = makefile->GetConfigurations(configs);
-  GetCompileDefinitionsAndDirectories(target, config, _moc_incs,
-                                      _moc_compile_defs);
+  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");
 
-  makefile->AddDefinition(
-    "_moc_incs", cmOutputConverter::EscapeForCMake(_moc_incs).c_str());
-  makefile->AddDefinition(
-    "_moc_compile_defs",
-    cmOutputConverter::EscapeForCMake(_moc_compile_defs).c_str());
-
-  for (std::vector<std::string>::const_iterator li = configs.begin();
-       li != configs.end(); ++li) {
-    std::string config_moc_incs;
-    std::string config_moc_compile_defs;
-    GetCompileDefinitionsAndDirectories(target, *li, config_moc_incs,
-                                        config_moc_compile_defs);
-    if (config_moc_incs != _moc_incs) {
-      configIncludes[*li] = cmOutputConverter::EscapeForCMake(config_moc_incs);
-      if (_moc_incs.empty()) {
-        _moc_incs = config_moc_incs;
+  // Moc includes and compile definitions
+  {
+    std::string _moc_incs;
+    std::string _moc_compile_defs;
+    std::vector<std::string> configs;
+    {
+      const std::string& config = makefile->GetConfigurations(configs);
+      GetCompileDefinitionsAndDirectories(target, config, _moc_incs,
+                                          _moc_compile_defs);
+      AddDefinitionEscaped(makefile, "_moc_incs", _moc_incs);
+      AddDefinitionEscaped(makefile, "_moc_compile_defs", _moc_compile_defs);
+    }
+    for (std::vector<std::string>::const_iterator li = configs.begin();
+         li != configs.end(); ++li) {
+      std::string config_moc_incs;
+      std::string config_moc_compile_defs;
+      GetCompileDefinitionsAndDirectories(target, *li, config_moc_incs,
+                                          config_moc_compile_defs);
+      if (config_moc_incs != _moc_incs) {
+        configIncludes[*li] =
+          cmOutputConverter::EscapeForCMake(config_moc_incs);
+        if (_moc_incs.empty()) {
+          _moc_incs = config_moc_incs;
+        }
       }
-    }
-    if (config_moc_compile_defs != _moc_compile_defs) {
-      configDefines[*li] =
-        cmOutputConverter::EscapeForCMake(config_moc_compile_defs);
-      if (_moc_compile_defs.empty()) {
-        _moc_compile_defs = config_moc_compile_defs;
+      if (config_moc_compile_defs != _moc_compile_defs) {
+        configDefines[*li] =
+          cmOutputConverter::EscapeForCMake(config_moc_compile_defs);
+        if (_moc_compile_defs.empty()) {
+          _moc_compile_defs = config_moc_compile_defs;
+        }
       }
     }
   }
 
-  const char* qtVersion = makefile->GetDefinition("_target_qt_version");
-  if (strcmp(qtVersion, "5") == 0) {
-    cmGeneratorTarget* qt5Moc = lg->FindGeneratorTargetToUse("Qt5::moc");
-    if (!qt5Moc) {
-      cmSystemTools::Error("Qt5::moc target not found ",
-                           autogenTargetName.c_str());
-      return;
+  // Moc executable
+  {
+    std::string err;
+    const char* mocExec = CM_NULLPTR;
+    if (qtMajorVersion == "5") {
+      cmGeneratorTarget* qt5Moc = lg->FindGeneratorTargetToUse("Qt5::moc");
+      if (qt5Moc != CM_NULLPTR) {
+        mocExec = qt5Moc->ImportedGetLocation("");
+      } else {
+        err = "Qt5::moc target not found " + autogenTargetName;
+      }
+    } else if (qtMajorVersion == "4") {
+      cmGeneratorTarget* qt4Moc = lg->FindGeneratorTargetToUse("Qt4::moc");
+      if (qt4Moc != CM_NULLPTR) {
+        mocExec = qt4Moc->ImportedGetLocation("");
+      } else {
+        err = "Qt4::moc target not found " + autogenTargetName;
+      }
+    } else {
+      err = "The CMAKE_AUTOMOC feature supports only Qt 4 and Qt 5 ";
+      err += autogenTargetName;
     }
-    makefile->AddDefinition("_qt_moc_executable",
-                            qt5Moc->ImportedGetLocation(""));
-  } else if (strcmp(qtVersion, "4") == 0) {
-    cmGeneratorTarget* qt4Moc = lg->FindGeneratorTargetToUse("Qt4::moc");
-    if (!qt4Moc) {
-      cmSystemTools::Error("Qt4::moc target not found ",
-                           autogenTargetName.c_str());
-      return;
+    // Add definition or error
+    if (err.empty()) {
+      AddDefinitionEscaped(makefile, "_qt_moc_executable",
+                           mocExec ? mocExec : "");
+    } else {
+      cmSystemTools::Error(err.c_str());
     }
-    makefile->AddDefinition("_qt_moc_executable",
-                            qt4Moc->ImportedGetLocation(""));
-  } else {
-    cmSystemTools::Error("The CMAKE_AUTOMOC feature supports only Qt 4 and "
-                         "Qt 5 ",
-                         autogenTargetName.c_str());
   }
 }
 
@@ -268,126 +295,126 @@ static void UicGetOpts(cmGeneratorTarget const* target,
 }
 
 static void UicSetupAutoTarget(
-  cmGeneratorTarget const* target, std::vector<std::string> const& skipUic,
+  cmGeneratorTarget const* target, const std::string& qtMajorVersion,
+  std::vector<std::string> const& uicSkipList,
   std::map<std::string, std::string>& configUicOptions)
 {
   cmLocalGenerator* lg = target->GetLocalGenerator();
   cmMakefile* makefile = target->Target->GetMakefile();
 
-  std::set<std::string> skipped;
-  skipped.insert(skipUic.begin(), skipUic.end());
+  AddDefinitionEscaped(makefile, "_uic_skip", uicSkipList);
 
-  makefile->AddDefinition(
-    "_skip_uic",
-    cmOutputConverter::EscapeForCMake(cmJoin(skipUic, ";")).c_str());
-
-  std::vector<cmSourceFile*> uiFilesWithOptions =
-    makefile->GetQtUiFilesWithOptions();
-
-  const char* qtVersion = makefile->GetDefinition("_target_qt_version");
-
-  std::string _uic_opts;
-  std::vector<std::string> configs;
-  const std::string& config = makefile->GetConfigurations(configs);
-  UicGetOpts(target, config, _uic_opts);
-
-  if (!_uic_opts.empty()) {
-    _uic_opts = cmOutputConverter::EscapeForCMake(_uic_opts);
-    makefile->AddDefinition("_uic_target_options", _uic_opts.c_str());
-  }
-  for (std::vector<std::string>::const_iterator li = configs.begin();
-       li != configs.end(); ++li) {
-    std::string config_uic_opts;
-    UicGetOpts(target, *li, config_uic_opts);
-    if (config_uic_opts != _uic_opts) {
-      configUicOptions[*li] =
-        cmOutputConverter::EscapeForCMake(config_uic_opts);
-      if (_uic_opts.empty()) {
-        _uic_opts = config_uic_opts;
+  // Uic target options
+  {
+    std::string _uic_opts;
+    std::vector<std::string> configs;
+    UicGetOpts(target, makefile->GetConfigurations(configs), _uic_opts);
+
+    AddDefinitionEscaped(makefile, "_uic_target_options", _uic_opts);
+
+    for (std::vector<std::string>::const_iterator li = configs.begin();
+         li != configs.end(); ++li) {
+      std::string config_uic_opts;
+      UicGetOpts(target, *li, config_uic_opts);
+      if (config_uic_opts != _uic_opts) {
+        configUicOptions[*li] =
+          cmOutputConverter::EscapeForCMake(config_uic_opts);
+        if (_uic_opts.empty()) {
+          _uic_opts = config_uic_opts;
+        }
       }
     }
   }
-
-  std::string uiFileFiles;
-  std::string uiFileOptions;
-  const char* sep = "";
-
-  for (std::vector<cmSourceFile*>::const_iterator fileIt =
-         uiFilesWithOptions.begin();
-       fileIt != uiFilesWithOptions.end(); ++fileIt) {
-    cmSourceFile* sf = *fileIt;
-    std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
-
-    if (!skipped.insert(absFile).second) {
-      continue;
+  // Uic files options
+  {
+    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, ";", "@list_sep@");
+            uiFileOptions.push_back(opts);
+          }
+        }
+      }
     }
-    uiFileFiles += sep;
-    uiFileFiles += absFile;
-    uiFileOptions += sep;
-    std::string opts = sf->GetProperty("AUTOUIC_OPTIONS");
-    cmSystemTools::ReplaceString(opts, ";", "@list_sep@");
-    uiFileOptions += opts;
-    sep = ";";
+    AddDefinitionEscaped(makefile, "_qt_uic_options_files", uiFileFiles);
+    AddDefinitionEscaped(makefile, "_qt_uic_options_options", uiFileOptions);
   }
 
-  makefile->AddDefinition(
-    "_qt_uic_options_files",
-    cmOutputConverter::EscapeForCMake(uiFileFiles).c_str());
-  makefile->AddDefinition(
-    "_qt_uic_options_options",
-    cmOutputConverter::EscapeForCMake(uiFileOptions).c_str());
-
-  std::string targetName = target->GetName();
-  if (strcmp(qtVersion, "5") == 0) {
-    cmGeneratorTarget* qt5Uic = lg->FindGeneratorTargetToUse("Qt5::uic");
-    if (!qt5Uic) {
-      // Project does not use Qt5Widgets, but has AUTOUIC ON anyway
+  // Uic executable
+  {
+    std::string err;
+    const char* uicExec = CM_NULLPTR;
+    if (qtMajorVersion == "5") {
+      cmGeneratorTarget* qt5Uic = lg->FindGeneratorTargetToUse("Qt5::uic");
+      if (qt5Uic != CM_NULLPTR) {
+        uicExec = qt5Uic->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("");
+      } else {
+        err = "Qt4::uic target not found " + target->GetName();
+      }
     } else {
-      makefile->AddDefinition("_qt_uic_executable",
-                              qt5Uic->ImportedGetLocation(""));
+      err = "The CMAKE_AUTOUIC feature supports only Qt 4 and Qt 5 ";
+      err += target->GetName();
     }
-  } else if (strcmp(qtVersion, "4") == 0) {
-    cmGeneratorTarget* qt4Uic = lg->FindGeneratorTargetToUse("Qt4::uic");
-    if (!qt4Uic) {
-      cmSystemTools::Error("Qt4::uic target not found ", targetName.c_str());
-      return;
+    // Add definition or error
+    if (err.empty()) {
+      AddDefinitionEscaped(makefile, "_qt_uic_executable",
+                           uicExec ? uicExec : "");
+    } else {
+      cmSystemTools::Error(err.c_str());
     }
-    makefile->AddDefinition("_qt_uic_executable",
-                            qt4Uic->ImportedGetLocation(""));
-  } else {
-    cmSystemTools::Error("The CMAKE_AUTOUIC feature supports only Qt 4 and "
-                         "Qt 5 ",
-                         targetName.c_str());
   }
 }
 
 static std::string RccGetExecutable(cmGeneratorTarget const* target,
                                     const std::string& qtMajorVersion)
 {
+  std::string rccExec;
   cmLocalGenerator* lg = target->GetLocalGenerator();
-
-  std::string const& targetName = target->GetName();
   if (qtMajorVersion == "5") {
     cmGeneratorTarget* qt5Rcc = lg->FindGeneratorTargetToUse("Qt5::rcc");
-    if (!qt5Rcc) {
-      cmSystemTools::Error("Qt5::rcc target not found ", targetName.c_str());
-      return std::string();
+    if (qt5Rcc != CM_NULLPTR) {
+      rccExec = qt5Rcc->ImportedGetLocation("");
+    } else {
+      cmSystemTools::Error("Qt5::rcc target not found ",
+                           target->GetName().c_str());
     }
-    return qt5Rcc->ImportedGetLocation("");
-  }
-  if (qtMajorVersion == "4") {
+  } else if (qtMajorVersion == "4") {
     cmGeneratorTarget* qt4Rcc = lg->FindGeneratorTargetToUse("Qt4::rcc");
-    if (!qt4Rcc) {
-      cmSystemTools::Error("Qt4::rcc target not found ", targetName.c_str());
-      return std::string();
+    if (qt4Rcc != CM_NULLPTR) {
+      rccExec = qt4Rcc->ImportedGetLocation("");
+    } else {
+      cmSystemTools::Error("Qt4::rcc target not found ",
+                           target->GetName().c_str());
     }
-    return qt4Rcc->ImportedGetLocation("");
+  } else {
+    cmSystemTools::Error(
+      "The CMAKE_AUTORCC feature supports only Qt 4 and Qt 5 ",
+      target->GetName().c_str());
   }
-
-  cmSystemTools::Error("The CMAKE_AUTORCC feature supports only Qt 4 and "
-                       "Qt 5 ",
-                       targetName.c_str());
-  return std::string();
+  return rccExec;
 }
 
 static void RccMergeOptions(std::vector<std::string>& opts,
@@ -397,26 +424,31 @@ static void RccMergeOptions(std::vector<std::string>& opts,
   static const char* valueOptions[] = { "name", "root", "compress",
                                         "threshold" };
   std::vector<std::string> extraOpts;
-  for (std::vector<std::string>::const_iterator it = fileOpts.begin();
-       it != fileOpts.end(); ++it) {
+  for (std::vector<std::string>::const_iterator fit = fileOpts.begin();
+       fit != fileOpts.end(); ++fit) {
     std::vector<std::string>::iterator existingIt =
-      std::find(opts.begin(), opts.end(), *it);
+      std::find(opts.begin(), opts.end(), *fit);
     if (existingIt != opts.end()) {
-      const char* o = it->c_str();
-      if (*o == '-') {
-        ++o;
-      }
-      if (isQt5 && *o == '-') {
-        ++o;
+      const char* optName = fit->c_str();
+      if (*optName == '-') {
+        ++optName;
+        if (isQt5 && *optName == '-') {
+          ++optName;
+        }
       }
-      if (std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
-                       cmStrCmp(*it)) != cmArrayEnd(valueOptions)) {
-        assert(existingIt + 1 != opts.end());
-        *(existingIt + 1) = *(it + 1);
-        ++it;
+      // Test if this is a value option and change the existing value
+      if ((optName != fit->c_str()) &&
+          std::find_if(cmArrayBegin(valueOptions), cmArrayEnd(valueOptions),
+                       cmStrCmp(optName)) != cmArrayEnd(valueOptions)) {
+        const std::vector<std::string>::iterator existValueIt(existingIt + 1);
+        const std::vector<std::string>::const_iterator fileValueIt(fit + 1);
+        if ((existValueIt != opts.end()) && (fileValueIt != fileOpts.end())) {
+          *existValueIt = *fileValueIt;
+          ++fit;
+        }
       }
     } else {
-      extraOpts.push_back(*it);
+      extraOpts.push_back(*fit);
     }
   }
   opts.insert(opts.end(), extraOpts.begin(), extraOpts.end());
@@ -526,23 +558,20 @@ static bool RccListInputsQt4(cmSourceFile* sf,
   }
 
   cmsys::RegularExpression fileMatchRegex("(<file[^<]+)");
+  cmsys::RegularExpression fileReplaceRegex("(^<file[^>]*>)");
 
   size_t offset = 0;
   while (fileMatchRegex.find(qrcContents.c_str() + offset)) {
     std::string qrcEntry = fileMatchRegex.match(1);
-
     offset += qrcEntry.size();
-
-    cmsys::RegularExpression fileReplaceRegex("(^<file[^>]*>)");
-    fileReplaceRegex.find(qrcEntry);
-    std::string tag = fileReplaceRegex.match(1);
-
-    qrcEntry = qrcEntry.substr(tag.size());
-
+    {
+      fileReplaceRegex.find(qrcEntry);
+      std::string tag = fileReplaceRegex.match(1);
+      qrcEntry = qrcEntry.substr(tag.size());
+    }
     if (!cmSystemTools::FileIsFullPath(qrcEntry.c_str())) {
       qrcEntry = sf->GetLocation().GetDirectory() + "/" + qrcEntry;
     }
-
     depends.push_back(qrcEntry);
   }
   return true;
@@ -563,89 +592,69 @@ static bool RccListInputs(const std::string& qtMajorVersion, cmSourceFile* sf,
 static void RccSetupAutoTarget(cmGeneratorTarget const* target,
                                const std::string& qtMajorVersion)
 {
-  std::string _rcc_files;
-  const char* sepRccFiles = "";
   cmMakefile* makefile = target->Target->GetMakefile();
-
-  std::vector<cmSourceFile*> srcFiles;
-  target->GetConfigCommonSourceFiles(srcFiles);
-
-  std::string qrcInputs;
-  const char* qrcInputsSep = "";
-
-  std::string rccFileFiles;
-  std::string rccFileOptions;
-  const char* optionSep = "";
-
   const bool qtMajorVersion5 = (qtMajorVersion == "5");
-
-  std::vector<std::string> rccOptions;
+  std::vector<std::string> _rcc_files;
+  std::vector<std::string> _rcc_inputs;
+  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, rccOptions);
+    cmSystemTools::ExpandListArgument(opts, rccOptionsTarget);
   }
 
+  std::vector<cmSourceFile*> srcFiles;
+  target->GetConfigCommonSourceFiles(srcFiles);
   for (std::vector<cmSourceFile*>::const_iterator fileIt = srcFiles.begin();
        fileIt != srcFiles.end(); ++fileIt) {
     cmSourceFile* sf = *fileIt;
-    std::string ext = sf->GetExtension();
-    if (ext == "qrc") {
-      std::string absFile = cmsys::SystemTools::GetRealPath(sf->GetFullPath());
+    if (sf->GetExtension() == "qrc") {
       const bool skip =
         cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTOGEN")) ||
         cmSystemTools::IsOn(sf->GetPropertyForUser("SKIP_AUTORCC"));
-
       if (!skip) {
-        _rcc_files += sepRccFiles;
-        _rcc_files += absFile;
-        sepRccFiles = ";";
-
-        if (const char* prop = sf->GetProperty("AUTORCC_OPTIONS")) {
-          std::vector<std::string> optsVec;
-          cmSystemTools::ExpandListArgument(prop, optsVec);
-          RccMergeOptions(rccOptions, optsVec, qtMajorVersion5);
-        }
-
-        if (!rccOptions.empty()) {
-          rccFileFiles += optionSep;
-          rccFileFiles += absFile;
-          rccFileOptions += optionSep;
-        }
-        const char* listSep = "";
-        for (std::vector<std::string>::const_iterator it = rccOptions.begin();
-             it != rccOptions.end(); ++it) {
-          rccFileOptions += listSep;
-          rccFileOptions += *it;
-          listSep = "@list_sep@";
+        const std::string absFile =
+          cmsys::SystemTools::GetRealPath(sf->GetFullPath());
+        // qrc file
+        _rcc_files.push_back(absFile);
+        // qrc file entries
+        {
+          std::string entriesList;
+          if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) {
+            std::vector<std::string> depends;
+            if (RccListInputs(qtMajorVersion, sf, target, depends)) {
+              entriesList = cmJoin(depends, "@list_sep@");
+            } else {
+              return;
+            }
+          }
+          _rcc_inputs.push_back(entriesList);
         }
-        optionSep = ";";
-
-        std::string entriesList;
-        if (!cmSystemTools::IsOn(sf->GetPropertyForUser("GENERATED"))) {
-          std::vector<std::string> depends;
-          if (RccListInputs(qtMajorVersion, sf, target, depends)) {
-            entriesList = cmJoin(depends, "@list_sep@");
-          } else {
-            return;
+        // rcc options for this qrc file
+        {
+          // Merged target and file options
+          std::vector<std::string> rccOptions(rccOptionsTarget);
+          if (const char* prop = sf->GetProperty("AUTORCC_OPTIONS")) {
+            std::vector<std::string> optsVec;
+            cmSystemTools::ExpandListArgument(prop, optsVec);
+            RccMergeOptions(rccOptions, optsVec, qtMajorVersion5);
+          }
+          // Only store non empty options lists
+          if (!rccOptions.empty()) {
+            rccFileFiles.push_back(absFile);
+            rccFileOptions.push_back(cmJoin(rccOptions, "@list_sep@"));
           }
         }
-        qrcInputs += qrcInputsSep;
-        qrcInputs += entriesList;
-        qrcInputsSep = ";";
       }
     }
   }
-  makefile->AddDefinition(
-    "_rcc_inputs", cmOutputConverter::EscapeForCMake(qrcInputs).c_str());
-  makefile->AddDefinition(
-    "_rcc_files", cmOutputConverter::EscapeForCMake(_rcc_files).c_str());
-  makefile->AddDefinition(
-    "_rcc_options_files",
-    cmOutputConverter::EscapeForCMake(rccFileFiles).c_str());
-  makefile->AddDefinition(
-    "_rcc_options_options",
-    cmOutputConverter::EscapeForCMake(rccFileOptions).c_str());
-  makefile->AddDefinition("_qt_rcc_executable",
-                          RccGetExecutable(target, qtMajorVersion).c_str());
+
+  AddDefinitionEscaped(makefile, "_rcc_files", _rcc_files);
+  AddDefinitionEscaped(makefile, "_rcc_inputs", _rcc_inputs);
+  AddDefinitionEscaped(makefile, "_rcc_options_files", rccFileFiles);
+  AddDefinitionEscaped(makefile, "_rcc_options_options", rccFileOptions);
+  AddDefinitionEscaped(makefile, "_qt_rcc_executable",
+                       RccGetExecutable(target, qtMajorVersion));
 }
 
 void cmQtAutoGeneratorInitializer::InitializeAutogenSources(
@@ -872,47 +881,42 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
   cmMakefile::ScopePushPop varScope(makefile);
   static_cast<void>(varScope);
 
-  // create a custom target for running generators at buildtime:
-  const std::string autogenTargetName = GetAutogenTargetName(target);
-  const std::string qtMajorVersion = GetQtMajorVersion(target);
-
-  makefile->AddDefinition(
-    "_moc_target_name",
-    cmOutputConverter::EscapeForCMake(autogenTargetName).c_str());
-  makefile->AddDefinition(
-    "_origin_target_name",
-    cmOutputConverter::EscapeForCMake(target->GetName()).c_str());
-  makefile->AddDefinition("_target_qt_version", qtMajorVersion.c_str());
-
-  std::vector<std::string> mocUicSources;
-  std::vector<std::string> mocUicHeaders;
-  std::vector<std::string> skipMoc;
-  std::vector<std::string> skipUic;
   std::map<std::string, std::string> configMocIncludes;
   std::map<std::string, std::string> configMocDefines;
   std::map<std::string, std::string> configUicOptions;
+  {
+    // create a custom target for running generators at buildtime:
+    const std::string autogenTargetName = GetAutogenTargetName(target);
+    const std::string qtMajorVersion = GetQtMajorVersion(target);
 
-  if (target->GetPropertyAsBool("AUTOMOC") ||
-      target->GetPropertyAsBool("AUTOUIC") ||
-      target->GetPropertyAsBool("AUTORCC")) {
-    SetupSourceFiles(target, mocUicSources, mocUicHeaders, skipMoc, skipUic);
-  }
-  makefile->AddDefinition(
-    "_moc_uic_sources",
-    cmOutputConverter::EscapeForCMake(cmJoin(mocUicSources, ";")).c_str());
-  makefile->AddDefinition(
-    "_moc_uic_headers",
-    cmOutputConverter::EscapeForCMake(cmJoin(mocUicHeaders, ";")).c_str());
+    AddDefinitionEscaped(makefile, "_autogen_target_name", autogenTargetName);
+    AddDefinitionEscaped(makefile, "_origin_target_name", target->GetName());
+    AddDefinitionEscaped(makefile, "_qt_version_major", qtMajorVersion);
 
-  if (target->GetPropertyAsBool("AUTOMOC")) {
-    MocSetupAutoTarget(target, autogenTargetName, skipMoc, configMocIncludes,
-                       configMocDefines);
-  }
-  if (target->GetPropertyAsBool("AUTOUIC")) {
-    UicSetupAutoTarget(target, skipUic, configUicOptions);
-  }
-  if (target->GetPropertyAsBool("AUTORCC")) {
-    RccSetupAutoTarget(target, qtMajorVersion);
+    std::vector<std::string> _sources;
+    std::vector<std::string> _headers;
+    std::vector<std::string> mocSkipList;
+    std::vector<std::string> uicSkipList;
+
+    if (target->GetPropertyAsBool("AUTOMOC") ||
+        target->GetPropertyAsBool("AUTOUIC") ||
+        target->GetPropertyAsBool("AUTORCC")) {
+      SetupSourceFiles(target, _sources, _headers, mocSkipList, uicSkipList);
+    }
+    AddDefinitionEscaped(makefile, "_sources", _sources);
+    AddDefinitionEscaped(makefile, "_headers", _headers);
+
+    if (target->GetPropertyAsBool("AUTOMOC")) {
+      MocSetupAutoTarget(target, autogenTargetName, qtMajorVersion,
+                         mocSkipList, configMocIncludes, configMocDefines);
+    }
+    if (target->GetPropertyAsBool("AUTOUIC")) {
+      UicSetupAutoTarget(target, qtMajorVersion, uicSkipList,
+                         configUicOptions);
+    }
+    if (target->GetPropertyAsBool("AUTORCC")) {
+      RccSetupAutoTarget(target, qtMajorVersion);
+    }
   }
 
   // Generate config file
@@ -924,7 +928,7 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
   makefile->ConfigureFile(inputFile.c_str(), outputFile.c_str(), false, true,
                           false);
 
-  // Append custom definitions to config file
+  // Append custom config definitions to info file
   if (!configMocDefines.empty() || !configMocIncludes.empty() ||
       !configUicOptions.empty()) {
 
@@ -946,33 +950,34 @@ void cmQtAutoGeneratorInitializer::SetupAutoGenerateTarget(
       error += outputFile;
       error += " for writing.";
       cmSystemTools::Error(error.c_str());
-      return;
-    }
-    if (!configMocDefines.empty()) {
-      for (std::map<std::string, std::string>::iterator
-             it = configMocDefines.begin(),
-             end = configMocDefines.end();
-           it != end; ++it) {
-        infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first << " "
-                 << it->second << ")\n";
+    } else {
+      infoFile << "# Configuration specific options\n";
+      if (!configMocDefines.empty()) {
+        for (std::map<std::string, std::string>::iterator
+               it = configMocDefines.begin(),
+               end = configMocDefines.end();
+             it != end; ++it) {
+          infoFile << "set(AM_MOC_COMPILE_DEFINITIONS_" << it->first << " "
+                   << it->second << ")\n";
+        }
       }
-    }
-    if (!configMocIncludes.empty()) {
-      for (std::map<std::string, std::string>::iterator
-             it = configMocIncludes.begin(),
-             end = configMocIncludes.end();
-           it != end; ++it) {
-        infoFile << "set(AM_MOC_INCLUDES_" << it->first << " " << it->second
-                 << ")\n";
+      if (!configMocIncludes.empty()) {
+        for (std::map<std::string, std::string>::iterator
+               it = configMocIncludes.begin(),
+               end = configMocIncludes.end();
+             it != end; ++it) {
+          infoFile << "set(AM_MOC_INCLUDES_" << it->first << " " << it->second
+                   << ")\n";
+        }
       }
-    }
-    if (!configUicOptions.empty()) {
-      for (std::map<std::string, std::string>::iterator
-             it = configUicOptions.begin(),
-             end = configUicOptions.end();
-           it != end; ++it) {
-        infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " "
-                 << it->second << ")\n";
+      if (!configUicOptions.empty()) {
+        for (std::map<std::string, std::string>::iterator
+               it = configUicOptions.begin(),
+               end = configUicOptions.end();
+             it != end; ++it) {
+          infoFile << "set(AM_UIC_TARGET_OPTIONS_" << it->first << " "
+                   << it->second << ")\n";
+        }
       }
     }
   }

Source/cmQtAutoGenerators.h

@@ -7,10 +7,10 @@
 #include <cmFilePathChecksum.h>
 #include <cmsys/RegularExpression.hxx>
 
-#include <list>
 #include <map>
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 class cmMakefile;
@@ -22,64 +22,92 @@ public:
   bool Run(const std::string& targetDirectory, const std::string& config);
 
 private:
+  // - Types
+
+  /// @brief Used to extract additional dependencies from content text
+  struct MocDependFilter
+  {
+    std::string key;
+    cmsys::RegularExpression regExp;
+  };
+  typedef std::pair<std::string, cmsys::RegularExpression> MacroFilter;
+
   // - Configuration
   bool ReadAutogenInfoFile(cmMakefile* makefile,
                            const std::string& targetDirectory,
                            const std::string& config);
 
-  std::string MocSettingsStringCompose();
-  std::string UicSettingsStringCompose();
-  std::string RccSettingsStringCompose();
-  void OldSettingsReadFile(cmMakefile* makefile,
-                           const std::string& targetDirectory);
-  bool OldSettingsWriteFile(const std::string& targetDirectory);
+  bool MocEnabled() const { return !this->MocExecutable.empty(); }
+  bool UicEnabled() const { return !this->UicExecutable.empty(); }
+  bool RccEnabled() const { return !this->RccExecutable.empty(); }
+
+  // - Settings file
+  void SettingsFileRead(cmMakefile* makefile,
+                        const std::string& targetDirectory);
+  bool SettingsFileWrite(const std::string& targetDirectory);
+
+  bool GenerateAllAny() const
+  {
+    return (this->GenerateAllMoc || this->GenerateAllRcc ||
+            this->GenerateAllUic);
+  }
 
   // - Init and run
-  void Init();
-  bool RunAutogen(cmMakefile* makefile);
+  void Init(cmMakefile* makefile);
+  bool RunAutogen();
 
   // - Content analysis
-  bool MocRequired(const std::string& text, std::string& macroName);
-  bool MocSkipTest(const std::string& absFilename);
-  bool UicSkipTest(const std::string& absFilename);
+  bool MocRequired(const std::string& contentText,
+                   std::string* macroName = CM_NULLPTR);
+  void MocFindDepends(
+    const std::string& absFilename, const std::string& contentText,
+    std::map<std::string, std::set<std::string> >& mocDepends);
+
+  bool MocSkip(const std::string& absFilename) const;
+  bool UicSkip(const std::string& absFilename) const;
 
   bool ParseSourceFile(
     const std::string& absFilename,
-    const std::vector<std::string>& headerExtensions,
-    std::map<std::string, std::string>& includedMocs,
+    std::map<std::string, std::string>& mocsIncluded,
+    std::map<std::string, std::set<std::string> >& mocDepends,
     std::map<std::string, std::vector<std::string> >& includedUis,
     bool relaxed);
 
-  void SearchHeadersForSourceFile(
-    const std::string& absFilename,
-    const std::vector<std::string>& headerExtensions,
-    std::set<std::string>& absHeadersMoc,
-    std::set<std::string>& absHeadersUic);
+  void SearchHeadersForSourceFile(const std::string& absFilename,
+                                  std::set<std::string>& mocHeaderFiles,
+                                  std::set<std::string>& uicHeaderFiles) const;
 
   void ParseHeaders(
-    const std::set<std::string>& absHeadersMoc,
-    const std::set<std::string>& absHeadersUic,
-    const std::map<std::string, std::string>& includedMocs,
-    std::map<std::string, std::string>& notIncludedMocs,
+    const std::set<std::string>& mocHeaderFiles,
+    const std::set<std::string>& uicHeaderFiles,
+    const std::map<std::string, std::string>& mocsIncluded,
+    std::map<std::string, std::string>& mocsNotIncluded,
+    std::map<std::string, std::set<std::string> >& mocDepends,
     std::map<std::string, std::vector<std::string> >& includedUis);
 
-  void ParseContentForUic(
-    const std::string& fileName, const std::string& contentsString,
+  void UicParseContent(
+    const std::string& fileName, const std::string& contentText,
     std::map<std::string, std::vector<std::string> >& includedUis);
 
-  bool ParseContentForMoc(const std::string& absFilename,
-                          const std::string& contentsString,
-                          const std::vector<std::string>& headerExtensions,
-                          std::map<std::string, std::string>& includedMocs,
-                          bool relaxed);
+  bool MocParseSourceContent(
+    const std::string& absFilename, const std::string& contentText,
+    std::map<std::string, std::string>& mocsIncluded,
+    std::map<std::string, std::set<std::string> >& mocDepends, bool relaxed);
+
+  void MocParseHeaderContent(
+    const std::string& absFilename, const std::string& contentText,
+    std::map<std::string, std::string>& mocsNotIncluded,
+    std::map<std::string, std::set<std::string> >& mocDepends);
 
   // - Moc file generation
   bool MocGenerateAll(
-    const std::map<std::string, std::string>& includedMocs,
-    const std::map<std::string, std::string>& notIncludedMocs);
-  bool MocGenerateFile(const std::string& sourceFile,
-                       const std::string& mocFileName,
-                       const std::string& subDirPrefix);
+    const std::map<std::string, std::string>& mocsIncluded,
+    const std::map<std::string, std::string>& mocsNotIncluded,
+    const std::map<std::string, std::set<std::string> >& mocDepends);
+  bool MocGenerateFile(
+    const std::string& sourceFile, const std::string& mocFileName,
+    const std::string& subDirPrefix,
+    const std::map<std::string, std::set<std::string> >& mocDepends);
 
   // - Uic file generation
   bool UicGenerateAll(
@@ -88,25 +116,39 @@ private:
                        const std::string& uiInputFile,
                        const std::string& uiOutputFile);
 
-  // - Qrc file generation
-  bool QrcGenerateAll();
-  bool QrcGenerateFile(const std::string& qrcInputFile,
+  // - Rcc file generation
+  bool RccGenerateAll();
+  bool RccGenerateFile(const std::string& qrcInputFile,
                        const std::string& qrcOutputFile, bool unique_n);
 
   // - Logging
   void LogErrorNameCollision(
     const std::string& message,
-    const std::multimap<std::string, std::string>& collisions);
-  void LogBold(const std::string& message);
-  void LogInfo(const std::string& message);
-  void LogWarning(const std::string& message);
-  void LogError(const std::string& message);
-  void LogCommand(const std::vector<std::string>& command);
+    const std::multimap<std::string, std::string>& collisions) const;
+  void LogBold(const std::string& message) const;
+  void LogInfo(const std::string& message) const;
+  void LogWarning(const std::string& message) const;
+  void LogError(const std::string& message) const;
+  void LogCommand(const std::vector<std::string>& command) const;
 
   // - Utility
-  bool NameCollisionTest(const std::map<std::string, std::string>& genFiles,
-                         std::multimap<std::string, std::string>& collisions);
-  bool MakeParentDirectory(const std::string& filename);
+  bool NameCollisionTest(
+    const std::map<std::string, std::string>& genFiles,
+    std::multimap<std::string, std::string>& collisions) const;
+  std::string ChecksumedPath(const std::string& sourceFile,
+                             const char* basePrefix,
+                             const char* baseSuffix) const;
+  bool MakeParentDirectory(const std::string& filename) const;
+
+  bool FindHeader(std::string& header, const std::string& testBasePath) const;
+  bool FindHeaderGlobal(std::string& header,
+                        const std::string& testBasePath) const;
+  std::string FindMocHeader(const std::string& basePath,
+                            const std::string& baseName,
+                            const std::string& subDir) const;
+  std::string FindIncludedFile(const std::string& sourceFile,
+                               const std::string& includeString) const;
+  std::string FindInIncludeDirectories(const std::string& includeString) const;
 
   // - Target names
   std::string OriginTargetName;
@@ -125,31 +167,31 @@ private:
   // - File lists
   std::vector<std::string> Sources;
   std::vector<std::string> Headers;
+  // - Settings
+  std::string SettingsStringMoc;
+  std::string SettingsStringUic;
+  std::string SettingsStringRcc;
   // - Moc
-  std::vector<std::string> SkipMoc;
-  std::string MocCompileDefinitionsStr;
-  std::string MocIncludesStr;
-  std::string MocOptionsStr;
-  std::string OutMocCppFilenameRel;
-  std::string OutMocCppFilenameAbs;
-  std::list<std::string> MocIncludes;
-  std::list<std::string> MocDefinitions;
+  std::string MocCppFilenameRel;
+  std::string MocCppFilenameAbs;
+  std::vector<std::string> MocSkipList;
+  std::vector<std::string> MocIncludePaths;
+  std::vector<std::string> MocIncludes;
+  std::vector<std::string> MocDefinitions;
   std::vector<std::string> MocOptions;
-  std::string MocSettingsString;
+  std::vector<MocDependFilter> MocDependFilters;
   // - Uic
-  std::vector<std::string> SkipUic;
+  std::vector<std::string> UicSkipList;
   std::vector<std::string> UicTargetOptions;
   std::map<std::string, std::string> UicOptions;
-  std::string UicSettingsString;
   // - Rcc
   std::vector<std::string> RccSources;
   std::map<std::string, std::string> RccOptions;
   std::map<std::string, std::vector<std::string> > RccInputs;
-  std::string RccSettingsString;
   // - Utility
   cmFilePathChecksum fpathCheckSum;
-  cmsys::RegularExpression RegExpQObject;
-  cmsys::RegularExpression RegExpQGadget;
+  std::vector<std::string> HeaderExtensions;
+  MacroFilter MacroFilters[2];
   cmsys::RegularExpression RegExpMocInclude;
   cmsys::RegularExpression RegExpUicInclude;
   // - Flags
@@ -159,9 +201,9 @@ private:
   bool RunMocFailed;
   bool RunUicFailed;
   bool RunRccFailed;
-  bool GenerateMocAll;
-  bool GenerateUicAll;
-  bool GenerateRccAll;
+  bool GenerateAllMoc;
+  bool GenerateAllUic;
+  bool GenerateAllRcc;
   bool MocRelaxedMode;
 };
 

Tests/QtAutogen/CMakeLists.txt

@@ -46,26 +46,26 @@ endif()
 
 get_property(QT_COMPILE_FEATURES TARGET ${QT_QTCORE_TARGET} PROPERTY INTERFACE_COMPILE_FEATURES)
 
-# -- Test: AUTORCC
+# -- Test
 # RCC only
 add_executable(rccOnly rccOnly.cpp rccOnlyRes.qrc)
 set_property(TARGET rccOnly PROPERTY AUTORCC ON)
 target_link_libraries(rccOnly ${QT_QTCORE_TARGET})
 
-# -- Test: AUTORCC
+# -- Test
 # RCC empty
 add_executable(rccEmpty rccEmpty.cpp rccEmptyRes.qrc)
 set_property(TARGET rccEmpty PROPERTY AUTORCC ON)
 target_link_libraries(rccEmpty ${QT_QTCORE_TARGET})
 
-# -- Test: AUTOUIC
+# -- Test
 # UIC only
 qtx_wrap_cpp(uicOnlyMoc uicOnlySource/uiconly.h)
 add_executable(uicOnly uicOnlySource/uiconly.cpp ${uicOnlyMoc})
 set_property(TARGET uicOnly PROPERTY AUTOUIC ON)
 target_link_libraries(uicOnly ${QT_LIBRARIES})
 
-# -- Test: AUTOMOC, AUTORCC
+# -- Test
 # Add not_generated_file.qrc to the source list to get the file-level
 # dependency, but don't generate a c++ file from it.  Disable the AUTORCC
 # feature for this target.  This tests that qrc files in the sources don't
@@ -80,13 +80,14 @@ set_target_properties(no_link_language PROPERTIES AUTOMOC TRUE)
 target_compile_features(no_link_language PRIVATE ${QT_COMPILE_FEATURES})
 target_compile_features(empty PRIVATE ${QT_COMPILE_FEATURES})
 
-# -- Test: AUTORCC
+# -- Test
 # When a file listed in a .qrc file changes the target must be rebuilt
 try_compile(RCC_DEPENDS
   "${CMAKE_CURRENT_BINARY_DIR}/autorcc_depends"
   "${CMAKE_CURRENT_SOURCE_DIR}/autorcc_depends"
   autorcc_depends
-  CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}" "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
+  CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}"
+              "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
               "-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
   OUTPUT_VARIABLE output
 )
@@ -115,13 +116,14 @@ if (NOT file1_step1 GREATER file1_before)
   message(SEND_ERROR "file1 (${qrc_file1}) should have changed in the first step!")
 endif()
 
-# -- Test: AUTOMOC
+# -- Test
 # Ensure a repeated build succeeds when a header containing a QObject changes
 try_compile(MOC_RERUN
   "${CMAKE_CURRENT_BINARY_DIR}/automoc_rerun"
   "${CMAKE_CURRENT_SOURCE_DIR}/automoc_rerun"
   automoc_rerun
-  CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}" "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
+  CMAKE_FLAGS "-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}"
+              "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
               "-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
   OUTPUT_VARIABLE output
 )
@@ -139,7 +141,7 @@ if (automoc_rerun_result)
   message(SEND_ERROR "Second build of automoc_rerun failed.")
 endif()
 
-# -- Test: AUTOMOC, SKIP_AUTOMOC
+# -- Test
 # Test for SKIP_AUTOMOC and SKIP_AUTOGEN on an AUTOMOC enabled target
 qtx_wrap_cpp(skipMocWrapMoc
   skipSource/qItemA.hpp
@@ -161,7 +163,7 @@ set_property(TARGET skipMocB PROPERTY AUTOMOC ON)
 set_property(TARGET skipMocB PROPERTY AUTOUIC ON)
 target_link_libraries(skipMocB ${QT_LIBRARIES})
 
-# -- Test: AUTOUIC, SKIP_AUTOUIC
+# -- Test
 # Test for SKIP_AUTOUIC and SKIP_AUTOGEN on an AUTOUIC enabled target
 set(skipUicSources
   skipUic.cpp
@@ -181,7 +183,7 @@ set_property(TARGET skipUicB PROPERTY AUTOUIC ON)
 set_property(TARGET skipUicB PROPERTY AUTOMOC ON)
 target_link_libraries(skipUicB ${QT_LIBRARIES})
 
-# -- Test: AUTORCC, SKIP_AUTORCC
+# -- Test
 # Test for SKIP_AUTORCC and SKIP_AUTOGEN on an AUTORCC enabled target
 set(skipRccSources
   skipRcc.cpp
@@ -202,10 +204,73 @@ set_property(TARGET skipRccB PROPERTY AUTOUIC ON)
 set_property(TARGET skipRccB PROPERTY AUTOMOC ON)
 target_link_libraries(skipRccB ${QT_LIBRARIES})
 
-# -- Test: AUTOMOC AUTORCC
+# -- Test
 # Source files with the same basename in different subdirectories
 add_subdirectory(sameName)
 
-# -- Test: AUTOMOC AUTORCC AUTOUIC
+# -- Test
+# Tests various include moc patterns
+add_subdirectory(mocIncludeStrict)
+
+# -- Test
+# Tests various include moc patterns
+add_subdirectory(mocIncludeRelaxed)
+
+# -- Test
+# Tests Q_PLUGIN_METADATA json file change detection
+if (NOT QT_TEST_VERSION STREQUAL 4)
+  try_compile(MOC_PLUGIN
+    "${CMAKE_CURRENT_BINARY_DIR}/mocPlugin"
+    "${CMAKE_CURRENT_SOURCE_DIR}/mocPlugin"
+    mocPlugin
+    CMAKE_FLAGS "-DQT_TEST_VERSION=${QT_TEST_VERSION}"
+                "-DCMAKE_PREFIX_PATH=${Qt_PREFIX_DIR}"
+    OUTPUT_VARIABLE output
+  )
+  if (NOT MOC_PLUGIN)
+    message(SEND_ERROR "Initial build of mocPlugin failed. Output: ${output}")
+  endif()
+
+  set(timeformat "%Y%j%H%M%S")
+  set(mocPluginBinDir "${CMAKE_CURRENT_BINARY_DIR}/mocPlugin")
+  find_library(style_a_file "PluginStyleA" "${mocPluginBinDir}")
+  find_library(style_b_file "PluginStyleB" "${mocPluginBinDir}")
+  find_library(style_c_file "PluginStyleC" "${mocPluginBinDir}")
+  find_library(style_d_file "PluginStyleD" "${mocPluginBinDir}")
+
+  file(TIMESTAMP "${style_a_file}" style_a_before "${timeformat}")
+  file(TIMESTAMP "${style_b_file}" style_b_before "${timeformat}")
+  file(TIMESTAMP "${style_c_file}" style_c_before "${timeformat}")
+  file(TIMESTAMP "${style_d_file}" style_d_before "${timeformat}")
+
+  # Ensure that the timestamp will change and touch the json files
+  execute_process(COMMAND "${CMAKE_COMMAND}" -E sleep 1)
+  execute_process(COMMAND "${CMAKE_COMMAND}" -E touch "${mocPluginBinDir}/jsonFiles/StyleC.json")
+  execute_process(COMMAND "${CMAKE_COMMAND}" -E touch "${mocPluginBinDir}/jsonFiles/sub/StyleD.json")
+
+  execute_process(COMMAND "${CMAKE_COMMAND}" --build .
+    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/mocPlugin"
+  )
+
+  file(TIMESTAMP "${style_a_file}" style_a_after "${timeformat}")
+  file(TIMESTAMP "${style_b_file}" style_b_after "${timeformat}")
+  file(TIMESTAMP "${style_c_file}" style_c_after "${timeformat}")
+  file(TIMESTAMP "${style_d_file}" style_d_after "${timeformat}")
+
+  if (style_a_after GREATER style_a_before)
+    message(SEND_ERROR "file (${style_a_file}) should not have changed!")
+  endif()
+  if (style_b_after GREATER style_b_before)
+    message(SEND_ERROR "file (${style_b_file}) should not have changed!")
+  endif()
+  if (NOT style_c_after GREATER style_c_before)
+    message(SEND_ERROR "file (${style_c_file}) should have changed!")
+  endif()
+  if (NOT style_d_after GREATER style_d_before)
+    message(SEND_ERROR "file (${style_d_file}) should have changed!")
+  endif()
+endif()
+
+# -- Test
 # Complex test case
 add_subdirectory(complex)

Tests/QtAutogen/mocInclude/ObjA.cpp

@@ -0,0 +1,24 @@
+#include "ObjA.hpp"
+
+class SubObjA : public QObject
+{
+  Q_OBJECT
+
+public:
+  SubObjA() {}
+  ~SubObjA() {}
+
+  Q_SLOT
+  void aSlot();
+};
+
+void SubObjA::aSlot()
+{
+}
+
+void ObjA::go()
+{
+  SubObjA subObj;
+}
+
+#include "ObjA.moc"

Tests/QtAutogen/mocInclude/ObjA.hpp

@@ -0,0 +1,13 @@
+#ifndef OBJA_HPP
+#define OBJA_HPP
+
+#include <QObject>
+
+class ObjA : public QObject
+{
+  Q_OBJECT
+  Q_SLOT
+  void go();
+};
+
+#endif

Tests/QtAutogen/mocInclude/ObjB.cpp

@@ -0,0 +1,25 @@
+#include "ObjB.hpp"
+
+class SubObjB : public QObject
+{
+  Q_OBJECT
+
+public:
+  SubObjB() {}
+  ~SubObjB() {}
+
+  Q_SLOT
+  void aSlot();
+};
+
+void SubObjB::aSlot()
+{
+}
+
+void ObjB::go()
+{
+  SubObjB subObj;
+}
+
+#include "ObjB.moc"
+#include "moc_ObjB.cpp"

Tests/QtAutogen/mocInclude/ObjB.hpp

@@ -0,0 +1,13 @@
+#ifndef OBJB_HPP
+#define OBJB_HPP
+
+#include <QObject>
+
+class ObjB : public QObject
+{
+  Q_OBJECT
+  Q_SLOT
+  void go();
+};
+
+#endif

Tests/QtAutogen/mocInclude/ObjC.cpp

@@ -0,0 +1,26 @@
+#include "ObjC.hpp"
+
+class SubObjC : public QObject
+{
+  Q_OBJECT
+
+public:
+  SubObjC() {}
+  ~SubObjC() {}
+
+  Q_SLOT
+  void aSlot();
+};
+
+void SubObjC::aSlot()
+{
+}
+
+void ObjC::go()
+{
+  SubObjC subObj;
+}
+
+#include "ObjC.moc"
+// Not the own header
+#include "moc_ObjD.cpp"

Tests/QtAutogen/mocInclude/ObjC.hpp

@@ -0,0 +1,13 @@
+#ifndef OBJC_HPP
+#define OBJC_HPP
+
+#include <QObject>
+
+class ObjC : public QObject
+{
+  Q_OBJECT
+  Q_SLOT
+  void go();
+};
+
+#endif

Tests/QtAutogen/mocInclude/ObjD.cpp

@@ -0,0 +1,26 @@
+#include "ObjD.hpp"
+
+class SubObjD : public QObject
+{
+  Q_OBJECT
+
+public:
+  SubObjD() {}
+  ~SubObjD() {}
+
+  Q_SLOT
+  void aSlot();
+};
+
+void SubObjD::aSlot()
+{
+}
+
+void ObjD::go()
+{
+  SubObjD subObj;
+}
+
+#include "ObjD.moc"
+// Header in subdirectory
+#include "subA/moc_SubObjA.cpp"

Tests/QtAutogen/mocInclude/ObjD.hpp

@@ -0,0 +1,13 @@
+#ifndef OBJD_HPP
+#define OBJD_HPP
+
+#include <QObject>
+
+class ObjD : public QObject
+{
+  Q_OBJECT
+  Q_SLOT
+  void go();
+};
+
+#endif

Tests/QtAutogen/mocInclude/subA/SubObjA.cpp

@@ -0,0 +1,27 @@
+#include "SubObjA.hpp"
+
+namespace subA {
+
+class SubObjA : public QObject
+{
+  Q_OBJECT
+
+public:
+  SubObjA() {}
+  ~SubObjA() {}
+
+  Q_SLOT
+  void aSlot();
+};
+
+void SubObjA::aSlot()
+{
+}
+
+void ObjA::go()
+{
+  SubObjA subObj;
+}
+}
+
+#include "SubObjA.moc"

Tests/QtAutogen/mocInclude/subA/SubObjA.hpp

@@ -0,0 +1,16 @@
+#ifndef SUBOBJA_HPP
+#define SUBOBJA_HPP
+
+#include <QObject>
+
+namespace subA {
+
+class ObjA : public QObject
+{
+  Q_OBJECT
+  Q_SLOT
+  void go();
+};
+}
+
+#endif

Tests/QtAutogen/mocInclude/subB/SubObjB.cpp

@@ -0,0 +1,27 @@
+#include "SubObjB.hpp"
+
+namespace subB {
+
+class SubObjB : public QObject
+{
+  Q_OBJECT
+
+public:
+  SubObjB() {}
+  ~SubObjB() {}
+
+  Q_SLOT
+  void aSlot();
+};
+
+void SubObjB::aSlot()
+{
+}
+
+void ObjB::go()
+{
+  SubObjB subObj;
+}
+}
+
+#include "SubObjB.moc"

Tests/QtAutogen/mocInclude/subB/SubObjB.hpp

@@ -0,0 +1,16 @@
+#ifndef SUBOBJB_HPP
+#define SUBOBJB_HPP
+
+#include <QObject>
+
+namespace subB {
+
+class ObjB : public QObject
+{
+  Q_OBJECT
+  Q_SLOT
+  void go();
+};
+}
+
+#endif

Tests/QtAutogen/mocInclude/subC/SubObjC.cpp

@@ -0,0 +1,27 @@
+#include "SubObjC.hpp"
+
+namespace subC {
+
+class SubObjC : public QObject
+{
+  Q_OBJECT
+
+public:
+  SubObjC() {}
+  ~SubObjC() {}
+
+  Q_SLOT
+  void aSlot();
+};
+
+void SubObjC::aSlot()
+{
+}
+
+void ObjC::go()
+{
+  SubObjC subObj;
+}
+}
+
+#include "SubObjC.moc"

Tests/QtAutogen/mocInclude/subC/SubObjC.hpp

@@ -0,0 +1,16 @@
+#ifndef SUBOBJC_HPP
+#define SUBOBJC_HPP
+
+#include <QObject>
+
+namespace subC {
+
+class ObjC : public QObject
+{
+  Q_OBJECT
+  Q_SLOT
+  void go();
+};
+}
+
+#endif

Tests/QtAutogen/mocIncludeRelaxed/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Test moc include patterns
+
+set(CMAKE_AUTOMOC_RELAXED_MODE TRUE)
+
+include_directories("../mocInclude")
+
+add_executable(mocIncludeRelaxed
+  ../mocInclude/ObjA.cpp
+  ../mocInclude/ObjB.cpp
+  ../mocInclude/ObjC.cpp
+  ../mocInclude/ObjD.cpp
+  ../mocInclude/subA/SubObjA.cpp
+  ../mocInclude/subB/SubObjB.cpp
+  ../mocInclude/subC/SubObjC.cpp
+  main.cpp
+)
+target_link_libraries(mocIncludeRelaxed ${QT_LIBRARIES})
+set_target_properties(mocIncludeRelaxed PROPERTIES AUTOMOC ON)

Tests/QtAutogen/mocIncludeRelaxed/main.cpp

@@ -0,0 +1,14 @@
+#include "ObjA.hpp"
+#include "ObjB.hpp"
+#include "ObjC.hpp"
+
+int main(int argv, char** args)
+{
+  ObjA objA;
+  ObjB objB;
+  ObjC objC;
+  return 0;
+}
+
+// Header in global subdirectory
+#include "subB/moc_SubObjB.cpp"

Tests/QtAutogen/mocIncludeStrict/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Test moc include patterns
+
+set(CMAKE_AUTOMOC_RELAXED_MODE FALSE)
+
+include_directories("../mocInclude")
+
+add_executable(mocIncludeStrict
+  ../mocInclude/ObjA.cpp
+  ../mocInclude/ObjB.cpp
+  ../mocInclude/ObjC.cpp
+  ../mocInclude/ObjD.cpp
+  ../mocInclude/subA/SubObjA.cpp
+  ../mocInclude/subB/SubObjB.cpp
+  ../mocInclude/subC/SubObjC.cpp
+  main.cpp
+)
+target_link_libraries(mocIncludeStrict ${QT_LIBRARIES})
+set_target_properties(mocIncludeStrict PROPERTIES AUTOMOC ON)

Tests/QtAutogen/mocIncludeStrict/main.cpp

@@ -0,0 +1,14 @@
+#include "ObjA.hpp"
+#include "ObjB.hpp"
+#include "ObjC.hpp"
+
+int main(int argv, char** args)
+{
+  ObjA objA;
+  ObjB objB;
+  ObjC objC;
+  return 0;
+}
+
+// Header in global subdirectory
+#include "subB/moc_SubObjB.cpp"

Tests/QtAutogen/mocPlugin/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.8)
+
+if (NOT QT_TEST_VERSION STREQUAL 5)
+  message(SEND_ERROR "Invalid Qt version specified.")
+endif()
+find_package(Qt5Widgets REQUIRED)
+
+if(Qt5_POSITION_INDEPENDENT_CODE AND CMAKE_CXX_COMPILE_OPTIONS_PIC)
+  add_definitions(${CMAKE_CXX_COMPILE_OPTIONS_PIC})
+endif()
+
+configure_file(jsonIn/StyleC.json jsonFiles/StyleC.json @ONLY)
+configure_file(jsonIn/StyleD.json jsonFiles/sub/StyleD.json @ONLY)
+
+# Enable automoc
+set(CMAKE_AUTOMOC TRUE)
+
+include_directories("${CMAKE_CURRENT_BINARY_DIR}/jsonFiles")
+link_libraries(Qt5::Widgets)
+
+add_library(PluginStyleA MODULE StyleA.cpp)
+add_library(PluginStyleB MODULE StyleB.cpp)
+add_library(PluginStyleC MODULE StyleC.cpp)
+add_library(PluginStyleD MODULE StyleD.cpp)
+add_library(PluginStyleE MODULE StyleE.cpp)

Tests/QtAutogen/mocPlugin/StyleA.cpp

@@ -0,0 +1,6 @@
+#include "StyleA.hpp"
+
+QStyle* StyleA::create(const QString& key)
+{
+  return 0;
+}

Tests/QtAutogen/mocPlugin/StyleA.hpp

@@ -0,0 +1,15 @@
+#ifndef STYLEA_HPP
+#define STYLEA_HPP
+
+#include <QStylePlugin>
+
+class StyleA : public QStylePlugin
+{
+  Q_OBJECT
+  // Json file in local directory
+  Q_PLUGIN_METADATA(IID "org.styles.A" FILE "StyleA.json")
+public:
+  QStyle* create(const QString& key);
+};
+
+#endif

Tests/QtAutogen/mocPlugin/StyleA.json

@@ -0,0 +1 @@
+{ "Keys": [ "Rocket", "Starbuster" ] }

Tests/QtAutogen/mocPlugin/StyleB.cpp

@@ -0,0 +1,6 @@
+#include "StyleB.hpp"
+
+QStyle* StyleB::create(const QString& key)
+{
+  return 0;
+}

Tests/QtAutogen/mocPlugin/StyleB.hpp

@@ -0,0 +1,15 @@
+#ifndef STYLEB_HPP
+#define STYLEB_HPP
+
+#include <QStylePlugin>
+
+class StyleB : public QStylePlugin
+{
+  Q_OBJECT
+  // Json file in local subdirectory
+  Q_PLUGIN_METADATA(IID "org.styles.B" FILE "jsonIn/StyleB.json")
+public:
+  QStyle* create(const QString& key);
+};
+
+#endif

Tests/QtAutogen/mocPlugin/StyleC.cpp

@@ -0,0 +1,6 @@
+#include "StyleC.hpp"
+
+QStyle* StyleC::create(const QString& key)
+{
+  return 0;
+}

Tests/QtAutogen/mocPlugin/StyleC.hpp

@@ -0,0 +1,15 @@
+#ifndef STYLEC_HPP
+#define STYLEC_HPP
+
+#include <QStylePlugin>
+
+class StyleC : public QStylePlugin
+{
+  Q_OBJECT
+  // Json file in global root directory
+  Q_PLUGIN_METADATA(IID "org.styles.C" FILE "StyleC.json")
+public:
+  QStyle* create(const QString& key);
+};
+
+#endif

Tests/QtAutogen/mocPlugin/StyleD.cpp

@@ -0,0 +1,6 @@
+#include "StyleD.hpp"
+
+QStyle* StyleD::create(const QString& key)
+{
+  return 0;
+}

Tests/QtAutogen/mocPlugin/StyleD.hpp

@@ -0,0 +1,15 @@
+#ifndef STYLED_HPP
+#define STYLED_HPP
+
+#include <QStylePlugin>
+
+class StyleD : public QStylePlugin
+{
+  Q_OBJECT
+  // Json file in global sub director
+  Q_PLUGIN_METADATA(IID "org.styles.D" FILE "sub/StyleD.json")
+public:
+  QStyle* create(const QString& key);
+};
+
+#endif

Tests/QtAutogen/mocPlugin/StyleE.cpp

@@ -0,0 +1,6 @@
+#include "StyleE.hpp"
+
+QStyle* StyleE::create(const QString& key)
+{
+  return 0;
+}

Tests/QtAutogen/mocPlugin/StyleE.hpp

@@ -0,0 +1,15 @@
+#ifndef STYLEE_HPP
+#define STYLEE_HPP
+
+#include <QStylePlugin>
+
+class StyleE : public QStylePlugin
+{
+  Q_OBJECT
+  // No Json file
+  Q_PLUGIN_METADATA(IID "org.styles.E")
+public:
+  QStyle* create(const QString& key);
+};
+
+#endif

Tests/QtAutogen/mocPlugin/jsonIn/StyleB.json

@@ -0,0 +1 @@
+{ "Keys": [ "Rocket", "StarbusterB" ] }

Tests/QtAutogen/mocPlugin/jsonIn/StyleC.json

@@ -0,0 +1 @@
+{ "Keys": [ "Rocket", "StarbusterC" ] }

Tests/QtAutogen/mocPlugin/jsonIn/StyleD.json

@@ -0,0 +1 @@
+{ "Keys": [ "Rocket", "StarbusterD" ] }

Tests/QtAutogen/mocPlugin/main.cpp

@@ -0,0 +1,6 @@
+#include "StyleA.hpp"
+
+int main(int argv, char** args)
+{
+  return 0;
+}

Tests/QtAutogen/sameName/CMakeLists.txt

@@ -18,3 +18,14 @@ add_executable(sameName
 )
 target_link_libraries(sameName ${QT_LIBRARIES})
 set_target_properties(sameName PROPERTIES AUTOMOC TRUE AUTORCC TRUE)
+
+# Set different compression levels
+if (QT_TEST_VERSION STREQUAL 4)
+  set(rccCompress "-compress")
+else()
+  set(rccCompress "--compress")
+endif()
+set_target_properties(sameName PROPERTIES AUTORCC_OPTIONS "${rccCompress};0" )
+set_source_files_properties(aaa/data.qrc PROPERTIES AUTORCC_OPTIONS "${rccCompress};1" )
+set_source_files_properties(bbb/data.qrc PROPERTIES AUTORCC_OPTIONS "${rccCompress};2" )
+set_source_files_properties(ccc/data.qrc PROPERTIES AUTORCC_OPTIONS "${rccCompress};3" )