Modularize the new configure system (infrastructure part)

This change implements the required infrastructure to modularize the new
configuration system.

This requires a hierarchy of configuration files, both for handling
multiple repositories and for individual modules inside the same
repository.

When configuring, they all need to get loaded first, as command line
processing needs to know about all possible command line options.

When the command line has been processed, the individual configuration
files need to get processed one after the other and independently from
each other.

Configure is now automatically invoked when building the a project
tree's "root" project; this works with both modular and top-level builds
of Qt (the latter with an according change in the super repo). As an
immediate consequence, the -skip option moves to the super repo with a
different implementation, as configuration is now done after the repo
list is determined. The option belongs there anyway.

This commit also adds an optional testDir entry to the json file. Like
this, we can still have all configure tests in qtbase/config.tests and
the configuration file in, e.g., corelib can reference those.

The files section can now be left out as long as a 'module' entry is
present, specifying the module name. The names of the files to generate
can then be deduced from that name. We still need to be able to specify
names directly for the global configuration files.

qtConfig() now also queries features which are module-specific. As it is
sometimes necessary to query the configuration of modules which should
not be actually linked (and cannot in the case of subdirs projects), the
new variable QT_FOR_CONFIG which allows specifying configuration-only
dependencies is introduced.

Done-with: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>
Change-Id: Id1b518a3aa34044748b87fb8fac14d79653f6b18
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>

8 files changed, 430 insertions, 167 deletions

diff --git a/mkspecs/features/configure.prf b/mkspecs/features/configure.prf
index bd53e31a04..f275e3ac06 100644
--- a/mkspecs/features/configure.prf
+++ b/mkspecs/features/configure.prf
@@ -1,5 +1,7 @@
 load(configure_base)
 
+isEmpty(QMAKE_CONFIG_TESTS_DIR): QMAKE_CONFIG_TESTS_DIR = $$_PRO_FILE_PWD_/config.tests
+
 # Try to build the test project in $$QMAKE_CONFIG_TESTS_DIR/$$1
 # ($$_PRO_FILE_PWD_/config.tests/$$1 by default).
 #
diff --git a/mkspecs/features/configure_base.prf b/mkspecs/features/configure_base.prf
index 08edba4b1c..dc630a3528 100644
--- a/mkspecs/features/configure_base.prf
+++ b/mkspecs/features/configure_base.prf
@@ -43,8 +43,6 @@ defineTest(qtRunLoggedCommand) {
     return(true)
 }
 
-isEmpty(QMAKE_CONFIG_TESTS_DIR): QMAKE_CONFIG_TESTS_DIR = $$_PRO_FILE_PWD_/config.tests
-
 # Ensure that a cache is present. If none was found on startup, this will create
 # one in the build directory of the project which loads this feature.
 cache()
diff --git a/mkspecs/features/qt_build_config.prf b/mkspecs/features/qt_build_config.prf
index e0e8ef9f51..95e63ecae0 100644
--- a/mkspecs/features/qt_build_config.prf
+++ b/mkspecs/features/qt_build_config.prf
@@ -95,3 +95,26 @@ defineTest(qtNomakeTools) {
         export($${d}.CONFIG)
     }
 }
+
+# This overloads the same function from qt_functions.prf.
+# This is not in qt_module.prf, as that gets loaded too late.
+defineTest(qtConfig) {
+    modules = $$QT $$QT_PRIVATE $$QT_FOR_PRIVATE $$QT_FOR_CONFIG
+    modules ~= s,-private$,_private,g
+    modules = $$resolve_depends(modules, "QT.", ".depends")
+    isEmpty(MODULE): \
+        MODULE = $$section($$list($$basename(_PRO_FILE_)), ., 0, 0)
+    exists($$OUT_PWD/qt$${MODULE}-config.pri) {
+        include($$OUT_PWD/qt$${MODULE}-config.pri)
+        modules += $${MODULE} $${MODULE}_private
+    }
+    modules += global global_private
+    modules = $$reverse(modules)
+    for (module, modules) {
+        contains(QT.$${module}.enabled_features, $$1): \
+            return(true)
+        contains(QT.$${module}.disabled_features, $$1): \
+            return(false)
+    }
+    error("Could not find feature $${1}.")
+}
diff --git a/mkspecs/features/qt_configure.prf b/mkspecs/features/qt_configure.prf
index 2067829a10..79fede1525 100644
--- a/mkspecs/features/qt_configure.prf
+++ b/mkspecs/features/qt_configure.prf
@@ -1,8 +1,3 @@
-CONFIG -= qt debug_and_release
-load(configure_base)
-
-QMAKE_CONFIG_CACHE = $$dirname(_QMAKE_CACHE_)/config.cache
-QMAKE_CONFIG_CACHE_USE = all
 
 QT_CONFIGURE_REPORT =
 QT_CONFIGURE_NOTES =
@@ -36,8 +31,8 @@ defineTest(qtConfAddError) {
 defineTest(qtConfCommandlineSetInput) {
     arg = $${1}
     val = $${2}
-    !isEmpty(config.commandline.options.$${arg}.name): \
-        arg = $$eval(config.commandline.options.$${arg}.name)
+    !isEmpty($${currentConfig}.commandline.options.$${arg}.name): \
+        arg = $$eval($${currentConfig}.commandline.options.$${arg}.name)
 
     config.input.$$arg = $$val
     export(config.input.$$arg)
@@ -74,7 +69,7 @@ defineTest(qtConfCommandline_void) {
         return()
     }
 
-    val = $$eval(config.commandline.options.$${opt}.value)
+    val = $$eval($${currentConfig}.commandline.options.$${opt}.value)
     isEmpty(val): val = yes
 
     qtConfCommandlineSetInput($$opt, $$val)
@@ -86,11 +81,11 @@ defineTest(qtConfCommandline_enum) {
     isEmpty(val): val = yes
 
     # validate and map value
-    mapped = $$eval(config.commandline.options.$${opt}.values.$${val})
+    mapped = $$eval($${currentConfig}.commandline.options.$${opt}.values.$${val})
     isEmpty(mapped) {
         # just a list of allowed values
-        for (i, config.commandline.options.$${opt}.values._KEYS_) {
-            equals(config.commandline.options.$${opt}.values.$${i}, $$val) {
+        for (i, $${currentConfig}.commandline.options.$${opt}.values._KEYS_) {
+            equals($${currentConfig}.commandline.options.$${opt}.values.$${i}, $$val) {
                 mapped = $$val
                 break()
             }
@@ -108,12 +103,12 @@ defineTest(qtConfValidateValue) {
     opt = $${1}
     val = $${2}
 
-    validValues = $$eval(config.commandline.options.$${opt}.values._KEYS_)
+    validValues = $$eval($${currentConfig}.commandline.options.$${opt}.values._KEYS_)
     isEmpty(validValues): \
         return(true)
 
     for (i, validValues) {
-        equals(config.commandline.options.$${opt}.values.$${i}, $$val): \
+        equals($${currentConfig}.commandline.options.$${opt}.values.$${i}, $$val): \
             return(true)
     }
 
@@ -169,20 +164,24 @@ defineTest(qtConfCommandline_addString) {
     !qtConfValidateValue($$opt, $$val): \
         return()
 
-    !isEmpty(config.commandline.options.$${opt}.name): \
-        opt = $$eval(config.commandline.options.$${opt}.name)
+    !isEmpty($${currentConfig}.commandline.options.$${opt}.name): \
+        opt = $$eval($${currentConfig}.commandline.options.$${opt}.name)
 
     config.input.$$opt += $$val
     export(config.input.$$opt)
 }
 
 defineTest(qtConfParseCommandLine) {
-    custom = $$config.commandline.custom
-    customCall =
-    !isEmpty(custom) {
-        customCall = qtConfCommandline_$$custom
-        !defined($$customCall, test): \
-            error("Custom command line callback '$$custom' is undefined.")
+    customCalls =
+    for (cc, allConfigs) {
+        custom = $$eval($${cc}.commandline.custom)
+
+        !isEmpty(custom) {
+            customCall = qtConfCommandline_$$custom
+            !defined($$customCall, test): \
+                error("Custom command line callback '$$custom' is undefined.")
+            customCalls += $$customCall
+        }
     }
 
     for (ever) {
@@ -212,15 +211,24 @@ defineTest(qtConfParseCommandLine) {
             next()
         }
 
-        !isEmpty(customCall) {
-            $${customCall}($$c): \
-                next()
+        didCustomCall = false
+        for (customCall, customCalls) {
+            $${customCall}($$c) {
+                didCustomCall = true
+                break()
+            }
         }
+        $$didCustomCall: \
+            next()
 
         contains(c, "([A-Z_]+)=(.*)") {
             opt = $$replace(c, "^([A-Z_]+)=(.*)", "\\1")
             val = $$replace(c, "^([A-Z_]+)=(.*)", "\\2")
-            var = $$eval(config.commandline.assignments.$${opt})
+            for (cc, allConfigs) {
+                var = $$eval($${cc}.commandline.assignments.$${opt})
+                !isEmpty(var): \
+                    break()
+            }
             isEmpty(var) {
                 qtConfAddError("Assigning unknown variable '$$opt' on command line.")
                 return()
@@ -254,20 +262,26 @@ defineTest(qtConfParseCommandLine) {
             return()
         }
 
-        type = $$eval(config.commandline.options.$${opt})
-        isEmpty(type): \
-            type = $$eval(config.commandline.options.$${opt}.type)
-        isEmpty(type) {
-            # no match in the regular options, try matching the prefixes
-            for (p, config.commandline.prefix._KEYS_) {
-                e = "^-$${p}(.*)"
-                contains(c, $$e) {
-                    opt = $$eval(config.commandline.prefix.$${p})
-                    val = $$replace(c, $$e, "\\1")
-                    type = "addString"
-                    break()
+        for (cc, allConfigs) {
+            type = $$eval($${cc}.commandline.options.$${opt})
+            isEmpty(type): \
+                type = $$eval($${cc}.commandline.options.$${opt}.type)
+            isEmpty(type) {
+                # no match in the regular options, try matching the prefixes
+                for (p, $${cc}.commandline.prefix._KEYS_) {
+                    e = "^-$${p}(.*)"
+                    contains(c, $$e) {
+                        opt = $$eval($${cc}.commandline.prefix.$${p})
+                        val = $$replace(c, $$e, "\\1")
+                        type = "addString"
+                        break()
+                    }
                 }
             }
+            !isEmpty(type) {
+                currentConfig = $$cc
+                break()
+            }
         }
         # handle builtin [-no]-feature-xxx
         isEmpty(type):contains(opt, "feature-(.*)") {
@@ -368,8 +382,8 @@ defineReplace(qtConfPrepareArgs) {
 }
 
 defineTest(qtConfSetupLibraries) {
-    for (l, config.libraries._KEYS_) {
-        lpfx = config.libraries.$${l}
+    for (l, $${currentConfig}.libraries._KEYS_) {
+        lpfx = $${currentConfig}.libraries.$${l}
         # 'export' may be omitted, in which case it falls back to the library's name
         !defined($${lpfx}.export, var) {
             $${lpfx}.export = $$l
@@ -396,8 +410,8 @@ defineTest(qtConfSetupLibraries) {
     }
 
     # reverse mapping for assignments on command line.
-    for (a, config.commandline.assignments._KEYS_) {
-        apfx = config.commandline.assignments.$${a}
+    for (a, $${currentConfig}.commandline.assignments._KEYS_) {
+        apfx = $${currentConfig}.commandline.assignments.$${a}
         ra = config.commandline.rev_assignments.$$eval($$apfx)
         $$ra = $$a
         export($$ra)
@@ -570,10 +584,12 @@ defineTest(qtConfExportLibrary) {
         qtConfOutputVar(assign, $$output, QMAKE_$${NAME}_VERSION_MINOR, $$member(version, 1))
         qtConfOutputVar(assign, $$output, QMAKE_$${NAME}_VERSION_PATCH, $$member(version, 2))
     }
+    !isEmpty($${currentConfig}.module): \
+        qtConfExtendVar($$output, "QT.$${currentModule}_private.libraries", $$2)
 }
 
 defineTest(qtConfHandleLibrary) {
-    lpfx = config.libraries.$$1
+    lpfx = $${currentConfig}.libraries.$$1
     defined($${lpfx}.result, var): return()
 
     qtConfEnsureTestTypeDeps("library")
@@ -647,10 +663,10 @@ defineTest(qtConfTest_library) {
 
 defineTest(qtConfTestPrepare_compile) {
     for (u, $$list($$eval($${1}.use))) {
-        !contains(config.libraries._KEYS_, $$u): \
+        !contains($${currentConfig}.libraries._KEYS_, $$u): \
             error("Test $$1 tries to use undeclared library '$$u'")
         qtConfHandleLibrary($$u)
-        lpfx = config.libraries.$${u}
+        lpfx = $${currentConfig}.libraries.$${u}
         isEmpty($${lpfx}.source): \
             return(false)
         $${1}.literal_args += $$qtConfLibraryArgs($${lpfx}.sources.$$eval($${lpfx}.source))
@@ -820,12 +836,12 @@ defineTest(qtConfIsBoolean) {
 }
 
 defineTest(qtConfSetupTestTypeDeps) {
-    for (tt, config.testTypeDependencies._KEYS_) {
+    for (tt, $${currentConfig}.testTypeDependencies._KEYS_) {
         !defined(qtConfTest_$${tt}, test): \
             error("Declaring dependency for undefined test type '$$tt'.")
-        for (f, config.testTypeDependencies.$${tt}._KEYS_) {
-            feature = $$eval(config.testTypeDependencies.$${tt}.$${f})
-            isEmpty(config.features.$${feature}._KEYS_): \
+        for (f, $${currentConfig}.testTypeDependencies.$${tt}._KEYS_) {
+            feature = $$eval($${currentConfig}.testTypeDependencies.$${tt}.$${f})
+            isEmpty($${currentConfig}.features.$${feature}._KEYS_): \
                 error("Test type '$$tt' depends on undefined feature '$$feature'.")
         }
     }
@@ -834,31 +850,31 @@ defineTest(qtConfSetupTestTypeDeps) {
     # the call to another one. The former representation is more natural
     # (and concise) to write, while the latter is more efficient to process.
     # Hence, this function inverts the mapping.
-    for (tt, config.testTypeAliases._KEYS_) {
+    for (tt, $${currentConfig}.testTypeAliases._KEYS_) {
         !defined(qtConfTest_$${tt}, test): \
             error("Aliasing undefined test type '$$tt'.")
-        for (tta, config.testTypeAliases.$${tt}._KEYS_) {
-            type = $$eval(config.testTypeAliases.$${tt}.$${tta})
+        for (tta, $${currentConfig}.testTypeAliases.$${tt}._KEYS_) {
+            type = $$eval($${currentConfig}.testTypeAliases.$${tt}.$${tta})
             !defined(qtConfTest_$${type}, test): \
                 error("Aliasing '$$tt' to undefined test type '$$type'.")
-            config.testTypeForwards.$${type} += $$tt
-            export(config.testTypeForwards.$${type})
+            $${currentConfig}.testTypeForwards.$${type} += $$tt
+            export($${currentConfig}.testTypeForwards.$${type})
         }
     }
 }
 
 defineTest(qtConfEnsureTestTypeDeps) {
-    depsn = config.testTypeDependencies.$${1}._KEYS_
+    depsn = $${currentConfig}.testTypeDependencies.$${1}._KEYS_
     !isEmpty($$depsn) {
         for (dep, $$depsn) {
-            feature = $$eval(config.testTypeDependencies.$${1}.$${dep})
+            feature = $$eval($${currentConfig}.testTypeDependencies.$${1}.$${dep})
             !qtConfCheckFeature($$feature): \
                 error("Test type '$$1' depends on non-emitted feature $${feature}.")
         }
         $$depsn =
         export($$depsn)
     }
-    fwdsn = config.testTypeForwards.$${1}
+    fwdsn = $${currentConfig}.testTypeForwards.$${1}
     !isEmpty($$fwdsn) {
         for (fwd, $$fwdsn): \
            qtConfEnsureTestTypeDeps($$fwd)
@@ -868,7 +884,7 @@ defineTest(qtConfEnsureTestTypeDeps) {
 }
 
 defineTest(qtRunSingleTest) {
-    tpfx = config.tests.$${1}
+    tpfx = $${currentConfig}.tests.$${1}
     defined($${tpfx}.result, var): \
         return()
 
@@ -945,10 +961,10 @@ defineReplace(qtConfEvaluateSingleExpression) {
         var = $$section(e, ".", 2, -1)
         isEmpty(var): \
             var = result
-        !contains(config.tests._KEYS_, $$test): \
+        !contains($${currentConfig}.tests._KEYS_, $$test): \
             error("Unknown test object $${test} in expression '$${1}'.")
         qtRunSingleTest($$test)
-        result = $$eval(config.tests.$${test}.$${var})
+        result = $$eval($${currentConfig}.tests.$${test}.$${var})
     } else: contains(e, "^libs\..*") {
         !qt_conf_tests_allowed: \
             error("Expression '$${1}' refers to a library, which is not allowed at this stage of configuring.")
@@ -956,22 +972,36 @@ defineReplace(qtConfEvaluateSingleExpression) {
         var = $$section(e, ".", 2, -1)
         isEmpty(var): \
             var = result
-        !contains(config.libraries._KEYS_, $$lib): \
+        !contains($${currentConfig}.libraries._KEYS_, $$lib): \
             error("Unknown library object $${lib} in expression '$${1}'.")
         qtConfHandleLibrary($$lib)
-        !defined(config.libraries.$${lib}.$${var}, var): \
-            var = sources.$$eval(config.libraries.$${lib}.$${source}).$$var
-        result = $$eval(config.libraries.$${lib}.$${var})
+        !defined($${currentConfig}.libraries.$${lib}.$${var}, var): \
+            var = sources.$$eval($${currentConfig}.libraries.$${lib}.$${source}).$$var
+        result = $$eval($${currentConfig}.libraries.$${lib}.$${var})
     } else: contains(e, "^features\..*") {
         feature = $$section(e, ".", 1, 1)
         var = $$section(e, ".", 2, -1)
         isEmpty(var): \
             var = available
-        !contains(config.features._KEYS_, $$feature): \
+        !contains($${currentConfig}.features._KEYS_, $$feature) {
+            # this is basically a copy of what qtConfig() in qt_build_config.prf
+            # does, but we produce a nicer error message.
+            for (module, QMAKE_CONFIG_DEPS) {
+                contains(QT.$${module}.enabled_features, $$feature): \
+                    result = true
+                else: contains(QT.$${module}.disabled_features, $$feature): \
+                    result = false
+                else: \
+                    next()
+                !equals(var, available): \
+                    error("Expression '$$1' is accessing field '$$var' of non-local feature $${feature}.")
+                return($$result)
+            }
             error("Unknown feature object $${feature} in expression '$${1}'.")
+        }
         !qtConfCheckFeature($$feature): \
             error("Expression '$$1' is accessing non-emitted feature $${feature}.")
-        result = $$eval(config.features.$${feature}.$${var})
+        result = $$eval($${currentConfig}.features.$${feature}.$${var})
     } else: contains(e, "^config\..*") {
         var = $$replace(e, "^config\.", "")
         result = false
@@ -1059,7 +1089,7 @@ defineReplace(qtConfEvaluateSubExpression) {
 }
 
 defineReplace(qtIsFeatureEnabled) {
-    enable = $$eval(config.features.$${1}.enable)
+    enable = $$eval($${currentConfig}.features.$${1}.enable)
     !isEmpty(enable) {
         $$qtConfEvaluate($$enable): \
             return(true)
@@ -1072,7 +1102,7 @@ defineReplace(qtIsFeatureEnabled) {
 }
 
 defineReplace(qtIsFeatureDisabled) {
-    disable = $$eval(config.features.$${1}.disable)
+    disable = $$eval($${currentConfig}.features.$${1}.disable)
     !isEmpty(disable) {
         $$qtConfEvaluate($$disable): \
             return(true)
@@ -1100,7 +1130,7 @@ defineReplace(qtConfCheckSingleCondition) {
 }
 
 defineTest(qtConfCheckFeature) {
-    fpfx = config.features.$${1}
+    fpfx = $${currentConfig}.features.$${1}
 
     available = $$eval($${fpfx}.available)
     !isEmpty(available): return(true)
@@ -1138,7 +1168,7 @@ defineTest(qtConfCheckFeature) {
     $${fpfx}.available = $$result
     export($${fpfx}.available)
 
-    for (i, config.features.$${feature}.output._KEYS_): \
+    for (i, $${currentConfig}.features.$${feature}.output._KEYS_): \
         qtConfProcessOneOutput($$feature, $$i)
 
     return(true)
@@ -1146,7 +1176,7 @@ defineTest(qtConfCheckFeature) {
 
 
 defineTest(qtConfProcessFeatures) {
-    for (feature, config.features._KEYS_): \
+    for (feature, $${currentConfig}.features._KEYS_): \
         qtConfCheckFeature($$feature)
 }
 
@@ -1167,8 +1197,8 @@ defineTest(qtConfReportPadded) {
 defineReplace(qtConfCollectFeatures) {
     l =
     for (feature, $$list($${1})) {
-        $$eval(config.features.$${feature}.available): \
-            l += $$eval(config.features.$${feature}.description)
+        $$eval($${currentConfig}.features.$${feature}.available): \
+            l += $$eval($${currentConfig}.features.$${feature}.description)
     }
 
     isEmpty(l): return("<none>")
@@ -1181,10 +1211,10 @@ defineTest(qtConfReport_featureList) {
 
 defineReplace(qtConfFindFirstAvailableFeature) {
     for (feature, $$list($${1})) {
-        isEmpty(config.features.$${feature}._KEYS_): \
+        isEmpty($${currentConfig}.features.$${feature}._KEYS_): \
             error("Asking for a report on undefined feature $${2}.")
-        $$eval(config.features.$${feature}.available): \
-            return($$eval(config.features.$${feature}.description))
+        $$eval($${currentConfig}.features.$${feature}.available): \
+            return($$eval($${currentConfig}.features.$${feature}.description))
     }
 
     return("<none>")
@@ -1195,14 +1225,14 @@ defineTest(qtConfReport_firstAvailableFeature) {
 }
 
 defineTest(qtConfReport_feature) {
-    !contains(config.features._KEYS_, $$2): \
+    !contains($${currentConfig}.features._KEYS_, $$2): \
         error("Asking for a report on undefined feature $${2}.")
 
     # hide report for not emitted features
-    isEmpty(config.features.$${2}.available): \
+    isEmpty($${currentConfig}.features.$${2}.available): \
         return()
 
-    $$eval(config.features.$${2}.available) {
+    $$eval($${currentConfig}.features.$${2}.available) {
         result = "yes"
         !isEmpty(3): result = "$${3}"
     } else {
@@ -1210,7 +1240,7 @@ defineTest(qtConfReport_feature) {
         !isEmpty(4): result = "$${4}"
     }
 
-    text = $$eval(config.features.$${2}.description)
+    text = $$eval($${currentConfig}.features.$${2}.description)
 
     qtConfReportPadded($${1}$$text, $$result)
 }
@@ -1270,17 +1300,15 @@ defineTest(qtConfCreateReportRecurse) {
 }
 
 defineTest(qtConfProcessEarlyChecks) {
-    qtConfCreateReportRecurse(config.earlyReport, false)
-    qtConfCheckErrors()
+    qtConfCreateReportRecurse($${currentConfig}.earlyReport, false)
 }
 
-
 defineTest(qtConfCreateReport) {
-    qtConfCreateReportRecurse(config.report, false)
+    qtConfCreateReportRecurse($${currentConfig}.report, false)
 }
 
 defineTest(qtConfCreateSummary) {
-    qtConfCreateReportRecurse(config.summary, "")
+    qtConfCreateReportRecurse($${currentConfig}.summary, "")
 }
 
 defineTest(qtConfPrintReport) {
@@ -1322,15 +1350,6 @@ defineTest(qtConfCheckErrors) {
 # output generation
 #
 
-defineReplace(qtConfOutputSelectProFile) {
-    !isEmpty($${1}.public) {
-        $$eval($${1}.public): \
-            return(publicPro)
-    }
-    return(privatePro)
-}
-
-
 # qtConfOutputVar(modifier, output, name, value)
 defineTest(qtConfOutputVar) {
     modifier = $$1
@@ -1338,35 +1357,53 @@ defineTest(qtConfOutputVar) {
     name = $$3
     value = $$val_escape(4)
 
-    !isEmpty(config.output.$${output}.assign.$${name}): \
+    defined($${currentConfig}.output.$${output}.assign.$${name}, var): \
         error("Trying to overwrite assigned variable '$$name' in '$$output' using modifier '$$modifier'.")
 
     equals(modifier, assign) {
-        !isEmpty(config.output.$${output}.append.$${name})|!isEmpty(config.output.$${output}.remove.$${name}): \
+        !isEmpty($${currentConfig}.output.$${output}.append.$${name})|!isEmpty($${currentConfig}.output.$${output}.remove.$${name}): \
             error("Trying to assign variable '$$name' in '$$output', which has already appended or removed parts.")
-        config.output.$${output}.assign.$${name} = $$value
+        $${currentConfig}.output.$${output}.assign.$${name} = $$value
     } else: equals(modifier, append) {
-        contains(config.output.$${output}.remove.$${name}, $$value): \
+        contains($${currentConfig}.output.$${output}.remove.$${name}, $$value): \
             error("Trying to append removed '$$value' to variable '$$name' in '$$output'.")
-        config.output.$${output}.append.$${name} += $$value
+        $${currentConfig}.output.$${output}.append.$${name} += $$value
     } else: equals(modifier, remove) {
-        contains(config.output.$${output}.append.$${name}, $$value): \
+        contains($${currentConfig}.output.$${output}.append.$${name}, $$value): \
             error("Trying to remove appended '$$value' to variable '$$name' in '$$output'.")
-        config.output.$${output}.remove.$${name} += $$value
+        $${currentConfig}.output.$${output}.remove.$${name} += $$value
     } else {
         error("Invalid modifier '$$modifier' passed to qtConfOutputVar.")
     }
-    config.output.$${output}.$${modifier}._KEYS_ *= $${name}
-    export(config.output.$${output}.$${modifier}.$${name})
-    export(config.output.$${output}.$${modifier}._KEYS_)
+    $${currentConfig}.output.$${output}.$${modifier}._KEYS_ *= $${name}
+    export($${currentConfig}.output.$${output}.$${modifier}.$${name})
+    export($${currentConfig}.output.$${output}.$${modifier}._KEYS_)
+}
+
+# qtConfExtendVar(output, name, value)
+defineTest(qtConfExtendVar) {
+    output = $$1
+    name = $$2
+    value = $$val_escape(3)
+
+    !defined($${currentConfig}.output.$${output}.assign.$${name}, var): \
+        error("Trying to extend undefined variable '$$name' in '$$output'.")
+
+    $${currentConfig}.output.$${output}.assign.$${name} += $$value
+    export($${currentConfig}.output.$${output}.assign.$${name})
 }
 
 defineTest(qtConfOutputVarHelper) {
+    !isEmpty($${2}.public):$$eval($${2}.public) {
+        output = "publicPro"
+    } else {
+        output = "privatePro"
+    }
+
     negative = $$eval($${2}.negative)
     isEmpty(negative): negative = false
     equals(3, $$negative): return()
 
-    output = $$qtConfOutputSelectProFile($${2})
     name = $$eval($${2}.name)
     isEmpty(name): \
         error("Output type 'var$$title($$1)' used in feature '$$eval($${2}.feature)' without a 'name' entry.")
@@ -1375,6 +1412,8 @@ defineTest(qtConfOutputVarHelper) {
     !isEmpty($${2}.eval):$$qtConfEvaluate($$eval($${2}.eval)): \
         eval(value = $$value)
     qtConfOutputVar($$1, $$output, $$name, $$value)
+    equals(output, "publicPro"):!isEmpty($${currentConfig}.module): \
+        qtConfExtendVar($$output, "QT.$${currentModule}.exports", $$name)
 }
 
 defineTest(qtConfOutput_varAssign) {
@@ -1392,6 +1431,8 @@ defineTest(qtConfOutput_varRemove) {
 defineTest(qtConfOutputConfigVar) {
     pro = $$3
     var = $$4
+    modular = $$5
+
     negative = $$eval($${1}.negative)
     isEmpty(negative): negative = false
     equals(2, $$negative): return()
@@ -1402,26 +1443,31 @@ defineTest(qtConfOutputConfigVar) {
         $$negative: val = no-$$val
     }
 
-    qtConfOutputVar(append, $$pro, $$var, $$val)
+    isEmpty($${currentConfig}.module)|!$$modular: \
+        qtConfOutputVar(append, $$pro, $$var, $$val)
+    else: \
+        qtConfExtendVar($$pro, "QT.$${currentModule}.$$var", $$val)
 }
 
 defineTest(qtConfOutput_publicQtConfig) {
-    qtConfOutputConfigVar($$1, $$2, "publicPro", "QT_CONFIG")
+    qtConfOutputConfigVar($$1, $$2, "publicPro", "QT_CONFIG", true)
 }
 
 defineTest(qtConfOutput_publicConfig) {
-    qtConfOutputConfigVar($$1, $$2, "publicPro", "CONFIG")
+    !isEmpty($${currentConfig}.module): \
+        error("Cannot use output type 'publicConfig' in module-local feature '$$eval($${1}.feature)'.")
+    qtConfOutputConfigVar($$1, $$2, "publicPro", "CONFIG", false)
 }
 
 defineTest(qtConfOutput_privateConfig) {
-    qtConfOutputConfigVar($$1, $$2, "privatePro", "CONFIG")
+    qtConfOutputConfigVar($$1, $$2, "privatePro", "CONFIG", false)
 }
 
 defineTest(qtConfOutputSetDefine) {
-    config.output.$${1}.$${2} = $${3}
-    config.output.$${1}._KEYS_ *= $${2}
-    export(config.output.$${1}.$${2})
-    export(config.output.$${1}._KEYS_)
+    $${currentConfig}.output.$${1}.$${2} = $${3}
+    $${currentConfig}.output.$${1}._KEYS_ *= $${2}
+    export($${currentConfig}.output.$${1}.$${2})
+    export($${currentConfig}.output.$${1}._KEYS_)
 }
 
 defineTest(qtConfOutput_define) {
@@ -1444,13 +1490,35 @@ defineTest(qtConfOutput_feature) {
         name = $$eval($${1}.feature)
 
     $${2} {
-        qtConfOutputVar(append, "publicPro", "QT_CONFIG", $$name)
+        isEmpty($${currentConfig}.module): \
+            qtConfOutputVar(append, "publicPro", "QT_CONFIG", $$name)
+        else: \
+            qtConfExtendVar("publicPro", "QT.$${currentModule}.QT_CONFIG", $$name)
     } else {
         f = $$upper($$replace(name, -, _))
         qtConfOutputSetDefine("publicHeader", "QT_NO_$$f")
     }
 }
 
+defineTest(qtConfSetModuleName) {
+    currentModule = $$eval($${currentConfig}.module)
+    isEmpty(currentModule): \
+        currentModule = global
+    export(currentModule)
+}
+
+defineTest(qtConfSetupModuleOutputs) {
+    qtConfOutputVar(assign, "publicPro", "QT.$${currentModule}.enabled_features", )
+    qtConfOutputVar(assign, "publicPro", "QT.$${currentModule}.disabled_features", )
+    qtConfOutputVar(assign, "privatePro", "QT.$${currentModule}_private.enabled_features", )
+    qtConfOutputVar(assign, "privatePro", "QT.$${currentModule}_private.disabled_features", )
+    !isEmpty($${currentConfig}.module) {
+        qtConfOutputVar(assign, "publicPro", "QT.$${currentModule}.QT_CONFIG", )
+        qtConfOutputVar(assign, "publicPro", "QT.$${currentModule}.exports", )
+        qtConfOutputVar(assign, "privatePro", "QT.$${currentModule}_private.libraries", )
+    }
+}
+
 defineTest(qtConfOutput_publicFeature) {
     name = "$$eval($${1}.name)"
     isEmpty(name): \
@@ -1458,10 +1526,14 @@ defineTest(qtConfOutput_publicFeature) {
     feature = $$replace(name, [-+.], _)
 
     $${2} {
-        qtConfOutputVar(append, "publicPro", "QT.global.enabled_features", $$name)
+        qtConfExtendVar("publicPro", "QT.$${currentModule}.enabled_features", $$name)
+        QT.$${currentModule}.enabled_features += $$name
+        export(QT.$${currentModule}.enabled_features)
         qtConfOutputSetDefine("publicHeader", "QT_FEATURE_$$feature", 1)
     } else {
-        qtConfOutputVar(append, "publicPro", "QT.global.disabled_features", $$name)
+        qtConfExtendVar("publicPro", "QT.$${currentModule}.disabled_features", $$name)
+        QT.$${currentModule}.disabled_features += $$name
+        export(QT.$${currentModule}.disabled_features)
         qtConfOutputSetDefine("publicHeader", "QT_FEATURE_$$feature", -1)
     }
 }
@@ -1476,17 +1548,21 @@ defineTest(qtConfOutput_privateFeature) {
     feature = $$replace(name, [-+.], _)
 
     $${2} {
-        qtConfOutputVar(append, "privatePro", "QT.global.enabled_features", $$name)
+        qtConfExtendVar("privatePro", "QT.$${currentModule}_private.enabled_features", $$name)
+        QT.$${currentModule}_private.enabled_features += $$name
+        export(QT.$${currentModule}_private.enabled_features)
         qtConfOutputSetDefine("privateHeader", "QT_FEATURE_$$feature", 1)
     } else {
-        qtConfOutputVar(append, "privatePro", "QT.global.disabled_features", $$name)
+        qtConfExtendVar("privatePro", "QT.$${currentModule}_private.disabled_features", $$name)
+        QT.$${currentModule}_private.disabled_features += $$name
+        export(QT.$${currentModule}_private.disabled_features)
         qtConfOutputSetDefine("privateHeader", "QT_FEATURE_$$feature", -1)
     }
 }
 
 defineTest(qtConfProcessOneOutput) {
     feature = $${1}
-    fpfx = config.features.$${feature}
+    fpfx = $${currentConfig}.features.$${feature}
     opfx = $${fpfx}.output.$${2}
 
     condition = $$eval($${opfx}.condition)
@@ -1512,64 +1588,167 @@ defineTest(qtConfProcessOneOutput) {
 }
 
 defineTest(qtConfProcessOutput) {
+    !contains($${currentConfig}._KEYS_, "features"): \
+        return()
+
+    basedir = $$shadowed($$eval($${currentConfig}.dir))
+    module = $$eval($${currentConfig}.module)
+
     # write it to the output files
-    for (type, config.files._KEYS_) {
-        file = $$OUT_PWD/$$eval(config.files.$${type})
+    isEmpty($${currentConfig}.files._KEYS_) {
+        # set defaults that should work for most Qt modules
+        isEmpty(module): \
+            error("Neither module nor files section specified in configuration file.")
+
+        $${currentConfig}.files._KEYS_ = publicPro privatePro publicHeader privateHeader
+        $${currentConfig}.files.publicPro = qt$${module}-config.pri
+        $${currentConfig}.files.privatePro = qt$${module}-config.pri  # sic!
+        $${currentConfig}.files.publicHeader = qt$${module}-config.h
+        $${currentConfig}.files.privateHeader = qt$${module}-config_p.h
+    }
+
+    for (type, $${currentConfig}.files._KEYS_) {
         contains(type, ".*Pro") {
-            for (k, config.output.$${type}.assign._KEYS_): \
-                config.output.$$type += "$$k = $$eval(config.output.$${type}.assign.$$k)"
-            for (k, config.output.$${type}.remove._KEYS_): \
-                config.output.$$type += "$$k -= $$eval(config.output.$${type}.remove.$$k)"
-            for (k, config.output.$${type}.append._KEYS_): \
-                config.output.$$type += "$$k += $$eval(config.output.$${type}.append.$$k)"
+            for (k, $${currentConfig}.output.$${type}.assign._KEYS_): \
+                $${currentConfig}.output.$$type += "$$k = $$eval($${currentConfig}.output.$${type}.assign.$$k)"
+            for (k, $${currentConfig}.output.$${type}.remove._KEYS_): \
+                $${currentConfig}.output.$$type += "$$k -= $$eval($${currentConfig}.output.$${type}.remove.$$k)"
+            for (k, $${currentConfig}.output.$${type}.append._KEYS_): \
+                $${currentConfig}.output.$$type += "$$k += $$eval($${currentConfig}.output.$${type}.append.$$k)"
         } else {
-            for (define, config.output.$${type}._KEYS_) {
-                value = $$eval(config.output.$${type}.$${define})
-                config.output.$$type += "$${LITERAL_HASH}define $$define $$value"
+            for (define, $${currentConfig}.output.$${type}._KEYS_) {
+                value = $$eval($${currentConfig}.output.$${type}.$${define})
+                $${currentConfig}.output.$$type += "$${LITERAL_HASH}define $$define $$value"
             }
         }
-        defined(qtConfOutputPostProcess_$${type}, test): \
-            qtConfOutputPostProcess_$${type}()
 
-        write_file($$file, config.output.$${type})|error()
+        ppScope =
+        !isEmpty(module): ppScope = $${module}_
+        defined(qtConfOutputPostProcess_$${ppScope}$${type}, test): \
+            qtConfOutputPostProcess_$${ppScope}$${type}()
+
+        file = $$eval($${currentConfig}.files.$${type})
+        fileCont.$$file += $$eval($${currentConfig}.output.$${type})
+        fileCont._KEYS_ *= $$file
     }
+
+    for (file, fileCont._KEYS_): \
+        write_file($$basedir/$$file, fileCont.$$file)|error()
 }
 
 #
 # tie it all together
 #
 
-defineTest(qtConfigure) {
+cfgs =
+isEmpty(_QMAKE_SUPER_CACHE_)|equals(OUT_PWD, $$dirname(_QMAKE_SUPER_CACHE_)) {
+    c = $$basename(_PRO_FILE_PWD_)
+    config.$${c}.dir = $$_PRO_FILE_PWD_
+    cfgs += $$c
+    !isEmpty(_QMAKE_SUPER_CACHE_) {
+        for (s, SUBDIRS) {
+            config.$${s}.dir = $$_PRO_FILE_PWD_/$${s}
+            cfgs += $$s
+        }
+    }
+}
+configsToProcess =
+for (c, cfgs) {
+    s = $$eval(config.$${c}.dir)
+    exists($$s/configure.json): \
+        configsToProcess += $$c
+}
+isEmpty(configsToProcess): \
+    return()
+
+load(configure_base)
+
+QMAKE_POST_CONFIGURE =
+allConfigs =
+for(ever) {
+    isEmpty(configsToProcess): \
+        break()
+
+    currentConfig = config.$$take_first(configsToProcess)
+    thisDir = $$eval($${currentConfig}.dir)
+    jsonFile = $$thisDir/configure.json
+    priFile = $$thisDir/configure.pri
+
+    allConfigs += $$currentConfig
+
     # load configuration data
-    configure_data = $$cat($${1}, blob)
-    !parseJson(configure_data, config): \
-        error("Invalid or non-existent file $${1}.")
+    configure_data = $$cat($$jsonFile, blob)
+    !parseJson(configure_data, $$currentConfig): \
+        error("Invalid or non-existent file $${jsonFile}.")
+    exists($$priFile): \
+        !include($$priFile): error()
+
+    # prepend all subconfigs to files to keep a depth first search order
+    subconfigs =
+    for(n, $${currentConfig}.subconfigs._KEYS_) {
+        subconfig = $$eval($${currentConfig}.subconfigs.$${n})
+        name = $$basename(subconfig)
+        config.$${name}.dir = $$thisDir/$$subconfig
+        subconfigs += $$name
+    }
+    configsToProcess = $$subconfigs $$configsToProcess
+}
 
+for (currentConfig, allConfigs): \
     qtConfSetupLibraries()
-    qtConfSetupTestTypeDeps()
 
-    qtConfParseCommandLine()
+!isEmpty(_QMAKE_SUPER_CACHE_): \
+    QMAKE_CONFIG_CACHE = $$dirname(_QMAKE_SUPER_CACHE_)/config.cache
+else: \
+    QMAKE_CONFIG_CACHE = $$dirname(_QMAKE_CACHE_)/config.cache
+QMAKE_CONFIG_CACHE_USE = all
 
-    !equals(QMAKE_CONFIG_CACHE_USE, none) {
-        include($$QMAKE_CONFIG_CACHE, , true)
-        # this crudely determines when to discard the cache. this also catches the case
-        # of no cache being there in the first place.
-        !equals(cache.platform, $$[QMAKE_SPEC])|!equals(cache.xplatform, $$[QMAKE_XSPEC]): \
-            QMAKE_CONFIG_CACHE_USE = none
-    }
-    equals(QMAKE_CONFIG_CACHE_USE, none) {
-        cont = \
-            "cache.platform = $$[QMAKE_SPEC]" \
-            "cache.xplatform = $$[QMAKE_XSPEC]"
-        write_file($$QMAKE_CONFIG_CACHE, cont)
-    }
+qtConfParseCommandLine()
+
+!equals(QMAKE_CONFIG_CACHE_USE, none) {
+    include($$QMAKE_CONFIG_CACHE, , true)
+    # this crudely determines when to discard the cache. this also catches the case
+    # of no cache being there in the first place.
+    !equals(cache.platform, $$[QMAKE_SPEC])|!equals(cache.xplatform, $$[QMAKE_XSPEC]): \
+        QMAKE_CONFIG_CACHE_USE = none
+}
+equals(QMAKE_CONFIG_CACHE_USE, none) {
+    cont = \
+        "cache.platform = $$[QMAKE_SPEC]" \
+        "cache.xplatform = $$[QMAKE_XSPEC]"
+    write_file($$QMAKE_CONFIG_CACHE, cont)
+}
 
+for (currentConfig, allConfigs) {
+    qtConfSetModuleName()
+    qtConfSetupModuleOutputs()
     # do early checks, mainly to validate the command line
     qtConfProcessEarlyChecks()
+}
+qtConfCheckErrors()
 
-    CONFIG += qt_conf_tests_allowed
-    logn()
-    logn("Running configuration tests...")
+CONFIG += qt_conf_tests_allowed
+logn()
+logn("Running configuration tests...")
+
+for (currentConfig, allConfigs) {
+    tdir = $$eval($${currentConfig}.testDir)
+    isEmpty(tdir): tdir = config.tests
+    QMAKE_CONFIG_TESTS_DIR = $$absolute_path($$tdir, $$eval($${currentConfig}.dir))
+
+    qtConfSetModuleName()
+
+    qtConfSetupTestTypeDeps()
+
+    # correctly setup dependencies
+    QMAKE_CONFIG_DEPS = global global_private
+    !isEmpty($${currentConfig}.module) {
+        for (d, $${currentConfig}.depends._KEYS_) {
+            dep = $$replace($${currentConfig}.depends.$$d, -private$, _private)
+            dep *= $$replace(dep, _private$, )
+            QMAKE_CONFIG_DEPS += $$dep
+        }
+    }
 
     # process all features
     qtConfProcessFeatures()
@@ -1578,14 +1757,15 @@ defineTest(qtConfigure) {
     qtConfProcessOutput()
     qtConfCreateReport()
     qtConfCreateSummary()
-
-    logn("Done running configuration tests.")
-    logn()
 }
 
-qtConfigure($$_PRO_FILE_PWD_/configure.json)
+# these come from the pri files loaded above.
+for (p, QMAKE_POST_CONFIGURE): \
+    eval($$p)
 
-logn("Configure summary:")
+logn("Done running configuration tests.")
 logn()
 
+logn("Configure summary:")
+logn()
 qtConfPrintReport()
diff --git a/mkspecs/features/qt_functions.prf b/mkspecs/features/qt_functions.prf
index 735ece45f2..efbf2fab1d 100644
--- a/mkspecs/features/qt_functions.prf
+++ b/mkspecs/features/qt_functions.prf
@@ -300,10 +300,16 @@ defineTest(prepareRecursiveTarget) {
 }
 
 defineTest(qtConfig) {
-    contains(QT.global.enabled_features, $$1): \
-        return(true)
-    contains(QT.global.disabled_features, $$1): \
-        return(false)
-
+    modules = $$QT $$QT_PRIVATE $$QT_FOR_CONFIG
+    modules ~= s,-private$,_private,g
+    modules = $$resolve_depends(modules, "QT.", ".depends")
+    modules += global global_private
+    modules = $$reverse(modules)
+    for (module, modules) {
+        contains(QT.$${module}.enabled_features, $$1): \
+            return(true)
+        contains(QT.$${module}.disabled_features, $$1): \
+            return(false)
+    }
     error("Could not find feature $${1}.")
 }
diff --git a/mkspecs/features/qt_module_headers.prf b/mkspecs/features/qt_module_headers.prf
index 9e0b21903f..229760068e 100644
--- a/mkspecs/features/qt_module_headers.prf
+++ b/mkspecs/features/qt_module_headers.prf
@@ -106,6 +106,16 @@ alien_syncqt: return()
 
 MODULE_INC_OUTDIR = $$MODULE_BASE_OUTDIR/include/$$MODULE_INCNAME
 
+exists($$OUT_PWD/qt$${MODULE}-config.h) {
+    fwd_rel = $$relative_path($$OUT_PWD, $$MODULE_INC_OUTDIR)
+    SYNCQT.INJECTIONS += \
+        $$fwd_rel/qt$${MODULE}-config.h:qt$${MODULE}-config.h \
+        $$fwd_rel/qt$${MODULE}-config_p.h:$$MODULE_VERSION/$$MODULE_INCNAME/private/qt$${MODULE}-config_p.h
+    inst_rel = $$relative_path($$OUT_PWD, $$_PRO_FILE_PWD_)
+    SYNCQT.HEADER_FILES += $$inst_rel/qt$${MODULE}-config.h
+    SYNCQT.PRIVATE_HEADER_FILES += $$inst_rel/qt$${MODULE}-config_p.h
+}
+
 for (injection, SYNCQT.INJECTIONS) {
     injects = $$split(injection, :)
     dst_hdr = $$absolute_path($$member(injects, 0), $$MODULE_INC_OUTDIR)
diff --git a/mkspecs/features/qt_module_pris.prf b/mkspecs/features/qt_module_pris.prf
index b67a56c7d5..9542a362d0 100644
--- a/mkspecs/features/qt_module_pris.prf
+++ b/mkspecs/features/qt_module_pris.prf
@@ -35,6 +35,41 @@ else: \
 MODULE_PRI = $$mod_inst_pfx/qt_lib_$${MODULE_ID}.pri
 MODULE_FWD_PRI = $$mod_work_pfx/qt_lib_$${MODULE_ID}.pri
 
+exists($$OUT_PWD/qt$${MODULE}-config.pri): \
+    include($$OUT_PWD/qt$${MODULE}-config.pri)
+
+defineReplace(qtGetFeaturesForModule) {
+    enabled = $$unique(QT.$${1}.enabled_features)
+    disabled = $$unique(QT.$${1}.disabled_features)
+    result = \
+        "QT.$${1}.enabled_features =$$join(enabled, " ", " ")" \
+        "QT.$${1}.disabled_features =$$join(disabled, " ", " ")"
+    return($$result)
+}
+
+defineReplace(qtGetExportsForModule) {
+    result =
+    for (var, QT.$${1}.exports): \
+        result += "$$var = $$val_escape($$var)"
+    return($$result)
+}
+
+defineReplace(qtExportLibsForModule) {
+    result =
+    for (lib, QT.$${1}.libraries) {
+        NAME = $$upper($$lib)
+        vars = \
+            QMAKE_LIBS_$$NAME QMAKE_LIBS_$${NAME}_DEBUG QMAKE_LIBS_$${NAME}_RELEASE \
+            QMAKE_CFLAGS_$$NAME QMAKE_INCDIR_$$NAME QMAKE_$${NAME}_VERSION \
+            QMAKE_$${NAME}_VERSION_MAJOR QMAKE_$${NAME}_VERSION_MINOR QMAKE_$${NAME}_VERSION_PATCH
+        for (var, vars) {
+            !isEmpty($$var): \
+                result += "$$var = $$val_escape($$var)"
+        }
+    }
+    return($$result)
+}
+
 !build_pass {
 
     # Create a module .pri file
@@ -102,6 +137,9 @@ MODULE_FWD_PRI = $$mod_work_pfx/qt_lib_$${MODULE_ID}.pri
         "QT.$${MODULE_ID}.module_config =$$join(module_build_type, " ", " ")" \
         $$module_config \
         "QT.$${MODULE_ID}.DEFINES = $$val_escape(MODULE_DEFINES)" \
+        $$qtGetFeaturesForModule($$MODULE_ID) \
+        $$qtGetExportsForModule($$MODULE_ID) \
+        "QT_CONFIG +=$$join(QT.$${MODULE_ID}.QT_CONFIG, " ", " ")" \
         "" \
         "QT_MODULES += $$MODULE"
     winrt: MODULE_PRI_CONT += \
@@ -126,7 +164,10 @@ MODULE_FWD_PRI = $$mod_work_pfx/qt_lib_$${MODULE_ID}.pri
             "QT.$${MODULE}_private.includes = $$MODULE_PRIVATE_INCLUDES" \
             "QT.$${MODULE}_private.frameworks =" \
             "QT.$${MODULE}_private.depends = $$private_deps" \
-            "QT.$${MODULE}_private.module_config =$$join(module_build_type, " ", " ")"
+            "QT.$${MODULE}_private.module_config =$$join(module_build_type, " ", " ")" \
+            $$qtGetFeaturesForModule($${MODULE}_private) \
+            "" \
+            $$qtExportLibsForModule($${MODULE}_private)
         write_file($$MODULE_PRIVATE_PRI, MODULE_PRIVATE_PRI_CONT)|error()
     }
     MODULE_PRI_FILES = $$MODULE_PRI $$MODULE_PRIVATE_PRI
diff --git a/mkspecs/features/qt_parts.prf b/mkspecs/features/qt_parts.prf
index fa62f40e35..0accef6665 100644
--- a/mkspecs/features/qt_parts.prf
+++ b/mkspecs/features/qt_parts.prf
@@ -12,6 +12,8 @@
 # Ensure that each module has a .qmake.cache when properly qmake'd.
 cache()
 
+load(qt_configure)
+
 load(qt_build_config)
 
 TEMPLATE = subdirs
@@ -74,6 +76,7 @@ QT_BUILD_PARTS -= libs tools examples tests
 
 QMAKE_DISTCLEAN += \
     .qmake.cache \
+    config.cache \
     config.log \
     mkspecs/modules/*.pri \
     mkspecs/modules-inst/*.pri