CMake: Enforce minimum CMake version in user projects

This change introduces new behavior to error out when configuring user
projects if the CMake version used is too old for Qt to work with.

The main motivator is the requirement of new CMake features to ensure
object libraries are placed in the proper place on the link line in
static builds.

The minimum CMake version is computed based on whether Qt was
configured as shared or static libraries.

At the moment the required versions for building and using Qt are the
same.

The minimum versions are defined in qtbase/.cmake.conf in the
following variables

QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_SHARED
QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_STATIC
QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_SHARED
QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_STATIC

Qt Packagers can disable the version check when configuring Qt
by setting
QT_FORCE_MIN_CMAKE_VERSION_FOR_BUILDING_QT and
QT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT.

In this case it is the packagers responsibility to ensure such a Qt
works correctly with the specified CMake version.

User projects can also set QT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT
to disable the version check. Then it's the project's developer
responsibility to ensure such a Qt works correctly.

No official support is provided for these cases.

Implementation notes.

The versions required to build Qt are stored in
QtBuildInternalsExtra.cmake
whereas the versions required to use Qt are stored in a new
QtConfigExtras.cmake.

Also the policy range variables stored in
QtBuildInternalsExtra.cmake are now regular variables instead of cache
variables, to properly allow overrides per-repository.

Some renaming of functions and variables was done for a bit more
clarity and easier grep-ability.

Pick-to: 6.2
Task-number: QTBUG-95018
Change-Id: I4279f2e10b6d3977319237ba21e2f4ed676aa48b
Reviewed-by: Alexey Edelev <alexey.edelev@qt.io>
Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>

9 files changed, 205 insertions, 53 deletions

diff --git a/.cmake.conf b/.cmake.conf
index ff95a9c186..12991eebd5 100644
--- a/.cmake.conf
+++ b/.cmake.conf
@@ -2,8 +2,14 @@ set(QT_REPO_MODULE_VERSION "6.2.0")
 set(QT_REPO_MODULE_PRERELEASE_VERSION_SEGMENT "alpha1")
 
 # Minimum requirement for building Qt
-set(QT_MIN_SUPPORTED_CMAKE_VERSION "3.16")
-set(QT_MIN_SUPPORTED_CMAKE_VERSION_FOR_STATIC_QT "3.20")
+set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_SHARED "3.16")
+set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_STATIC "3.20")
+
+# Minimum requirement for consuming Qt in a user project.
+# This might be different in the future, e.g. be lower than the requirement for
+# building Qt.
+set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_SHARED "3.16")
+set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_STATIC "3.20")
 
 # Policy settings for commands defined by qtbase. These will also be injected
 # into the top level policy scope of each Qt module when building Qt so that
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c3dcc2f731..f453505ee8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -57,7 +57,8 @@ set(QT6_IS_SHARED_LIBS_BUILD ${BUILD_SHARED_LIBS})
 #   or specified via a toolchain file that is loaded by the project() call
 #   or set by the option() call above
 include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/QtCMakeVersionHelpers.cmake")
-qt_internal_check_for_suitable_cmake_version()
+include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/QtPublicCMakeVersionHelpers.cmake")
+qt_internal_check_and_warn_about_unsuitable_cmake_version()
 
 if(NOT QT_BUILD_STANDALONE_TESTS)
     ## Add some paths to check for cmake modules:
diff --git a/cmake/QtBaseGlobalTargets.cmake b/cmake/QtBaseGlobalTargets.cmake
index aab7646b25..0ed881aac5 100644
--- a/cmake/QtBaseGlobalTargets.cmake
+++ b/cmake/QtBaseGlobalTargets.cmake
@@ -142,16 +142,28 @@ qt_internal_export_modern_cmake_config_targets_file(TARGETS ${__export_targets}
                                                     CONFIG_INSTALL_DIR
                                                     ${__GlobalConfig_install_dir})
 
-# Generate and install Qt6 config file. Make sure it happens after the global feature evaluation so
-# they can be accessed in the Config file if needed.
+# Save minimum required CMake version to use Qt.
+qt_internal_get_supported_min_cmake_version_for_using_qt(supported_min_version_for_using_qt)
+qt_internal_get_computed_min_cmake_version_for_using_qt(computed_min_version_for_using_qt)
+
+# Get the lower and upper policy range to embed into the Qt6 config file.
 qt_internal_get_min_new_policy_cmake_version(min_new_policy_version)
 qt_internal_get_max_new_policy_cmake_version(max_new_policy_version)
+
+# Generate and install Qt6 config file. Make sure it happens after the global feature evaluation so
+# they can be accessed in the Config file if needed.
 configure_package_config_file(
     "${PROJECT_SOURCE_DIR}/cmake/QtConfig.cmake.in"
     "${__GlobalConfig_build_dir}/${INSTALL_CMAKE_NAMESPACE}Config.cmake"
     INSTALL_DESTINATION "${__GlobalConfig_install_dir}"
 )
 
+configure_file(
+    "${PROJECT_SOURCE_DIR}/cmake/QtConfigExtras.cmake.in"
+    "${__GlobalConfig_build_dir}/${INSTALL_CMAKE_NAMESPACE}ConfigExtras.cmake"
+    @ONLY
+)
+
 write_basic_package_version_file(
     "${__GlobalConfig_build_dir}/${INSTALL_CMAKE_NAMESPACE}ConfigVersion.cmake"
     VERSION ${PROJECT_VERSION}
@@ -160,6 +172,7 @@ write_basic_package_version_file(
 
 qt_install(FILES
     "${__GlobalConfig_build_dir}/${INSTALL_CMAKE_NAMESPACE}Config.cmake"
+    "${__GlobalConfig_build_dir}/${INSTALL_CMAKE_NAMESPACE}ConfigExtras.cmake"
     "${__GlobalConfig_build_dir}/${INSTALL_CMAKE_NAMESPACE}ConfigVersion.cmake"
     DESTINATION "${__GlobalConfig_install_dir}"
     COMPONENT Devel
@@ -257,6 +270,7 @@ qt_copy_or_install(DIRECTORY
 set(__public_cmake_helpers
     cmake/QtFeature.cmake
     cmake/QtFeatureCommon.cmake
+    cmake/QtPublicCMakeVersionHelpers.cmake
     cmake/QtPublicFinalizerHelpers.cmake
     cmake/QtPublicPluginHelpers.cmake
     cmake/QtPublicTargetHelpers.cmake
diff --git a/cmake/QtBuildInternalsExtra.cmake.in b/cmake/QtBuildInternalsExtra.cmake.in
index b089f00fd6..640fbdca9d 100644
--- a/cmake/QtBuildInternalsExtra.cmake.in
+++ b/cmake/QtBuildInternalsExtra.cmake.in
@@ -69,5 +69,20 @@ set(QT_USE_CCACHE @QT_USE_CCACHE@ CACHE BOOL "Enable the use of ccache")
 set(QT_CREATE_VERSIONED_HARD_LINK "@QT_CREATE_VERSIONED_HARD_LINK@" CACHE BOOL
     "Enable the use of versioned hard link")
 
+# The minimum version required to build Qt.
+set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT "@supported_min_version_for_building_qt@")
+set(QT_COMPUTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT "@computed_min_version_for_building_qt@")
+
+# The lower and upper CMake version policy range as computed by qtbase.
+# These values are inherited when building other Qt repositories, unless overridden
+# in the respective repository .cmake.conf file.
+# These are not cache variables, so that they can be overridden in each repo directory scope.
+if(NOT DEFINED QT_MIN_NEW_POLICY_CMAKE_VERSION)
+    set(QT_MIN_NEW_POLICY_CMAKE_VERSION "@min_new_policy_version@")
+endif()
+if(NOT DEFINED QT_MAX_NEW_POLICY_CMAKE_VERSION)
+    set(QT_MAX_NEW_POLICY_CMAKE_VERSION "@max_new_policy_version@")
+endif()
+
 # Extra set of exported variables
 @QT_EXTRA_BUILD_INTERNALS_VARS@
diff --git a/cmake/QtCMakeVersionHelpers.cmake b/cmake/QtCMakeVersionHelpers.cmake
index 31eb78b667..9013c2321a 100644
--- a/cmake/QtCMakeVersionHelpers.cmake
+++ b/cmake/QtCMakeVersionHelpers.cmake
@@ -1,38 +1,74 @@
-# Returns the minimum supported CMake version required to build Qt as originally advertised by Qt.
-function(qt_internal_get_qt_supported_minimum_cmake_version out_var)
+# Returns the minimum supported CMake version required to /build/ Qt as originally advertised by Qt.
+function(qt_internal_get_supported_min_cmake_version_for_building_qt out_var)
     if(NOT DEFINED BUILD_SHARED_LIBS)
         message(FATAL_ERROR "BUILD_SHARED_LIBS is needed to decide the minimum CMake version. "
             "It should have been set by this point.")
     endif()
 
-    # QT_MIN_SUPPORTED_CMAKE_VERSION is set either in .cmake.conf or in QtBuildInternalsExtras.cmake
-    # when building a repo.
-    set(supported_version "${QT_MIN_SUPPORTED_CMAKE_VERSION}")
+    # First check if a value is already set in QtBuildInternalsExtras.cmake, which means we're
+    # building a repo other than qtbase and the minimum version was already recorded.
+    if(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT)
+        set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT}")
 
-    if(NOT BUILD_SHARED_LIBS)
-        set(supported_version "${QT_MIN_SUPPORTED_CMAKE_VERSION_FOR_STATIC_QT}")
+    # We're building qtbase so the values come from .cmake.conf.
+    elseif(BUILD_SHARED_LIBS)
+        set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_SHARED}")
+    else()
+        set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_STATIC}")
     endif()
+
     set(${out_var} "${supported_version}" PARENT_SCOPE)
 endfunction()
 
-# Returns the computed minimum supported CMake version required to build Qt.
-function(qt_internal_get_computed_minimum_cmake_version out_var)
+# Returns the minimum supported CMake version required to /use/ Qt as originally advertised by Qt.
+function(qt_internal_get_supported_min_cmake_version_for_using_qt out_var)
+    if(NOT DEFINED BUILD_SHARED_LIBS)
+        message(FATAL_ERROR "BUILD_SHARED_LIBS is needed to decide the minimum CMake version. "
+            "It should have been set by this point.")
+    endif()
+
+    if(BUILD_SHARED_LIBS)
+        set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_SHARED}")
+    else()
+        set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_STATIC}")
+    endif()
+
+    set(${out_var} "${supported_version}" PARENT_SCOPE)
+endfunction()
+
+# Returns the computed minimum supported CMake version required to /build/ Qt.
+function(qt_internal_get_computed_min_cmake_version_for_building_qt out_var)
     # An explicit override for those that take it upon themselves to fix the build system
     # when using a CMake version lower than the one officially supported.
     # Also useful for build testing locally with different minimum versions to observe different
     # policy behaviors.
-    if(QT_FORCE_MIN_CMAKE_VERSION)
-        set(computed_min_version "${QT_FORCE_MIN_CMAKE_VERSION}")
+    if(QT_FORCE_MIN_CMAKE_VERSION_FOR_BUILDING_QT)
+        set(computed_min_version "${QT_FORCE_MIN_CMAKE_VERSION_FOR_BUILDING_QT}")
 
     # Set in QtBuildInternalsExtras.cmake, which means it was already computed as part of qtbase
     # configuration.
-    elseif(QT_COMPUTED_MIN_CMAKE_VERSION)
-        set(computed_min_version "${QT_COMPUTED_MIN_CMAKE_VERSION}")
+    elseif(QT_COMPUTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT)
+        set(computed_min_version "${QT_COMPUTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT}")
 
     # No override was given and the version was not computed before, thus initialize with the
     # default minimum.
     else()
-        qt_internal_get_qt_supported_minimum_cmake_version(min_supported_version)
+        qt_internal_get_supported_min_cmake_version_for_building_qt(min_supported_version)
+        set(computed_min_version "${min_supported_version}")
+    endif()
+    set(${out_var} "${computed_min_version}" PARENT_SCOPE)
+endfunction()
+
+# Returns the computed minimum supported CMake version required to /use/ Qt.
+function(qt_internal_get_computed_min_cmake_version_for_using_qt out_var)
+    # Allow overriding the required minimum CMake version for user projects, without forcing
+    # each project developer to have to override it manually.
+    if(QT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT)
+        set(computed_min_version "${QT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT}")
+
+    # No override was given, thus initialize with the default minimum.
+    else()
+        qt_internal_get_supported_min_cmake_version_for_using_qt(min_supported_version)
         set(computed_min_version "${min_supported_version}")
     endif()
     set(${out_var} "${computed_min_version}" PARENT_SCOPE)
@@ -63,49 +99,54 @@ function(qt_internal_get_max_new_policy_cmake_version out_var)
     set(${out_var} "${upper_version}" PARENT_SCOPE)
 endfunction()
 
-function(qt_internal_check_for_suitable_cmake_version)
-    # Implementation note.
-    # The very first cmake_minimum_required() call can't be placed in an include()d file.
-    # It causes CMake to fail to configure with 'No cmake_minimum_required command is present.'
-    # The first cmake_minimum_required() must be called directly in the top-level CMakeLists.txt
-    # file.
-    # That's why this function only handles output of warnings, and doesn't try to set the required
-    # version.
-    qt_internal_check_minimum_cmake_version()
-    qt_internal_warn_about_unsuitable_cmake_versions()
+function(qt_internal_check_and_warn_about_unsuitable_cmake_version)
+    # Don't show the warnings multiple times in a top-level build.
+    get_cmake_property(check_done _qt_unsuitable_cmake_version_check_done)
+    if(check_done)
+        return()
+    endif()
+    set_property(GLOBAL PROPERTY _qt_unsuitable_cmake_version_check_done TRUE)
+
+    qt_internal_warn_if_min_cmake_version_not_met()
+    qt_internal_warn_about_buggy_cmake_versions()
 endfunction()
 
-# Function to be used in downstream repos like qtsvg to require a minimum CMake version.
+# Function to be used in downstream repos (like qtsvg) to require a minimum CMake version and warn
+# about unsuitable cmake versions.
 #
 # Such repos don't have the required version information at cmake_minimum_required() time, that's
 # why we provide this function to be called at a time when the info is available.
 function(qt_internal_require_suitable_cmake_version)
-    qt_internal_check_for_suitable_cmake_version()
-    qt_internal_get_computed_minimum_cmake_version(computed_min_version)
+    qt_internal_check_and_warn_about_unsuitable_cmake_version()
+    qt_internal_get_computed_min_cmake_version_for_building_qt(computed_min_version)
 
     if(CMAKE_VERSION VERSION_LESS computed_min_version)
+        set(major_minor "${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}")
         message(FATAL_ERROR
             "CMake ${computed_min_version} or higher is required. "
             "You are running version ${CMAKE_VERSION} "
             "\nQt requires newer CMake features to build correctly. You can lower the minimum "
-            "required version by passing a QT_FORCE_MIN_CMAKE_VERSION cache variable when configuring Qt.")
+            "required version by passing "
+            "-DQT_FORCE_MIN_CMAKE_VERSION_FOR_BUILDING_QT=${major_minor} when configuring Qt. "
+            "Building Qt with this CMake version is not officially supported. Use at your own risk."
+            )
     endif()
 endfunction()
 
-function(qt_internal_check_minimum_cmake_version)
-    qt_internal_get_qt_supported_minimum_cmake_version(min_supported_version)
-    qt_internal_get_computed_minimum_cmake_version(computed_min_version)
+function(qt_internal_warn_if_min_cmake_version_not_met)
+    qt_internal_get_supported_min_cmake_version_for_building_qt(min_supported_version)
+    qt_internal_get_computed_min_cmake_version_for_building_qt(computed_min_version)
 
     if(NOT min_supported_version STREQUAL computed_min_version
             AND computed_min_version VERSION_LESS min_supported_version)
         message(WARNING
-               "The minimum required CMake version to build Qt is '${min_supported_version}'. "
-               "You have explicitly chosen to require a lower minimum CMake version, namely '${computed_min_version}'. "
-               "Building Qt with such a CMake version is not officially supported. Use at your own risk.")
+               "The minimum required CMake version to build Qt is: '${min_supported_version}'. "
+               "You have explicitly chosen to require a lower minimum CMake version: '${computed_min_version}'. "
+               "Building Qt with this CMake version is not officially supported. Use at your own risk.")
     endif()
 endfunction()
 
-function(qt_internal_warn_about_unsuitable_cmake_versions)
+function(qt_internal_warn_about_buggy_cmake_versions)
     set(unsuitable_versions "")
 
     # Touching a library's source file causes unnecessary rebuilding of unrelated targets.
@@ -161,13 +202,15 @@ function(qt_internal_warn_about_unsuitable_cmake_versions)
     endif()
 endfunction()
 
+# Used to upgrade policies only when building Qt repositories.
+#
 # Functions don't have their own policy scope, so the policy settings modified
 # here will be those of the caller's policy scope. Note that these settings
 # will only apply to functions and macros defined after this function is called,
 # but not to any that are already defined. Ordinary CMake code not inside a
 # function or macro will be affected by these policy settings too.
 function(qt_internal_upgrade_cmake_policies)
-    qt_internal_get_computed_minimum_cmake_version(lower_version)
+    qt_internal_get_computed_min_cmake_version_for_building_qt(lower_version)
     qt_internal_get_max_new_policy_cmake_version(upper_version)
     cmake_minimum_required(VERSION ${lower_version}...${upper_version})
 endfunction()
diff --git a/cmake/QtConfig.cmake.in b/cmake/QtConfig.cmake.in
index 92e47a04a0..7f5698a34c 100644
--- a/cmake/QtConfig.cmake.in
+++ b/cmake/QtConfig.cmake.in
@@ -2,6 +2,10 @@
 
 cmake_minimum_required(VERSION @min_new_policy_version@...@max_new_policy_version@)
 
+include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@ConfigExtras.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/QtPublicCMakeVersionHelpers.cmake")
+__qt_internal_require_suitable_cmake_version_for_using_qt()
+
 get_filename_component(_qt_cmake_dir "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE)
 set(_qt_@PROJECT_VERSION_MAJOR@_config_cmake_dir "${CMAKE_CURRENT_LIST_DIR}")
 
diff --git a/cmake/QtConfigExtras.cmake.in b/cmake/QtConfigExtras.cmake.in
new file mode 100644
index 0000000000..bde3460cdc
--- /dev/null
+++ b/cmake/QtConfigExtras.cmake.in
@@ -0,0 +1,2 @@
+set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT "@supported_min_version_for_using_qt@")
+set(QT_COMPUTED_MIN_CMAKE_VERSION_FOR_USING_QT "@computed_min_version_for_using_qt@")
diff --git a/cmake/QtPostProcessHelpers.cmake b/cmake/QtPostProcessHelpers.cmake
index 248989c81c..f8f42d273e 100644
--- a/cmake/QtPostProcessHelpers.cmake
+++ b/cmake/QtPostProcessHelpers.cmake
@@ -556,18 +556,16 @@ endif()\n")
         endif()
 
         # Save minimum and policy-related CMake versions to ensure the same minimum is
-        # checked for when building other child repos (qtsvg, etc) and the policy settings
-        # will be consistent unless the child repos explicitly override them.
-        qt_internal_get_qt_supported_minimum_cmake_version(min_supported_version)
-        qt_internal_get_computed_minimum_cmake_version(computed_min_version)
-        qt_internal_get_min_new_policy_cmake_version(lower_policy_version)
-        qt_internal_get_max_new_policy_cmake_version(upper_policy_version)
-        string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS
-            "set(QT_MIN_SUPPORTED_CMAKE_VERSION \"${min_supported_version}\" CACHE STRING \"Minimum supported CMake version required to build Qt\")\n"
-            "set(QT_COMPUTED_MIN_CMAKE_VERSION \"${computed_min_version}\" CACHE STRING \"Computed minimum CMake version required to build Qt\")\n"
-            "set(QT_MIN_NEW_POLICY_CMAKE_VERSION \"${lower_policy_version}\" CACHE STRING \"Oldest CMake version for which NEW policies should be enabled\")\n"
-            "set(QT_MAX_NEW_POLICY_CMAKE_VERSION \"${upper_policy_version}\" CACHE STRING \"Latest CMake version for which NEW policies should be enabled\")\n"
-        )
+        # checked for when building other downstream repos (qtsvg, etc) and the policy settings
+        # will be consistent unless the downstream repos explicitly override them.
+        # Policy settings can be overridden per-repo, but the minimum CMake version is global for all of
+        # Qt.
+        qt_internal_get_supported_min_cmake_version_for_building_qt(
+            supported_min_version_for_building_qt)
+        qt_internal_get_computed_min_cmake_version_for_building_qt(
+            computed_min_version_for_building_qt)
+        qt_internal_get_min_new_policy_cmake_version(min_new_policy_version)
+        qt_internal_get_max_new_policy_cmake_version(max_new_policy_version)
 
         # Rpath related things that need to be re-used when building other repos.
         string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS
diff --git a/cmake/QtPublicCMakeVersionHelpers.cmake b/cmake/QtPublicCMakeVersionHelpers.cmake
new file mode 100644
index 0000000000..2b3c697f4c
--- /dev/null
+++ b/cmake/QtPublicCMakeVersionHelpers.cmake
@@ -0,0 +1,69 @@
+function(__qt_internal_get_supported_min_cmake_version_for_using_qt out_var)
+    # This is recorded in Qt6ConfigExtras.cmake
+    set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT}")
+    set(${out_var} "${supported_version}" PARENT_SCOPE)
+endfunction()
+
+function(__qt_internal_get_computed_min_cmake_version_for_using_qt out_var)
+    # Allow override when configuring user project.
+    if(QT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT)
+        set(computed_min_version "${QT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT}")
+
+    # Set in QtConfigExtras.cmake.
+    elseif(QT_COMPUTED_MIN_CMAKE_VERSION_FOR_USING_QT)
+        set(computed_min_version "${QT_COMPUTED_MIN_CMAKE_VERSION_FOR_USING_QT}")
+    else()
+        message(FATAL_ERROR
+            "Qt Developer error: Can't compute the minimum CMake version required to use this Qt.")
+    endif()
+
+    set(${out_var} "${computed_min_version}" PARENT_SCOPE)
+endfunction()
+
+function(__qt_internal_warn_if_min_cmake_version_not_met)
+    __qt_internal_get_supported_min_cmake_version_for_using_qt(min_supported_version)
+    __qt_internal_get_computed_min_cmake_version_for_using_qt(computed_min_version)
+
+    if(NOT min_supported_version STREQUAL computed_min_version
+            AND computed_min_version VERSION_LESS min_supported_version)
+        message(WARNING
+               "The minimum required CMake version to use Qt is: '${min_supported_version}'. "
+               "You have explicitly chosen to require a lower minimum CMake version: '${computed_min_version}'. "
+               "Using Qt with this CMake version is not officially supported. Use at your own risk."
+               )
+    endif()
+endfunction()
+
+function(__qt_internal_require_suitable_cmake_version_for_using_qt)
+    # Skip the public project check if we're building a Qt repo because it's too early to do
+    # it at find_package(Qt6) time.
+    # Instead, a separate check is done in qt_build_repo_begin.
+    # We detect a Qt repo by the presence of the QT_REPO_MODULE_VERSION variable set in .cmake.conf
+    # of each repo.
+    if(QT_REPO_MODULE_VERSION)
+        return()
+    endif()
+
+    # Only do the setup once per directory scope, because Qt6 is a dependency for many packages,
+    # and a recursive call will show the warning multiple times.
+    if(__qt_internal_set_up_cmake_minimum_required_version_already_done)
+        return()
+    endif()
+    set(__qt_internal_set_up_cmake_minimum_required_version_already_done TRUE PARENT_SCOPE)
+
+    # Check the overall minimum required CMake version when consuming any Qt CMake package.
+    __qt_internal_warn_if_min_cmake_version_not_met()
+    __qt_internal_get_computed_min_cmake_version_for_using_qt(computed_min_version)
+
+    if(CMAKE_VERSION VERSION_LESS computed_min_version)
+        set(major_minor "${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}")
+        message(FATAL_ERROR
+            "CMake ${computed_min_version} or higher is required to use Qt. "
+            "You are running version ${CMAKE_VERSION} "
+            "Qt requires newer CMake features to work correctly. You can lower the minimum "
+            "required version by passing "
+            "-DQT_FORCE_MIN_CMAKE_VERSION_FOR_USING_QT=${major_minor} when configuring the "
+            "project. Using Qt with this CMake version is not officially supported. "
+            "Use at your own risk.")
+    endif()
+endfunction()