QVarLengthArray: fix memory leak in (qsizetype) ctor

Instead of duplicating the logic of resize() to avoid three stores to
(ptr, a, s), and getting the memory management wrong (malloc()ed ptr
leaked when a following default-construction failed), simply call the
QVLA default ctor followed by std::uninitialized_default_construct_n().

After we called the QVLA default ctor, the lifetime of this object has
begun, so if the following code throws, ~QVLA will be called to clean
up. This was not the case when we didn't delegate the ctor: if the
body of this ctor threw, ~QVLA would _not_ have been called, since the
lifetime of the object had never started.

Since the dtor may now run, we need to maintain the class invariants,
so we can't just set the size() before we have constructed all
elements. This is where std::uninitialized_default_construct_n() comes
in: it's strongly exception-safe, so if a constructor throws, it will
destroy all previously-constructed elements, so that either we fail
and size() == 0 is true or it doesn't, then we can set size() to
asize.

Change-Id: I03408d8a473e8a31fa0086ef5ac551ce46a758f8
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
(cherry picked from commit 217f2ab3eb04b7489959e8e1134184e8071dbaf0)

.cmake.conf

@@ -7,7 +7,7 @@ if (NOT DEFINED QT_SUPERBUILD OR DEFINED QT_REPO_MODULE_VERSION)
     set(QT_EXTRA_INTERNAL_TARGET_DEFINES "QT_LEAN_HEADERS=1")
 endif()
 
-set(QT_REPO_MODULE_VERSION "6.4.0")
+set(QT_REPO_MODULE_VERSION "6.4.3")
 set(QT_REPO_MODULE_PRERELEASE_VERSION_SEGMENT "alpha1")
 
 # Minimum requirement for building Qt

LICENSES/AFL-2.1.txt

@@ -0,0 +1,45 @@
+The Academic Free License
+v.2.1
+
+This Academic Free License (the "License") applies to any original work of authorship (the "Original Work") whose owner (the "Licensor") has placed the following notice immediately following the copyright notice for the Original Work:
+
+     Licensed under the Academic Free License version 2.1
+
+1) Grant of Copyright License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license to do the following:
+
+     a) to reproduce the Original Work in copies;
+     b) to prepare derivative works ("Derivative Works") based upon the Original Work;
+     c) to distribute copies of the Original Work and Derivative Works to the public;
+     d) to perform the Original Work publicly; and
+     e) to display the Original Work publicly.
+
+2) Grant of Patent License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, to make, use, sell and offer for sale the Original Work and Derivative Works.
+
+3) Grant of Source Code License. The term "Source Code" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.
+
+4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior written permission of the Licensor. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor except as expressly stated herein. No patent license is granted to make, use, sell or offer to sell embodiments of any patent claims other than the licensed claims defined in Section 2. No right is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any Original Work that Licensor otherwise would have a right to license.
+
+5) This section intentionally omitted.
+
+6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an "Attribution Notice." You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.
+
+7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work and the patent rights granted herein by Licensor are owned by the Licensor or are sublicensed to You under the terms of this License with the permission of the contributor(s) of those copyrights and patent rights. Except as expressly stated in the immediately proceeding sentence, the Original Work is provided under this License on an "AS IS" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to Original Work is granted hereunder except under this disclaimer.
+
+8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to any person for any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to liability for death or personal injury resulting from Licensor's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.
+
+ 9) Acceptance and Termination. If You distribute copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. Nothing else but this License (or another written agreement between Licensor and You) grants You permission to create Derivative Works based upon the Original Work or to exercise any of the rights granted in Section 1 herein, and any attempt to do so except under the terms of this License (or another written agreement between Licensor and You) is expressly prohibited by U.S. copyright law, the equivalent laws of other countries, and by international treaty. Therefore, by exercising any of the rights granted to You in Section 1 herein, You indicate Your acceptance of this License and all of its terms and conditions.
+
+10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, against Licensor or any licensee alleging that the Original Work infringes a patent. This termination provision shall not apply for an action alleging patent infringement by combinations of the Original Work with other software or hardware.
+
+11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et seq., the equivalent laws of other countries, and international treaty. This section shall survive the termination of this License.
+
+12) Attorneys Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.
+
+13) Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.
+
+14) Definition of "You" in This License. "You" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, "You" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.
+
+This license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights reserved.
+Permission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner.

LICENSES/CC0-1.0.txt

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

LICENSES/GPL-2.0-or-later.txt

@@ -0,0 +1 @@
+GPL-2.0-only.txt

bin/qt-cmake.bat.in

@@ -6,5 +6,5 @@ set script_dir_path=%~dp0
 set cmake_path=@CMAKE_COMMAND@
 if not exist "%cmake_path%" set cmake_path=cmake
 
-set toolchain_path=%script_dir_path%/@__GlobalConfig_relative_path_from_bin_dir_to_cmake_config_dir@/qt.toolchain.cmake
+set toolchain_path=%script_dir_path%\@__GlobalConfig_relative_path_from_bin_dir_to_cmake_config_dir@\qt.toolchain.cmake
 "%cmake_path%" -DCMAKE_TOOLCHAIN_FILE="%toolchain_path%" @__qt_cmake_extra@ %*

cmake/3rdparty/extra-cmake-modules/find-modules/FindWaylandScanner.cmake

@@ -107,9 +107,6 @@ set_package_properties(WaylandScanner PROPERTIES
     DESCRIPTION "Executable that converts XML protocol files to C code"
 )
 
-
-include(CMakeParseArguments)
-
 function(ecm_add_wayland_client_protocol out_var)
     # Parse arguments
     set(oneValueArgs PROTOCOL BASENAME)

cmake/3rdparty/extra-cmake-modules/modules/ECMFindModuleHelpers.cmake

@@ -68,7 +68,7 @@
 # If SKIP_DEPENDENCY_HANDLING is not set, the INTERFACE_LINK_LIBRARIES property
 # of the imported target for <component> will be set to contain the imported
 # targets for the components listed in <name>_<component>_component_deps.
-# <component>_FOUND will also be set to false if any of the compoments in
+# <component>_FOUND will also be set to false if any of the components in
 # <name>_<component>_component_deps are not found.  This requires the components
 # in <name>_<component>_component_deps to be listed before <component> in the
 # COMPONENTS argument.
@@ -123,8 +123,6 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-include(CMakeParseArguments)
-
 macro(ecm_find_package_version_check module_name)
     if(CMAKE_VERSION VERSION_LESS 2.8.12)
         message(FATAL_ERROR "CMake 2.8.12 is required by Find${module_name}.cmake")

cmake/FindCups.cmake

@@ -1,98 +0,0 @@
-# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-#[=======================================================================[.rst:
-FindCups
---------
-
-Find the CUPS printing system.
-
-Set CUPS_REQUIRE_IPP_DELETE_ATTRIBUTE to TRUE if you need a version which
-features this function (i.e. at least 1.1.19)
-
-Imported targets
-^^^^^^^^^^^^^^^^
-
-This module defines :prop_tgt:`IMPORTED` target ``Cups::Cups``, if Cups has
-been found.
-
-Result variables
-^^^^^^^^^^^^^^^^
-
-This module will set the following variables in your project:
-
-``CUPS_FOUND``
-  true if CUPS headers and libraries were found
-``CUPS_INCLUDE_DIRS``
-  the directory containing the Cups headers
-``CUPS_LIBRARIES``
-  the libraries to link against to use CUPS.
-``CUPS_VERSION_STRING``
-  the version of CUPS found (since CMake 2.8.8)
-
-Cache variables
-^^^^^^^^^^^^^^^
-
-The following cache variables may also be set:
-
-``CUPS_INCLUDE_DIR``
-  the directory containing the Cups headers
-#]=======================================================================]
-
-find_path(CUPS_INCLUDE_DIR cups/cups.h )
-
-find_library(CUPS_LIBRARIES NAMES cups )
-
-if (CUPS_INCLUDE_DIR AND CUPS_LIBRARIES AND CUPS_REQUIRE_IPP_DELETE_ATTRIBUTE)
-    include(${CMAKE_CURRENT_LIST_DIR}/CheckLibraryExists.cmake)
-    include(${CMAKE_CURRENT_LIST_DIR}/CMakePushCheckState.cmake)
-    cmake_push_check_state()
-    set(CMAKE_REQUIRED_QUIET ${Cups_FIND_QUIETLY})
-
-    # ippDeleteAttribute is new in cups-1.1.19 (and used by kdeprint)
-    CHECK_LIBRARY_EXISTS(cups ippDeleteAttribute "" CUPS_HAS_IPP_DELETE_ATTRIBUTE)
-    cmake_pop_check_state()
-endif ()
-
-if (CUPS_INCLUDE_DIR AND EXISTS "${CUPS_INCLUDE_DIR}/cups/cups.h")
-    file(STRINGS "${CUPS_INCLUDE_DIR}/cups/cups.h" cups_version_str
-         REGEX "^#[\t ]*define[\t ]+CUPS_VERSION_(MAJOR|MINOR|PATCH)[\t ]+[0-9]+$")
-
-    unset(CUPS_VERSION_STRING)
-    foreach(VPART MAJOR MINOR PATCH)
-        foreach(VLINE ${cups_version_str})
-            if(VLINE MATCHES "^#[\t ]*define[\t ]+CUPS_VERSION_${VPART}[\t ]+([0-9]+)$")
-                set(CUPS_VERSION_PART "${CMAKE_MATCH_1}")
-                if(CUPS_VERSION_STRING)
-                    string(APPEND CUPS_VERSION_STRING ".${CUPS_VERSION_PART}")
-                else()
-                    set(CUPS_VERSION_STRING "${CUPS_VERSION_PART}")
-                endif()
-            endif()
-        endforeach()
-    endforeach()
-endif ()
-
-include(FindPackageHandleStandardArgs)
-
-if (CUPS_REQUIRE_IPP_DELETE_ATTRIBUTE)
-    FIND_PACKAGE_HANDLE_STANDARD_ARGS(Cups
-                                      REQUIRED_VARS CUPS_LIBRARIES CUPS_INCLUDE_DIR CUPS_HAS_IPP_DELETE_ATTRIBUTE
-                                      VERSION_VAR CUPS_VERSION_STRING)
-else ()
-    FIND_PACKAGE_HANDLE_STANDARD_ARGS(Cups
-                                      REQUIRED_VARS CUPS_LIBRARIES CUPS_INCLUDE_DIR
-                                      VERSION_VAR CUPS_VERSION_STRING)
-endif ()
-
-mark_as_advanced(CUPS_INCLUDE_DIR CUPS_LIBRARIES)
-
-if (CUPS_FOUND)
-    set(CUPS_INCLUDE_DIRS "${CUPS_INCLUDE_DIR}")
-    if (NOT TARGET Cups::Cups)
-        add_library(Cups::Cups INTERFACE IMPORTED)
-        set_target_properties(Cups::Cups PROPERTIES
-            INTERFACE_LINK_LIBRARIES      "${CUPS_LIBRARIES}"
-            INTERFACE_INCLUDE_DIRECTORIES "${CUPS_INCLUDE_DIR}")
-    endif ()
-endif ()

cmake/FindGSSAPI.cmake

@@ -13,6 +13,7 @@ find_library(GSSAPI_LIBRARIES
              NAMES
              GSS # framework
              gss # solaris
+             gssapi # FreeBSD
              gssapi_krb5
              HINTS ${PC_GSSAPI_LIBDIR}
 )

cmake/FindMySQL.cmake

@@ -3,7 +3,25 @@
 # ---------
 #
 # Try to locate the mysql client library.
-# If found, this will define the following variables:
+#
+# By default, pkg-config is used, if available.
+# If pkg-config is not available or if you want to disable it, set the ``MySQL_ROOT`` variable.
+# The following variables can be set to control the behavior of this find module.
+#
+# ``MySQL_ROOT``
+#     The root directory of the mysql client library's installation.
+# ``MySQL_INCLUDE_DIR``
+#     The directory containing the include files of the mysql client library.
+#     If not set, the directory is detected within ``MySQL_ROOT`` using find_path.
+# ``MySQL_LIBRARY_DIR``
+#     The directory containing the binaries of the mysql client library.
+#     This is used to detect ``MySQL_LIBRARY`` and passed as HINT to find_library.
+# ``MySQL_LIBRARY``
+#     The file path to the mysql client library.
+# ``MySQL_LIBRARY_DEBUG``
+#     The file path to the mysql client library for the DEBUG configuration.
+#
+# If the mysql client library is found, this will define the following variables:
 #
 # ``MySQL_FOUND``
 #     True if the mysql library is available
@@ -18,17 +36,39 @@
 # ``MySQL::MySQL``
 #     The mysql client library
 
-find_package(PkgConfig QUIET)
-pkg_check_modules(PC_MySQL QUIET mysqlclient)
+if(NOT DEFINED MySQL_ROOT)
+    find_package(PkgConfig QUIET)
+endif()
+if(PkgConfig_FOUND AND NOT DEFINED MySQL_ROOT)
+    pkg_check_modules(PC_MySQL QUIET mysqlclient)
+    set(MySQL_include_dir_hints ${PC_MySQL_INCLUDEDIR})
+    set(MySQL_library_hints ${PC_MySQL_LIBDIR})
+    set(MySQL_library_hints_debug "")
+else()
+    set(MySQL_include_dir_hints "")
+    if(NOT DEFINED MySQL_LIBRARY_DIR)
+        set(MySQL_LIBRARY_DIR "${MySQL_ROOT}/lib")
+    endif()
+    set(MySQL_library_hints "${MySQL_LIBRARY_DIR}")
+    set(MySQL_library_hints_debug "${MySQL_LIBRARY_DIR}/debug")
+endif()
 
 find_path(MySQL_INCLUDE_DIR
           NAMES mysql.h
-          HINTS ${PC_MySQL_INCLUDEDIR}
+          HINTS "${MySQL_include_dir_hints}"
           PATH_SUFFIXES mysql mariadb)
 
 find_library(MySQL_LIBRARY
+             NO_PACKAGE_ROOT_PATH
              NAMES libmysql mysql mysqlclient libmariadb mariadb
-             HINTS ${PC_MySQL_LIBDIR})
+             HINTS ${MySQL_library_hints})
+
+if(MySQL_library_hints_debug)
+    find_library(MySQL_LIBRARY_DEBUG
+                 NO_PACKAGE_ROOT_PATH
+                 NAMES libmysql mysql mysqlclient libmariadb mariadb
+                 HINTS ${MySQL_library_hints_debug})
+endif()
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(MySQL DEFAULT_MSG MySQL_LIBRARY MySQL_INCLUDE_DIR)
@@ -41,6 +81,10 @@ if(MySQL_FOUND)
     set_target_properties(MySQL::MySQL PROPERTIES
                           IMPORTED_LOCATION "${MySQL_LIBRARIES}"
                           INTERFACE_INCLUDE_DIRECTORIES "${MySQL_INCLUDE_DIRS}")
+    if(MySQL_LIBRARY_DEBUG)
+      set_target_properties(MySQL::MySQL PROPERTIES
+                            IMPORTED_LOCATION_DEBUG "${MySQL_LIBRARY_DEBUG}")
+    endif()
   endif()
 endif()
 

cmake/FindPPS.cmake

@@ -16,8 +16,8 @@ mark_as_advanced(PPS_INCLUDE_DIR PPS_LIBRARY)
 
 if(PPS_FOUND)
     add_library(__PPS INTERFACE IMPORTED)
-    target_link_libraries(__PPS INTERFACE ${PPS_LIBRARY})
-    target_include_directories(__PPS INTERFACE ${PPS_INCLUDE_DIR})
+    target_link_libraries(__PPS INTERFACE "${PPS_LIBRARY}")
+    target_include_directories(__PPS INTERFACE "${PPS_INCLUDE_DIR}")
 
     add_library(PPS::PPS ALIAS __PPS)
 endif()

cmake/FindWrapDoubleConversion.cmake

@@ -1,22 +0,0 @@
-# We can't create the same interface imported target multiple times, CMake will complain if we do
-# that. This can happen if the find_package call is done in multiple different subdirectories.
-if(TARGET WrapDoubleConversion::WrapDoubleConversion)
-    set(WrapDoubleConversion_FOUND ON)
-    return()
-endif()
-
-set(WrapDoubleConversion_FOUND OFF)
-
-find_package(double-conversion QUIET)
-if (double-conversion_FOUND)
-    include(FeatureSummary)
-    set_package_properties(double-conversion PROPERTIES TYPE REQUIRED)
-    add_library(WrapDoubleConversion::WrapDoubleConversion INTERFACE IMPORTED)
-    target_link_libraries(WrapDoubleConversion::WrapDoubleConversion
-                          INTERFACE double-conversion::double-conversion)
-    set(WrapDoubleConversion_FOUND ON)
-    return()
-endif()
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(WrapDoubleConversion DEFAULT_MSG WrapDoubleConversion_FOUND)

cmake/FindWrapSystemDoubleConversion.cmake

@@ -0,0 +1,82 @@
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapSystemDoubleConversion::WrapSystemDoubleConversion)
+    set(WrapSystemDoubleConversion_FOUND ON)
+    return()
+endif()
+
+set(WrapSystemDoubleConversion_REQUIRED_VARS "__double_conversion_found")
+
+# Find either Config package or Find module.
+# Upstream can be built either with CMake and then provides a Config file, or with Scons in which
+# case there's no Config file.
+# A Find module might be provided by a 3rd party, for example Conan might generate a Find module.
+find_package(double-conversion ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} QUIET)
+set(__double_conversion_target_name "double-conversion::double-conversion")
+if(double-conversion_FOUND AND TARGET "${__double_conversion_target_name}")
+    set(__double_conversion_found TRUE)
+    # This ensures the Config file is shown in the fphsa message.
+    if(double-conversion_CONFIG)
+        list(PREPEND WrapSystemDoubleConversion_REQUIRED_VARS
+            double-conversion_CONFIG)
+    endif()
+endif()
+
+if(NOT __double_conversion_found)
+    list(PREPEND WrapSystemDoubleConversion_REQUIRED_VARS
+        DOUBLE_CONVERSION_LIBRARY DOUBLE_CONVERSION_INCLUDE_DIR)
+
+    find_path(DOUBLE_CONVERSION_INCLUDE_DIR
+        NAMES
+            double-conversion/double-conversion.h
+    )
+
+    find_library(DOUBLE_CONVERSION_LIBRARY_RELEASE NAMES double-conversion)
+
+    # We assume a possible debug build of this library to be named with a d suffix.
+    # Adjust accordingly if a different naming scheme is established.
+    find_library(DOUBLE_CONVERSION_LIBRARY_DEBUG NAMES double-conversiond)
+
+    include(SelectLibraryConfigurations)
+    select_library_configurations(DOUBLE_CONVERSION)
+    mark_as_advanced(DOUBLE_CONVERSION_INCLUDE_DIR DOUBLE_CONVERSION_LIBRARY)
+    set(DOUBLE_CONVERSION_INCLUDE_DIRS "${DOUBLE_CONVERSION_INCLUDE_DIR}")
+
+    if(DOUBLE_CONVERSION_LIBRARIES AND DOUBLE_CONVERSION_INCLUDE_DIRS)
+        set(__double_conversion_found TRUE)
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+
+set(__double_conversion_fphsa_args "")
+if(double-conversion_VERSION)
+    set(WrapSystemDoubleConversion_VERSION "${double-conversion_VERSION}")
+    list(APPEND __double_conversion_fphsa_args VERSION_VAR WrapSystemDoubleConversion_VERSION)
+endif()
+
+find_package_handle_standard_args(WrapSystemDoubleConversion
+    REQUIRED_VARS ${WrapSystemDoubleConversion_REQUIRED_VARS}
+    ${__double_conversion_fphsa_args})
+
+if(WrapSystemDoubleConversion_FOUND)
+    add_library(WrapSystemDoubleConversion::WrapSystemDoubleConversion INTERFACE IMPORTED)
+    if(TARGET "${__double_conversion_target_name}")
+        target_link_libraries(WrapSystemDoubleConversion::WrapSystemDoubleConversion
+                              INTERFACE "${__double_conversion_target_name}")
+    else()
+        target_link_libraries(WrapSystemDoubleConversion::WrapSystemDoubleConversion
+            INTERFACE ${DOUBLE_CONVERSION_LIBRARIES})
+        target_include_directories(WrapSystemDoubleConversion::WrapSystemDoubleConversion
+            INTERFACE ${DOUBLE_CONVERSION_INCLUDE_DIRS})
+    endif()
+endif()
+unset(__double_conversion_target_name)
+unset(__double_conversion_found)
+unset(__double_conversion_fphsa_args)
+
+include(FeatureSummary)
+set_package_properties(WrapSystemDoubleConversion PROPERTIES
+  URL "https://github.com/google/double-conversion"
+  DESCRIPTION "double-conversion library")
+

cmake/FindWrapSystemHarfbuzz.cmake

@@ -28,22 +28,38 @@ if(harfbuzz_FOUND AND TARGET "${__harfbuzz_target_name}")
 endif()
 
 if(__harfbuzz_broken_config_file OR NOT __harfbuzz_found)
-    list(PREPEND WrapSystemHarfbuzz_REQUIRED_VARS HARFBUZZ_LIBRARIES HARFBUZZ_INCLUDE_DIRS)
-
     find_package(PkgConfig QUIET)
     pkg_check_modules(PC_HARFBUZZ harfbuzz IMPORTED_TARGET)
+    if(PC_HARFBUZZ_FOUND)
+        set(__harfbuzz_target_name "PkgConfig::PC_HARFBUZZ")
+        set(__harfbuzz_find_include_dirs_hints
+            HINTS ${PC_HARFBUZZ_INCLUDEDIR})
+        set(__harfbuzz_find_library_hints
+            HINTS ${PC_HARFBUZZ_LIBDIR})
+        if(PC_HARFBUZZ_VERSION)
+            set(WrapSystemHarfbuzz_VERSION "${PC_HARFBUZZ_VERSION}")
+        endif()
+    else()
+        set(__harfbuzz_target_name "Harfbuzz::Harfbuzz")
+    endif()
 
     find_path(HARFBUZZ_INCLUDE_DIRS
-              NAMES harfbuzz/hb.h
-              HINTS ${PC_HARFBUZZ_INCLUDEDIR})
+        NAMES harfbuzz/hb.h
+        ${__harfbuzz_find_include_dirs_hints})
     find_library(HARFBUZZ_LIBRARIES
-                NAMES harfbuzz
-                HINTS ${PC_HARFBUZZ_LIBDIR})
+        NAMES harfbuzz
+        ${__harfbuzz_find_library_hints})
 
-    set(__harfbuzz_target_name "PkgConfig::PC_HARFBUZZ")
-    set(__harfbuzz_found TRUE)
-    if(PC_HARFBUZZ_VERSION)
-        set(WrapSystemHarfbuzz_VERSION "${PC_HARFBUZZ_VERSION}")
+    if(HARFBUZZ_INCLUDE_DIRS AND HARFBUZZ_LIBRARIES)
+        set(__harfbuzz_found TRUE)
+        if(NOT PC_HARFBUZZ_FOUND)
+            add_library(${__harfbuzz_target_name} UNKNOWN IMPORTED)
+            list(TRANSFORM HARFBUZZ_INCLUDE_DIRS APPEND "/harfbuzz")
+            set_target_properties(${__harfbuzz_target_name} PROPERTIES
+                IMPORTED_LOCATION "${HARFBUZZ_LIBRARIES}"
+                INTERFACE_INCLUDE_DIRECTORIES "${HARFBUZZ_INCLUDE_DIRS}"
+            )
+        endif()
     endif()
 endif()
 
@@ -57,6 +73,8 @@ if(WrapSystemHarfbuzz_FOUND)
                           INTERFACE "${__harfbuzz_target_name}")
 endif()
 unset(__harfbuzz_target_name)
+unset(__harfbuzz_find_include_dirs_hints)
+unset(__harfbuzz_find_library_hints)
 unset(__harfbuzz_found)
 unset(__harfbuzz_include_dir)
 unset(__harfbuzz_broken_config_file)

cmake/FindWrapSystemPCRE2.cmake

@@ -4,8 +4,12 @@ if(TARGET WrapSystemPCRE2::WrapSystemPCRE2)
 endif()
 set(WrapSystemPCRE2_REQUIRED_VARS __pcre2_found)
 
-find_package(PCRE2 COMPONENTS 16BIT ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} CONFIG QUIET)
+find_package(PCRE2 ${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION} COMPONENTS 16BIT QUIET)
 
+# TODO: pcre2-16 is not the target name provided by the upstream Config file. It is PCRE2::16BIT.
+# https://github.com/PCRE2Project/pcre2/blob/2410fbe3869cab403f02b94caa9ab37ee9f5854b/cmake/pcre2-config.cmake.in#L122
+# We don't strictly need to handle that though, because the pkg-config code path below still
+# finds the correct libraries.
 set(__pcre2_target_name "PCRE2::pcre2-16")
 if(PCRE2_FOUND AND TARGET "${__pcre2_target_name}")
   # Hunter case.

cmake/FindWrapZSTD.cmake

@@ -56,9 +56,12 @@ else()
     include(SelectLibraryConfigurations)
     select_library_configurations(ZSTD)
 
+    if(PC_ZSTD_VERSION)
+        set(WrapZSTD_VERSION "${PC_ZSTD_VERSION}")
+    endif()
     find_package_handle_standard_args(WrapZSTD
                                       REQUIRED_VARS ZSTD_LIBRARIES ZSTD_INCLUDE_DIRS
-                                      VERSION_VAR PC_ZSTD_VERSION)
+                                      VERSION_VAR WrapZSTD_VERSION)
 
     if(WrapZSTD_FOUND AND NOT TARGET WrapZSTD::WrapZSTD)
       add_library(WrapZSTD::WrapZSTD UNKNOWN IMPORTED)

cmake/Finddouble-conversion.cmake

@@ -1,32 +0,0 @@
-# Fallback find module for double-conversion
-# if double-conversion is built with CMake it'll install a config module, which we prefer
-# if it's built with Scons (their default), we search ourselves
-
-find_package(double-conversion CONFIG)
-if (double-conversion_FOUND)
-    if(TARGET double-conversion::double-conversion)
-        return()
-    endif()
-endif()
-
-find_path(DOUBLE_CONVERSION_INCLUDE_DIR
-    NAMES
-        double-conversion.h
-    PATH_SUFFIXES
-        double-conversion
-)
-find_library(DOUBLE_CONVERSION_LIBRARY NAMES double-conversion)
-
-include(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(
-    double-conversion DEFAULT_MSG
-    DOUBLE_CONVERSION_LIBRARY DOUBLE_CONVERSION_INCLUDE_DIR)
-
-if(double-conversion_FOUND AND NOT TARGET double-conversion::double-conversion)
-    add_library(double-conversion::double-conversion UNKNOWN IMPORTED)
-    set_target_properties(double-conversion::double-conversion PROPERTIES
-        IMPORTED_LOCATION "${DOUBLE_CONVERSION_LIBRARY}"
-        INTERFACE_INCLUDE_DIRECTORIES "${DOUBLE_CONVERSION_INCLUDE_DIR}")
-endif()
-
-mark_as_advanced(DOUBLE_CONVERSION_INCLUDE_DIR DOUBLE_CONVERSION_LIBRARY)

cmake/PkgConfigLibrary.pc.in

@@ -1,6 +1,7 @@
 prefix=@CMAKE_INSTALL_PREFIX@
 exec_prefix=${prefix}
 bindir=${prefix}/@INSTALL_BINDIR@
+libexecdir=${prefix}/@INSTALL_LIBEXECDIR@
 libdir=${prefix}/@INSTALL_LIBDIR@
 includedir=${prefix}/@INSTALL_INCLUDEDIR@
 $<$<BOOL:@contains_mkspecs@>:mkspecsdir=${prefix}/@INSTALL_MKSPECSDIR@>

cmake/Qt3rdPartyLibraryHelpers.cmake

@@ -164,7 +164,22 @@ function(qt_internal_add_3rdparty_library target)
 
     set_target_properties(${target} PROPERTIES
         _qt_module_interface_name "${target}"
+        _qt_package_version "${PROJECT_VERSION}"
+        _qt_package_name "${INSTALL_CMAKE_NAMESPACE}${target}"
+        _qt_module_is_3rdparty_library TRUE
     )
+
+    set(export_properties
+        "_qt_module_interface_name"
+        "_qt_package_version"
+        "_qt_package_name"
+        "_qt_module_is_3rdparty_library"
+    )
+
+    set_property(TARGET ${target}
+                 APPEND PROPERTY
+                 EXPORT_PROPERTIES "${export_properties}")
+
     qt_internal_add_qt_repo_known_module(${target})
     qt_internal_add_target_aliases(${target})
     _qt_internal_apply_strict_cpp(${target})
@@ -177,7 +192,6 @@ function(qt_internal_add_3rdparty_library target)
         ARCHIVE_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_LIBDIR}"
         VERSION ${PROJECT_VERSION}
         SOVERSION ${PROJECT_VERSION_MAJOR}
-        _qt_module_is_3rdparty_library TRUE
         _qt_module_skip_depends_include TRUE
     )
     set_property(TARGET "${target}"

cmake/QtAndroidHelpers.cmake

@@ -127,8 +127,9 @@ function(qt_internal_android_dependencies_content target file_content_out)
             if (init_class)
                 set(init_class "initClass=\"${init_class}\"")
             endif()
-            file(TO_NATIVE_PATH ${jar_file} jar_file_native)
-            string(APPEND file_contents "<jar file=\"${jar_file_native}\" ${init_class} />\n")
+            # Use unix path to allow using files on any host platform.
+            file(TO_CMAKE_PATH ${jar_file} jar_file_unix_path)
+            string(APPEND file_contents "<jar file=\"${jar_file_unix_path}\" ${init_class} />\n")
         endforeach()
     endif()
 
@@ -139,8 +140,10 @@ function(qt_internal_android_dependencies_content target file_content_out)
             if (init_class)
                 set(init_class "initClass=\"${init_class}\"")
             endif()
-            file(TO_NATIVE_PATH ${bundle_file} jar_bundle_native)
-            string(APPEND file_contents "<jar bundling=\"1\" file=\"${jar_bundle_native}\" ${init_class} />\n")
+            # Use unix path to allow using files on any host platform.
+            file(TO_CMAKE_PATH ${bundle_file} jar_bundle_unix_path)
+            string(APPEND file_contents
+                   "<jar bundling=\"1\" file=\"${jar_bundle_unix_path}\" ${init_class} />\n")
         endforeach()
     endif()
 
@@ -152,8 +155,9 @@ function(qt_internal_android_dependencies_content target file_content_out)
             if (lib_extends)
                 set(lib_extends "extends=\"${lib_extends}\"")
             endif()
-            file(TO_NATIVE_PATH ${lib_file} lib_file_native)
-            string(APPEND file_contents "<lib file=\"${lib_file_native}\" ${lib_extends} />\n")
+            # Use unix path to allow using files on any host platform.
+            file(TO_CMAKE_PATH ${lib_file} lib_file_unix_path)
+            string(APPEND file_contents "<lib file=\"${lib_file_unix_path}\" ${lib_extends} />\n")
         endforeach()
     endif()
 
@@ -163,19 +167,23 @@ function(qt_internal_android_dependencies_content target file_content_out)
             string(REPLACE ".so" "_${CMAKE_ANDROID_ARCH_ABI}.so" lib ${lib})
             section(${lib} ":" lib_file lib_replacement)
             if (lib_replacement)
-                file(TO_NATIVE_PATH ${lib_replacement} lib_replacement_native)
-                set(lib_replacement "replaces=\"${lib_replacement_native}\"")
+                # Use unix path to allow using files on any host platform.
+                file(TO_CMAKE_PATH ${lib_replacement} lib_replacement_unix_path)
+                set(lib_replacement "replaces=\"${lib_replacement_unix_path}\"")
             endif()
-            file(TO_NATIVE_PATH ${lib_file} lib_file_native)
-            string(APPEND file_contents "<lib file=\"${lib_file_native}\" ${lib_replacement} />\n")
+            # Use unix path to allow using files on any host platform.
+            file(TO_CMAKE_PATH ${lib_file} lib_file_unix_path)
+            string(APPEND file_contents
+                   "<lib file=\"${lib_file_unix_path}\" ${lib_replacement} />\n")
         endforeach()
     endif()
 
     # Bundled files
     if(arg_BUNDLED_FILES)
         foreach(bundled_file IN LISTS arg_BUNDLED_FILES)
-            file(TO_NATIVE_PATH ${bundled_file} file_native)
-            string(APPEND file_contents "<bundled file=\"${file_native}\" />\n")
+            # Use unix path to allow using files on any host platform.
+            file(TO_CMAKE_PATH ${bundled_file} file_unix_path)
+            string(APPEND file_contents "<bundled file=\"${file_unix_path}\" />\n")
         endforeach()
     endif()
 

cmake/QtAppHelpers.cmake

@@ -53,7 +53,7 @@ function(qt_internal_add_app target)
     # but don't enable macOS bundles.
     # Bundles are enabled in a separate set_target_properties call if an Info.plist file
     # is provided.
-    # Similary, the Windows GUI flag is disabled in a separate call
+    # Similarly, the Windows GUI flag is disabled in a separate call
     # if CONFIG += console was encountered during conversion.
     set_target_properties("${target}" PROPERTIES WIN32_EXECUTABLE TRUE)
 
@@ -75,7 +75,7 @@ function(qt_internal_get_title_case value out_var)
     endif()
     string(SUBSTRING "${value}" 0 1 first_char)
     string(TOUPPER "${first_char}" first_char_upper)
-    string(SUBSTRING "${target}" 1 -1 rest_of_value)
+    string(SUBSTRING "${value}" 1 -1 rest_of_value)
     set(title_value "${first_char_upper}${rest_of_value}")
     set(${out_var} "${title_value}" PARENT_SCOPE)
 endfunction()

cmake/QtAutoDetect.cmake

@@ -182,9 +182,7 @@ function(qt_auto_detect_vcpkg)
 endfunction()
 
 function(qt_auto_detect_ios)
-    if(CMAKE_SYSTEM_NAME STREQUAL iOS
-            OR CMAKE_SYSTEM_NAME STREQUAL watchOS
-            OR CMAKE_SYSTEM_NAME STREQUAL tvOS)
+    if(CMAKE_SYSTEM_NAME STREQUAL iOS)
         message(STATUS "Using internal CMake ${CMAKE_SYSTEM_NAME} toolchain file.")
 
         # The QT_UIKIT_SDK check simulates the input.sdk condition for simulator_and_device in
@@ -201,55 +199,21 @@ function(qt_auto_detect_ios)
         message(STATUS "simulator_and_device set to: \"${simulator_and_device}\".")
 
         # Choose relevant architectures.
-        # Using a non xcode generator requires explicit setting of the
+        # Using a non Xcode generator requires explicit setting of the
         # architectures, otherwise compilation fails with unknown defines.
-        if(CMAKE_SYSTEM_NAME STREQUAL iOS)
-            if(simulator_and_device)
-                set(osx_architectures "arm64;x86_64")
-            elseif(QT_UIKIT_SDK STREQUAL "iphoneos")
-                set(osx_architectures "arm64")
-            elseif(QT_UIKIT_SDK STREQUAL "iphonesimulator")
-                set(osx_architectures "x86_64")
+        if(simulator_and_device)
+            set(osx_architectures "arm64;x86_64")
+        elseif(QT_UIKIT_SDK STREQUAL "iphoneos")
+            set(osx_architectures "arm64")
+        elseif(QT_UIKIT_SDK STREQUAL "iphonesimulator")
+            set(osx_architectures "x86_64")
+        else()
+            if(NOT DEFINED QT_UIKIT_SDK)
+                message(FATAL_ERROR "Please provide a value for -DQT_UIKIT_SDK."
+                    " Possible values: iphoneos, iphonesimulator.")
             else()
-                if(NOT DEFINED QT_UIKIT_SDK)
-                    message(FATAL_ERROR "Please proviude a value for -DQT_UIKIT_SDK."
-                        " Possible values: iphoneos, iphonesimulator.")
-                else()
-                    message(FATAL_ERROR
-                            "Unknown SDK argument given to QT_UIKIT_SDK: ${QT_UIKIT_SDK}.")
-                endif()
-            endif()
-        elseif(CMAKE_SYSTEM_NAME STREQUAL tvOS)
-            if(simulator_and_device)
-                set(osx_architectures "arm64;x86_64")
-            elseif(QT_UIKIT_SDK STREQUAL "appletvos")
-                set(osx_architectures "arm64")
-            elseif(QT_UIKIT_SDK STREQUAL "appletvsimulator")
-                set(osx_architectures "x86_64")
-            else()
-                if(NOT DEFINED QT_UIKIT_SDK)
-                    message(FATAL_ERROR "Please proviude a value for -DQT_UIKIT_SDK."
-                        " Possible values: appletvos, appletvsimulator.")
-                else()
-                    message(FATAL_ERROR
-                            "Unknown SDK argument given to QT_UIKIT_SDK: ${QT_UIKIT_SDK}.")
-                endif()
-            endif()
-        elseif(CMAKE_SYSTEM_NAME STREQUAL watchOS)
-            if(simulator_and_device)
-                set(osx_architectures "armv7k;i386")
-            elseif(QT_UIKIT_SDK STREQUAL "watchos")
-                set(osx_architectures "armv7k")
-            elseif(QT_UIKIT_SDK STREQUAL "watchsimulator")
-                set(osx_architectures "i386")
-            else()
-                if(NOT DEFINED QT_UIKIT_SDK)
-                    message(FATAL_ERROR "Please proviude a value for -DQT_UIKIT_SDK."
-                        " Possible values: watchos, watchsimulator.")
-                else()
-                    message(FATAL_ERROR
-                            "Unknown SDK argument given to QT_UIKIT_SDK: ${QT_UIKIT_SDK}.")
-                endif()
+                message(FATAL_ERROR
+                        "Unknown SDK argument given to QT_UIKIT_SDK: ${QT_UIKIT_SDK}.")
             endif()
         endif()
 
@@ -305,12 +269,8 @@ endfunction()
 
 function(qt_internal_get_darwin_sdk_version out_var)
     if(APPLE)
-        if(IOS)
+        if(CMAKE_SYSTEM_NAME STREQUAL iOS)
             set(sdk_name "iphoneos")
-        elseif(TVOS)
-            set(sdk_name "appletvos")
-        elseif(WATCHOS)
-            set(sdk_name "watchos")
         else()
             # Default to macOS
             set(sdk_name "macosx")
@@ -352,10 +312,6 @@ function(qt_auto_detect_darwin)
                 set(version "10.14")
             elseif(CMAKE_SYSTEM_NAME STREQUAL iOS)
                 set(version "13.0")
-            elseif(CMAKE_SYSTEM_NAME STREQUAL watchOS)
-                set(version "6.0")
-            elseif(CMAKE_SYSTEM_NAME STREQUAL tvOS)
-                set(version "13.0")
             endif()
             if(version)
                 set(CMAKE_OSX_DEPLOYMENT_TARGET "${version}" CACHE STRING "${description}")
@@ -368,9 +324,8 @@ function(qt_auto_detect_darwin)
         qt_internal_get_xcode_version(xcode_version)
         set(QT_MAC_XCODE_VERSION "${xcode_version}" CACHE STRING "Xcode version.")
 
-        set(device_names "iOS" "watchOS" "tvOS")
         list(LENGTH CMAKE_OSX_ARCHITECTURES arch_count)
-        if(NOT CMAKE_SYSTEM_NAME IN_LIST device_names AND arch_count GREATER 0)
+        if(NOT CMAKE_SYSTEM_NAME STREQUAL iOS AND arch_count GREATER 0)
             foreach(arch ${CMAKE_OSX_ARCHITECTURES})
                 if(arch STREQUAL "arm64e")
                     message(WARNING "Applications built against an arm64e Qt architecture will "
@@ -383,8 +338,7 @@ function(qt_auto_detect_darwin)
 endfunction()
 
 function(qt_auto_detect_macos_universal)
-    set(device_names "iOS" "watchOS" "tvOS")
-    if(APPLE AND NOT CMAKE_SYSTEM_NAME IN_LIST device_names)
+    if(APPLE AND NOT CMAKE_SYSTEM_NAME STREQUAL iOS)
         list(LENGTH CMAKE_OSX_ARCHITECTURES arch_count)
 
         set(is_universal "OFF")

cmake/QtBaseGlobalTargets.cmake

@@ -322,11 +322,13 @@ set(__public_cmake_helpers
     cmake/QtCopyFileIfDifferent.cmake
     cmake/QtFeature.cmake
     cmake/QtFeatureCommon.cmake
+    cmake/QtPublicAppleHelpers.cmake
     cmake/QtPublicCMakeHelpers.cmake
     cmake/QtPublicCMakeVersionHelpers.cmake
     cmake/QtPublicFinalizerHelpers.cmake
     cmake/QtPublicPluginHelpers.cmake
     cmake/QtPublicTargetHelpers.cmake
+    cmake/QtPublicTestHelpers.cmake
     cmake/QtPublicToolHelpers.cmake
     cmake/QtPublicWalkLibsHelpers.cmake
     cmake/QtPublicFindPackageHelpers.cmake
@@ -383,7 +385,7 @@ if(MACOS)
     )
 elseif(IOS)
     qt_copy_or_install(FILES
-        cmake/ios/MacOSXBundleInfo.plist.in
+        cmake/ios/Info.plist.app.in
         cmake/ios/LaunchScreen.storyboard
         DESTINATION "${__GlobalConfig_install_dir}/ios"
     )

cmake/QtBuild.cmake

@@ -159,7 +159,7 @@ function(qt_internal_set_up_global_paths)
     #
     # These values should be prepended to file paths in commands or properties,
     # in order to correctly place generated Config files, generated Targets files,
-    # excutables / libraries, when copying / installing files, etc.
+    # executables / libraries, when copying / installing files, etc.
     #
     # The build dir variables will always be absolute paths.
     # The QT_INSTALL_DIR variable will have a relative path in a prefix build,
@@ -263,28 +263,11 @@ function(qt_setup_tool_path_command)
     list(APPEND command COMMAND)
     list(APPEND command set PATH=${bindir}$<SEMICOLON>%PATH%)
     set(QT_TOOL_PATH_SETUP_COMMAND "${command}" CACHE INTERNAL "internal command prefix for tool invocations" FORCE)
-    # QT_TOOL_PATH_SETUP_COMMAND is deprecated. Please use _qt_internal_wrap_tool_command
+    # QT_TOOL_PATH_SETUP_COMMAND is deprecated. Please use _qt_internal_get_wrap_tool_script_path
     # instead.
 endfunction()
 qt_setup_tool_path_command()
 
-function(qt_internal_generate_tool_command_wrapper)
-    get_property(is_called GLOBAL PROPERTY _qt_internal_generate_tool_command_wrapper_called)
-    if(NOT CMAKE_HOST_WIN32 OR is_called)
-        return()
-    endif()
-    set(bindir "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_BINDIR}")
-    file(TO_NATIVE_PATH "${bindir}" bindir)
-    set(tool_command_wrapper_path "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/qt_setup_tool_path.bat")
-    file(WRITE "${tool_command_wrapper_path}" "@echo off
-set PATH=${bindir};%PATH%
-%*")
-    set(QT_TOOL_COMMAND_WRAPPER_PATH "${tool_command_wrapper_path}"
-        CACHE INTERNAL "Path to the wrapper of the tool commands")
-    set_property(GLOBAL PROPERTY _qt_internal_generate_tool_command_wrapper_called TRUE)
-endfunction()
-qt_internal_generate_tool_command_wrapper()
-
 # Platform define path, etc.
 if(WIN32)
     set(QT_DEFAULT_PLATFORM_DEFINITIONS WIN32 _ENABLE_EXTENDED_ALIGNED_STORAGE)
@@ -543,15 +526,30 @@ if(ANDROID)
     include(QtAndroidHelpers)
 endif()
 
+if(WASM)
+    include(QtWasmHelpers)
+endif()
+
 # Helpers that are available in public projects and while building Qt itself.
+include(QtPublicAppleHelpers)
 include(QtPublicCMakeHelpers)
 include(QtPublicPluginHelpers)
 include(QtPublicTargetHelpers)
 include(QtPublicWalkLibsHelpers)
 include(QtPublicFindPackageHelpers)
 include(QtPublicDependencyHelpers)
+include(QtPublicTestHelpers)
 include(QtPublicToolHelpers)
 
+if(CMAKE_CROSSCOMPILING)
+    if(NOT IS_DIRECTORY "${QT_HOST_PATH}")
+        message(FATAL_ERROR "You need to set QT_HOST_PATH to cross compile Qt.")
+    endif()
+endif()
+
+_qt_internal_determine_if_host_info_package_needed(__qt_build_requires_host_info_package)
+_qt_internal_find_host_info_package("${__qt_build_requires_host_info_package}")
+
 # TODO: This block provides support for old variables. It should be removed once
 #       we remove all references to these variables in other Qt module repos.
 #       Prefer to use the provided commands to retrieve the relevant things instead.
@@ -589,6 +587,11 @@ if(COMMAND _qt_internal_get_add_plugin_keywords)
     unset(__qt_internal_add_plugin_multi_args)
 endif()
 
+# Create tool script wrapper if necessary.
+# TODO: Remove once all direct usages of QT_TOOL_COMMAND_WRAPPER_PATH are replaced with function
+# calls.
+_qt_internal_generate_tool_command_wrapper()
+
 # This sets up the poor man's scope finalizer mechanism.
 # For newer CMake versions, we use cmake_language(DEFER CALL) instead.
 if(CMAKE_VERSION VERSION_LESS "3.19.0")

cmake/QtBuildInformation.cmake

@@ -1,4 +1,13 @@
 function(qt_print_feature_summary)
+    if(QT_SUPERBUILD)
+        qt_internal_set_message_log_level(message_log_level)
+        if(message_log_level)
+            # In a top-level build, ensure that the feature_summary is affected by the
+            # selected log-level.
+            set(CMAKE_MESSAGE_LOG_LEVEL "${message_log_level}")
+        endif()
+    endif()
+
     include(FeatureSummary)
     # Show which packages were found.
     feature_summary(INCLUDE_QUIET_PACKAGES
@@ -37,6 +46,15 @@ function(qt_print_build_instructions)
         return()
     endif()
 
+    if(QT_SUPERBUILD)
+        qt_internal_set_message_log_level(message_log_level)
+        if(message_log_level)
+            # In a top-level build, ensure that qt_print_build_instructions is affected by the
+            # selected log-level.
+            set(CMAKE_MESSAGE_LOG_LEVEL "${message_log_level}")
+        endif()
+    endif()
+
     set(build_command "cmake --build . --parallel")
     set(install_command "cmake --install .")
 
@@ -76,36 +94,76 @@ from the build directory \n")
     list(JOIN msg "\n" msg)
 
     if(NOT QT_INTERNAL_BUILD_INSTRUCTIONS_SHOWN)
-        message(STATUS "${msg}")
+        qt_configure_print_build_instructions_helper("${msg}")
     endif()
 
     set(QT_INTERNAL_BUILD_INSTRUCTIONS_SHOWN "TRUE" CACHE STRING "" FORCE)
 endfunction()
 
+function(qt_configure_print_summary_helper summary_reports force_show)
+    # We force show the summary by temporarily (within the scope of the function) resetting the
+    # current log level.
+    if(force_show)
+        set(CMAKE_MESSAGE_LOG_LEVEL "STATUS")
+    endif()
+    message(STATUS "Configure summary:\n${__qt_configure_reports}")
+endfunction()
+
+function(qt_configure_print_build_instructions_helper msg)
+    # We want to ensure build instructions are always shown the first time, regardless of the
+    # current log level.
+    set(CMAKE_MESSAGE_LOG_LEVEL "STATUS")
+    message(STATUS "${msg}")
+endfunction()
+
 function(qt_configure_print_summary)
     # Evaluate all recorded commands.
     qt_configure_eval_commands()
 
     set(summary_file "${CMAKE_BINARY_DIR}/config.summary")
     file(WRITE "${summary_file}" "")
-    # Show Qt-specific configure summary and any notes, wranings, etc.
+
+    get_property(features_possibly_changed GLOBAL PROPERTY _qt_dirty_build)
+
+    # Show Qt-specific configuration summary.
     if(__qt_configure_reports)
-        if(NOT QT_INTERNAL_SUMMARY_INSTRUCTIONS_SHOWN)
+        # We want to show the the summary file and log level messages only on first configuration
+        # or when we detect a feature change, to keep most reconfiguration output as quiet as
+        # possible. Currently feature change detection is not entirely reliable.
+        if(NOT QT_INTERNAL_SUMMARY_INSTRUCTIONS_SHOWN OR features_possibly_changed)
             message("")
             message(
-                "-- Configuration summary has been written to ${CMAKE_BINARY_DIR}/config.summary")
+                "-- Configuration summary shown below. It has also been written to"
+                " ${CMAKE_BINARY_DIR}/config.summary")
             message(
-                "-- Configure with --log-level=STATUS or higher to increase the output verbosity.")
+                "-- Configure with --log-level=STATUS or higher to increase "
+                "CMake's message verbosity. "
+                "The log level does not persist across reconfigurations.")
         endif()
 
         # Need 2 flushes to ensure no interleaved input is printed due to a mix of message(STATUS)
         # and message(NOTICE) calls.
         execute_process(COMMAND ${CMAKE_COMMAND} -E echo " ")
-        message(STATUS "Configure summary:\n${__qt_configure_reports}")
+
+        # We want to show the configuration summary only on first configuration or when we detect
+        # a feature change, to keep most reconfiguration output as quiet as possible.
+        # Currently feature change detection is not entirely reliable.
+        if(NOT QT_INTERNAL_SUMMARY_INSTRUCTIONS_SHOWN OR features_possibly_changed)
+            set(force_show_summary TRUE)
+        else()
+            set(force_show_summary FALSE)
+        endif()
+
+        qt_configure_print_summary_helper(
+            "Configuration summary:\n${__qt_configure_reports}"
+            ${force_show_summary})
+
         execute_process(COMMAND ${CMAKE_COMMAND} -E echo " ")
 
         file(APPEND "${summary_file}" "${__qt_configure_reports}")
     endif()
+
+    # Show Qt specific notes, warnings, errors.
     if(__qt_configure_notes)
         message("${__qt_configure_notes}")
         file(APPEND "${summary_file}" "${__qt_configure_notes}")

cmake/QtBuildInternals/QtBuildInternalsConfig.cmake

@@ -128,9 +128,14 @@ function(qt_build_internals_disable_pkg_config_if_needed)
     endif()
 
     # Features won't have been evaluated yet if this is the first run, have to evaluate this here
-    if(NOT "${FEATURE_pkg_config}" AND "${INPUT_pkg_config}"
-       AND NOT "${INPUT_pkg_config}" STREQUAL "undefined")
-        set(FEATURE_pkg_config ON)
+    if ((NOT DEFINED "FEATURE_pkg_config") AND (DEFINED "INPUT_pkg_config")
+            AND (NOT "${INPUT_pkg_config}" STREQUAL "undefined")
+            AND (NOT "${INPUT_pkg_config}" STREQUAL ""))
+        if(INPUT_pkg_config)
+            set(FEATURE_pkg_config ON)
+        else()
+            set(FEATURE_pkg_config OFF)
+        endif()
     endif()
 
     # If user explicitly specified a value for the feature, honor it, even if it might break
@@ -250,7 +255,7 @@ macro(qt_build_internals_get_repo_targets subdir)
     if(_targets)
         foreach(_target IN LISTS _targets)
             get_target_property(_type ${_target} TYPE)
-            if(NOT (${_type} STREQUAL "UTILITY" OR ${_type} STREQUAL "INTERFACE"))
+            if(NOT ${_type} STREQUAL "UTILITY")
                 list(APPEND qt_repo_targets "${_target}")
             endif()
         endforeach()
@@ -276,15 +281,17 @@ function(qt_build_internals_add_toplevel_targets)
             set(qt_repo_target_name "${qt_repo_targets_name}_${qt_repo_target_basename}")
             message(DEBUG "${qt_repo_target_name} depends on ${qt_repo_targets}")
             add_custom_target("${qt_repo_target_name}"
-                                DEPENDS ${qt_repo_targets}
-                                COMMENT "Building everything in ${qt_repo_targets_name}/${qt_repo_target_basename}")
+                COMMENT "Building everything in ${qt_repo_targets_name}/${qt_repo_target_basename}")
+            add_dependencies("${qt_repo_target_name}" ${qt_repo_targets})
             list(APPEND qt_repo_target_all "${qt_repo_target_name}")
         endif()
     endforeach()
     if (qt_repo_target_all)
+        # Note qt_repo_targets_name is different from qt_repo_target_name that is used above.
         add_custom_target("${qt_repo_targets_name}"
-                            DEPENDS ${qt_repo_target_all}
                             COMMENT "Building everything in ${qt_repo_targets_name}")
+        add_dependencies("${qt_repo_targets_name}" ${qt_repo_target_all})
+        message(DEBUG "${qt_repo_targets_name} depends on ${qt_repo_target_all}")
     endif()
 endfunction()
 
@@ -520,7 +527,18 @@ macro(qt_build_repo_impl_find_package_tests)
     # Do this before adding src, because there might be test related conditions
     # in source.
     if (QT_BUILD_TESTS AND NOT QT_BUILD_STANDALONE_TESTS)
-        find_package(Qt6 ${PROJECT_VERSION} CONFIG REQUIRED COMPONENTS Test)
+        # When looking for the Test package, do it using the Qt6 package version, in case if
+        # PROJECT_VERSION is following a different versioning scheme.
+        if(Qt6_VERSION)
+            set(_qt_build_repo_impl_find_package_tests_version "${Qt6_VERSION}")
+        else()
+            set(_qt_build_repo_impl_find_package_tests_version "${PROJECT_VERSION}")
+        endif()
+
+        find_package(Qt6
+            "${_qt_build_repo_impl_find_package_tests_version}"
+            CONFIG REQUIRED COMPONENTS Test)
+        unset(_qt_build_repo_impl_find_package_tests_version)
     endif()
 endmacro()
 
@@ -620,7 +638,15 @@ macro(qt_build_tests)
         unset(_qt_tests_config_file_name)
 
         # Of course we always need the test module as well.
-        find_package(Qt6 ${PROJECT_VERSION} CONFIG REQUIRED COMPONENTS Test)
+        # When looking for the Test package, do it using the Qt6 package version, in case if
+        # PROJECT_VERSION is following a different versioning scheme.
+        if(Qt6_VERSION)
+            set(_qt_build_tests_package_version "${Qt6_VERSION}")
+        else()
+            set(_qt_build_tests_package_version "${PROJECT_VERSION}")
+        endif()
+        find_package(Qt6 "${_qt_build_tests_package_version}" CONFIG REQUIRED COMPONENTS Test)
+        unset(_qt_build_tests_package_version)
 
         # Set language standards after finding Core, because that's when the relevant
         # feature variables are available, and the call in QtSetup is too early when building
@@ -727,7 +753,7 @@ endfunction()
 # Mean to be called when configuring examples as part of the main build tree, as well as for CMake
 # tests (tests that call CMake to try and build CMake applications).
 macro(qt_internal_set_up_build_dir_package_paths)
-    list(APPEND CMAKE_PREFIX_PATH "${QT_BUILD_DIR}")
+    list(PREPEND CMAKE_PREFIX_PATH "${QT_BUILD_DIR}/${INSTALL_LIBDIR}/cmake")
     # Make sure the CMake config files do not recreate the already-existing targets
     set(QT_NO_CREATE_TARGETS TRUE)
 endmacro()
@@ -809,15 +835,15 @@ macro(qt_examples_build_begin)
 
     # Examples that are built as part of the Qt build need to use the CMake config files from the
     # build dir, because they are not installed yet in a prefix build.
-    # Appending to CMAKE_PREFIX_PATH helps find the initial Qt6Config.cmake.
-    # Appending to QT_EXAMPLES_CMAKE_PREFIX_PATH helps find components of Qt6, because those
+    # Prepending to CMAKE_PREFIX_PATH helps find the initial Qt6Config.cmake.
+    # Prepending to QT_EXAMPLES_CMAKE_PREFIX_PATH helps find components of Qt6, because those
     # find_package calls use NO_DEFAULT_PATH, and thus CMAKE_PREFIX_PATH is ignored.
-    # Appending to CMAKE_FIND_ROOT_PATH ensures the components are found while cross-compiling
+    # Prepending to CMAKE_FIND_ROOT_PATH ensures the components are found while cross-compiling
     # without setting CMAKE_FIND_ROOT_PATH_MODE_PACKAGE to BOTH.
     if(NOT QT_IS_EXTERNAL_EXAMPLES_BUILD OR NOT __qt_all_examples_ported_to_external_projects)
         qt_internal_set_up_build_dir_package_paths()
-        list(APPEND CMAKE_FIND_ROOT_PATH "${QT_BUILD_DIR}")
-        list(APPEND QT_EXAMPLES_CMAKE_PREFIX_PATH "${QT_BUILD_DIR}/${INSTALL_LIBDIR}/cmake")
+        list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_BUILD_DIR}")
+        list(PREPEND QT_EXAMPLES_CMAKE_PREFIX_PATH "${QT_BUILD_DIR}/${INSTALL_LIBDIR}/cmake")
     endif()
 
     # Because CMAKE_INSTALL_RPATH is empty by default in the repo project, examples need to have
@@ -1034,6 +1060,41 @@ function(qt_internal_add_example_external_project subdir)
         endforeach()
     endif()
 
+    # When cross-compiling for a qemu target in our CI, we source an environment script
+    # that sets environment variables like CC and CXX. These are parsed by CMake on initial
+    # configuration to populate the cache vars CMAKE_${lang}_COMPILER.
+    # If the environment variable specified not only the compiler path, but also a list of flags
+    # to pass to the compiler, CMake parses those out into a separate CMAKE_${lang}_COMPILER_ARG1
+    # cache variable. In such a case, we want to ensure that the external project also sees those
+    # flags.
+    # Unfortunately we can't do that by simply forwarding CMAKE_${lang}_COMPILER_ARG1 to the EP
+    # because it breaks the compiler identification try_compile call, it simply doesn't consider
+    # the cache var. From what I could gather, it's a limitation of try_compile and the list
+    # of variables it considers for forwarding.
+    # To fix this case, we ensure not to pass either cache variable, and let the external project
+    # and its compiler identification try_compile project pick up the compiler and the flags
+    # from the environment variables instead.
+    foreach(lang_as_env_var CC CXX OBJC OBJCXX)
+        if(lang_as_env_var STREQUAL "CC")
+            set(lang_as_cache_var "C")
+        else()
+            set(lang_as_cache_var "${lang_as_env_var}")
+        endif()
+        set(lang_env_value "$ENV{${lang_as_env_var}}")
+        if(lang_env_value
+                AND CMAKE_${lang_as_cache_var}_COMPILER
+                AND CMAKE_${lang_as_cache_var}_COMPILER_ARG1)
+            # The compiler environment variable is set and specifies a list of extra flags, don't
+            # forward the compiler cache vars and rely on the environment variable to be picked up
+            # instead.
+        else()
+            list(APPEND vars_to_pass_if_defined "CMAKE_${lang_as_cache_var}_COMPILER:STRING")
+        endif()
+    endforeach()
+    unset(lang_as_env_var)
+    unset(lang_as_cache_var)
+    unset(lang_env_value)
+
     list(APPEND vars_to_pass_if_defined
         CMAKE_BUILD_TYPE:STRING
         CMAKE_CONFIGURATION_TYPES:STRING
@@ -1046,13 +1107,9 @@ function(qt_internal_add_example_external_project subdir)
         CMAKE_OSX_DEPLOYMENT_TARGET:STRING
         CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED:BOOL
         CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH:BOOL
-        CMAKE_C_COMPILER:STRING
         CMAKE_C_COMPILER_LAUNCHER:STRING
-        CMAKE_CXX_COMPILER:STRING
         CMAKE_CXX_COMPILER_LAUNCHER:STRING
-        CMAKE_OBJC_COMPILER:STRING
         CMAKE_OBJC_COMPILER_LAUNCHER:STRING
-        CMAKE_OBJCXX_COMPILER:STRING
         CMAKE_OBJCXX_COMPILER_LAUNCHER:STRING
     )
 

cmake/QtBuildInternals/QtStandaloneTestTemplateProject/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.16)
 project(qt_single_test VERSION 6.0.0 LANGUAGES C CXX ASM)
 
-find_package(Qt6 REQUIRED COMPONENTS BuildInternals)
+find_package(Qt6 REQUIRED COMPONENTS BuildInternals Core)
 
 include(${CMAKE_CURRENT_LIST_DIR}/Main.cmake)
 
@@ -15,5 +15,14 @@ else()
     set(absolute_project_path "${QT_STANDALONE_TEST_PATH}")
 endif()
 
+if(NOT IS_DIRECTORY "${absolute_project_path}")
+    get_filename_component(filename "${absolute_project_path}" NAME)
+    get_filename_component(directory "${absolute_project_path}" DIRECTORY)
+
+    if(filename STREQUAL "CMakeLists.txt")
+        set(absolute_project_path "${directory}")
+    endif()
+endif()
+
 # Add the test project path as a subdirectory project.
 add_subdirectory("${absolute_project_path}" "build_dir")

cmake/QtBuildInternals/QtStandaloneTestTemplateProject/Main.cmake

@@ -12,6 +12,10 @@ foreach(file ${config_files})
     include("${file}")
 endforeach()
 
+# Set language standards after finding Core, because that's when the relevant
+# feature variables are available.
+qt_set_language_standards()
+
 # Just before adding the test, change the local (non-cache) install prefix to something other than
 # the Qt install prefix, so that tests don't try to install and pollute the Qt install prefix.
 # Needs to be called after qt_get_standalone_tests_confg_files_path().

cmake/QtBuildInternalsExtra.cmake.in

@@ -13,6 +13,25 @@ get_filename_component(QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX
                        ${CMAKE_CURRENT_LIST_DIR}/../@qt_path_from_cmake_config_dir_to_prefix@
                        ABSOLUTE)
 
+# Stores in out_var the new install/staging prefix for this build.
+#
+# new_prefix: the new prefix for this repository
+# orig_prefix: the prefix that was used when qtbase was configured
+#
+# On Windows hosts, this function makes sure that we use exactly the original prefix if it points to
+# the same directory as the new one. This is needed for the case where the original prefix is passed
+# without drive letter to support installing with DESTDIR set.
+function(qt_internal_new_prefix out_var new_prefix orig_prefix)
+    if(CMAKE_HOST_WIN32)
+        get_filename_component(real_new_prefix "${new_prefix}" REALPATH)
+        get_filename_component(real_orig_prefix "${orig_prefix}" REALPATH)
+        if(real_new_prefix STREQUAL real_orig_prefix)
+            set(new_prefix "${orig_prefix}")
+        endif()
+    endif()
+    set(${out_var} "${new_prefix}" PARENT_SCOPE)
+endfunction()
+
 # If no explicit CMAKE_INSTALL_PREFIX is provided, force set the original Qt installation prefix,
 # so that further modules / repositories are  installed into same original location.
 # This means by default when configuring qtsvg / qtdeclarative, they will be installed the regular
@@ -25,32 +44,26 @@ if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND
         NOT QT_BUILD_INTERNALS_NO_FORCE_SET_INSTALL_PREFIX
         AND NOT QT_SUPERBUILD)
     set(qtbi_orig_prefix "@CMAKE_INSTALL_PREFIX@")
-    set(qtbi_new_prefix "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}")
     set(qtbi_orig_staging_prefix "@CMAKE_STAGING_PREFIX@")
-    if(CMAKE_HOST_WIN32)
-        # Make sure we use exactly the original prefix if it points to the same directory as the new
-        # one. This is needed for the case where the original prefix is passed without drive letter
-        # to support installing with DESTDIR set.
-        get_filename_component(qtbi_real_orig_prefix "${qtbi_orig_prefix}" REALPATH)
-        get_filename_component(qtbi_real_new_prefix "${qtbi_new_prefix}" REALPATH)
-        if(qtbi_real_orig_prefix STREQUAL qtbi_real_new_prefix)
-            set(qtbi_new_prefix "${qtbi_orig_prefix}")
-        endif()
-    endif()
+    qt_internal_new_prefix(qtbi_new_prefix
+        "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}"
+        "${qtbi_orig_prefix}")
     if(NOT qtbi_orig_staging_prefix STREQUAL ""
             AND "${CMAKE_STAGING_PREFIX}" STREQUAL ""
             AND NOT QT_BUILD_INTERNALS_NO_FORCE_SET_STAGING_PREFIX)
-        set(CMAKE_STAGING_PREFIX "${qtbi_new_prefix}" CACHE PATH
+        qt_internal_new_prefix(qtbi_new_staging_prefix
+            "${qtbi_new_prefix}"
+            "${qtbi_orig_staging_prefix}")
+        set(CMAKE_STAGING_PREFIX "${qtbi_new_staging_prefix}" CACHE PATH
             "Staging path prefix, prepended onto install directories on the host machine." FORCE)
         set(qtbi_new_prefix "${qtbi_orig_prefix}")
     endif()
     set(CMAKE_INSTALL_PREFIX "${qtbi_new_prefix}" CACHE PATH
         "Install path prefix, prepended onto install directories." FORCE)
     unset(qtbi_orig_prefix)
-    unset(qtbi_real_orig_prefix)
     unset(qtbi_new_prefix)
-    unset(qtbi_real_new_prefix)
     unset(qtbi_orig_staging_prefix)
+    unset(qtbi_new_staging_prefix)
 endif()
 
 # Propagate developer builds to other modules via BuildInternals package.

cmake/QtCMakeHelpers.cmake

@@ -3,8 +3,9 @@
 # output-file is relative to ${CMAKE_CURRENT_BINARY_DIR}
 #
 # This function is similar to file(GENERATE OUTPUT) except it writes the content
-# to the file at configure time, rather than at generate time. Once CMake 3.18 is released, it can use file(CONFIGURE) in its implmenetation. Until then, it
-# uses configure_file() with a generic input file as source, when used with the CONTENT signature.
+# to the file at configure time, rather than at generate time. Once CMake 3.18 is released, it can
+# use file(CONFIGURE) in its implementation. Until then, it  uses configure_file() with a generic
+# input file as source, when used with the CONTENT signature.
 function(qt_configure_file)
     qt_parse_all_arguments(arg "qt_configure_file" "" "OUTPUT;INPUT;CONTENT" "" ${ARGN})
 

cmake/QtCMakePackageVersionFile.cmake.in

@@ -17,9 +17,17 @@ else()
 endif()
 
 if(__qt_disable_package_version_check)
+    # Don't show the warning needlessly if we know that we're doing an exact search, and the
+    # version found is not the exactly same.
+    if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION_EXACT
+        AND NOT PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+        set(QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING TRUE)
+    endif()
+
     # Warn if version check is disabled regardless if it's a Qt repo build or user project build.
     # Allow to opt out of warning.
-    if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING)
+    if(__qt_package_version_incompatible AND NOT QT_NO_PACKAGE_VERSION_INCOMPATIBLE_WARNING
+       AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
         message(WARNING
             "Package ${PACKAGE_FIND_NAME} with version ${PACKAGE_VERSION} was accepted as "
             "compatible because QT_NO_PACKAGE_VERSION_CHECK was set to TRUE. There is no guarantee "

cmake/QtCMakeVersionHelpers.cmake

@@ -189,6 +189,12 @@ function(qt_internal_warn_about_buggy_cmake_versions)
     # https://gitlab.kitware.com/cmake/cmake/-/issues/16776
     list(APPEND unsuitable_versions "3.21.0")
 
+    # Changing a C++ source file can trigger rebuilds of a lot of other source files that might
+    # include AUTOGEN'ed headers or sources.
+    # https://gitlab.kitware.com/cmake/cmake/-/issues/22531
+    # Fixed in 3.21.2.
+    list(APPEND unsuitable_versions "3.21.1")
+
     # qt_ensure_perl fails to find perl in host PATH via find_program
     # due to Android Platform module setting CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH to OFF
     # Fixed in 3.20.6, 3.21.3. not a problem in CMake versions earlier than 3.20.0

cmake/QtConfig.cmake.in

@@ -23,16 +23,6 @@ else()
                              QT_VERSION_PATCH @PROJECT_VERSION_PATCH@)
 endif()
 
-if(NOT "${QT_HOST_PATH}" STREQUAL "")
-    find_package(Qt@PROJECT_VERSION_MAJOR@HostInfo
-                 CONFIG
-                 REQUIRED
-                 PATHS "${QT_HOST_PATH}"
-                       "${QT_HOST_PATH_CMAKE_DIR}"
-                 NO_CMAKE_FIND_ROOT_PATH
-                 NO_DEFAULT_PATH)
-endif()
-
 get_filename_component(_qt_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH)
 get_filename_component(_qt_import_prefix "${_qt_import_prefix}" REALPATH)
 list(APPEND CMAKE_MODULE_PATH "${_qt_import_prefix}")
@@ -48,86 +38,32 @@ elseif(APPLE AND CMAKE_SYSTEM_NAME STREQUAL "iOS")
     list(APPEND CMAKE_MODULE_PATH "${__qt_internal_cmake_ios_support_files_path}")
 endif()
 
-set(QT_ADDITIONAL_PACKAGES_PREFIX_PATH "" CACHE STRING
-    "Additional directories where find(Qt6 ...) components are searched")
-set(QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH "" CACHE STRING
-    "Additional directories where find(Qt6 ...) host Qt components are searched")
-
-# Collect additional package prefix paths to look for Qt packages, both from command line and the
-# env variable ${prefixes_var}. The result is stored in ${out_var} and is a list of paths ending
-# with "/lib/cmake".
-function(__qt_internal_collect_additional_prefix_paths out_var prefixes_var)
-    if(DEFINED "${out_var}")
-        return()
-    endif()
-
-    set(additional_packages_prefix_paths "")
-
-    set(additional_packages_prefixes "")
-    if(${prefixes_var})
-        list(APPEND additional_packages_prefixes ${${prefixes_var}})
-    endif()
-    if(DEFINED ENV{${prefixes_var}}
-        AND NOT "$ENV{${prefixes_var}}" STREQUAL "")
-        set(prefixes_from_env "$ENV{${prefixes_var}}")
-        if(NOT CMAKE_HOST_WIN32)
-            string(REPLACE ":" ";" prefixes_from_env "${prefixes_from_env}")
-        endif()
-        list(APPEND additional_packages_prefixes ${prefixes_from_env})
-    endif()
-
-    foreach(additional_path IN LISTS additional_packages_prefixes)
-        file(TO_CMAKE_PATH "${additional_path}" additional_path)
-
-        # The prefix paths need to end with lib/cmake to ensure the packages are found when
-        # cross compiling. Search for REROOT_PATH_ISSUE_MARKER in the qt.toolchain.cmake file for
-        # details.
-        # We must pass the values via the PATHS options because the main find_package call uses
-        # NO_DEFAULT_PATH, and thus CMAKE_PREFIX_PATH values are discarded.
-        # CMAKE_FIND_ROOT_PATH values are not discarded and togegher with the PATHS option, it
-        # ensures packages from additional prefixes are found.
-        if(NOT additional_path MATCHES "/lib/cmake$")
-            string(APPEND additional_path "/lib/cmake")
-        endif()
-        list(APPEND additional_packages_prefix_paths "${additional_path}")
-    endforeach()
-
-    set("${out_var}" "${additional_packages_prefix_paths}" PARENT_SCOPE)
-endfunction()
-
-__qt_internal_collect_additional_prefix_paths(_qt_additional_packages_prefix_paths
-    QT_ADDITIONAL_PACKAGES_PREFIX_PATH)
-__qt_internal_collect_additional_prefix_paths(_qt_additional_host_packages_prefix_paths
-    QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH)
-
-# Take a list of prefix paths ending with "/lib/cmake", and return a list of absolute paths with
-# "/lib/cmake" removed.
-function(__qt_internal_prefix_paths_to_roots out_var prefix_paths)
-    set(result "")
-    foreach(path IN LISTS prefix_paths)
-        if(path MATCHES "/lib/cmake$")
-            string(APPEND path "/../..")
-        endif()
-        get_filename_component(path "${path}" ABSOLUTE)
-        list(APPEND result "${path}")
-    endforeach()
-    set("${out_var}" "${result}" PARENT_SCOPE)
-endfunction()
-
-__qt_internal_prefix_paths_to_roots(_qt_additional_host_packages_root_paths
-    "${_qt_additional_host_packages_prefix_paths}")
-
 # Public helpers available to all Qt packages.
 include("${CMAKE_CURRENT_LIST_DIR}/QtFeature.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/QtPublicAppleHelpers.cmake")
 include("${CMAKE_CURRENT_LIST_DIR}/QtPublicFinalizerHelpers.cmake")
 include("${CMAKE_CURRENT_LIST_DIR}/QtPublicPluginHelpers.cmake")
 include("${CMAKE_CURRENT_LIST_DIR}/QtPublicTargetHelpers.cmake")
 include("${CMAKE_CURRENT_LIST_DIR}/QtPublicWalkLibsHelpers.cmake")
 include("${CMAKE_CURRENT_LIST_DIR}/QtPublicFindPackageHelpers.cmake")
 include("${CMAKE_CURRENT_LIST_DIR}/QtPublicDependencyHelpers.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/QtPublicTestHelpers.cmake")
 include("${CMAKE_CURRENT_LIST_DIR}/QtPublicToolHelpers.cmake")
 include("${CMAKE_CURRENT_LIST_DIR}/QtPublicCMakeHelpers.cmake")
 
+set(QT_ADDITIONAL_PACKAGES_PREFIX_PATH "" CACHE STRING
+    "Additional directories where find(Qt6 ...) components are searched")
+set(QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH "" CACHE STRING
+    "Additional directories where find(Qt6 ...) host Qt components are searched")
+
+__qt_internal_collect_additional_prefix_paths(_qt_additional_packages_prefix_paths
+    QT_ADDITIONAL_PACKAGES_PREFIX_PATH)
+__qt_internal_collect_additional_prefix_paths(_qt_additional_host_packages_prefix_paths
+    QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH)
+
+__qt_internal_prefix_paths_to_roots(_qt_additional_host_packages_root_paths
+    "${_qt_additional_host_packages_prefix_paths}")
+
 if(NOT DEFINED QT_CMAKE_EXPORT_NAMESPACE)
     set(QT_CMAKE_EXPORT_NAMESPACE @QT_CMAKE_EXPORT_NAMESPACE@)
 endif()
@@ -150,10 +86,14 @@ set(__qt_sanitizer_options_set TRUE)
 include(CMakeFindDependencyMacro)
 if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@Dependencies.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@Dependencies.cmake")
-    if(NOT @INSTALL_CMAKE_NAMESPACE@_DEPENDENCIES_FOUND)
-        set(@INSTALL_CMAKE_NAMESPACE@_FOUND FALSE)
-        message(FATAL_ERROR "Failed to find Qt Platform dependency: "
-            "${@INSTALL_CMAKE_NAMESPACE@_DEPENDENCY_NOT_FOUND_MESSAGE}")
+
+    _qt_internal_suggest_dependency_debugging(@INSTALL_CMAKE_NAMESPACE@
+        __qt_@INSTALL_CMAKE_NAMESPACE@_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE)
+
+    if(NOT @INSTALL_CMAKE_NAMESPACE@_FOUND)
+        # Clear the components, no need to look for them if dependencies were not found, otherwise
+        # you get a wall of recursive error messages.
+        set(@INSTALL_CMAKE_NAMESPACE@_FIND_COMPONENTS "")
     endif()
 endif()
 
@@ -187,17 +127,21 @@ foreach(module ${@INSTALL_CMAKE_NAMESPACE@_FIND_COMPONENTS})
             ${_qt_additional_host_packages_root_paths})
     endif()
 
-    find_package(@INSTALL_CMAKE_NAMESPACE@${module}
-        ${@INSTALL_CMAKE_NAMESPACE@_FIND_VERSION}
-        ${_@INSTALL_CMAKE_NAMESPACE@_FIND_PARTS_QUIET}
-        PATHS
-            ${_qt_cmake_dir}
-            ${_qt_additional_packages_prefix_paths}
-            ${QT_EXAMPLES_CMAKE_PREFIX_PATH}
-            ${__qt_find_package_host_qt_path}
-            ${_qt_additional_host_packages_prefix_paths}
-        ${__qt_use_no_default_path_for_qt_packages}
-    )
+    _qt_internal_save_find_package_context_for_debugging(@INSTALL_CMAKE_NAMESPACE@${module})
+
+    if(NOT @INSTALL_CMAKE_NAMESPACE@${module}_FOUND)
+        find_package(@INSTALL_CMAKE_NAMESPACE@${module}
+            ${@INSTALL_CMAKE_NAMESPACE@_FIND_VERSION}
+            ${_@INSTALL_CMAKE_NAMESPACE@_FIND_PARTS_QUIET}
+            PATHS
+                ${_qt_cmake_dir}
+                ${_qt_additional_packages_prefix_paths}
+                ${QT_EXAMPLES_CMAKE_PREFIX_PATH}
+                ${__qt_find_package_host_qt_path}
+                ${_qt_additional_host_packages_prefix_paths}
+            ${__qt_use_no_default_path_for_qt_packages}
+        )
+    endif()
 
     if(NOT "${__qt_find_package_host_qt_path}" STREQUAL "")
         set(CMAKE_PREFIX_PATH "${__qt_backup_cmake_prefix_path}")
@@ -234,11 +178,17 @@ foreach(module ${@INSTALL_CMAKE_NAMESPACE@_FIND_COMPONENTS})
         endif()
 
         if(@INSTALL_CMAKE_NAMESPACE@_FIND_REQUIRED_${module})
+            set(@INSTALL_CMAKE_NAMESPACE@_FOUND False)
             set(_Qt_NOTFOUND_MESSAGE
-                "${_Qt_NOTFOUND_MESSAGE}Failed to find Qt component \"${module}\". ${_qt_component_not_found_msg}")
+                "${_Qt_NOTFOUND_MESSAGE}Failed to find required Qt component \"${module}\". ${_qt_component_not_found_msg}")
+            set(_qt_full_component_name "@INSTALL_CMAKE_NAMESPACE@${module}")
+            _qt_internal_suggest_dependency_debugging(${_qt_full_component_name}
+                _qt_full_component_name _Qt_NOTFOUND_MESSAGE)
+            unset(_qt_full_component_name)
+            break()
         elseif(NOT @INSTALL_CMAKE_NAMESPACE@_FIND_QUIETLY)
             message(WARNING
-                "Failed to find Qt component \"${module}\". ${_qt_component_not_found_msg}")
+                "Failed to find optional Qt component \"${module}\". ${_qt_component_not_found_msg}")
         endif()
 
         unset(_qt_expected_component_config_path)
@@ -250,10 +200,15 @@ endforeach()
 
 if(@INSTALL_CMAKE_NAMESPACE@_FIND_COMPONENTS AND _Qt_NOTFOUND_MESSAGE)
     set(@INSTALL_CMAKE_NAMESPACE@_NOT_FOUND_MESSAGE "${_Qt_NOTFOUND_MESSAGE}")
-    set(@INSTALL_CMAKE_NAMESPACE@_FOUND False)
     unset(_Qt_NOTFOUND_MESSAGE)
 endif()
 
+if(@INSTALL_CMAKE_NAMESPACE@_FOUND
+    AND COMMAND _qt_internal_override_example_install_dir_to_dot
+    AND NOT _qt_internal_example_dir_set_to_dot)
+    _qt_internal_override_example_install_dir_to_dot()
+endif()
+
 __qt_internal_defer_promote_targets_in_dir_scope_to_global()
 if(CMAKE_VERSION VERSION_LESS 3.21)
     __qt_internal_check_link_order_matters()

cmake/QtConfigDependencies.cmake.in

@@ -1,51 +1,24 @@
-set(@INSTALL_CMAKE_NAMESPACE@_DEPENDENCIES_FOUND FALSE)
+set(@INSTALL_CMAKE_NAMESPACE@_FOUND FALSE)
+
+set(__qt_platform_requires_host_info_package "@platform_requires_host_info_package@")
+set(__qt_platform_initial_qt_host_path "@qt_host_path_absolute@")
+set(__qt_platform_initial_qt_host_path_cmake_dir "@qt_host_path_cmake_dir_absolute@")
+
+_qt_internal_setup_qt_host_path(
+    "${__qt_platform_requires_host_info_package}"
+    "${__qt_platform_initial_qt_host_path}"
+    "${__qt_platform_initial_qt_host_path_cmake_dir}")
+_qt_internal_find_host_info_package(${__qt_platform_requires_host_info_package})
 
 # note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;"
 set(__qt_third_party_deps "@third_party_deps@")
 
 @third_party_extra@
 
-foreach(__qt_target_dep ${__qt_third_party_deps})
-    list(GET __qt_target_dep 0 __qt_pkg)
-    list(GET __qt_target_dep 1 __qt_is_optional)
-    list(GET __qt_target_dep 2 __qt_version)
-    list(GET __qt_target_dep 3 __qt_components)
-    list(GET __qt_target_dep 4 __qt_optional_components)
-    set(__qt_find_package_args "${__qt_pkg}")
-    if(__qt_version)
-        list(APPEND __qt_find_package_args "${__qt_version}")
-    endif()
-    if(__qt_components)
-        string(REPLACE " " ";" __qt_components "${__qt_components}")
-        list(APPEND __qt_find_package_args COMPONENTS ${__qt_components})
-    endif()
-    if(__qt_optional_components)
-        string(REPLACE " " ";" __qt_optional_components "${__qt_optional_components}")
-        list(APPEND __qt_find_package_args OPTIONAL_COMPONENTS ${__qt_optional_components})
-    endif()
+# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls
+# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file.
+set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE)
 
-    # Already build an error message, because find_dependency calls return() on failure.
-    set(__qt_message "\nPackage: ${__qt_pkg}")
-    if(__qt_version)
-        string(APPEND __qt_message "\nVersion: ${__qt_version}")
-    endif()
-    if(__qt_components)
-        string(APPEND __qt_message "\nComponents: ${__qt_components}")
-    endif()
-    if(__qt_optional_components)
-        string(APPEND __qt_message "\nComponents: ${__qt_optional_components}")
-    endif()
-    set(@INSTALL_CMAKE_NAMESPACE@_DEPENDENCY_NOT_FOUND_MESSAGE "${__qt_message}")
+_qt_internal_find_third_party_dependencies(@INSTALL_CMAKE_NAMESPACE@ __qt_third_party_deps)
 
-    if(__qt_is_optional)
-        if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
-            list(APPEND __qt_find_package_args QUIET)
-        endif()
-        find_package(${__qt_find_package_args})
-    else()
-        find_dependency(${__qt_find_package_args})
-    endif()
-endforeach()
-
-set(@INSTALL_CMAKE_NAMESPACE@_DEPENDENCIES_FOUND TRUE)
-unset(@INSTALL_CMAKE_NAMESPACE@_DEPENDENCY_NOT_FOUND_MESSAGE)
+set(@INSTALL_CMAKE_NAMESPACE@_FOUND TRUE)

cmake/QtDocsHelpers.cmake

@@ -94,6 +94,7 @@ function(qt_internal_add_docs)
     add_custom_target(qattributionsscanner_${target}
         COMMAND ${qtattributionsscanner_bin}
         ${PROJECT_SOURCE_DIR}
+        --basedir "${PROJECT_SOURCE_DIR}/.."
         --filter "QDocModule=${doc_target}"
         -o "${target_bin_dir}/codeattributions.qdoc"
     )

cmake/QtExecutableHelpers.cmake

@@ -6,7 +6,7 @@
 #         The argument accepts 'Bootstrap' or 'None' values. If the argument value is set to
 #         'Bootstrap' the Qt::Bootstrap library is linked to the executable instead of Qt::Core.
 #         The 'None' value points that core library is not necessary and avoids linking neither
-#         Qt::Core or Qt::Bootstrap libraries. Otherwise the Qt::Core library will be publically
+#         Qt::Core or Qt::Bootstrap libraries. Otherwise the Qt::Core library will be publicly
 #         linked to the executable target by default.
 function(qt_internal_add_executable name)
     qt_parse_all_arguments(arg "qt_internal_add_executable"
@@ -37,8 +37,10 @@ function(qt_internal_add_executable name)
     endif()
 
     if(WASM)
+        qt_internal_wasm_add_finalizers("${name}")
         _qt_internal_wasm_add_target_helpers("${name}")
     endif()
+
     if (arg_VERSION)
         if(arg_VERSION MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+")
             # nothing to do

cmake/QtFeature.cmake

@@ -236,7 +236,7 @@ function(qt_feature_check_and_save_user_provided_value resultVar feature conditi
     if (DEFINED "FEATURE_${feature}")
         # Revisit new user provided value
         set(user_value "${FEATURE_${feature}}")
-        set(result "${user_value}")
+        string(TOUPPER "${user_value}" result)
 
         # If the build is marked as dirty and the user_value doesn't meet the new condition,
         # reset it to the computed one.
@@ -921,6 +921,7 @@ function(qt_config_compile_test name)
                 # fail instead of cmake abort later via CMAKE_REQUIRED_LIBRARIES.
                 string(FIND "${library}" "::" cmake_target_namespace_separator)
                 if(NOT cmake_target_namespace_separator EQUAL -1)
+                    message(STATUS "Performing Test ${arg_LABEL} - Failed because ${library} not found")
                     set(HAVE_${name} FALSE)
                     break()
                 endif()
@@ -1246,7 +1247,15 @@ function(qt_make_features_available target)
             endif()
             foreach(feature IN ITEMS ${features})
                 if (DEFINED "QT_FEATURE_${feature}" AND NOT "${QT_FEATURE_${feature}}" STREQUAL "${value}")
-                    message(FATAL_ERROR "Feature ${feature} is already defined to be \"${QT_FEATURE_${feature}}\" and should now be set to \"${value}\" when importing features from ${target}.")
+                    message(WARNING
+                        "This project was initially configured with the Qt feature \"${feature}\" "
+                        "set to \"${QT_FEATURE_${feature}}\". While loading the "
+                        "\"${target}\" package, the value of the feature "
+                        "has changed to \"${value}\". That might cause a project rebuild due to "
+                        "updated C++ headers. \n"
+                        "In case of build issues, consider removing the CMakeCache.txt file and "
+                        "reconfiguring the project."
+                    )
                 endif()
                 set(QT_FEATURE_${feature} "${value}" CACHE INTERNAL "Qt feature: ${feature} (from target ${target})")
             endforeach()

cmake/QtFindPackageHelpers.cmake

@@ -25,7 +25,7 @@ macro(qt_find_package)
     # found as part of a find_dependency() call from a ModuleDependencies.cmake file (or similar),
     # and the provided target is also found, that means this might have been an unnecessary
     # qt_find_package() call, because the dependency was already found via some other transitive
-    # dependency. Return early, so that CMake doesn't fail wiht an error with trying to promote the
+    # dependency. Return early, so that CMake doesn't fail with an error with trying to promote the
     # targets to be global. This behavior is not enabled by default, because there are cases
     # when a regular find_package() (non qt_) can find a package (Freetype -> PNG), and a subsequent
     # qt_find_package(PNG PROVIDED_TARGET PNG::PNG) still needs to succeed and register the provided
@@ -284,6 +284,8 @@ endfunction()
 # Needed to record a dependency on the package that provides WrapVulkanHeaders::WrapVulkanHeaders.
 # The package version, components, whether the package is optional, etc, are queried from the
 # ${dep_target} target properties.
+# Usually these are set at the qt_find_package() call site of a configure.cmake file e.g. using
+# Qt's MARK_OPTIONAL option.
 function(qt_record_extra_third_party_dependency main_target_name dep_target)
     if(NOT TARGET "${main_target_name}")
         qt_get_tool_target_name(main_target_name "${main_target_name}")
@@ -307,13 +309,112 @@ function(qt_internal_is_lib_part_of_qt6_package lib out_var)
             OR lib STREQUAL "GlobalConfigPrivate"
             OR lib STREQUAL "PlatformModuleInternal"
             OR lib STREQUAL "PlatformPluginInternal"
-            OR lib STREQUAL "PlatformToolInternal")
+            OR lib STREQUAL "PlatformToolInternal"
+            OR lib STREQUAL "PlatformCommonInternal"
+    )
         set(${out_var} "TRUE" PARENT_SCOPE)
     else()
         set(${out_var} "FALSE" PARENT_SCOPE)
     endif()
 endfunction()
 
+# Try to get the CMake package version of a Qt target.
+#
+# Query the target's _qt_package_version property, or try to read it from the CMake package version
+# variable set from calling find_package(Qt6${target}).
+# Not all targets will have a find_package _VERSION variable, for example if the target is an
+# executable.
+# A heuristic is used to handle QtFooPrivate module targets.
+# If no version can be found, fall back to ${PROJECT_VERSION} and issue a warning.
+function(qt_internal_get_package_version_of_target target package_version_out_var)
+    qt_internal_is_lib_part_of_qt6_package("${target}" is_part_of_qt6)
+
+    if(is_part_of_qt6)
+        # When building qtbase, Qt6_VERSION is not set (unless examples are built in-tree,
+        # non-ExternalProject). Use the Platform target's version instead which would be the
+        # equivalent.
+        if(TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::Platform")
+            get_target_property(package_version
+                "${QT_CMAKE_EXPORT_NAMESPACE}::Platform" _qt_package_version)
+        endif()
+        if(NOT package_version)
+            set(package_version "${${QT_CMAKE_EXPORT_NAMESPACE}_VERSION}")
+        endif()
+    else()
+        # Try to get the version from the target.
+        # Try the Private target first and if it doesn't exist, try the non-Private target later.
+        if(TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::${target}")
+            get_target_property(package_version
+                "${QT_CMAKE_EXPORT_NAMESPACE}::${target}" _qt_package_version)
+        endif()
+
+        # Try to get the version from the corresponding package version variable.
+        if(NOT package_version)
+            set(package_version "${${QT_CMAKE_EXPORT_NAMESPACE}${target}_VERSION}")
+        endif()
+
+        # Try non-Private target.
+        if(NOT package_version AND target MATCHES "(.*)Private$")
+            set(target "${CMAKE_MATCH_1}")
+        endif()
+
+        if(NOT package_version AND TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::${target}")
+            get_target_property(package_version
+                "${QT_CMAKE_EXPORT_NAMESPACE}::${target}" _qt_package_version)
+        endif()
+
+        if(NOT package_version)
+            set(package_version "${${QT_CMAKE_EXPORT_NAMESPACE}${target}_VERSION}")
+        endif()
+    endif()
+
+    if(NOT package_version)
+        set(package_version "${PROJECT_VERSION}")
+        if(FEATURE_developer_build)
+            message(WARNING
+                "Could not determine package version of target ${target}. "
+                "Defaulting to project version ${PROJECT_VERSION}.")
+        endif()
+    endif()
+
+    set(${package_version_out_var} "${package_version}" PARENT_SCOPE)
+endfunction()
+
+# Get the CMake package name that contains / exported the Qt module target.
+function(qt_internal_get_package_name_of_target target package_name_out_var)
+    qt_internal_is_lib_part_of_qt6_package("${target}" is_part_of_qt6)
+
+    if(is_part_of_qt6)
+        set(package_name "${INSTALL_CMAKE_NAMESPACE}")
+    else()
+        # Get the package name from the module's target property.
+        # If not set, fallback to a name based on the target name.
+        #
+        # TODO: Remove fallback once sufficient time has passed, aka all developers updated
+        # their builds not to contain stale FooDependencies.cmakes files without the
+        # _qt_package_name property.
+        set(package_name "")
+        set(package_name_default "${INSTALL_CMAKE_NAMESPACE}${target}")
+        set(target_namespaced "${QT_CMAKE_EXPORT_NAMESPACE}::${target}")
+        if(TARGET "${target_namespaced}")
+            get_target_property(package_name_from_prop "${target_namespaced}" _qt_package_name)
+            if(package_name_from_prop)
+                set(package_name "${package_name_from_prop}")
+            endif()
+        endif()
+        if(NOT package_name)
+            message(WARNING
+                "Could not find target ${target_namespaced} to query its package name. "
+                "Defaulting to package name ${package_name_default}. Consider re-arranging the "
+                "project structure to ensure the target exists by this point."
+            )
+            set(package_name "${package_name_default}")
+        endif()
+    endif()
+
+    set(${package_name_out_var} "${package_name}" PARENT_SCOPE)
+endfunction()
+
 # This function stores the list of Qt targets a library depend on,
 # along with their version info, for usage in ${target}Depends.cmake file
 function(qt_register_target_dependencies target public_libs private_libs)
@@ -345,12 +446,9 @@ function(qt_register_target_dependencies target public_libs private_libs)
     foreach(lib IN LISTS lib_list)
         if ("${lib}" MATCHES "^Qt::(.*)")
             set(lib "${CMAKE_MATCH_1}")
-            qt_internal_is_lib_part_of_qt6_package("${lib}" is_part_of_qt6)
-            if (is_part_of_qt6)
-                list(APPEND target_deps "Qt6\;${PROJECT_VERSION}")
-            else()
-                list(APPEND target_deps "${INSTALL_CMAKE_NAMESPACE}${lib}\;${PROJECT_VERSION}")
-            endif()
+            qt_internal_get_package_name_of_target("${lib}" package_name)
+            qt_internal_get_package_version_of_target("${lib}" package_version)
+            list(APPEND target_deps "${package_name}\;${package_version}")
         endif()
     endforeach()
 
@@ -370,7 +468,9 @@ function(qt_register_target_dependencies target public_libs private_libs)
                 qt_internal_is_lib_part_of_qt6_package("${lib}" is_part_of_qt6)
                 get_target_property(lib_type "${lib_namespaced}" TYPE)
                 if(NOT lib_type STREQUAL "STATIC_LIBRARY" AND NOT is_part_of_qt6)
-                    list(APPEND target_deps "${INSTALL_CMAKE_NAMESPACE}${lib}\;${PROJECT_VERSION}")
+                    qt_internal_get_package_name_of_target("${lib}" package_name)
+                    qt_internal_get_package_version_of_target("${lib}" package_version)
+                    list(APPEND target_deps "${package_name}\;${package_version}")
                 endif()
             endif()
         endforeach()

cmake/QtFinishPrlFile.cmake

@@ -89,7 +89,34 @@ foreach(line ${lines})
             # qmake's UnixMakefileGenerator::findLibraries then takes care of deduplication, which
             # keeps the last occurrence of the library on the link line, the one after the object
             # files.
-            list(APPEND libs_to_prepend "${target_library_path}")
+            qt_internal_path_is_relative_to_qt_lib_path(
+                "${target_library_path}" "${QT_LIB_DIRS}" lib_is_a_qt_module relative_lib)
+            if(NOT lib_is_a_qt_module)
+                qt_internal_path_is_relative_to_qt_lib_path(
+                    "${target_library_path}" "${QT_PLUGIN_DIRS}" lib_is_a_qt_plugin relative_lib)
+            endif()
+            if(NOT lib_is_a_qt_module AND NOT lib_is_a_qt_plugin)
+                qt_internal_path_is_relative_to_qt_lib_path(
+                    "${target_library_path}" "${QT_QML_DIRS}" lib_is_a_qt_qml_plugin relative_lib)
+            endif()
+            if(NOT lib_is_a_qt_module AND NOT lib_is_a_qt_plugin AND NOT lib_is_a_qt_qml_plugin)
+                message(AUTHOR_WARNING
+                    "Could not determine relative path for library ${target_library_path} when "
+                    "generating prl file contents. An absolute path will be embedded, which "
+                    "will cause issues if the Qt installation is relocated.")
+                list(APPEND libs_to_prepend "${target_library_path}")
+            else()
+                set(qmake_lib_path_prefix "$$[QT_PRL_INVALID_QMAKE_VARIABLE]")
+                if(lib_is_a_qt_module)
+                    set(qmake_lib_path_prefix "$$[QT_INSTALL_LIBS]")
+                elseif(lib_is_a_qt_plugin)
+                    set(qmake_lib_path_prefix "$$[QT_INSTALL_PLUGINS]")
+                elseif(lib_is_a_qt_qml_plugin)
+                    set(qmake_lib_path_prefix "$$[QT_INSTALL_QML]")
+                endif()
+                qt_strip_library_version_suffix(relative_lib "${relative_lib}")
+                list(APPEND libs_to_prepend "${qmake_lib_path_prefix}/${relative_lib}")
+            endif()
 
             list(PREPEND adjusted_libs ${libs_to_prepend})
         endif()

cmake/QtFlagHandlingHelpers.cmake

@@ -236,11 +236,8 @@ function(qt_set_language_standards)
         set(CMAKE_CXX_STANDARD 17 PARENT_SCOPE)
     endif()
 
-    if (c_std_11 IN_LIST CMAKE_C_COMPILE_FEATURES)
-        set(CMAKE_C_STANDARD 11 PARENT_SCOPE)
-    elseif (c_std_99 IN_LIST CMAKE_C_COMPILE_FEATURES)
-        set(CMAKE_C_STANDARD 99 PARENT_SCOPE)
-    endif()
+    set(CMAKE_C_STANDARD 11 PARENT_SCOPE)
+    set(CMAKE_C_STANDARD_REQUIRED ON PARENT_SCOPE)
 endfunction()
 
 function(qt_set_language_standards_interface_compile_features target)

cmake/QtHeadersClean.cmake

@@ -124,10 +124,6 @@ function(qt_internal_add_headers_clean_target
             endif()
             if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 4.9)
                 list(APPEND hcleanFLAGS -Wfloat-conversion)
-
-                # GCC 9 has a lot of false positives relating to these
-                list(APPEND hcleanFlags -Wno-deprecated-copy -Wno-redundant-move
-                    -Wno-format-overflow -Wno-init-list-lifetime)
             endif()
         endif()
 

cmake/QtInternalTargets.cmake

@@ -68,7 +68,7 @@ function(qt_internal_set_warnings_are_errors_flags target target_scope)
     set(warnings_are_errors_enabled_genex
         "$<NOT:$<BOOL:$<TARGET_PROPERTY:QT_SKIP_WARNINGS_ARE_ERRORS>>>")
 
-    # Apprently qmake only adds -Werror to CXX and OBJCXX files, not C files. We have to do the
+    # Apparently qmake only adds -Werror to CXX and OBJCXX files, not C files. We have to do the
     # same otherwise MinGW builds break when building 3rdparty\md4c\md4c.c (and probably on other
     # platforms too).
     set(cxx_only_genex "$<OR:$<COMPILE_LANGUAGE:CXX>,$<COMPILE_LANGUAGE:OBJCXX>>")
@@ -128,23 +128,23 @@ function(qt_internal_add_global_definition definition)
 endfunction()
 
 add_library(PlatformCommonInternal INTERFACE)
-add_library(Qt::PlatformCommonInternal ALIAS PlatformCommonInternal)
+qt_internal_add_target_aliases(PlatformCommonInternal)
 target_link_libraries(PlatformCommonInternal INTERFACE Platform)
 
 add_library(PlatformModuleInternal INTERFACE)
-add_library(Qt::PlatformModuleInternal ALIAS PlatformModuleInternal)
+qt_internal_add_target_aliases(PlatformModuleInternal)
 target_link_libraries(PlatformModuleInternal INTERFACE PlatformCommonInternal)
 
 add_library(PlatformPluginInternal INTERFACE)
-add_library(Qt::PlatformPluginInternal ALIAS PlatformPluginInternal)
+qt_internal_add_target_aliases(PlatformPluginInternal)
 target_link_libraries(PlatformPluginInternal INTERFACE PlatformCommonInternal)
 
 add_library(PlatformAppInternal INTERFACE)
-add_library(Qt::PlatformAppInternal ALIAS PlatformAppInternal)
+qt_internal_add_target_aliases(PlatformAppInternal)
 target_link_libraries(PlatformAppInternal INTERFACE PlatformCommonInternal)
 
 add_library(PlatformToolInternal INTERFACE)
-add_library(Qt::PlatformToolInternal ALIAS PlatformToolInternal)
+qt_internal_add_target_aliases(PlatformToolInternal)
 target_link_libraries(PlatformToolInternal INTERFACE PlatformAppInternal)
 
 qt_internal_add_global_definition(QT_NO_JAVA_STYLE_ITERATORS)
@@ -223,7 +223,6 @@ if(UIKIT)
         # TODO: Figure out if this ok or not (sounds ok to me).
         target_compile_definitions(PlatformCommonInternal INTERFACE QT_COMPILER_SUPPORTS_SSE2)
     endif()
-    qt_internal_apply_bitcode_flags(PlatformCommonInternal)
 endif()
 
 if(WASM AND QT_FEATURE_sse2)
@@ -285,11 +284,8 @@ endif()
 
 if(QT_FEATURE_intelcet)
     if(MSVC)
-        target_compile_options(PlatformCommonInternal INTERFACE
-            -guard:ehcont
-        )
         target_link_options(PlatformCommonInternal INTERFACE
-            -guard:ehcont -CETCOMPAT
+            -CETCOMPAT
         )
     else()
         target_compile_options(PlatformCommonInternal INTERFACE

cmake/QtModuleConfig.cmake.in

@@ -14,6 +14,8 @@ get_filename_component(_import_prefix "${_import_prefix}" REALPATH)
 # Find required dependencies, if any.
 if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake")
+    _qt_internal_suggest_dependency_debugging(@target@
+        __qt_@target@_pkg ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE)
 endif()
 
 # If *ConfigDependencies.cmake exists, the variable value will be defined there.
@@ -119,7 +121,7 @@ else()
     set(@INSTALL_CMAKE_NAMESPACE@@target@_FOUND FALSE)
     if(NOT DEFINED @INSTALL_CMAKE_NAMESPACE@@target@_NOT_FOUND_MESSAGE)
         set(@INSTALL_CMAKE_NAMESPACE@@target@_NOT_FOUND_MESSAGE
-            "Target \"@QT_CMAKE_EXPORT_NAMESPACE@::@target@\" was not found. ${@INSTALL_CMAKE_NAMESPACE@@target@_extra_not_found_message}")
+            "Target \"@QT_CMAKE_EXPORT_NAMESPACE@::@target@\" was not found.")
 
         if(QT_NO_CREATE_TARGETS)
             string(APPEND @INSTALL_CMAKE_NAMESPACE@@target@_NOT_FOUND_MESSAGE

cmake/QtModuleDependencies.cmake.in

@@ -8,92 +8,36 @@ set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH")
 if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES)
     set(__qt_use_no_default_path_for_qt_packages "")
 endif()
-find_dependency(@INSTALL_CMAKE_NAMESPACE@ @PROJECT_VERSION@
-    PATHS
-        "${CMAKE_CURRENT_LIST_DIR}/.."
-        "${_qt_cmake_dir}"
-        ${_qt_additional_packages_prefix_paths}
-        ${QT_EXAMPLES_CMAKE_PREFIX_PATH}
-    ${__qt_use_no_default_path_for_qt_packages}
-)
+
+# Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls
+# set _NOT_FOUND_MESSAGE which will be displayed by the includer of the Dependencies file.
+set(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED FALSE)
+
+if(NOT @INSTALL_CMAKE_NAMESPACE@_FOUND)
+    find_dependency(@INSTALL_CMAKE_NAMESPACE@ @main_qt_package_version@
+        PATHS
+            "${CMAKE_CURRENT_LIST_DIR}/.."
+            "${_qt_cmake_dir}"
+            ${_qt_additional_packages_prefix_paths}
+            ${QT_EXAMPLES_CMAKE_PREFIX_PATH}
+        ${__qt_use_no_default_path_for_qt_packages}
+    )
+endif()
+
 
 # note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;"
 set(__qt_@target@_third_party_deps "@third_party_deps@")
-
-foreach(__qt_@target@_target_dep ${__qt_@target@_third_party_deps})
-    list(GET __qt_@target@_target_dep 0 __qt_@target@_pkg)
-    list(GET __qt_@target@_target_dep 1 __qt_@target@_is_optional)
-    list(GET __qt_@target@_target_dep 2 __qt_@target@_version)
-    list(GET __qt_@target@_target_dep 3 __qt_@target@_components)
-    list(GET __qt_@target@_target_dep 4 __qt_@target@_optional_components)
-    set(__qt_@target@_find_package_args "${__qt_@target@_pkg}")
-    if(__qt_@target@_version)
-        list(APPEND __qt_@target@_find_package_args "${__qt_@target@_version}")
-    endif()
-    if(__qt_@target@_components)
-        string(REPLACE " " ";" __qt_@target@_components "${__qt_@target@_components}")
-        list(APPEND __qt_@target@_find_package_args COMPONENTS ${__qt_@target@_components})
-    endif()
-    if(__qt_@target@_optional_components)
-        string(REPLACE " " ";" __qt_@target@_optional_components "${__qt_@target@_optional_components}")
-        list(APPEND __qt_@target@_find_package_args OPTIONAL_COMPONENTS ${__qt_@target@_optional_components})
-    endif()
-
-    if(__qt_@target@_is_optional)
-        if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
-            list(APPEND __qt_@target@_find_package_args QUIET)
-        endif()
-        find_package(${__qt_@target@_find_package_args})
-    else()
-        find_dependency(${__qt_@target@_find_package_args})
-    endif()
-endforeach()
+_qt_internal_find_third_party_dependencies("@target@" __qt_@target@_third_party_deps)
 
 # Find Qt tool package.
 set(__qt_@target@_tool_deps "@main_module_tool_deps@")
-
-if(__qt_@target@_tool_deps AND NOT "${QT_HOST_PATH}" STREQUAL "")
-     # Make sure that the tools find the host tools first
-     set(BACKUP_@target@_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH})
-     set(BACKUP_@target@_CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH})
-     list(PREPEND CMAKE_PREFIX_PATH "${QT_HOST_PATH_CMAKE_DIR}"
-         "${_qt_additional_host_packages_prefix_paths}")
-     list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_HOST_PATH}"
-         "${_qt_additional_host_packages_root_paths}")
-endif()
-
-foreach(__qt_@target@_target_dep ${__qt_@target@_tool_deps})
-    list(GET __qt_@target@_target_dep 0 __qt_@target@_pkg)
-    list(GET __qt_@target@_target_dep 1 __qt_@target@_version)
-
-    unset(__qt_@target@_find_package_args)
-    if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
-        list(APPEND __qt_@target@_find_package_args QUIET)
-    endif()
-    if(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED)
-        list(APPEND __qt_@target@_find_package_args REQUIRED)
-    endif()
-    find_package(${__qt_@target@_pkg} ${__qt_@target@_version} ${__qt_@target@_find_package_args}
-        PATHS
-            ${_qt_additional_packages_prefix_paths}
-    )
-    if (NOT ${__qt_@target@_pkg}_FOUND)
-        if(NOT "${QT_HOST_PATH}" STREQUAL "")
-             set(CMAKE_PREFIX_PATH ${BACKUP_@target@_CMAKE_PREFIX_PATH})
-             set(CMAKE_FIND_ROOT_PATH ${BACKUP_@target@_CMAKE_FIND_ROOT_PATH})
-        endif()
-        return()
-    endif()
-endforeach()
-if(__qt_@target@_tool_deps AND NOT "${QT_HOST_PATH}" STREQUAL "")
-     set(CMAKE_PREFIX_PATH ${BACKUP_@target@_CMAKE_PREFIX_PATH})
-     set(CMAKE_FIND_ROOT_PATH ${BACKUP_@target@_CMAKE_FIND_ROOT_PATH})
-endif()
+_qt_internal_find_tool_dependencies("@target@" __qt_@target@_tool_deps)
 
 # note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0"
 set(__qt_@target@_target_deps "@target_deps@")
 set(__qt_@target@_find_dependency_paths "${CMAKE_CURRENT_LIST_DIR}/.." "${_qt_cmake_dir}")
-_qt_internal_find_dependencies(__qt_@target@_target_deps __qt_@target@_find_dependency_paths)
+_qt_internal_find_qt_dependencies("@target@" __qt_@target@_target_deps
+                                  __qt_@target@_find_dependency_paths)
 
 set(_@QT_CMAKE_EXPORT_NAMESPACE@@target@_MODULE_DEPENDENCIES "@qt_module_dependencies@")
 set(@INSTALL_CMAKE_NAMESPACE@@target@_FOUND TRUE)

cmake/QtModuleHelpers.cmake

@@ -95,7 +95,9 @@ function(qt_internal_add_module target)
         ${ARGN}
     )
 
+    set(is_internal_module FALSE)
     if(arg_INTERNAL_MODULE)
+        set(is_internal_module TRUE)
         set(arg_INTERNAL_MODULE "INTERNAL_MODULE")
         set(arg_NO_PRIVATE_MODULE TRUE)
         # Assume the interface name of the internal module should be the module name without the
@@ -153,8 +155,32 @@ function(qt_internal_add_module target)
 
     set_target_properties(${target} PROPERTIES
         _qt_module_interface_name "${arg_MODULE_INTERFACE_NAME}"
+        _qt_package_version "${PROJECT_VERSION}"
+        _qt_package_name "${INSTALL_CMAKE_NAMESPACE}${target}"
     )
-    set_property(TARGET ${target} APPEND PROPERTY EXPORT_PROPERTIES _qt_module_interface_name)
+    set(export_properties
+        "_qt_module_interface_name"
+        "_qt_package_version"
+        "_qt_package_name"
+    )
+    if(NOT is_internal_module)
+        set_target_properties(${target} PROPERTIES
+            _qt_is_public_module TRUE
+        )
+        list(APPEND export_properties
+            "_qt_is_public_module"
+        )
+        if(NOT ${arg_NO_PRIVATE_MODULE})
+            set_target_properties(${target} PROPERTIES
+                _qt_private_module_target_name "${target}Private"
+            )
+            list(APPEND export_properties
+                "_qt_private_module_target_name"
+            )
+        endif()
+    endif()
+
+    set_property(TARGET ${target} APPEND PROPERTY EXPORT_PROPERTIES "${export_properties}")
 
     qt_internal_module_info(module "${target}")
     qt_internal_add_qt_repo_known_module("${target}")
@@ -201,7 +227,7 @@ function(qt_internal_add_module target)
         qt_internal_get_framework_info(fw ${target})
     endif()
 
-    if(NOT QT_FEATURE_no_extern_direct_access AND QT_FEATURE_reduce_relocations AND
+    if(NOT QT_FEATURE_no_direct_extern_access AND QT_FEATURE_reduce_relocations AND
             UNIX AND NOT is_interface_lib)
         # On x86 and x86-64 systems with ELF binaries (especially Linux), due to
         # a new optimization in GCC 5.x in combination with a recent version of
@@ -238,9 +264,21 @@ function(qt_internal_add_module target)
         add_library("${target_private}" INTERFACE)
         qt_internal_add_target_aliases("${target_private}")
         set_target_properties(${target_private} PROPERTIES
-            _qt_config_module_name ${arg_CONFIG_MODULE_NAME}_private)
+            _qt_config_module_name ${arg_CONFIG_MODULE_NAME}_private
+            _qt_package_version "${PROJECT_VERSION}"
+            _qt_package_name "${INSTALL_CMAKE_NAMESPACE}${target}"
+            _qt_is_private_module TRUE
+            _qt_public_module_target_name "${target}"
+        )
+        set(export_properties
+            "_qt_config_module_name"
+            "_qt_package_version"
+            "_qt_package_name"
+            "_qt_is_private_module"
+            "_qt_public_module_target_name"
+        )
         set_property(TARGET "${target_private}" APPEND PROPERTY
-                     EXPORT_PROPERTIES _qt_config_module_name)
+                     EXPORT_PROPERTIES "${export_properties}")
     endif()
 
     if(NOT arg_HEADER_MODULE)
@@ -631,6 +669,11 @@ set(QT_VISIBILITY_AVAILABLE TRUE)")
 set(QT_LIBINFIX \"${QT_LIBINFIX}\")")
             endif()
 
+            # Store whether find_package(Qt6Foo) should succeed if Qt6FooTools is missing.
+            if(QT_ALLOW_MISSING_TOOLS_PACKAGES)
+                string(APPEND qtcore_extra_cmake_code "
+set(QT_ALLOW_MISSING_TOOLS_PACKAGES TRUE)")
+            endif()
         endif()
 
         configure_file("${CMAKE_CURRENT_LIST_DIR}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigExtras.cmake.in"
@@ -710,9 +753,8 @@ set(QT_LIBINFIX \"${QT_LIBINFIX}\")")
         qt_install(DIRECTORY "${arg_EXTERNAL_HEADERS_DIR}/"
             DESTINATION "${module_install_interface_include_dir}"
         )
-        unset(public_header_destination)
-    else()
-        set(public_header_destination PUBLIC_HEADER DESTINATION "${module_install_interface_include_dir}")
+        get_target_property(public_header_backup ${target} PUBLIC_HEADER)
+        set_property(TARGET ${target} PROPERTY PUBLIC_HEADER "")
     endif()
 
     qt_install(TARGETS ${exported_targets}
@@ -722,8 +764,12 @@ set(QT_LIBINFIX \"${QT_LIBINFIX}\")")
         ARCHIVE DESTINATION ${INSTALL_LIBDIR}
         FRAMEWORK DESTINATION ${INSTALL_LIBDIR}
         PRIVATE_HEADER DESTINATION "${module_install_interface_private_include_dir}"
-        ${public_header_destination}
-        )
+        PUBLIC_HEADER DESTINATION "${module_install_interface_include_dir}"
+    )
+    if(arg_EXTERNAL_HEADERS_DIR)
+        set_property(TARGET ${target} PROPERTY PUBLIC_HEADER ${public_header_backup})
+        unset(public_header_backup)
+    endif()
 
     if(BUILD_SHARED_LIBS)
         qt_apply_rpaths(TARGET "${target}" INSTALL_PATH "${INSTALL_LIBDIR}" RELATIVE_RPATH)
@@ -927,7 +973,7 @@ the different base name for the module info variables.")
     set("${result}_build_interface_qpa_include_dir"
         "${repo_build_interface_include_dir}/${${result}_qpa_include_dir}")
 
-    # Module install interface direcotries
+    # Module install interface directories
     set(repo_install_interface_include_dir "${INSTALL_INCLUDEDIR}")
     set("${result}_install_interface_include_dir"
         "${repo_install_interface_include_dir}/${${result}_include_name}")

cmake/QtNoLinkTargetHelpers.cmake

@@ -26,7 +26,7 @@ function(qt_create_nolink_target target dependee_target)
         add_library("${nolink_target}" INTERFACE)
         set(prefixed_nolink_target "${target}_nolink")
 
-        # Whe configuring an example with qmake, if QtGui is built with Vulkan support but the
+        # When configuring an example with qmake, if QtGui is built with Vulkan support but the
         # user's machine where Qt is installed doesn't have Vulkan, qmake doesn't fail saying
         # that vulkan is not installed. Instead it silently configures and just doesn't add
         # the include headers.

cmake/QtPkgConfigHelpers.cmake

@@ -19,7 +19,8 @@ endmacro()
 # Create a Qt6*.pc file intended for pkg-config consumption.
 function(qt_internal_generate_pkg_config_file module)
     # TODO: PkgConfig is supported under MSVC with pkgconf (github.com/pkgconf/pkgconf)
-    if((NOT UNIX OR QT_FEATURE_framework) AND NOT MINGW OR CMAKE_VERSION VERSION_LESS "3.20")
+    if((NOT UNIX OR QT_FEATURE_framework)
+        AND NOT MINGW OR CMAKE_VERSION VERSION_LESS "3.20" OR ANDROID)
         return()
     endif()
     if(NOT BUILD_SHARED_LIBS)

cmake/QtPlatformTargetHelpers.cmake

@@ -19,6 +19,13 @@ function(qt_internal_setup_public_platform_target)
         )
     target_compile_definitions(Platform INTERFACE ${QT_PLATFORM_DEFINITIONS})
 
+    set_target_properties(Platform PROPERTIES
+        _qt_package_version "${PROJECT_VERSION}"
+    )
+    set_property(TARGET Platform
+                 APPEND PROPERTY
+                 EXPORT_PROPERTIES "_qt_package_version")
+
     # When building on android we need to link against the logging library
     # in order to satisfy linker dependencies. Both of these libraries are part of
     # the NDK.
@@ -34,8 +41,9 @@ function(qt_internal_setup_public_platform_target)
         endif()
         target_link_options(Platform INTERFACE "${libc_link_option}")
     endif()
-    if (QT_FEATURE_no_extern_direct_access)
-        target_compile_options(Platform INTERFACE "-mno-direct-extern-access")
+    if (QT_FEATURE_no_direct_extern_access)
+        target_compile_options(Platform INTERFACE "$<$<CXX_COMPILER_ID:GNU>:-mno-direct-extern-access>")
+        target_compile_options(Platform INTERFACE "$<$<CXX_COMPILER_ID:Clang>:-fno-direct-access-external-data>")
     endif()
 
     qt_set_msvc_cplusplus_options(Platform INTERFACE)

cmake/QtPluginDependencies.cmake.in

@@ -2,35 +2,7 @@ set(@target@_FOUND FALSE)
 
 # note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;"
 set(__qt_@target@_third_party_deps "@third_party_deps@")
-
-foreach(__qt_@target@_target_dep ${__qt_@target@_third_party_deps})
-    list(GET __qt_@target@_target_dep 0 __qt_@target@_pkg)
-    list(GET __qt_@target@_target_dep 1 __qt_@target@_is_optional)
-    list(GET __qt_@target@_target_dep 2 __qt_@target@_version)
-    list(GET __qt_@target@_target_dep 3 __qt_@target@_components)
-    list(GET __qt_@target@_target_dep 4 __qt_@target@_optional_components)
-    set(__qt_@target@_find_package_args "${__qt_@target@_pkg}")
-    if(__qt_@target@_version)
-        list(APPEND __qt_@target@_find_package_args "${__qt_@target@_version}")
-    endif()
-    if(__qt_@target@_components)
-        string(REPLACE " " ";" __qt_@target@_components "${__qt_@target@_components}")
-        list(APPEND __qt_@target@_find_package_args COMPONENTS ${__qt_@target@_components})
-    endif()
-    if(__qt_@target@_optional_components)
-        string(REPLACE " " ";" __qt_@target@_optional_components "${__qt_@target@_optional_components}")
-        list(APPEND __qt_@target@_find_package_args OPTIONAL_COMPONENTS ${__qt_@target@_optional_components})
-    endif()
-
-    if(__qt_@target@_is_optional)
-        if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
-            list(APPEND __qt_@target@_find_package_args QUIET)
-        endif()
-        find_package(${__qt_@target@_find_package_args})
-    else()
-        find_dependency(${__qt_@target@_find_package_args})
-    endif()
-endforeach()
+_qt_internal_find_third_party_dependencies("@target@" __qt_@target@_third_party_deps)
 
 set(__qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH")
 if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES)
@@ -40,6 +12,7 @@ endif()
 # note: target_deps example: "Qt6Core\;5.12.0;Qt6Gui\;5.12.0"
 set(__qt_@target@_target_deps "@target_deps@")
 set(__qt_@target@_find_dependency_paths "@find_dependency_paths@")
-_qt_internal_find_dependencies(__qt_@target@_target_deps __qt_@target@_find_dependency_paths)
+_qt_internal_find_qt_dependencies("@target@" __qt_@target@_target_deps
+                                  __qt_@target@_find_dependency_paths)
 
 set(@target@_FOUND TRUE)

cmake/QtPluginHelpers.cmake

@@ -117,7 +117,14 @@ function(qt_internal_add_plugin target)
         endif()
     endif()
 
-    qt_set_target_info_properties(${target} ${ARGN} TARGET_VERSION "${arg_VERSION}")
+    qt_set_target_info_properties(${target} ${ARGN})
+
+    set_target_properties(${target} PROPERTIES
+        _qt_package_version "${PROJECT_VERSION}"
+    )
+    set_property(TARGET ${target}
+                 APPEND PROPERTY
+                 EXPORT_PROPERTIES "_qt_package_version")
 
     # Override the OUTPUT_NAME that qt6_add_plugin() set, we need to account for
     # QT_LIBINFIX, which is specific to building Qt.

cmake/QtPlugins.cmake.in

@@ -1,67 +1,6 @@
 include_guard(DIRECTORY)
 @QT_MODULE_PLUGIN_INCLUDES@
 
-# Use a function to hide all the temporary variables we use so they don't leak
-# out into the consuming scope
-function(__qt_internal_add_static_plugins_once)
-    set(_module_target "@INSTALL_CMAKE_NAMESPACE@::@QT_MODULE@")
-    set(_qt_plugins "")
-
-    # Properties can't be set on aliased targets, so make sure to unalias the target. This is needed
-    # when Qt examples are built as part of the Qt build itself.
-    get_target_property(_aliased_target ${_module_target} ALIASED_TARGET)
-    if(_aliased_target)
-        set(_module_target ${_aliased_target})
-    endif()
-
-    # Include all PluginConfig.cmake files and update the _qt_plugins and QT_PLUGINS property of
-    # the module. The underscored version is the one we will use going forward to have compatibility
-    # with INTERFACE libraries. QT_PLUGINS is now deprecated and only kept so that we don't break
-    # existing projects using it (like CMake itself).
-    file(GLOB _qt_plugin_config_files "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@*PluginConfig.cmake")
-    foreach(_config_file ${_qt_plugin_config_files})
-        string(REGEX REPLACE "^.*/@INSTALL_CMAKE_NAMESPACE@(.*Plugin)Config.cmake$" "\\1" _qt_plugin "${_config_file}")
-        include("${_config_file}")
-        if(TARGET "@INSTALL_CMAKE_NAMESPACE@::${_qt_plugin}")
-            list(APPEND _qt_plugins ${_qt_plugin})
-        endif()
-    endforeach()
-    set_property(TARGET ${_module_target} PROPERTY _qt_plugins ${_qt_plugins})
-
-    # TODO: Deprecated. Remove in Qt 7.
-    set_property(TARGET ${_module_target} PROPERTY QT_PLUGINS ${_qt_plugins})
-
-    get_target_property(_have_added_plugins_already ${_module_target} __qt_internal_plugins_added)
-    if(_have_added_plugins_already)
-        return()
-    endif()
-
-    foreach(plugin_target ${_qt_plugins})
-        __qt_internal_plugin_get_plugin_type("${plugin_target}" __has_plugin_type __plugin_type)
-        if(NOT __has_plugin_type)
-            continue()
-        endif()
-
-        __qt_internal_plugin_has_class_name("${plugin_target}" __has_class_name)
-        if(NOT __has_class_name)
-            continue()
-        endif()
-
-        list(APPEND "QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${__plugin_type}" "${plugin_target}")
-
-        __qt_internal_add_static_plugin_linkage("${plugin_target}" "${_module_target}")
-        __qt_internal_add_static_plugin_import_macro(
-            "${plugin_target}" ${_module_target} "@QT_MODULE@")
-    endforeach()
-
-    set("QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${__plugin_type}"
-        "${QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${__plugin_type}}"
-        PARENT_SCOPE
-    )
-
-    set_target_properties(${_module_target} PROPERTIES __qt_internal_plugins_added TRUE)
-endfunction()
-
-if(NOT @BUILD_SHARED_LIBS@ AND NOT QT_NO_CREATE_TARGETS)
-    __qt_internal_add_static_plugins_once()
+if(NOT QT_NO_CREATE_TARGETS AND NOT QT_SKIP_AUTO_PLUGIN_INCLUSION)
+    __qt_internal_include_plugin_packages(@QT_MODULE@)
 endif()

cmake/QtPostProcess.cmake

@@ -2,7 +2,7 @@ include(QtPostProcessHelpers)
 
 qt_internal_create_depends_files()
 qt_generate_build_internals_extra_cmake_code()
-qt_internal_create_plugins_files()
+qt_internal_create_plugins_auto_inclusion_files()
 qt_internal_create_config_file_for_standalone_tests()
 
 # Needs to run after qt_internal_create_depends_files.

cmake/QtPostProcessHelpers.cmake

@@ -80,11 +80,6 @@ function(qt_internal_remove_qt_dependency_duplicates out_deps deps)
         if(dep)
             list(FIND ${out_deps} "${dep}" dep_seen)
 
-            # If the library depends on the Private and non-Private targets,
-            # we only need to 'find_dependency' for one of them.
-            if(dep_seen EQUAL -1 AND "${dep}" MATCHES "(.+)Private\;(.+)")
-                list(FIND ${out_deps} "${CMAKE_MATCH_1};${CMAKE_MATCH_2}" dep_seen)
-            endif()
             if(dep_seen EQUAL -1)
                 list(LENGTH dep len)
                 if(NOT (len EQUAL 2))
@@ -209,9 +204,10 @@ function(qt_internal_create_module_depends_file target)
             # Make the ModuleTool package depend on dep's ModuleTool package.
             list(FIND tool_deps_seen ${dep} dep_seen)
             if(dep_seen EQUAL -1 AND ${dep} IN_LIST QT_KNOWN_MODULES_WITH_TOOLS)
+                qt_internal_get_package_version_of_target("${dep}" dep_package_version)
                 list(APPEND tool_deps_seen ${dep})
                 list(APPEND tool_deps
-                            "${INSTALL_CMAKE_NAMESPACE}${dep}Tools\;${PROJECT_VERSION}")
+                            "${INSTALL_CMAKE_NAMESPACE}${dep}Tools\;${dep_package_version}")
             endif()
         endif()
     endforeach()
@@ -220,14 +216,15 @@ function(qt_internal_create_module_depends_file target)
 
     # Add dependency to the main ModuleTool package to ModuleDependencies file.
     if(${target} IN_LIST QT_KNOWN_MODULES_WITH_TOOLS)
+        qt_internal_get_package_version_of_target("${target}" main_module_tool_package_version)
         list(APPEND main_module_tool_deps
-            "${INSTALL_CMAKE_NAMESPACE}${target}Tools\;${PROJECT_VERSION}")
+            "${INSTALL_CMAKE_NAMESPACE}${target}Tools\;${main_module_tool_package_version}")
     endif()
 
     foreach(dep ${target_deps})
         if(NOT dep MATCHES ".+Private$" AND
            dep MATCHES "${INSTALL_CMAKE_NAMESPACE}(.+)")
-            # target_deps cointains elements that are a pair of target name and version,
+            # target_deps contains elements that are a pair of target name and version,
             # e.g. 'Core\;6.2'
             # After the extracting from the target_deps list, the element becomes a list itself,
             # because it loses escape symbol before the semicolon, so ${CMAKE_MATCH_1} is the list:
@@ -259,6 +256,10 @@ function(qt_internal_create_module_depends_file target)
         qt_path_join(config_build_dir ${QT_CONFIG_BUILD_DIR} ${path_suffix})
         qt_path_join(config_install_dir ${QT_CONFIG_INSTALL_DIR} ${path_suffix})
 
+        # All module packages should look for the Qt6 package version that qtbase was originally
+        # built as.
+        qt_internal_get_package_version_of_target(Platform main_qt_package_version)
+
         # Configure and install ModuleDependencies file.
         configure_file(
             "${QT_CMAKE_DIR}/QtModuleDependencies.cmake.in"
@@ -272,6 +273,9 @@ function(qt_internal_create_module_depends_file target)
             COMPONENT Devel
         )
 
+        message(TRACE "Recorded dependencies for module: ${target}\n"
+            "    Qt dependencies: ${target_deps}\n"
+            "    3rd-party dependencies: ${third_party_deps}")
     endif()
     if(tool_deps)
         # The value of the property will be used by qt_export_tools.
@@ -287,6 +291,13 @@ function(qt_internal_create_plugin_depends_file target)
     unset(optional_public_depends)
     set(target_deps_seen "")
 
+
+    # Extra 3rd party targets who's packages should be considered dependencies.
+    get_target_property(extra_third_party_deps "${target}" _qt_extra_third_party_dep_targets)
+    if(NOT extra_third_party_deps)
+        set(extra_third_party_deps "")
+    endif()
+
     qt_collect_third_party_deps(${target})
 
     qt_internal_remove_qt_dependency_duplicates(target_deps "${target_deps}")
@@ -323,6 +334,10 @@ function(qt_internal_create_plugin_depends_file target)
             DESTINATION "${config_install_dir}"
             COMPONENT Devel
         )
+
+        message(TRACE "Recorded dependencies for plugin: ${target}\n"
+            "    Qt dependencies: ${target_deps}\n"
+            "    3rd-party dependencies: ${third_party_deps}")
     endif()
 endfunction()
 
@@ -349,7 +364,17 @@ function(qt_internal_create_qt6_dependencies_file)
 endif()")
     endif()
 
-    if(third_party_deps)
+    _qt_internal_determine_if_host_info_package_needed(platform_requires_host_info_package)
+
+    if(platform_requires_host_info_package)
+        # TODO: Figure out how to make the initial QT_HOST_PATH var relocatable in relation
+        # to the target CMAKE_INSTALL_DIR, if at all possible to do so in a reliable way.
+        get_filename_component(qt_host_path_absolute "${QT_HOST_PATH}" ABSOLUTE)
+        get_filename_component(qt_host_path_cmake_dir_absolute
+            "${Qt${PROJECT_VERSION_MAJOR}HostInfo_DIR}/.." ABSOLUTE)
+    endif()
+
+    if(third_party_deps OR platform_requires_host_info_package)
         # Setup build and install paths.
         set(path_suffix "${INSTALL_CMAKE_NAMESPACE}")
 
@@ -388,17 +413,14 @@ function(qt_internal_create_depends_files)
     endforeach()
 endfunction()
 
-# This function creates the Qt<Module>Plugins.cmake used to list all
-# the plug-in target files.
-function(qt_internal_create_plugins_files)
-    # The plugins cmake configuration is only needed for static builds. Dynamic builds don't need
-    # the application to link against plugins at build time.
-    if(QT_BUILD_SHARED_LIBS)
-        return()
-    endif()
+# This function creates Qt<Module>Plugins.cmake files used to include all
+# the plugin Config files that belong to that module.
+function(qt_internal_create_plugins_auto_inclusion_files)
+    # For static library builds, the plugin targets need to be available for linking.
+    # For shared library builds, the plugin targets are useful for deployment purposes.
     qt_internal_get_qt_repo_known_modules(repo_known_modules)
 
-    message("Generating Plugins files for ${repo_known_modules}...")
+    set(modules_with_plugins "")
     foreach (QT_MODULE ${repo_known_modules})
         get_target_property(target_type "${QT_MODULE}" TYPE)
         if(target_type STREQUAL "INTERFACE_LIBRARY")
@@ -428,9 +450,9 @@ if (__qt_qml_plugins_config_file_list AND NOT QT_SKIP_AUTO_QML_PLUGIN_INCLUSION)
     foreach(__qt_qml_plugin_config_file \${__qt_qml_plugins_config_file_list})
         include(\${__qt_qml_plugin_config_file})
 
-        # Temporarily unset any failure markers.
+        # Temporarily unset any failure markers and mark the Qml package as found.
         unset(\${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE)
-        unset(\${CMAKE_FIND_PACKAGE_NAME}_FOUND)
+        set(\${CMAKE_FIND_PACKAGE_NAME}_FOUND TRUE)
     endforeach()
 
     # For the second round of inclusions, check and bail out early if there are errors.
@@ -450,6 +472,7 @@ endif()")
 
         get_target_property(qt_plugins "${QT_MODULE}" QT_PLUGINS)
         if(qt_plugins OR QT_MODULE_PLUGIN_INCLUDES)
+            list(APPEND modules_with_plugins "${QT_MODULE}")
             configure_file(
                 "${QT_CMAKE_DIR}/QtPlugins.cmake.in"
                 "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${QT_MODULE}Plugins.cmake"
@@ -462,6 +485,10 @@ endif()")
             )
         endif()
     endforeach()
+    if(modules_with_plugins)
+        message(STATUS "Generated QtModulePlugins.cmake files for the following modules:"
+            " ${modules_with_plugins}")
+    endif()
 endfunction()
 
 function(qt_generate_install_prefixes out_var)
@@ -679,18 +706,16 @@ endif()\n")
 
         string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS "${install_prefix_content}")
 
-        if(NOT BUILD_SHARED_LIBS)
-            # The top-level check needs to happen inside QtBuildInternals, because it's possible
-            # to configure a top-level build with a few repos and then configure another repo
-            # using qt-configure-module in a separate build dir, where QT_SUPERBUILD will not
-            # be set anymore.
-            string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS
-                "
+        # The top-level check needs to happen inside QtBuildInternals, because it's possible
+        # to configure a top-level build with a few repos and then configure another repo
+        # using qt-configure-module in a separate build dir, where QT_SUPERBUILD will not
+        # be set anymore.
+        string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS
+            "
 if(DEFINED QT_REPO_MODULE_VERSION AND NOT DEFINED QT_REPO_DEPENDENCIES AND NOT QT_SUPERBUILD)
     qt_internal_read_repo_dependencies(QT_REPO_DEPENDENCIES \"$\{PROJECT_SOURCE_DIR}\")
 endif()
 ")
-        endif()
 
         if(DEFINED OpenGL_GL_PREFERENCE)
             string(APPEND QT_EXTRA_BUILD_INTERNALS_VARS
@@ -764,9 +789,13 @@ function(qt_internal_create_config_file_for_standalone_tests)
         return()
     endif()
 
-    # Ceate a Config file that calls find_package on the modules that were built as part
+    # Create a Config file that calls find_package on the modules that were built as part
     # of the current repo. This is used for standalone tests.
     qt_internal_get_standalone_tests_config_file_name(tests_config_file_name)
+
+    # Standalone tests Config files should follow the main versioning scheme.
+    qt_internal_get_package_version_of_target(Platform main_qt_package_version)
+
     configure_file(
         "${QT_CMAKE_DIR}/QtStandaloneTestsConfig.cmake.in"
         "${config_build_dir}/${tests_config_file_name}"

cmake/QtPriHelpers.cmake

@@ -532,12 +532,15 @@ QT.${config_module_name}_private.disabled_features = ${disabled_private_features
                     "-DIMPLICIT_LINK_DIRECTORIES=${implicit_link_directories}"
                     -P "${QT_CMAKE_DIR}/QtGenerateLibPri.cmake"
             VERBATIM)
-        add_custom_target(${target}_lib_pri DEPENDS "${private_pri_file_path}")
+        # add_dependencies has no effect when adding interface libraries. So need to add the
+        # '_lib_pri' targets to ALL to make sure that the related rules executed.
+        unset(add_pri_target_to_all)
         if(arg_HEADER_MODULE)
-            add_dependencies(${target}_timestamp ${target}_lib_pri)
-        else()
-            add_dependencies(${target} ${target}_lib_pri)
+            set(add_pri_target_to_all ALL)
         endif()
+        add_custom_target(${target}_lib_pri ${add_pri_target_to_all}
+            DEPENDS "${private_pri_file_path}")
+        add_dependencies(${target} ${target}_lib_pri)
     endif()
 
     qt_install(FILES "${pri_files}" DESTINATION ${INSTALL_MKSPECSDIR}/modules)

cmake/QtPrlHelpers.cmake

@@ -139,6 +139,18 @@ ${prl_step1_content_libs}
              "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_LIBDIR}")
     endif()
 
+    set(qt_plugin_dirs "${QT_BUILD_DIR}/${INSTALL_PLUGINSDIR}")
+    if(QT_WILL_INSTALL)
+        list(APPEND qt_plugin_dirs
+             "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_PLUGINSDIR}")
+    endif()
+
+    set(qt_qml_dirs "${QT_BUILD_DIR}/${INSTALL_QMLDIR}")
+    if(QT_WILL_INSTALL)
+        list(APPEND qt_qml_dirs
+             "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_QMLDIR}")
+    endif()
+
     foreach(config ${configs})
         # Output file for dependency tracking, and which will contain the final content.
         qt_path_join(prl_step2_path
@@ -173,6 +185,8 @@ ${prl_step1_content_libs}
                     "-DLIBRARY_SUFFIXES=${library_suffixes}"
                     "-DLINK_LIBRARY_FLAG=${link_library_flag}"
                     "-DQT_LIB_DIRS=${qt_lib_dirs}"
+                    "-DQT_PLUGIN_DIRS=${qt_plugin_dirs}"
+                    "-DQT_QML_DIRS=${qt_qml_dirs}"
                     "-DIMPLICIT_LINK_DIRECTORIES=${implicit_link_directories}"
                     -P "${QT_CMAKE_DIR}/QtFinishPrlFile.cmake"
             VERBATIM

cmake/QtPublicAppleHelpers.cmake

@@ -0,0 +1,641 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+function(_qt_internal_handle_ios_launch_screen target)
+    # Check if user provided a launch screen path via a variable.
+    set(launch_screen "")
+
+    # Check if the project provided a launch screen path via a variable.
+    # This variable is currently in Technical Preview.
+    if(QT_IOS_LAUNCH_SCREEN)
+        set(launch_screen "${QT_IOS_LAUNCH_SCREEN}")
+    endif()
+
+    # Check if the project provided a launch screen path via a target property, it takes precedence
+    # over the variable.
+    # This property is currently in Technical Preview.
+    get_target_property(launch_screen_from_prop "${target}" QT_IOS_LAUNCH_SCREEN)
+    if(launch_screen_from_prop)
+        set(launch_screen "${launch_screen_from_prop}")
+    endif()
+
+    # If the project hasn't provided a launch screen file path, use a copy of the template
+    # that qmake uses.
+    # It needs to be a copy because configure_file can't handle all the escaped double quotes
+    # present in the qmake template file.
+    set(is_default_launch_screen FALSE)
+    if(NOT launch_screen AND NOT QT_NO_SET_DEFAULT_IOS_LAUNCH_SCREEN)
+        set(is_default_launch_screen TRUE)
+        set(launch_screen
+            "${__qt_internal_cmake_ios_support_files_path}/LaunchScreen.storyboard")
+    endif()
+
+    # Check that the launch screen exists.
+    if(launch_screen)
+        if(NOT IS_ABSOLUTE "${launch_screen}")
+            message(FATAL_ERROR
+                "Provided launch screen value should be an absolute path: '${launch_screen}'")
+        endif()
+
+        if(NOT EXISTS "${launch_screen}")
+            message(FATAL_ERROR
+                "Provided launch screen file does not exist: '${launch_screen}'")
+        endif()
+    endif()
+
+    if(launch_screen AND NOT QT_NO_ADD_IOS_LAUNCH_SCREEN_TO_BUNDLE)
+        get_filename_component(launch_screen_name "${launch_screen}" NAME)
+
+        # Make a copy of the default launch screen template for this target and replace the
+        # label inside the template with the target name.
+        if(is_default_launch_screen)
+            # Configure our default template and place it in the build dir.
+            set(launch_screen_in_path "${launch_screen}")
+
+            string(MAKE_C_IDENTIFIER "${target}" target_identifier)
+            set(launch_screen_out_dir
+                "${CMAKE_CURRENT_BINARY_DIR}/.qt/launch_screen_storyboards/${target_identifier}")
+
+            set(launch_screen_out_path
+                "${launch_screen_out_dir}/${launch_screen_name}")
+
+            file(MAKE_DIRECTORY "${launch_screen_out_dir}")
+
+            # Replaces the value in the default template.
+            set(QT_IOS_LAUNCH_SCREEN_TEXT "${target}")
+            configure_file(
+                "${launch_screen_in_path}"
+                "${launch_screen_out_path}"
+                @ONLY
+            )
+
+            set(final_launch_screen_path "${launch_screen_out_path}")
+        else()
+            set(final_launch_screen_path "${launch_screen}")
+        endif()
+
+        # Add the launch screen storyboard file as a source file, otherwise CMake doesn't consider
+        # it as a resource file and MACOSX_PACKAGE_LOCATION processing will be skipped.
+        target_sources("${target}" PRIVATE "${final_launch_screen_path}")
+
+        # Ensure Xcode compiles the storyboard file and installs the compiled storyboard .nib files
+        # into the app bundle.
+        # We use target_sources and the MACOSX_PACKAGE_LOCATION source file property for that
+        # instead of the RESOURCE target property, becaues the latter could potentially end up
+        # needlessly installing the source storyboard file.
+        #
+        # We can't rely on policy CMP0118 since user project controls it.
+        set(scope_args)
+        if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
+            set(scope_args TARGET_DIRECTORY ${target})
+        endif()
+        set_source_files_properties("${final_launch_screen_path}" ${scope_args}
+            PROPERTIES MACOSX_PACKAGE_LOCATION Resources)
+
+        # Save the launch screen name, so its value is added as an UILaunchStoryboardName entry
+        # in the Qt generated Info.plist file.
+        # Xcode expects an Info.plist storyboard entry without an extension.
+        get_filename_component(launch_screen_base_name "${launch_screen}" NAME_WE)
+        set_target_properties("${target}" PROPERTIES
+                              _qt_ios_launch_screen_name "${launch_screen_name}"
+                              _qt_ios_launch_screen_base_name "${launch_screen_base_name}"
+                              _qt_ios_launch_screen_path "${final_launch_screen_path}")
+    endif()
+endfunction()
+
+function(_qt_internal_find_ios_development_team_id out_var)
+    get_property(team_id GLOBAL PROPERTY _qt_internal_ios_development_team_id)
+    get_property(team_id_computed GLOBAL PROPERTY _qt_internal_ios_development_team_id_computed)
+    if(team_id_computed)
+        # Just in case if the value is non-empty but still booly FALSE.
+        if(NOT team_id)
+            set(team_id "")
+        endif()
+        set("${out_var}" "${team_id}" PARENT_SCOPE)
+        return()
+    endif()
+
+    set_property(GLOBAL PROPERTY _qt_internal_ios_development_team_id_computed "TRUE")
+
+    set(home_dir "$ENV{HOME}")
+    set(xcode_preferences_path "${home_dir}/Library/Preferences/com.apple.dt.Xcode.plist")
+
+    # Extract the first account name (email) from the user's Xcode preferences
+    message(DEBUG "Trying to extract an Xcode development team id from '${xcode_preferences_path}'")
+    execute_process(COMMAND "/usr/libexec/PlistBuddy"
+                            -x -c "print IDEProvisioningTeams" "${xcode_preferences_path}"
+                    OUTPUT_VARIABLE teams_xml
+                    ERROR_VARIABLE plist_error)
+
+    # Parsing state.
+    set(is_free "")
+    set(current_team_id "")
+    set(parsing_is_free FALSE)
+    set(parsing_team_id FALSE)
+    set(first_team_id "")
+
+    # Parse the xml output and return the first encountered non-free team id. If no non-free team id
+    # is found, return the first encountered free team id.
+    # If no team is found, return an empty string.
+    #
+    # Example input:
+    #<plist version="1.0">
+    #<dict>
+    #    <key>marty@planet.local</key>
+    #    <array>
+    #        <dict>
+    #            <key>isFreeProvisioningTeam</key>
+    #            <false/>
+    #            <key>teamID</key>
+    #            <string>AAA</string>
+    #            ...
+    #        </dict>
+    #        <dict>
+    #            <key>isFreeProvisioningTeam</key>
+    #            <true/>
+    #            <key>teamID</key>
+    #            <string>BBB</string>
+    #            ...
+    #        </dict>
+    #    </array>
+    #</dict>
+    #</plist>
+    if(teams_xml AND NOT plist_error)
+        string(REPLACE "\n" ";" teams_xml_lines "${teams_xml}")
+
+        foreach(xml_line ${teams_xml_lines})
+            string(STRIP "${xml_line}" xml_line)
+            if(xml_line STREQUAL "<dict>")
+                # Clean any previously found values when a new team dict is matched.
+                set(is_free "")
+                set(current_team_id "")
+
+            elseif(xml_line STREQUAL "<key>isFreeProvisioningTeam</key>")
+                set(parsing_is_free TRUE)
+
+            elseif(parsing_is_free)
+                set(parsing_is_free FALSE)
+
+                if(xml_line MATCHES "true")
+                    set(is_free TRUE)
+                else()
+                    set(is_free FALSE)
+                endif()
+
+            elseif(xml_line STREQUAL "<key>teamID</key>")
+                set(parsing_team_id TRUE)
+
+            elseif(parsing_team_id)
+                set(parsing_team_id FALSE)
+                if(xml_line MATCHES "<string>([^<]+)</string>")
+                    set(current_team_id "${CMAKE_MATCH_1}")
+                else()
+                    continue()
+                endif()
+
+                string(STRIP "${current_team_id}" current_team_id)
+
+                # If this is the first team id we found so far, remember that, regardless if's free
+                # or not.
+                if(NOT first_team_id AND current_team_id)
+                    set(first_team_id "${current_team_id}")
+                endif()
+
+                # Break early if we found a non-free team id and use it, because we prefer
+                # a non-free team for signing, just like qmake.
+                if(NOT is_free AND current_team_id)
+                    set(first_team_id "${current_team_id}")
+                    break()
+                endif()
+            endif()
+        endforeach()
+    endif()
+
+    if(NOT first_team_id)
+        message(DEBUG "Failed to extract an Xcode development team id.")
+        set("${out_var}" "" PARENT_SCOPE)
+    else()
+        message(DEBUG "Successfully extracted the first encountered Xcode development team id.")
+        set_property(GLOBAL PROPERTY _qt_internal_ios_development_team_id "${first_team_id}")
+        set("${out_var}" "${first_team_id}" PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(_qt_internal_get_ios_bundle_identifier_prefix out_var)
+    get_property(prefix GLOBAL PROPERTY _qt_internal_ios_bundle_identifier_prefix)
+    get_property(prefix_computed GLOBAL PROPERTY
+                 _qt_internal_ios_bundle_identifier_prefix_computed)
+    if(prefix_computed)
+        # Just in case if the value is non-empty but still booly FALSE.
+        if(NOT prefix)
+            set(prefix "")
+        endif()
+        set("${out_var}" "${prefix}" PARENT_SCOPE)
+        return()
+    endif()
+
+    set_property(GLOBAL PROPERTY _qt_internal_ios_bundle_identifier_prefix_computed "TRUE")
+
+    set(home_dir "$ENV{HOME}")
+    set(xcode_preferences_path "${home_dir}/Library/Preferences/com.apple.dt.Xcode.plist")
+
+    message(DEBUG "Trying to extract the default bundle identifier prefix from Xcode preferences.")
+    execute_process(COMMAND "/usr/libexec/PlistBuddy"
+                            -c "print IDETemplateOptions:bundleIdentifierPrefix"
+                            "${xcode_preferences_path}"
+                    OUTPUT_VARIABLE prefix
+                    ERROR_VARIABLE prefix_error)
+    if(prefix AND NOT prefix_error)
+        message(DEBUG "Successfully extracted the default bundle identifier prefix.")
+        string(STRIP "${prefix}" prefix)
+    else()
+        message(DEBUG "Failed to extract the default bundle identifier prefix.")
+    endif()
+
+    if(prefix AND NOT prefix_error)
+        set_property(GLOBAL PROPERTY _qt_internal_ios_bundle_identifier_prefix "${prefix}")
+        set("${out_var}" "${prefix}" PARENT_SCOPE)
+    else()
+        set("${out_var}" "" PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(_qt_internal_escape_rfc_1034_identifier value out_var)
+    # According to https://datatracker.ietf.org/doc/html/rfc1034#section-3.5
+    # we can only use letters, digits, dot (.) and hyphens (-).
+    # Underscores are not allowed.
+    string(REGEX REPLACE "[^A-Za-z0-9.]" "-" value "${value}")
+
+    set("${out_var}" "${value}" PARENT_SCOPE)
+endfunction()
+
+function(_qt_internal_get_default_ios_bundle_identifier out_var)
+    _qt_internal_get_ios_bundle_identifier_prefix(prefix)
+    if(NOT prefix)
+        set(prefix "com.yourcompany")
+
+        # For a better out-of-the-box experience, try to create a unique prefix by appending
+        # the sha1 of the team id, if one is found.
+        _qt_internal_find_ios_development_team_id(team_id)
+        if(team_id)
+            string(SHA1 hash "${team_id}")
+            string(SUBSTRING "${hash}" 0 8 infix)
+            string(APPEND prefix ".${infix}")
+        else()
+            message(WARNING
+                "No organization bundle identifier prefix could be retrieved from Xcode "
+                "preferences. This can lead to code signing issues due to a non-unique bundle "
+                "identifier. Please set up an organization prefix by creating a new project within "
+                "Xcode, or consider providing a custom bundle identifier by specifying the "
+                "XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER property."
+            )
+        endif()
+    endif()
+
+    # Escape the prefix according to rfc 1034, it's important for code-signing. If an invalid
+    # identifier is used, calling xcodebuild on the command line says that no provisioning profile
+    # could be found, with no additional error message. If one opens the generated project with
+    # Xcode and clicks on 'Try again' to get a new profile, it shows a semi-useful error message
+    # that the identifier is invalid.
+    _qt_internal_escape_rfc_1034_identifier("${prefix}" prefix)
+
+    set(identifier "${prefix}.\${PRODUCT_NAME:rfc1034identifier}")
+    set("${out_var}" "${identifier}" PARENT_SCOPE)
+endfunction()
+
+function(_qt_internal_set_placeholder_apple_bundle_version target)
+    # If user hasn't provided neither a bundle version nor a bundle short version string for the
+    # app, set a placeholder value for both which will add them to the generated Info.plist file.
+    # This is required so that the app launches in the simulator (but apparently not for running
+    # on-device).
+    get_target_property(bundle_version "${target}" MACOSX_BUNDLE_BUNDLE_VERSION)
+    get_target_property(bundle_short_version "${target}" MACOSX_BUNDLE_SHORT_VERSION_STRING)
+
+    if(NOT MACOSX_BUNDLE_BUNDLE_VERSION AND
+       NOT MACOSX_BUNDLE_SHORT_VERSION_STRING AND
+       NOT bundle_version AND
+       NOT bundle_short_version AND
+       NOT QT_NO_SET_XCODE_BUNDLE_VERSION
+    )
+        get_target_property(version "${target}" VERSION)
+        if(NOT version)
+            set(version "${PROJECT_VERSION}")
+            if(NOT version)
+                set(version "1.0.0")
+            endif()
+        endif()
+
+        # Use x.y for short version and x.y.z for full version
+        # Any versions longer than this will fail App Store
+        # submission.
+        string(REPLACE "." ";" version_list ${version})
+        list(LENGTH version_list version_list_length)
+        list(GET version_list 0 version_major)
+        set(bundle_short_version "${version_major}")
+        if(version_list_length GREATER 1)
+            list(GET version_list 1 version_minor)
+            string(APPEND bundle_short_version ".${version_minor}")
+        endif()
+        set(bundle_version "${bundle_short_version}")
+        if(version_list_length GREATER 2)
+            list(GET version_list 2 version_patch)
+            string(APPEND bundle_version ".${version_patch}")
+        endif()
+
+
+        if(NOT CMAKE_XCODE_ATTRIBUTE_MARKETING_VERSION
+            AND NOT QT_NO_SET_XCODE_ATTRIBUTE_MARKETING_VERSION
+            AND NOT CMAKE_XCODE_ATTRIBUTE_CURRENT_PROJECT_VERSION
+            AND NOT QT_NO_SET_XCODE_ATTRIBUTE_CURRENT_PROJECT_VERSION
+            AND CMAKE_GENERATOR STREQUAL "Xcode")
+            get_target_property(marketing_version "${target}"
+                XCODE_ATTRIBUTE_MARKETING_VERSION)
+            get_target_property(current_project_version "${target}"
+                XCODE_ATTRIBUTE_CURRENT_PROJECT_VERSION)
+            if(NOT marketing_version AND NOT current_project_version)
+                set_target_properties("${target}"
+                    PROPERTIES
+                        XCODE_ATTRIBUTE_CURRENT_PROJECT_VERSION "${bundle_version}"
+                        XCODE_ATTRIBUTE_MARKETING_VERSION "${bundle_short_version}"
+                )
+                set(bundle_version "$(CURRENT_PROJECT_VERSION)")
+                set(bundle_short_version "$(MARKETING_VERSION)")
+            endif()
+        endif()
+
+        set_target_properties("${target}"
+                               PROPERTIES
+                               MACOSX_BUNDLE_BUNDLE_VERSION "${bundle_version}"
+                               MACOSX_BUNDLE_SHORT_VERSION_STRING "${bundle_short_version}"
+                               )
+    endif()
+endfunction()
+
+function(_qt_internal_set_xcode_development_team_id target)
+    # If user hasn't provided a development team id, try to find the first one specified
+    # in the Xcode preferences.
+    if(NOT CMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM AND NOT QT_NO_SET_XCODE_DEVELOPMENT_TEAM_ID)
+        get_target_property(existing_team_id "${target}" XCODE_ATTRIBUTE_DEVELOPMENT_TEAM)
+        if(NOT existing_team_id)
+            _qt_internal_find_ios_development_team_id(team_id)
+            set_target_properties("${target}"
+                                  PROPERTIES XCODE_ATTRIBUTE_DEVELOPMENT_TEAM "${team_id}")
+        endif()
+    endif()
+endfunction()
+
+function(_qt_internal_set_xcode_bundle_identifier target)
+    # Skip all logic if requested.
+    if(QT_NO_SET_XCODE_BUNDLE_IDENTIFIER)
+        return()
+    endif()
+
+    # There are two fields to consider: the CFBundleIdentifier key (CFBI) to be written to
+    # Info.plist
+    # and the PRODUCT_BUNDLE_IDENTIFIER (PBI) property to set in the Xcode project.
+    # The following logic enables the best out-of-the-box experience combined with maximum
+    # customization.
+    # 1) If values for both fields are not provided, assign ${PRODUCT_BUNDLE_IDENTIFIER} to CFBI
+    #    (which is expanded by xcodebuild at build time and will use the value of PBI) and
+    #    auto-compute a default PBI from Xcode's ${PRODUCT_NAME}.
+    # 2) If CFBI is set and PBI isn't, use given CFBI and keep PBI empty.
+    # 3) If PBI is set and CFBI isn't, assign ${PRODUCT_BUNDLE_IDENTIFIER} to CFBI and use
+    #    the given PBI.
+    # 4) If both are set, use both given values.
+    # TLDR:
+    # cfbi    pbi   -> result_cfbi result_pbi
+    # unset   unset    computed    computed
+    # set     unset    given_val   unset
+    # unset   set      computed    given_val
+    # set     set      given_val   given_val
+
+    get_target_property(existing_cfbi "${target}" MACOSX_BUNDLE_GUI_IDENTIFIER)
+    if(NOT MACOSX_BUNDLE_GUI_IDENTIFIER AND NOT existing_cfbi)
+        set(is_cfbi_given FALSE)
+    else()
+        set(is_cfbi_given TRUE)
+    endif()
+
+    if(NOT is_cfbi_given)
+        set_target_properties("${target}"
+                              PROPERTIES
+                              MACOSX_BUNDLE_GUI_IDENTIFIER "\${PRODUCT_BUNDLE_IDENTIFIER}")
+    endif()
+
+    get_target_property(existing_pbi "${target}" XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER)
+    if(NOT CMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER AND NOT existing_pbi)
+        set(is_pbi_given FALSE)
+    else()
+        set(is_pbi_given TRUE)
+    endif()
+
+    if(NOT is_pbi_given AND NOT is_cfbi_given)
+        _qt_internal_get_default_ios_bundle_identifier(bundle_id)
+        set_target_properties("${target}"
+                              PROPERTIES
+                              XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER "${bundle_id}")
+    endif()
+endfunction()
+
+function(_qt_internal_set_xcode_targeted_device_family target)
+    if(NOT CMAKE_XCODE_ATTRIBUTE_TARGETED_DEVICE_FAMILY
+            AND NOT QT_NO_SET_XCODE_TARGETED_DEVICE_FAMILY)
+        get_target_property(existing_device_family
+            "${target}" XCODE_ATTRIBUTE_TARGETED_DEVICE_FAMILY)
+        if(NOT existing_device_family)
+            set(device_family_iphone_and_ipad "1,2")
+            set_target_properties("${target}"
+                                  PROPERTIES
+                                  XCODE_ATTRIBUTE_TARGETED_DEVICE_FAMILY
+                                  "${device_family_iphone_and_ipad}")
+        endif()
+    endif()
+endfunction()
+
+function(_qt_internal_set_xcode_code_sign_style target)
+    if(NOT CMAKE_XCODE_ATTRIBUTE_CODE_SIGN_STYLE
+            AND NOT QT_NO_SET_XCODE_CODE_SIGN_STYLE)
+        get_target_property(existing_code_style
+            "${target}" XCODE_ATTRIBUTE_CODE_SIGN_STYLE)
+        if(NOT existing_code_style)
+            set(existing_code_style "Automatic")
+            set_target_properties("${target}"
+                                  PROPERTIES
+                                  XCODE_ATTRIBUTE_CODE_SIGN_STYLE
+                                  "${existing_code_style}")
+        endif()
+    endif()
+endfunction()
+
+# Workaround for https://gitlab.kitware.com/cmake/cmake/-/issues/15183
+function(_qt_internal_set_xcode_install_path target)
+    if(NOT CMAKE_XCODE_ATTRIBUTE_INSTALL_PATH
+            AND NOT QT_NO_SET_XCODE_INSTALL_PATH)
+        get_target_property(existing_install_path
+            "${target}" XCODE_ATTRIBUTE_INSTALL_PATH)
+        if(NOT existing_install_path)
+            set_target_properties("${target}"
+                                  PROPERTIES
+                                  XCODE_ATTRIBUTE_INSTALL_PATH
+                                  "$(inherited)")
+        endif()
+    endif()
+endfunction()
+
+function(_qt_internal_set_xcode_bundle_display_name target)
+    # We want the value of CFBundleDisplayName to be ${PRODUCT_NAME}, but we can't put that
+    # into the Info.plist.in template file directly, because the implicit configure_file(Info.plist)
+    # done by CMake is not using the @ONLY option, so CMake would treat the assignment as
+    # variable expansion. Escaping using backslashes does not help.
+    # Work around it by assigning the dollar char to a separate cache var, and expand it, so that
+    # the final value in the file will be ${PRODUCT_NAME}, to be evaluated at build time by Xcode.
+    set(QT_INTERNAL_DOLLAR_VAR "$" CACHE STRING "")
+endfunction()
+
+# Adds ${PRODUCT_NAME} to the Info.plist file, which is then evaluated by Xcode itself.
+function(_qt_internal_set_xcode_bundle_name target)
+    if(QT_NO_SET_XCODE_BUNDLE_NAME)
+        return()
+    endif()
+
+    get_target_property(existing_bundle_name "${target}" MACOSX_BUNDLE_BUNDLE_NAME)
+    if(NOT MACOSX_BUNDLE_BUNDLE_NAME AND NOT existing_bundle_name)
+        if(CMAKE_GENERATOR STREQUAL Xcode)
+            set_target_properties("${target}"
+                                  PROPERTIES
+                                  MACOSX_BUNDLE_BUNDLE_NAME "\${PRODUCT_NAME}")
+        else()
+            set_target_properties("${target}"
+                                  PROPERTIES
+                                  MACOSX_BUNDLE_BUNDLE_NAME "${target}")
+        endif()
+    endif()
+endfunction()
+
+function(_qt_internal_set_xcode_bitcode_enablement target)
+    if(CMAKE_XCODE_ATTRIBUTE_ENABLE_BITCODE
+        OR QT_NO_SET_XCODE_ENABLE_BITCODE)
+        return()
+    endif()
+
+    get_target_property(existing_bitcode_enablement
+        "${target}" XCODE_ATTRIBUTE_ENABLE_BITCODE)
+    if(NOT existing_bitcode_enablement MATCHES "-NOTFOUND")
+        return()
+    endif()
+
+    # Disable bitcode to match Xcode 14's new default
+    set_target_properties("${target}"
+        PROPERTIES
+        XCODE_ATTRIBUTE_ENABLE_BITCODE
+        "NO")
+endfunction()
+
+function(_qt_internal_generate_ios_info_plist target)
+    # If the project already specifies a custom file, we don't override it.
+    get_target_property(existing_plist "${target}" MACOSX_BUNDLE_INFO_PLIST)
+    if(existing_plist)
+        return()
+    endif()
+
+    set(info_plist_in "${__qt_internal_cmake_ios_support_files_path}/Info.plist.app.in")
+
+    string(MAKE_C_IDENTIFIER "${target}" target_identifier)
+    set(info_plist_out_dir
+        "${CMAKE_CURRENT_BINARY_DIR}/.qt/info_plist/${target_identifier}")
+    set(info_plist_out "${info_plist_out_dir}/Info.plist")
+
+    # Check if we need to specify a custom launch screen storyboard entry.
+    get_target_property(launch_screen_base_name "${target}" _qt_ios_launch_screen_base_name)
+    if(launch_screen_base_name)
+        set(qt_ios_launch_screen_plist_entry "${launch_screen_base_name}")
+    endif()
+
+    # Call configure_file to substitute Qt-specific @FOO@ values, not ${FOO} values.
+    #
+    # The output file will be another template file to be fed to CMake via the
+    # MACOSX_BUNDLE_INFO_PLIST property. CMake will then call configure_file on it to provide
+    # content for regular entries like CFBundleName, etc.
+    #
+    # We require this extra configure_file call so we can create unique Info.plist files for each
+    # target in a project, while also providing a way to add Qt specific entries that CMake
+    # does not support out of the box (e.g. a launch screen name).
+    configure_file(
+        "${info_plist_in}"
+        "${info_plist_out}"
+        @ONLY
+    )
+
+    set_target_properties("${target}" PROPERTIES MACOSX_BUNDLE_INFO_PLIST "${info_plist_out}")
+endfunction()
+
+function(_qt_internal_set_ios_simulator_arch target)
+    if(CMAKE_XCODE_ATTRIBUTE_ARCHS
+        OR QT_NO_SET_XCODE_ARCHS)
+        return()
+    endif()
+
+    get_target_property(existing_archs
+        "${target}" XCODE_ATTRIBUTE_ARCHS)
+    if(NOT existing_archs MATCHES "-NOTFOUND")
+        return()
+    endif()
+
+    if(NOT x86_64 IN_LIST QT_OSX_ARCHITECTURES)
+        return()
+    endif()
+
+    if(CMAKE_OSX_ARCHITECTURES AND NOT x86_64 IN_LIST CMAKE_OSX_ARCHITECTURES)
+        return()
+    endif()
+
+    set_target_properties("${target}"
+        PROPERTIES
+        "XCODE_ATTRIBUTE_ARCHS[sdk=iphonesimulator*]"
+        "x86_64")
+endfunction()
+
+function(_qt_internal_finalize_apple_app target)
+    # Shared between macOS and iOS apps
+
+    # Only set the various properties if targeting the Xcode generator, otherwise the various
+    # Xcode tokens are embedded as-is instead of being dynamically evaluated.
+    # This affects things like the version number or application name as reported by Qt API.
+    if(CMAKE_GENERATOR STREQUAL "Xcode")
+        _qt_internal_set_xcode_development_team_id("${target}")
+        _qt_internal_set_xcode_bundle_identifier("${target}")
+        _qt_internal_set_xcode_code_sign_style("${target}")
+        _qt_internal_set_xcode_bundle_display_name("${target}")
+        _qt_internal_set_xcode_install_path("${target}")
+    endif()
+    _qt_internal_set_xcode_bundle_name("${target}")
+    _qt_internal_set_placeholder_apple_bundle_version("${target}")
+endfunction()
+
+function(_qt_internal_finalize_ios_app target)
+    _qt_internal_finalize_apple_app("${target}")
+
+    _qt_internal_set_xcode_targeted_device_family("${target}")
+    _qt_internal_set_xcode_bitcode_enablement("${target}")
+    _qt_internal_handle_ios_launch_screen("${target}")
+    _qt_internal_generate_ios_info_plist("${target}")
+    _qt_internal_set_ios_simulator_arch("${target}")
+endfunction()
+
+function(_qt_internal_finalize_macos_app target)
+    get_target_property(is_bundle ${target} MACOSX_BUNDLE)
+    if(NOT is_bundle)
+        return()
+    endif()
+
+    _qt_internal_finalize_apple_app("${target}")
+
+    # Make sure the install rpath has at least the minimum needed if the app
+    # has any non-static frameworks. We can't rigorously know if the app will
+    # have any, even with a static Qt, so always add this. If there are no
+    # frameworks, it won't do any harm.
+    get_property(install_rpath TARGET ${target} PROPERTY INSTALL_RPATH)
+    list(APPEND install_rpath "@executable_path/../Frameworks")
+    list(REMOVE_DUPLICATES install_rpath)
+    set_property(TARGET ${target} PROPERTY INSTALL_RPATH "${install_rpath}")
+endfunction()

cmake/QtPublicCMakeHelpers.cmake

@@ -32,3 +32,59 @@ function(_qt_internal_check_depfile_support out_var)
     endif()
     set(${out_var} "${${out_var}}" PARENT_SCOPE)
 endfunction()
+
+# Collect additional package prefix paths to look for Qt packages, both from command line and the
+# env variable ${prefixes_var}. The result is stored in ${out_var} and is a list of paths ending
+# with "/lib/cmake".
+function(__qt_internal_collect_additional_prefix_paths out_var prefixes_var)
+    if(DEFINED "${out_var}")
+        return()
+    endif()
+
+    set(additional_packages_prefix_paths "")
+
+    set(additional_packages_prefixes "")
+    if(${prefixes_var})
+        list(APPEND additional_packages_prefixes ${${prefixes_var}})
+    endif()
+    if(DEFINED ENV{${prefixes_var}}
+        AND NOT "$ENV{${prefixes_var}}" STREQUAL "")
+        set(prefixes_from_env "$ENV{${prefixes_var}}")
+        if(NOT CMAKE_HOST_WIN32)
+            string(REPLACE ":" ";" prefixes_from_env "${prefixes_from_env}")
+        endif()
+        list(APPEND additional_packages_prefixes ${prefixes_from_env})
+    endif()
+
+    foreach(additional_path IN LISTS additional_packages_prefixes)
+        file(TO_CMAKE_PATH "${additional_path}" additional_path)
+
+        # The prefix paths need to end with lib/cmake to ensure the packages are found when
+        # cross compiling. Search for REROOT_PATH_ISSUE_MARKER in the qt.toolchain.cmake file for
+        # details.
+        # We must pass the values via the PATHS options because the main find_package call uses
+        # NO_DEFAULT_PATH, and thus CMAKE_PREFIX_PATH values are discarded.
+        # CMAKE_FIND_ROOT_PATH values are not discarded and togegher with the PATHS option, it
+        # ensures packages from additional prefixes are found.
+        if(NOT additional_path MATCHES "/lib/cmake$")
+            string(APPEND additional_path "/lib/cmake")
+        endif()
+        list(APPEND additional_packages_prefix_paths "${additional_path}")
+    endforeach()
+
+    set("${out_var}" "${additional_packages_prefix_paths}" PARENT_SCOPE)
+endfunction()
+
+# Take a list of prefix paths ending with "/lib/cmake", and return a list of absolute paths with
+# "/lib/cmake" removed.
+function(__qt_internal_prefix_paths_to_roots out_var prefix_paths)
+    set(result "")
+    foreach(path IN LISTS prefix_paths)
+        if(path MATCHES "/lib/cmake$")
+            string(APPEND path "/../..")
+        endif()
+        get_filename_component(path "${path}" ABSOLUTE)
+        list(APPEND result "${path}")
+    endforeach()
+    set("${out_var}" "${result}" PARENT_SCOPE)
+endfunction()

cmake/QtPublicDependencyHelpers.cmake

@@ -1,19 +1,113 @@
+# Note that target_dep_list does not accept a list of values, but a var name that contains the
+# list of dependencies. See foreach block for reference.
+macro(_qt_internal_find_third_party_dependencies target target_dep_list)
+    foreach(__qt_${target}_target_dep IN LISTS ${target_dep_list})
+        list(GET __qt_${target}_target_dep 0 __qt_${target}_pkg)
+        list(GET __qt_${target}_target_dep 1 __qt_${target}_is_optional)
+        list(GET __qt_${target}_target_dep 2 __qt_${target}_version)
+        list(GET __qt_${target}_target_dep 3 __qt_${target}_components)
+        list(GET __qt_${target}_target_dep 4 __qt_${target}_optional_components)
+        set(__qt_${target}_find_package_args "${__qt_${target}_pkg}")
+        if(__qt_${target}_version)
+            list(APPEND __qt_${target}_find_package_args "${__qt_${target}_version}")
+        endif()
+        if(__qt_${target}_components)
+            string(REPLACE " " ";" __qt_${target}_components "${__qt_${target}_components}")
+            list(APPEND __qt_${target}_find_package_args COMPONENTS ${__qt_${target}_components})
+        endif()
+        if(__qt_${target}_optional_components)
+            string(REPLACE " " ";"
+                __qt_${target}_optional_components "${__qt_${target}_optional_components}")
+            list(APPEND __qt_${target}_find_package_args
+                 OPTIONAL_COMPONENTS ${__qt_${target}_optional_components})
+        endif()
+
+        _qt_internal_save_find_package_context_for_debugging(${target})
+
+        if(__qt_${target}_is_optional)
+            if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+                list(APPEND __qt_${target}_find_package_args QUIET)
+            endif()
+            find_package(${__qt_${target}_find_package_args})
+        else()
+            find_dependency(${__qt_${target}_find_package_args})
+        endif()
+    endforeach()
+endmacro()
+
+# Note that target_dep_list does not accept a list of values, but a var name that contains the
+# list of dependencies. See foreach block for reference.
+macro(_qt_internal_find_tool_dependencies target target_dep_list)
+    if(NOT "${${target_dep_list}}" STREQUAL "" AND NOT "${QT_HOST_PATH}" STREQUAL "")
+         # Make sure that the tools find the host tools first
+         set(BACKUP_${target}_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH})
+         set(BACKUP_${target}_CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH})
+         list(PREPEND CMAKE_PREFIX_PATH "${QT_HOST_PATH_CMAKE_DIR}"
+             "${_qt_additional_host_packages_prefix_paths}")
+         list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_HOST_PATH}"
+             "${_qt_additional_host_packages_root_paths}")
+    endif()
+
+    foreach(__qt_${target}_target_dep IN LISTS ${target_dep_list})
+        list(GET __qt_${target}_target_dep 0 __qt_${target}_pkg)
+        list(GET __qt_${target}_target_dep 1 __qt_${target}_version)
+
+        unset(__qt_${target}_find_package_args)
+        if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+            list(APPEND __qt_${target}_find_package_args QUIET)
+        endif()
+
+        _qt_internal_save_find_package_context_for_debugging(${target})
+
+        find_package(${__qt_${target}_pkg}
+            ${__qt_${target}_version}
+            ${__qt_${target}_find_package_args}
+            PATHS
+                "${CMAKE_CURRENT_LIST_DIR}/.."
+                "${_qt_cmake_dir}"
+                ${_qt_additional_packages_prefix_paths}
+        )
+        if (NOT ${__qt_${target}_pkg}_FOUND AND NOT QT_ALLOW_MISSING_TOOLS_PACKAGES)
+            set(${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE)
+            set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE
+"${CMAKE_FIND_PACKAGE_NAME} could not be found because dependency \
+${__qt_${target}_pkg} could not be found.")
+            if(NOT "${QT_HOST_PATH}" STREQUAL "")
+                 set(CMAKE_PREFIX_PATH ${BACKUP_${target}_CMAKE_PREFIX_PATH})
+                 set(CMAKE_FIND_ROOT_PATH ${BACKUP_${target}_CMAKE_FIND_ROOT_PATH})
+            endif()
+            return()
+        endif()
+    endforeach()
+    if(NOT "${${target_dep_list}}" STREQUAL "" AND NOT "${QT_HOST_PATH}" STREQUAL "")
+         set(CMAKE_PREFIX_PATH ${BACKUP_${target}_CMAKE_PREFIX_PATH})
+         set(CMAKE_FIND_ROOT_PATH ${BACKUP_${target}_CMAKE_FIND_ROOT_PATH})
+    endif()
+endmacro()
+
 # Please note the target_dep_list accepts not the actual list values but the list names that
 # contain preformed dependencies. See foreach block for reference.
 # The same applies for find_dependency_path_list.
-macro(_qt_internal_find_dependencies target_dep_list find_dependency_path_list)
-    foreach(__qt_target_dep IN LISTS ${target_dep_list})
-        list(GET __qt_target_dep 0 __qt_pkg)
-        list(GET __qt_target_dep 1 __qt_version)
+macro(_qt_internal_find_qt_dependencies target target_dep_list find_dependency_path_list)
+    foreach(__qt_${target}_target_dep IN LISTS ${target_dep_list})
+        list(GET __qt_${target}_target_dep 0 __qt_${target}_pkg)
+        list(GET __qt_${target}_target_dep 1 __qt_${target}_version)
 
-        if (NOT ${__qt_pkg}_FOUND)
-            set(__qt_pkg_names ${__qt_pkg})
-            if(__qt_pkg MATCHES "(.*)Private$")
-                set(__qt_pkg_names "${CMAKE_MATCH_1};${__qt_pkg}")
+        if (NOT ${__qt_${target}_pkg}_FOUND)
+
+            # TODO: Remove Private handling once sufficient time has passed, aka all developers
+            # updated their builds not to contain stale FooDependencies.cmake files without the
+            # _qt_package_name property.
+            set(__qt_${target}_pkg_names ${__qt_${target}_pkg})
+            if(__qt_${target}_pkg MATCHES "(.*)Private$")
+                set(__qt_${target}_pkg_names "${CMAKE_MATCH_1};${__qt_${target}_pkg}")
             endif()
-            find_dependency(${__qt_pkg} ${__qt_version}
+
+            _qt_internal_save_find_package_context_for_debugging(${target})
+
+            find_dependency(${__qt_${target}_pkg} ${__qt_${target}_version}
                 NAMES
-                    ${__qt_pkg_names}
+                    ${__qt_${target}_pkg_names}
                 PATHS
                     ${${find_dependency_path_list}}
                     ${_qt_additional_packages_prefix_paths}
@@ -23,3 +117,175 @@ macro(_qt_internal_find_dependencies target_dep_list find_dependency_path_list)
         endif()
     endforeach()
 endmacro()
+
+
+# TODO: Remove once a dependency update completes and most developers have the Dependencies.cmake
+# files updated in their builds.
+# The name is too generic, it doesn't look for any kind of dependencies but only Qt package
+# dependencies.
+macro(_qt_internal_find_dependencies target_dep_list find_dependency_path_list)
+    _qt_internal_find_qt_dependencies("none" "${target_dep_list}" "${find_dependency_path_list}")
+endmacro()
+
+# If a dependency package was not found, provide some hints in the error message on how to debug
+# the issue.
+#
+# pkg_name_var should be the variable name that contains the package that was not found.
+# e.g. __qt_Core_pkg
+#
+# message_out_var should contain the variable name of the  original "not found" message, and it
+# will have the hints appended to it as a string. e.g. ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE
+#
+# infix is used as a unique prefix to retrieve the find_package paths context for the last package
+# that was not found, for debugging purposes.
+#
+# The function should not be called in Dependencies.cmake files directly, because find_dependency
+# returns out of the included file.
+macro(_qt_internal_suggest_dependency_debugging infix pkg_name_var message_out_var)
+    if(${pkg_name_var}
+        AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FOUND
+        AND ${message_out_var})
+        if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.23")
+            string(APPEND ${message_out_var}
+                "\nConfiguring with --debug-find-pkg=${${pkg_name_var}} might reveal \
+details why the package was not found.")
+        elseif(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
+            string(APPEND ${message_out_var}
+                "\nConfiguring with -DCMAKE_FIND_DEBUG_MODE=TRUE might reveal \
+details why the package was not found.")
+        endif()
+
+        if(NOT QT_DEBUG_FIND_PACKAGE)
+            string(APPEND ${message_out_var}
+                "\nConfiguring with -DQT_DEBUG_FIND_PACKAGE=ON will print the values of some of \
+the path variables that find_package uses to try and find the package.")
+        else()
+            string(APPEND ${message_out_var}
+                "\n find_package search path values and other context for the last package that was not found:"
+                "\n  CMAKE_MODULE_PATH: ${_qt_${infix}_CMAKE_MODULE_PATH}"
+                "\n  CMAKE_PREFIX_PATH: ${_qt_${infix}_CMAKE_PREFIX_PATH}"
+                "\n  \$ENV{CMAKE_PREFIX_PATH}: $ENV{CMAKE_PREFIX_PATH}"
+                "\n  CMAKE_FIND_ROOT_PATH: ${_qt_${infix}_CMAKE_FIND_ROOT_PATH}"
+                "\n  _qt_additional_packages_prefix_paths: ${_qt_${infix}_qt_additional_packages_prefix_paths}"
+                "\n  _qt_additional_host_packages_prefix_paths: ${_qt_${infix}_qt_additional_host_packages_prefix_paths}"
+                "\n  _qt_cmake_dir: ${_qt_${infix}_qt_cmake_dir}"
+                "\n  QT_HOST_PATH: ${QT_HOST_PATH}"
+                "\n  Qt6HostInfo_DIR: ${Qt6HostInfo_DIR}"
+                "\n  Qt6_DIR: ${Qt6_DIR}"
+                "\n  CMAKE_TOOLCHAIN_FILE: ${CMAKE_TOOLCHAIN_FILE}"
+                "\n  CMAKE_FIND_ROOT_PATH_MODE_PACKAGE: ${CMAKE_FIND_ROOT_PATH_MODE_PACKAGE}"
+                "\n  CMAKE_SYSROOT: ${CMAKE_SYSROOT}"
+                "\n  \$ENV{PATH}: $ENV{PATH}"
+            )
+        endif()
+    endif()
+endmacro()
+
+# Save find_package search paths context just before a find_package call, to be shown with a
+# package not found message.
+macro(_qt_internal_save_find_package_context_for_debugging infix)
+    if(QT_DEBUG_FIND_PACKAGE)
+        set(_qt_${infix}_CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}")
+        set(_qt_${infix}_CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH}")
+        set(_qt_${infix}_CMAKE_FIND_ROOT_PATH "${CMAKE_FIND_ROOT_PATH}")
+        set(_qt_${infix}_qt_additional_packages_prefix_paths
+            "${_qt_additional_packages_prefix_paths}")
+        set(_qt_${infix}_qt_additional_host_packages_prefix_paths
+            "${_qt_additional_host_packages_prefix_paths}")
+        set(_qt_${infix}_qt_cmake_dir "${_qt_cmake_dir}")
+    endif()
+endmacro()
+
+function(_qt_internal_determine_if_host_info_package_needed out_var)
+    set(needed FALSE)
+
+    # If a QT_HOST_PATH is provided when configuring qtbase, we assume it's a cross build
+    # and thus we require the QT_HOST_PATH to be provided also when using the cross-built Qt.
+    # This tells the QtConfigDependencies file to do appropriate requirement checks.
+    if(NOT "${QT_HOST_PATH}" STREQUAL "" AND NOT QT_NO_REQUIRE_HOST_PATH_CHECK)
+        set(needed TRUE)
+    endif()
+    set(${out_var} "${needed}" PARENT_SCOPE)
+endfunction()
+
+macro(_qt_internal_find_host_info_package platform_requires_host_info)
+    if(${platform_requires_host_info})
+        find_package(Qt6HostInfo
+                     CONFIG
+                     REQUIRED
+                     PATHS "${QT_HOST_PATH}"
+                           "${QT_HOST_PATH_CMAKE_DIR}"
+                     NO_CMAKE_FIND_ROOT_PATH
+                     NO_DEFAULT_PATH)
+    endif()
+endmacro()
+
+macro(_qt_internal_setup_qt_host_path
+        host_path_required
+        initial_qt_host_path
+        initial_qt_host_path_cmake_dir
+    )
+    # Set up QT_HOST_PATH and do sanity checks.
+    # A host path is required when cross-compiling but optional when doing a native build.
+    # Requiredness can be overridden via variable.
+    if(DEFINED QT_REQUIRE_HOST_PATH_CHECK)
+        set(_qt_platform_host_path_required "${QT_REQUIRE_HOST_PATH_CHECK}")
+    else()
+        set(_qt_platform_host_path_required "${host_path_required}")
+    endif()
+
+    if(_qt_platform_host_path_required)
+        # QT_HOST_PATH precedence:
+        # - cache variable / command line option
+        # - environment variable
+        # - initial QT_HOST_PATH when qtbase was configured (and the directory exists)
+        if(NOT DEFINED QT_HOST_PATH)
+            if(DEFINED ENV{QT_HOST_PATH})
+                set(QT_HOST_PATH "$ENV{QT_HOST_PATH}" CACHE PATH "")
+            elseif(NOT "${initial_qt_host_path}" STREQUAL "" AND EXISTS "${initial_qt_host_path}")
+                set(QT_HOST_PATH "${initial_qt_host_path}" CACHE PATH "")
+            endif()
+        endif()
+
+        if(NOT QT_HOST_PATH STREQUAL "")
+            get_filename_component(_qt_platform_host_path_absolute "${QT_HOST_PATH}" ABSOLUTE)
+        endif()
+
+        if("${QT_HOST_PATH}" STREQUAL "" OR NOT EXISTS "${_qt_platform_host_path_absolute}")
+            message(FATAL_ERROR
+                "To use a cross-compiled Qt, please set the QT_HOST_PATH cache variable to the "
+                "location of your host Qt installation.")
+        endif()
+
+        # QT_HOST_PATH_CMAKE_DIR is needed to work around the rerooting issue when looking for host
+        # tools. See REROOT_PATH_ISSUE_MARKER.
+        # Prefer initially configured path if none was explicitly set.
+        if(NOT DEFINED QT_HOST_PATH_CMAKE_DIR)
+            if(NOT "${initial_qt_host_path_cmake_dir}" STREQUAL ""
+                  AND EXISTS "${initial_qt_host_path_cmake_dir}")
+                set(QT_HOST_PATH_CMAKE_DIR "${initial_qt_host_path_cmake_dir}" CACHE PATH "")
+            else()
+                # First try to auto-compute the location instead of requiring to set
+                # QT_HOST_PATH_CMAKE_DIR explicitly.
+                set(__qt_candidate_host_path_cmake_dir "${QT_HOST_PATH}/lib/cmake")
+                if(__qt_candidate_host_path_cmake_dir
+                        AND EXISTS "${__qt_candidate_host_path_cmake_dir}")
+                    set(QT_HOST_PATH_CMAKE_DIR
+                        "${__qt_candidate_host_path_cmake_dir}" CACHE PATH "")
+                endif()
+            endif()
+        endif()
+
+        if(NOT QT_HOST_PATH_CMAKE_DIR STREQUAL "")
+            get_filename_component(_qt_platform_host_path_cmake_dir_absolute
+                                   "${QT_HOST_PATH_CMAKE_DIR}" ABSOLUTE)
+        endif()
+
+        if("${QT_HOST_PATH_CMAKE_DIR}" STREQUAL ""
+                OR NOT EXISTS "${_qt_platform_host_path_cmake_dir_absolute}")
+            message(FATAL_ERROR
+                "To use a cross-compiled Qt, please set the QT_HOST_PATH_CMAKE_DIR cache variable "
+                "to the location of your host Qt installation lib/cmake directory.")
+        endif()
+    endif()
+endmacro()

cmake/QtPublicPluginHelpers.cmake

@@ -408,3 +408,74 @@ function(__qt_internal_apply_plugin_imports_finalizer_mode target)
 
     set_target_properties(${target} PROPERTIES _qt_plugin_finalizer_imports_processed TRUE)
 endfunction()
+
+# Include CMake plugin packages that belong to the Qt module ${target} and initialize automatic
+# linkage of the plugins in static builds.
+# The variables inside the macro have to be named unique to the module because an included Plugin
+# file might look up another module dependency that calls the same macro before the first one
+# has finished processing, which can silently override the values if the variables are not unique.
+macro(__qt_internal_include_plugin_packages target)
+    set(__qt_${target}_plugin_module_target "${QT_CMAKE_EXPORT_NAMESPACE}::${target}")
+    set(__qt_${target}_plugins "")
+
+    # Properties can't be set on aliased targets, so make sure to unalias the target. This is needed
+    # when Qt examples are built as part of the Qt build itself.
+    get_target_property(_aliased_target ${__qt_${target}_plugin_module_target} ALIASED_TARGET)
+    if(_aliased_target)
+        set(__qt_${target}_plugin_module_target ${_aliased_target})
+    endif()
+
+    # Include all PluginConfig.cmake files and update the _qt_plugins and QT_PLUGINS property of
+    # the module. The underscored version is the one we will use going forward to have compatibility
+    # with INTERFACE libraries. QT_PLUGINS is now deprecated and only kept so that we don't break
+    # existing projects using it (like CMake itself).
+    file(GLOB __qt_${target}_plugin_config_files
+        "${CMAKE_CURRENT_LIST_DIR}/${QT_CMAKE_EXPORT_NAMESPACE}*PluginConfig.cmake")
+    foreach(__qt_${target}_plugin_config_file ${__qt_${target}_plugin_config_files})
+        string(REGEX REPLACE
+            "^.*/${QT_CMAKE_EXPORT_NAMESPACE}(.*Plugin)Config.cmake$"
+            "\\1"
+            __qt_${target}_qt_plugin "${__qt_${target}_plugin_config_file}")
+        include("${__qt_${target}_plugin_config_file}")
+        if(TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::${__qt_${target}_qt_plugin}")
+            list(APPEND __qt_${target}_plugins ${__qt_${target}_qt_plugin})
+        endif()
+    endforeach()
+    set_property(TARGET ${__qt_${target}_plugin_module_target}
+                 PROPERTY _qt_plugins ${__qt_${target}_plugins})
+
+    # TODO: Deprecated. Remove in Qt 7.
+    set_property(TARGET ${__qt_${target}_plugin_module_target}
+                 PROPERTY QT_PLUGINS ${__qt_${target}_plugins})
+
+    get_target_property(__qt_${target}_have_added_plugins_already
+        ${__qt_${target}_plugin_module_target} __qt_internal_plugins_added)
+    if(__qt_${target}_have_added_plugins_already)
+        return()
+    endif()
+
+    foreach(plugin_target ${__qt_${target}_plugins})
+        __qt_internal_plugin_get_plugin_type("${plugin_target}" __has_plugin_type __plugin_type)
+        if(NOT __has_plugin_type)
+            continue()
+        endif()
+
+        __qt_internal_plugin_has_class_name("${plugin_target}" __has_class_name)
+        if(NOT __has_class_name)
+            continue()
+        endif()
+
+        list(APPEND "QT_ALL_PLUGINS_FOUND_BY_FIND_PACKAGE_${__plugin_type}" "${plugin_target}")
+
+        # Auto-linkage should be set up only for static library builds.
+        if(NOT QT6_IS_SHARED_LIBS_BUILD)
+            __qt_internal_add_static_plugin_linkage(
+                "${plugin_target}" "${__qt_${target}_plugin_module_target}")
+            __qt_internal_add_static_plugin_import_macro(
+                "${plugin_target}" ${__qt_${target}_plugin_module_target} "${target}")
+        endif()
+    endforeach()
+
+    set_target_properties(
+        ${__qt_${target}_plugin_module_target} PROPERTIES __qt_internal_plugins_added TRUE)
+endmacro()

cmake/QtPublicTestHelpers.cmake

@@ -0,0 +1,104 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+# This function wraps COMMAND with cmake script, that makes possible standalone run with external
+# arguments.
+#
+# Generated wrapper will be written to OUTPUT_FILE.
+# If WORKING_DIRECTORY is not set COMMAND will be executed in CMAKE_CURRENT_BINARY_DIR.
+# Variables from ENVIRONMENT will be set before COMMAND execution.
+# PRE_RUN and POST_RUN arguments may contain extra cmake code that supposed to be executed before
+# and after COMMAND, respectively. Both arguments accept a list of cmake script language
+# constructions. Each item of the list will be concantinated into single string with '\n' separator.
+# COMMAND_ECHO option takes a value like it does for execute_process, and passes that value to
+# execute_process.
+function(_qt_internal_create_command_script)
+    #This style of parsing keeps ';' in ENVIRONMENT variables
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+                          ""
+                          "OUTPUT_FILE;WORKING_DIRECTORY;COMMAND_ECHO"
+                          "COMMAND;ENVIRONMENT;PRE_RUN;POST_RUN"
+    )
+
+    if(NOT arg_COMMAND)
+        message(FATAL_ERROR "qt_internal_create_command_script: COMMAND is not specified")
+    endif()
+
+    if(NOT arg_OUTPUT_FILE)
+        message(FATAL_ERROR "qt_internal_create_command_script: Wrapper OUTPUT_FILE\
+is not specified")
+    endif()
+
+    if(NOT arg_WORKING_DIRECTORY AND NOT QNX)
+        set(arg_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
+    endif()
+
+    set(environment_extras)
+    set(skipNext false)
+    if(arg_ENVIRONMENT)
+        list(LENGTH arg_ENVIRONMENT length)
+        math(EXPR length "${length} - 1")
+        foreach(envIdx RANGE ${length})
+            if(skipNext)
+                set(skipNext FALSE)
+                continue()
+            endif()
+
+            set(envVariable "")
+            set(envValue "")
+
+            list(GET arg_ENVIRONMENT ${envIdx} envVariable)
+            math(EXPR envIdx "${envIdx} + 1")
+            if (envIdx LESS_EQUAL ${length})
+                list(GET arg_ENVIRONMENT ${envIdx} envValue)
+            endif()
+
+            if(NOT "${envVariable}" STREQUAL "")
+                set(environment_extras "${environment_extras}\nset(ENV{${envVariable}} \
+\"${envValue}\")")
+            endif()
+            set(skipNext TRUE)
+        endforeach()
+    endif()
+
+    #Escaping environment variables before expand them by file GENERATE
+    string(REPLACE "\\" "\\\\" environment_extras "${environment_extras}")
+
+    if(WIN32)
+        # It's necessary to call actual test inside 'cmd.exe', because 'execute_process' uses
+        # SW_HIDE to avoid showing a console window, it affects other GUI as well.
+        # See https://gitlab.kitware.com/cmake/cmake/-/issues/17690 for details.
+        set(extra_runner "cmd /c")
+    endif()
+
+    if(arg_PRE_RUN)
+        string(JOIN "\n" pre_run ${arg_PRE_RUN})
+    endif()
+
+    if(arg_POST_RUN)
+        string(JOIN "\n" post_run ${arg_POST_RUN})
+    endif()
+
+    set(command_echo "")
+    if(arg_COMMAND_ECHO)
+        set(command_echo "COMMAND_ECHO ${arg_COMMAND_ECHO}")
+    endif()
+
+    file(GENERATE OUTPUT "${arg_OUTPUT_FILE}" CONTENT
+"#!${CMAKE_COMMAND} -P
+# Qt generated command wrapper
+
+${environment_extras}
+${pre_run}
+execute_process(COMMAND ${extra_runner} ${arg_COMMAND}
+                WORKING_DIRECTORY \"${arg_WORKING_DIRECTORY}\"
+                ${command_echo}
+                RESULT_VARIABLE result
+)
+${post_run}
+if(NOT result EQUAL 0)
+    string(JOIN \" \" full_command ${arg_COMMAND})
+    message(FATAL_ERROR \"\${full_command} execution failed with exit code \${result}.\")
+endif()"
+    )
+endfunction()

cmake/QtPublicToolHelpers.cmake

@@ -22,7 +22,7 @@ function(__qt_internal_get_tool_imported_location out_var tool)
     get_target_property(configs ${target} IMPORTED_CONFIGURATIONS)
     list(TRANSFORM configs PREPEND _)
     # Well-known configuration types
-    list(APPEND
+    list(APPEND configs
         _RELWITHDEBINFO
         _RELEASE
         _MINSIZEREL
@@ -41,3 +41,105 @@ function(__qt_internal_get_tool_imported_location out_var tool)
 
     set(${out_var} "${${out_var}}" PARENT_SCOPE)
 endfunction()
+
+function(_qt_internal_generate_tool_command_wrapper)
+    get_property(is_called GLOBAL PROPERTY _qt_internal_generate_tool_command_wrapper_called)
+    if(NOT CMAKE_HOST_WIN32 OR is_called)
+        return()
+    endif()
+
+    set(prefixes "")
+
+    # In a prefix build, the just-built tools should pick up libraries from the current repo build
+    # dir.
+    if(QT_BUILD_DIR)
+        list(APPEND prefixes "${QT_BUILD_DIR}")
+    endif()
+
+    # Pick up libraries from the main location where Qt was installed during a Qt build.
+    if(QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX)
+        list(APPEND prefixes "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}")
+    endif()
+
+    # Needed for ExternalProjects examples, where the Qt build dir is passed via this variable
+    # to the example project.
+    if(QT_ADDITIONAL_PACKAGES_PREFIX_PATH)
+        __qt_internal_prefix_paths_to_roots(additional_roots
+            "${QT_ADDITIONAL_PACKAGES_PREFIX_PATH}")
+        list(APPEND prefixes ${QT_ADDITIONAL_PACKAGES_PREFIX_PATH})
+    endif()
+
+    # Fallback to wherever Qt6 package is.
+    if(QT6_INSTALL_PREFIX)
+        list(APPEND prefixes "${QT6_INSTALL_PREFIX}")
+    endif()
+
+    # When building qtbase, QT6_INSTALL_BINS is not set yet.
+    if(INSTALL_BINDIR)
+        set(bin_suffix "${INSTALL_BINDIR}")
+    else()
+        set(bin_suffix "${QT6_INSTALL_BINS}")
+    endif()
+
+    set(path_dirs "")
+    foreach(prefix IN LISTS prefixes)
+        set(bin_dir "${prefix}/${bin_suffix}")
+        if(EXISTS "${bin_dir}")
+            file(TO_NATIVE_PATH "${bin_dir}" path_dir)
+            list(APPEND path_dirs "${path_dir}")
+        endif()
+    endforeach()
+
+    set(tool_command_wrapper_dir "${CMAKE_BINARY_DIR}/.qt/bin")
+    file(MAKE_DIRECTORY "${tool_command_wrapper_dir}")
+    set(tool_command_wrapper_path "${tool_command_wrapper_dir}/qt_setup_tool_path.bat")
+
+    file(WRITE "${tool_command_wrapper_path}" "@echo off
+set PATH=${path_dirs};%PATH%
+%*")
+
+    set(QT_TOOL_COMMAND_WRAPPER_PATH "${tool_command_wrapper_path}"
+        CACHE INTERNAL "Path to the wrapper of the tool commands")
+
+    set_property(GLOBAL PROPERTY _qt_internal_generate_tool_command_wrapper_called TRUE)
+endfunction()
+
+# Wraps a tool command with a script that contains the necessary environment for the tool to run
+# correctly.
+# _qt_internal_wrap_tool_command(var <SET|APPEND> <command> [args...])
+# Arguments:
+#    APPEND Selects the 'append' mode for the out_variable argument.
+#    SET Selects the 'set' mode for the out_variable argument.
+#
+# FIXME: Replace all usages of _qt_internal_wrap_tool_command
+# with _qt_internal_get_wrap_tool_script_path and remove the former.
+# The former always adds the COMMAND keyword, which does not allow the caller to wrap the
+# commands in a generator expression. See _qt_internal_target_enable_qmllint for an example.
+function(_qt_internal_wrap_tool_command out_variable action)
+    set(append FALSE)
+    if(action STREQUAL "APPEND")
+        set(append TRUE)
+    elseif(NOT action STREQUAL "SET")
+        message(FATAL_ERROR "Invalid action specified ${action}. Supported actions: SET, APPEND")
+    endif()
+
+    # Ensure the script wrapper exists.
+    _qt_internal_generate_tool_command_wrapper()
+
+    set(cmd COMMAND ${QT_TOOL_COMMAND_WRAPPER_PATH} ${ARGN})
+
+    if(append)
+        list(APPEND ${out_variable} ${cmd})
+    else()
+        set(${out_variable} ${cmd})
+    endif()
+    set(${out_variable} "${${out_variable}}" PARENT_SCOPE)
+endfunction()
+
+# Gets the path to tool wrapper shell script.
+function(_qt_internal_get_tool_wrapper_script_path out_variable)
+    # Ensure the script wrapper exists.
+    _qt_internal_generate_tool_command_wrapper()
+
+    set(${out_variable} "${QT_TOOL_COMMAND_WRAPPER_PATH}" PARENT_SCOPE)
+endfunction()

cmake/QtPublicWasmToolchainHelpers.cmake

@@ -50,7 +50,7 @@ endfunction()
 
 function(__qt_internal_get_emcc_recommended_version out_var)
     # This version of Qt needs this version of emscripten.
-    set(QT_EMCC_RECOMMENDED_VERSION "3.1.10")
+    set(QT_EMCC_RECOMMENDED_VERSION "3.1.14")
     set(${out_var} "${QT_EMCC_RECOMMENDED_VERSION}" PARENT_SCOPE)
 endfunction()
 
@@ -69,3 +69,33 @@ function(__qt_internal_show_error_no_emscripten_toolchain_file_found_when_using_
         "or provide a path to a valid emscripten installation via the EMSDK "
         "environment variable.")
 endfunction()
+
+function(__qt_internal_get_qt_build_emsdk_version out_var)
+    if(QT6_INSTALL_PREFIX)
+        set(WASM_BUILD_DIR "${QT6_INSTALL_PREFIX}")
+    elseif(QT_BUILD_DIR)
+        set(WASM_BUILD_DIR "${QT_BUILD_DIR}")
+    endif()
+    if(EXISTS "${WASM_BUILD_DIR}/src/corelib/global/qconfig.h")
+        file(READ "${WASM_BUILD_DIR}/src/corelib/global/qconfig.h" ver)
+    else()
+        file(READ "${WASM_BUILD_DIR}/include/QtCore/qconfig.h" ver)
+    endif()
+    string(REGEX MATCH "#define QT_EMCC_VERSION.\"[0-9]+\\.[0-9]+\\.[0-9]+\"" emOutput ${ver})
+    string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" build_emcc_version "${emOutput}")
+    set(${out_var} "${build_emcc_version}" PARENT_SCOPE)
+endfunction()
+
+function(_qt_test_emscripten_version)
+    __qt_internal_get_emcc_recommended_version(_recommended_emver)
+    __qt_internal_get_emroot_path_suffix_from_emsdk_env(emroot_path)
+    __qt_internal_query_emsdk_version("${emroot_path}" TRUE current_emsdk_ver)
+    __qt_internal_get_qt_build_emsdk_version(qt_build_emcc_version)
+
+    if(NOT "${qt_build_emcc_version}" STREQUAL "${current_emsdk_ver}")
+        message("Qt Wasm built with Emscripten version: ${qt_build_emcc_version}")
+        message("You are using Emscripten version: ${current_emsdk_ver}")
+        message("The recommended version of Emscripten for this Qt is: ${_recommended_emver}")
+        message("This may not work correctly")
+    endif()
+endfunction()

cmake/QtQmakeHelpers.cmake

@@ -95,7 +95,8 @@ function(qt_generate_qmake_and_qtpaths_wrapper_for_target)
         "${host_prefix}")
     file(RELATIVE_PATH ext_prefix_relative_to_conf_file "${ext_prefix}/${INSTALL_BINDIR}"
         "${ext_prefix}")
-    file(RELATIVE_PATH ext_prefix_relative_to_host_prefix "${host_prefix}" "${ext_prefix}")
+    file(RELATIVE_PATH ext_datadir_relative_to_host_prefix "${host_prefix}"
+        "${ext_prefix}/${INSTALL_MKSPECSDIR}/..")
 
     set(content "")
 
@@ -127,7 +128,10 @@ Prefix=${prefix}
         "[Paths]
 Prefix=${ext_prefix_relative_to_conf_file}
 HostPrefix=${host_prefix_relative_to_conf_file}
-HostData=${ext_prefix_relative_to_host_prefix}
+HostBinaries=${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR}
+HostLibraries=${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBDIR}
+HostLibraryExecutables=${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR}
+HostData=${ext_datadir_relative_to_host_prefix}
 Sysroot=${sysroot}
 SysrootifyPrefix=${sysrootify_prefix}
 TargetSpec=${QT_QMAKE_TARGET_MKSPEC}

cmake/QtScopeFinalizerHelpers.cmake

@@ -8,7 +8,7 @@
 # because CMake's handling of empty list elements is a cruel joke.
 # For CMake < 3.18 the function qt_watch_current_list_dir must know about the finalizer.
 #
-# When using CMake 3.19 or higher, no more INGORE parameters are passed. Instead we
+# When using CMake 3.19 or higher, no more IGNORE parameters are passed. Instead we
 # use cmake_language(DEFER CALL) and pass arguments as usual.
 # qt_watch_current_list_dir also doesn't need to know about the finalizer
 function(qt_add_list_file_finalizer func)

cmake/QtSetup.cmake

@@ -23,18 +23,22 @@ if(FEATURE_developer_build)
     set(_default_build_type "Debug")
 endif()
 
-# Decide whether output should be verbose or not.
-# Default to verbose (--log-level=STATUS) in a developer-build and
-# non-verbose (--log-level=NOTICE) otherwise.
-# If a custom CMAKE_MESSAGE_LOG_LEVEL was specified, it takes priority.
-# Passing an explicit --log-level=Foo has the highest priority.
-if(NOT CMAKE_MESSAGE_LOG_LEVEL)
-    if(FEATURE_developer_build OR QT_FEATURE_developer_build)
-        set(CMAKE_MESSAGE_LOG_LEVEL "STATUS")
-    else()
-        set(CMAKE_MESSAGE_LOG_LEVEL "NOTICE")
+function(qt_internal_set_message_log_level out_var)
+    # Decide whether output should be verbose or not.
+    # Default to verbose (--log-level=STATUS) in a developer-build and
+    # non-verbose (--log-level=NOTICE) otherwise.
+    # If a custom CMAKE_MESSAGE_LOG_LEVEL was specified, it takes priority.
+    # Passing an explicit --log-level=Foo has the highest priority.
+    if(NOT CMAKE_MESSAGE_LOG_LEVEL)
+        if(FEATURE_developer_build OR QT_FEATURE_developer_build)
+            set(CMAKE_MESSAGE_LOG_LEVEL "STATUS")
+        else()
+            set(CMAKE_MESSAGE_LOG_LEVEL "NOTICE")
+        endif()
+        set(${out_var} "${CMAKE_MESSAGE_LOG_LEVEL}" PARENT_SCOPE)
     endif()
-endif()
+endfunction()
+qt_internal_set_message_log_level(CMAKE_MESSAGE_LOG_LEVEL)
 
 # Reset content of extra build internal vars for each inclusion of QtSetup.
 unset(QT_EXTRA_BUILD_INTERNALS_VARS)
@@ -55,6 +59,12 @@ elseif(CMAKE_CONFIGURATION_TYPES)
         message(STATUS
             "Default build configuration set to '${CMAKE_NINJA_MULTI_DEFAULT_BUILD_TYPE}'.")
     endif()
+    if(CMAKE_GENERATOR STREQUAL "Ninja")
+        message(FATAL_ERROR
+            "It's not possible to build multiple configurations with the single config Ninja "
+            "generator. Consider configuring with -G\"Ninja Multi-Config\" instead of -GNinja."
+        )
+    endif()
 else()
     message(STATUS "CMAKE_BUILD_TYPE was set to: '${CMAKE_BUILD_TYPE}'")
 endif()
@@ -106,6 +116,10 @@ endif()
 ## Position independent code:
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
+# Does the linker support position independent code?
+include(CheckPIESupported)
+check_pie_supported()
+
 # Do not relink dependent libraries when no header has changed:
 set(CMAKE_LINK_DEPENDS_NO_SHARED ON)
 
@@ -248,28 +262,18 @@ option(QT_BUILD_EXAMPLES_AS_EXTERNAL "Should examples be built as ExternalProjec
 unset(_qt_build_examples_as_external)
 
 option(QT_BUILD_MANUAL_TESTS "Build Qt manual tests" OFF)
-option(QT_BUILD_MINIMAL_STATIC_TESTS "Build minimal subset of tests for static Qt builds" OFF)
 
-## Find host tools (if non native):
+if(WASM)
+    option(QT_BUILD_MINIMAL_STATIC_TESTS "Build minimal subset of tests for static Qt builds" ON)
+else()
+    option(QT_BUILD_MINIMAL_STATIC_TESTS "Build minimal subset of tests for static Qt builds" OFF)
+endif()
+
+## Path used to find host tools, either when cross-compiling or just when using the tools from
+## a different host build.
 set(QT_HOST_PATH "$ENV{QT_HOST_PATH}" CACHE PATH
     "Installed Qt host directory path, used for cross compiling.")
 
-if (CMAKE_CROSSCOMPILING)
-    if(NOT IS_DIRECTORY "${QT_HOST_PATH}")
-        message(FATAL_ERROR "You need to set QT_HOST_PATH to cross compile Qt.")
-    endif()
-endif()
-
-if(NOT "${QT_HOST_PATH}" STREQUAL "")
-    find_package(${INSTALL_CMAKE_NAMESPACE}HostInfo
-                 CONFIG
-                 REQUIRED
-                 PATHS "${QT_HOST_PATH}"
-                       "${QT_HOST_PATH_CMAKE_DIR}"
-                 NO_CMAKE_FIND_ROOT_PATH
-                 NO_DEFAULT_PATH)
-endif()
-
 ## Android platform settings
 if(ANDROID)
     include(QtPlatformAndroid)

cmake/QtStandaloneTestsConfig.cmake.in

@@ -1,2 +1,5 @@
-find_package(@INSTALL_CMAKE_NAMESPACE@ @PROJECT_VERSION@
+# TODO: Ideally this should look for each Qt module separately, with each module's specific version,
+# bypassing the Qt6 Config file, aka find_package(Qt6SpecificFoo) repated x times. But it's not
+# critical.
+find_package(@INSTALL_CMAKE_NAMESPACE@ @main_qt_package_version@
              REQUIRED COMPONENTS @QT_REPO_KNOWN_MODULES_STRING@)

cmake/QtTargetHelpers.cmake

@@ -480,7 +480,7 @@ endif()
 
         # INTERFACE libraries don't have IMPORTED_LOCATION-like properties.
         # OBJECT libraries have properties like IMPORTED_OBJECTS instead.
-        # Skip the rest of the procesing for those.
+        # Skip the rest of the processing for those.
         if(target_type STREQUAL "INTERFACE_LIBRARY" OR target_type STREQUAL "OBJECT_LIBRARY")
             continue()
         endif()
@@ -664,12 +664,12 @@ endfunction()
 #
 # MSVC generates 2 types of pdb files:
 #  - compile-time generated pdb files (compile flag /Zi + /Fd<pdb_name>)
-#  - link-time genereated pdb files (link flag /debug + /PDB:<pdb_name>)
+#  - link-time generated pdb files (link flag /debug + /PDB:<pdb_name>)
 #
 # CMake allows changing the names of each of those pdb file types by setting
 # the COMPILE_PDB_NAME_<CONFIG> and PDB_NAME_<CONFIG> properties. If they are
 # left empty, CMake will compute the default names itself (or rather in certain cases
-# leave it up to te compiler), without actually setting the property values.
+# leave it up to the compiler), without actually setting the property values.
 #
 # For installation purposes, CMake only provides a generator expression to the
 # link time pdb file path, not the compile path one, which means we have to compute the
@@ -850,7 +850,7 @@ endfunction()
 # To achieve that, consumers of ${target} will only get the include directories of ${dep_target}
 # if the latter package and target exists.
 #
-# A find_package(dep_target) dependency is added to ${target}'s ModuleDependencies.cmake file.
+# A find_package(dep_target) dependency is added to ${target}'s *Dependencies.cmake file.
 #
 # We use target_include_directories(PRIVATE) instead of target_link_libraries(PRIVATE) because the
 # latter would propagate a mandatory LINK_ONLY dependency on the ${dep_target} in a static Qt build.

cmake/QtTestHelpers.cmake

@@ -33,6 +33,10 @@ function(qt_internal_add_benchmark target)
         ${exec_args}
     )
 
+    # Benchmarks on iOS must be app bundles.
+    if(IOS)
+        set_target_properties(${target} PROPERTIES MACOSX_BUNDLE TRUE)
+    endif()
 
     qt_internal_add_repo_local_defines(${target})
 
@@ -43,7 +47,7 @@ function(qt_internal_add_benchmark target)
 
     # Add a ${target}_benchmark generator target, to run single benchmark more easily.
     set(benchmark_wrapper_file "${arg_OUTPUT_DIRECTORY}/${target}Wrapper$<CONFIG>.cmake")
-    qt_internal_create_command_script(COMMAND "$<TARGET_FILE:${target}>"
+    _qt_internal_create_command_script(COMMAND "$<TARGET_FILE:${target}>"
                                       OUTPUT_FILE "${benchmark_wrapper_file}"
                                       ENVIRONMENT "PATH" "${benchmark_env_path}"
                                                   "QT_PLUGIN_PATH" "${benchmark_env_plugin_path}"
@@ -61,6 +65,8 @@ function(qt_internal_add_benchmark target)
     if (TARGET benchmark)
         add_dependencies("benchmark" "${target}_benchmark")
     endif()
+
+    qt_internal_add_test_finalizers("${target}")
 endfunction()
 
 # Simple wrapper around qt_internal_add_executable for manual tests which insure that
@@ -98,9 +104,15 @@ function(qt_internal_add_manual_test target)
         ${exec_args}
     )
 
+    # Tests on iOS must be app bundles.
+    if(IOS)
+        set_target_properties(${target} PROPERTIES MACOSX_BUNDLE TRUE)
+    endif()
+
     # Disable the QT_NO_NARROWING_CONVERSIONS_IN_CONNECT define for manual tests
     qt_internal_undefine_global_definition(${target} QT_NO_NARROWING_CONVERSIONS_IN_CONNECT)
 
+    qt_internal_add_test_finalizers("${target}")
 endfunction()
 
 # This function will configure the fixture for the network tests that require docker network services
@@ -187,7 +199,7 @@ endfunction()
 # to ON. This is helpful if you want to use internal CMake tools within tests, like memory or
 # sanitizer checks. See https://cmake.org/cmake/help/v3.19/manual/ctest.1.html#ctest-memcheck-step
 # Arguments:
-#    BUILTIN_TESTDATA the option forces adding the provded TESTDATA to resources.
+#    BUILTIN_TESTDATA the option forces adding the provided TESTDATA to resources.
 function(qt_internal_add_test name)
     # EXCEPTIONS is a noop as they are enabled by default.
     set(optional_args
@@ -282,6 +294,11 @@ function(qt_internal_add_test name)
         # and not print anything.
         set_property(TARGET "${name}" PROPERTY WIN32_EXECUTABLE FALSE)
 
+        # Tests on iOS must be app bundles.
+        if(IOS)
+            set_target_properties(${name} PROPERTIES MACOSX_BUNDLE TRUE)
+        endif()
+
         # QMLTest specifics
         qt_internal_extend_target("${name}" CONDITION arg_QMLTEST
             PUBLIC_LIBRARIES ${QT_CMAKE_EXPORT_NAMESPACE}::QuickTest
@@ -467,6 +484,7 @@ function(qt_internal_add_test name)
         endif()
     endif()
 
+    qt_internal_add_test_finalizers("${name}")
 endfunction()
 
 # This function adds test with specified NAME and wraps given test COMMAND with standalone cmake
@@ -477,7 +495,7 @@ endfunction()
 # directly by 'cmake -P path/to/scriptWrapper.cmake', COMMAND will be executed in specified
 # WORKING_DIRECTORY with arguments specified in ARGS.
 #
-# See also qt_internal_create_command_script for details.
+# See also _qt_internal_create_command_script for details.
 function(qt_internal_create_test_script)
     #This style of parsing keeps ';' in ENVIRONMENT variables
     cmake_parse_arguments(PARSE_ARGV 0 arg
@@ -538,7 +556,7 @@ for this function. Will be ignored")
         endif()
     endif()
 
-    qt_internal_create_command_script(COMMAND "${crosscompiling_emulator} \${env_test_runner} \
+    _qt_internal_create_command_script(COMMAND "${crosscompiling_emulator} \${env_test_runner} \
 \"${executable_file}\" \${env_test_args} ${command_args}"
                                       OUTPUT_FILE "${arg_OUTPUT_FILE}"
                                       WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
@@ -550,103 +568,11 @@ for this function. Will be ignored")
     )
 endfunction()
 
-# This function wraps COMMAND with cmake script, that makes possible standalone run with external
-# arguments.
-#
-# Generated wrapper will be written to OUTPUT_FILE.
-# If WORKING_DIRECTORY is not set COMMAND will be executed in CMAKE_CURRENT_BINARY_DIR.
-# Variables from ENVIRONMENT will be set before COMMAND execution.
-# PRE_RUN and POST_RUN arguments may contain extra cmake code that supposed to be executed before
-# and after COMMAND, respectively. Both arguments accept a list of cmake script language
-# constructions. Each item of the list will be concantinated into single string with '\n' sepatator.
-function(qt_internal_create_command_script)
-    #This style of parsing keeps ';' in ENVIRONMENT variables
-    cmake_parse_arguments(PARSE_ARGV 0 arg
-                          ""
-                          "OUTPUT_FILE;WORKING_DIRECTORY"
-                          "COMMAND;ENVIRONMENT;PRE_RUN;POST_RUN"
-    )
 
-    if(NOT arg_COMMAND)
-        message(FATAL_ERROR "qt_internal_create_command_script: COMMAND is not specified")
-    endif()
-
-    if(NOT arg_OUTPUT_FILE)
-        message(FATAL_ERROR "qt_internal_create_command_script: Wrapper OUTPUT_FILE\
-is not specified")
-    endif()
-
-    if(NOT arg_WORKING_DIRECTORY AND NOT QNX)
-        set(arg_WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
-    endif()
-
-    set(environment_extras)
-    set(skipNext false)
-    if(arg_ENVIRONMENT)
-        list(LENGTH arg_ENVIRONMENT length)
-        math(EXPR length "${length} - 1")
-        foreach(envIdx RANGE ${length})
-            if(skipNext)
-                set(skipNext FALSE)
-                continue()
-            endif()
-
-            set(envVariable "")
-            set(envValue "")
-
-            list(GET arg_ENVIRONMENT ${envIdx} envVariable)
-            math(EXPR envIdx "${envIdx} + 1")
-            if (envIdx LESS_EQUAL ${length})
-                list(GET arg_ENVIRONMENT ${envIdx} envValue)
-            endif()
-
-            if(NOT "${envVariable}" STREQUAL "")
-                set(environment_extras "${environment_extras}\nset(ENV{${envVariable}} \
-\"${envValue}\")")
-            endif()
-            set(skipNext TRUE)
-        endforeach()
-    endif()
-
-    #Escaping environment variables before expand them by file GENERATE
-    string(REPLACE "\\" "\\\\" environment_extras "${environment_extras}")
-
-    if(WIN32)
-        # It's necessary to call actual test inside 'cmd.exe', because 'execute_process' uses
-        # SW_HIDE to avoid showing a console window, it affects other GUI as well.
-        # See https://gitlab.kitware.com/cmake/cmake/-/issues/17690 for details.
-        set(extra_runner "cmd /c")
-    endif()
-
-    if(arg_PRE_RUN)
-        string(JOIN "\n" pre_run ${arg_PRE_RUN})
-    endif()
-
-    if(arg_POST_RUN)
-        string(JOIN "\n" post_run ${arg_POST_RUN})
-    endif()
-
-    file(GENERATE OUTPUT "${arg_OUTPUT_FILE}" CONTENT
-"#!${CMAKE_COMMAND} -P
-# Qt generated command wrapper
-
-${environment_extras}
-${pre_run}
-execute_process(COMMAND ${extra_runner} ${arg_COMMAND}
-                WORKING_DIRECTORY \"${arg_WORKING_DIRECTORY}\"
-                RESULT_VARIABLE result
-)
-${post_run}
-if(NOT result EQUAL 0)
-    string(JOIN \" \" full_command ${arg_COMMAND})
-    message(FATAL_ERROR \"\${full_command} execution failed with exit code \${result}.\")
-endif()"
-    )
-endfunction()
 
 # This function creates an executable for use as a helper program with tests. Some
 # tests launch separate programs to test certain input/output behavior.
-# Specify OVERRIDE_OUTPUT_DIRECTORY if you dont' want to place the helper in the parent directory,
+# Specify OVERRIDE_OUTPUT_DIRECTORY if you don't want to place the helper in the parent directory,
 # in which case you should specify OUTPUT_DIRECTORY "/foo/bar" manually.
 function(qt_internal_add_test_helper name)
 
@@ -730,3 +656,14 @@ function(qt_internal_collect_command_environment out_path out_plugin_path)
     string(REPLACE ";" "\;" plugin_paths_joined "${plugin_paths_joined}")
     set(${out_plugin_path} "${plugin_paths_joined}" PARENT_SCOPE)
 endfunction()
+
+function(qt_internal_add_test_finalizers target)
+    # It might not be safe to run all the finalizers of _qt_internal_finalize_executable
+    # within the context of a Qt build (not a user project) when targeting a host build.
+    # At least one issue is missing qmlimportscanner at configure time.
+    # For now, we limit it to iOS, where it was tested to work, an we know that host tools
+    # should already be built and available.
+    if(IOS)
+        qt_add_list_file_finalizer(_qt_internal_finalize_executable "${target}")
+    endif()
+endfunction()

cmake/QtToolHelpers.cmake

@@ -30,7 +30,7 @@
 #         The argument accepts 'Bootstrap' or 'None' values. If the argument value is set to
 #         'Bootstrap' the Qt::Bootstrap library is linked to the executable instead of Qt::Core.
 #         The 'None' value points that core library is not necessary and avoids linking neither
-#         Qt::Core or Qt::Bootstrap libraries. Otherwise the Qt::Core library will be publically
+#         Qt::Core or Qt::Bootstrap libraries. Otherwise the Qt::Core library will be publicly
 #         linked to the executable target by default.
 function(qt_internal_add_tool target_name)
     qt_tool_target_to_name(name ${target_name})
@@ -168,9 +168,22 @@ function(qt_internal_add_tool target_name)
     endif()
 
     if(NOT QT_WILL_BUILD_TOOLS)
-        message(FATAL_ERROR "The tool \"${full_name}\" was not found in the "
-                           "${tools_package_name} package. "
-                           "Package found: ${${tools_package_name}_FOUND}")
+        if(${${tools_package_name}_FOUND})
+            set(pkg_found_msg "")
+            string(APPEND pkg_found_msg
+                "the ${tools_package_name} package, but the package did not contain the tool. "
+                "Make sure that the host module ${arg_TOOLS_TARGET} was built with all features "
+                "enabled (no explicitly disabled tools).")
+        else()
+            set(pkg_found_msg "")
+            string(APPEND pkg_found_msg
+                "the ${tools_package_name} package, but the package could not be found. "
+                "Make sure you have built and installed the host ${arg_TOOLS_TARGET} module, "
+                "which will ensure the creation of the ${tools_package_name} package.")
+        endif()
+        message(FATAL_ERROR
+            "Failed to find the host tool \"${full_name}\". It is part of "
+            ${pkg_found_msg})
     else()
         message(STATUS "Tool '${full_name}' will be built from source.")
     endif()
@@ -220,6 +233,13 @@ function(qt_internal_add_tool target_name)
     _qt_internal_apply_strict_cpp("${target_name}")
     qt_internal_adjust_main_config_runtime_output_dir("${target_name}" "${output_dir}")
 
+    set_target_properties(${target_name} PROPERTIES
+        _qt_package_version "${PROJECT_VERSION}"
+    )
+    set_property(TARGET ${target_name}
+                 APPEND PROPERTY
+                 EXPORT_PROPERTIES "_qt_package_version")
+
     if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.19.0" AND QT_FEATURE_debug_and_release)
         set_property(TARGET "${target_name}"
             PROPERTY EXCLUDE_FROM_ALL "$<NOT:$<CONFIG:${QT_MULTI_CONFIG_FIRST_CONFIG}>>")
@@ -335,6 +355,8 @@ function(qt_export_tools module_name)
     set(extra_cmake_files "")
     set(extra_cmake_includes "")
 
+    set(first_tool_package_version "")
+
     foreach(tool_name ${QT_KNOWN_MODULE_${module_name}_TOOLS})
         # Specific tools can have package dependencies.
         # e.g. qtwaylandscanner depends on WaylandScanner (non-qt package).
@@ -366,6 +388,13 @@ endif()
 ")
         list(APPEND tool_targets "${QT_CMAKE_EXPORT_NAMESPACE}::${tool_name}")
         list(APPEND tool_targets_non_prefixed "${tool_name}")
+
+        if(NOT first_tool_package_version)
+            qt_internal_get_package_version_of_target("${tool_name}" tool_package_version)
+            if(tool_package_version)
+                set(first_tool_package_version "${tool_package_version}")
+            endif()
+        endif()
     endforeach()
 
     string(APPEND extra_cmake_statements
@@ -411,9 +440,30 @@ endif()
         "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}Config.cmake"
         INSTALL_DESTINATION "${config_install_dir}"
     )
+
+    # There might be Tools packages which don't have a corresponding real module_name target, like
+    # WaylandScannerTools.
+    # In that case we'll use the package version of the first tool that belongs to that package.
+    if(TARGET "${module_name}")
+        qt_internal_get_package_version_of_target("${module_name}" tools_package_version)
+    elseif(first_tool_package_version)
+        set(tools_package_version "${first_tool_package_version}")
+    else()
+        # This should never happen, because tools_package_version should always have at least some
+        # value. Issue an assertion message just in case the pre-condition ever changes.
+        set(tools_package_version "${PROJECT_VERSION}")
+        if(FEATURE_developer_build)
+            message(WARNING
+                "Could not determine package version of tools package ${module_name}. "
+                "Defaulting to project version ${PROJECT_VERSION}.")
+        endif()
+    endif()
+    message(TRACE
+        "Exporting tools package ${module_name}Tools with package version ${tools_package_version}"
+        "\n     included targets: ${tool_targets_non_prefixed}")
     write_basic_package_version_file(
         "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigVersionImpl.cmake"
-        VERSION ${PROJECT_VERSION}
+        VERSION "${tools_package_version}"
         COMPATIBILITY AnyNewerVersion
         ARCH_INDEPENDENT
     )

cmake/QtToolchainHelpers.cmake

@@ -2,21 +2,6 @@
 # as well as CMake application projects.
 # Expects various global variables to be set.
 function(qt_internal_create_toolchain_file)
-    set(qt_host_path_required FALSE)
-
-    if(NOT "${QT_HOST_PATH}" STREQUAL "")
-        # If a QT_HOST_PATH is provided when configuring qtbase, we assume it's a cross build
-        # and thus we require the QT_HOST_PATH to be provided also when using the cross-built Qt.
-        # This tells the Qt toolchain file to do appropriate requirement checks.
-        set(qt_host_path_required TRUE)
-
-        # TODO: Figure out how to make the initial QT_HOST_PATH var relocatable in relation
-        # to the target CMAKE_INSTALL_DIR, if at all possible to do so in a reliable way.
-        get_filename_component(qt_host_path_absolute "${QT_HOST_PATH}" ABSOLUTE)
-        get_filename_component(qt_host_path_cmake_dir_absolute
-            "${Qt${PROJECT_VERSION_MAJOR}HostInfo_DIR}/.." ABSOLUTE)
-    endif()
-
     if(CMAKE_TOOLCHAIN_FILE)
         file(TO_CMAKE_PATH "${CMAKE_TOOLCHAIN_FILE}" __qt_chainload_toolchain_file)
         set(init_original_toolchain_file
@@ -210,8 +195,8 @@ set(__qt_chainload_toolchain_file \"\${__qt_initially_configured_toolchain_file}
         # xcodebuild from the command line would try to build with the wrong architecture. Also
         # provide an opt-out option just in case.
         #
-        # For a multi-architecture build (so simulator_and_device) we don't set an explicit
-        # architecture and let Xcode and the developer handle it.
+        # For a multi-architecture build (so simulator_and_device) we set an explicit
+        # architecture for simulator only, via _qt_internal_set_ios_simulator_arch.
         #
         # When using the Ninja generator, specify the first architecture from QT_OSX_ARCHITECTURES
         # (even with a simulator_and_device Qt build). This ensures that the default configuration

cmake/QtWasmHelpers.cmake

@@ -4,8 +4,7 @@ function (qt_internal_setup_wasm_target_properties wasmTarget)
 
     target_link_options("${wasmTarget}" INTERFACE
     "SHELL:-s ERROR_ON_UNDEFINED_SYMBOLS=1"
-    "SHELL:-s EXPORTED_RUNTIME_METHODS=[UTF16ToString,stringToUTF16]"
-    "SHELL:-s USE_WEBGL2=1"
+    "SHELL:-s MAX_WEBGL_VERSION=2"
     "SHELL:-s FETCH=1"
     "SHELL:-s WASM_BIGINT=1")
 
@@ -25,16 +24,6 @@ function (qt_internal_setup_wasm_target_properties wasmTarget)
         target_compile_options("${wasmTarget}" INTERFACE -O2 -msimd128 -msse -msse2)
     endif()
 
-    if (QT_FEATURE_opengles3)
-        target_link_options("${wasmTarget}" INTERFACE "SHELL:-s FULL_ES3=1")
-
-        target_link_options("${wasmTarget}" INTERFACE "SHELL:-s FULL_ES3=1"
-            "SHELL:-s MAX_WEBGL_VERSION=2"
-            "SHELL:-s WEBGL2_BACKWARDS_COMPATIBILITY_EMULATION=1")
-    else()
-        target_link_options("${wasmTarget}" INTERFACE "SHELL:-s FULL_ES2=1")
-    endif()
-
     set(disable_exceptions_catching 1)
     if (QT_FEATURE_exceptions)
         set(disable_exceptions_catching 0)
@@ -83,7 +72,17 @@ function (qt_internal_setup_wasm_target_properties wasmTarget)
         set(QT_CFLAGS_OPTIMIZE_DEBUG "-Os" CACHE STRING INTERNAL FORCE)
         set(QT_FEATURE_optimize_debug ON CACHE BOOL INTERNAL FORCE)
 
-        target_link_options("${wasmTarget}" INTERFACE "SHELL:-s ASYNCIFY" "-Os" "-s" "ASYNCIFY_IMPORTS=[qt_asyncify_suspend_js, qt_asyncify_resume_js]")
+        target_link_options("${wasmTarget}" INTERFACE "SHELL:-s ASYNCIFY" "-Os")
         target_compile_definitions("${wasmTarget}" INTERFACE QT_HAVE_EMSCRIPTEN_ASYNCIFY)
     endif()
+
+    #  Set ASYNCIFY_IMPORTS unconditionally in order to support enabling asyncify at link time.
+    target_link_options("${wasmTarget}" INTERFACE "SHELL:-sASYNCIFY_IMPORTS=qt_asyncify_suspend_js,qt_asyncify_resume_js")
+
 endfunction()
+
+function(qt_internal_wasm_add_finalizers target)
+    qt_add_list_file_finalizer(_qt_internal_add_wasm_extra_exported_methods ${target})
+endfunction()
+
+

cmake/QtWrapperScriptHelpers.cmake

@@ -95,8 +95,18 @@ function(qt_internal_create_wrapper_scripts)
     set(__qt_cmake_standalone_test_bin_name "qt-cmake-standalone-test")
     set(__qt_cmake_standalone_test_bin_path
         "${INSTALL_BINDIR}/${__qt_cmake_standalone_test_bin_name}")
-    set(__qt_cmake_private_path
-        "${QT_STAGING_PREFIX}/${INSTALL_BINDIR}/qt-cmake-private")
+
+    # Configuring a standalone test on iOS should use the Xcode generator, but qt-cmake-private uses
+    # the generator that was used to build Qt itself (e.g. Ninja).
+    # Use qt-cmake instead, which does use the Xcode generator since Qt 6.2.5, 6.3.1, 6.4.
+    if(IOS)
+        set(__qt_cmake_private_path
+            "${QT_STAGING_PREFIX}/${INSTALL_BINDIR}/qt-cmake")
+    else()
+        set(__qt_cmake_private_path
+            "${QT_STAGING_PREFIX}/${INSTALL_BINDIR}/qt-cmake-private")
+    endif()
+
     set(__qt_cmake_standalone_test_path
         "${__build_internals_install_dir}/${__build_internals_standalone_test_template_dir}")
 

cmake/README.md

@@ -132,7 +132,7 @@ Compiling for a target architecture that's different than the host requires one
 host. This "host build" is needed because the process of building Qt involves the compilation of
 intermediate code generator tools, that in turn are called to produce source code that needs to be
 compiled into the final libraries. These tools are built using Qt itself and they need to run on the
-machine you're building on, regardless of the architecure you are targeting.
+machine you're building on, regardless of the architecture you are targeting.
 
 Build Qt regularly for your host system and install it into a directory of your choice using the
 ``CMAKE_INSTALL_PREFIX`` variable. You are free to disable the build of tests and examples by

cmake/ios/Info.plist.app.in

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+
+    <key>CFBundleName</key>
+    <string>${MACOSX_BUNDLE_BUNDLE_NAME}</string>
+
+    <key>CFBundleDisplayName</key>
+    <string>${QT_INTERNAL_DOLLAR_VAR}{PRODUCT_NAME}</string>
+
+    <key>CFBundleIdentifier</key>
+    <string>${MACOSX_BUNDLE_GUI_IDENTIFIER}</string>
+
+    <key>CFBundleExecutable</key>
+    <string>${MACOSX_BUNDLE_EXECUTABLE_NAME}</string>
+
+    <key>CFBundleVersion</key>
+    <string>${MACOSX_BUNDLE_BUNDLE_VERSION}</string>
+
+    <key>CFBundleShortVersionString</key>
+    <string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
+
+    <key>CFBundleIconFile</key>
+    <string>${MACOSX_BUNDLE_ICON_FILE}</string>
+
+    <key>CFBundleDevelopmentRegion</key>
+    <string>$(DEVELOPMENT_LANGUAGE)</string>
+    <key>CFBundleAllowMixedLocalizations</key>
+    <true/>
+
+    <key>LSRequiresIPhoneOS</key>
+    <true/>
+
+    <key>NOTE</key>
+    <string>This file was generated by Qt's default CMake support.</string>
+
+    <key>UILaunchStoryboardName</key>
+    <string>@qt_ios_launch_screen_plist_entry@</string>
+
+    <key>UISupportedInterfaceOrientations</key>
+    <array>
+        <string>UIInterfaceOrientationPortrait</string>
+        <string>UIInterfaceOrientationPortraitUpsideDown</string>
+        <string>UIInterfaceOrientationLandscapeLeft</string>
+        <string>UIInterfaceOrientationLandscapeRight</string>
+    </array>
+</dict>
+</plist>

cmake/ios/MacOSXBundleInfo.plist.in

@@ -1,55 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-
-	<key>CFBundlePackageType</key>
-	<string>APPL</string>
-
-	<key>CFBundleName</key>
-	<string>${MACOSX_BUNDLE_BUNDLE_NAME}</string>
-
-	<key>CFBundleDisplayName</key>
-	<string>${QT_INTERNAL_DOLLAR_VAR}{PRODUCT_NAME}</string>
-
-	<key>CFBundleIdentifier</key>
-	<string>${MACOSX_BUNDLE_GUI_IDENTIFIER}</string>
-
-	<key>CFBundleExecutable</key>
-	<string>${MACOSX_BUNDLE_EXECUTABLE_NAME}</string>
-
-	<key>CFBundleVersion</key>
-	<string>${MACOSX_BUNDLE_BUNDLE_VERSION}</string>
-
-	<key>CFBundleShortVersionString</key>
-	<string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
-
-	<key>NSHumanReadableCopyright</key>
-	<string>${MACOSX_BUNDLE_COPYRIGHT}</string>
-
-	<key>CFBundleIconFile</key>
-	<string>${MACOSX_BUNDLE_ICON_FILE}</string>
-
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-
-	<key>LSRequiresIPhoneOS</key>
-	<true/>
-
-	<key>NOTE</key>
-	<string>This file was generated by Qt's default CMake support.</string>
-
-	<key>UILaunchStoryboardName</key>
-	<string>${QT_INTERNAL_IOS_LAUNCH_SCREEN_PLIST_ENTRY}</string>
-
-	<key>UISupportedInterfaceOrientations</key>
-	<array>
-		<string>UIInterfaceOrientationPortrait</string>
-		<string>UIInterfaceOrientationPortraitUpsideDown</string>
-		<string>UIInterfaceOrientationLandscapeLeft</string>
-		<string>UIInterfaceOrientationLandscapeRight</string>
-	</array>
-</dict>
-</plist>

cmake/macos/MacOSXBundleInfo.plist.in

@@ -29,7 +29,9 @@
 	<string>${MACOSX_BUNDLE_ICON_FILE}</string>
 
 	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
+	<string>en</string>
+	<key>CFBundleAllowMixedLocalizations</key>
+	<true/>
 
 	<key>NSPrincipalClass</key>
 	<string>NSApplication</string>

cmake/modulecppexports.h.in

@@ -1,4 +1,4 @@
-// Copyright (C) 2021 The Qt Company Ltd.
+// Copyright (C) 2022 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
 #ifndef @header_base_name_upper@_H
@@ -16,10 +16,33 @@
 #  define Q_@module_define_infix@_EXPORT
 #endif
 
-#ifdef QT_@module_define_infix@_BUILD_REMOVED_API
-#define QT_@module_define_infix@_REMOVED_SINCE(major, minor) QT_DEPRECATED_SINCE(major, minor)
+#if !defined(QT_BUILD_@module_define_infix@_LIB) && !defined(QT_STATIC)
+/* outside library → inline decl + defi */
+/* static builds treat everything as part of the library, so they never inline */
+#  define QT_@module_define_infix@_INLINE_SINCE(major, minor) inline
+#  define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) 1
+#elif defined(QT_@module_define_infix@_BUILD_REMOVED_API)
+/* inside library, inside removed_api.cpp:
+ * keep deprecated API → non-inline decl;
+ * remove deprecated API → inline decl;
+ * definition is always available */
+#  define QT_@module_define_infix@_INLINE_SINCE(major, minor) \
+    QT_IF_DEPRECATED_SINCE(major, minor, inline, /* not inline */)
+#  define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) 1
 #else
-#define QT_@module_define_infix@_REMOVED_SINCE(major, minor) 0
+/* inside library, outside removed_api.cpp:
+ * keep deprecated API → non-inline decl, no defi;
+ * remove deprecated API → inline decl, defi */
+#  define QT_@module_define_infix@_INLINE_SINCE(major, minor) \
+    QT_IF_DEPRECATED_SINCE(major, minor, inline, /* not inline */)
+#  define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) \
+    QT_IF_DEPRECATED_SINCE(major, minor, 1, 0)
+#endif
+
+#ifdef QT_@module_define_infix@_BUILD_REMOVED_API
+#  define QT_@module_define_infix@_REMOVED_SINCE(major, minor) QT_DEPRECATED_SINCE(major, minor)
+#else
+#  define QT_@module_define_infix@_REMOVED_SINCE(major, minor) 0
 #endif
 
 #endif // @header_base_name_upper@_H

cmake/qt.toolchain.cmake.in

@@ -3,11 +3,7 @@ set(__qt_toolchain_used_variables
     QT_TOOLCHAIN_INCLUDE_FILE
     QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR
     QT_TOOLCHAIN_RELOCATABLE_PREFIX
-    QT_HOST_PATH
-    QT_HOST_PATH_CMAKE_DIR
-    QT_REQUIRE_HOST_PATH_CHECK
     QT_ADDITIONAL_PACKAGES_PREFIX_PATH
-    QT_ADDITIONAL_HOST_PACKAGES_PREFIX_PATH
 )
 @init_additional_used_variables@
 
@@ -38,7 +34,7 @@ if(__qt_chainload_toolchain_file)
                           "${__qt_chainload_toolchain_file}" REALPATH)
     if(__qt_chainload_toolchain_file_real_path STREQUAL CMAKE_CURRENT_LIST_FILE)
         message(FATAL_ERROR
-                "Woah, the Qt toolchain file tried to include itself recusively! '${__qt_chainload_toolchain_file}' "
+                "Woah, the Qt toolchain file tried to include itself recursively! '${__qt_chainload_toolchain_file}' "
                 "Make sure to remove qtbase/CMakeCache.txt and reconfigure qtbase with 'cmake' "
                 "rather than 'qt-cmake', and then you can reconfigure your own project."
         )
@@ -154,73 +150,6 @@ if(QT_TOOLCHAIN_INCLUDE_FILE)
     endif()
 endif()
 
-# Set up QT_HOST_PATH and do sanity checks.
-# A host path is required when cross-compiling but optional when doing a native build.
-# Requiredness can be overridden via variable.
-if(DEFINED QT_REQUIRE_HOST_PATH_CHECK)
-    set(__qt_toolchain_host_path_required "${QT_REQUIRE_HOST_PATH_CHECK}")
-else()
-    set(__qt_toolchain_host_path_required "@qt_host_path_required@")
-endif()
-set(__qt_toolchain_initial_qt_host_path
-    "@qt_host_path_absolute@")
-set(__qt_toolchain_initial_qt_host_path_cmake_dir
-    "@qt_host_path_cmake_dir_absolute@")
-
-# QT_HOST_PATH precedence:
-# - cache variable / command line option
-# - environment variable
-# - initial QT_HOST_PATH when qtbase was configured (and the directory exists)
-if(NOT DEFINED QT_HOST_PATH)
-    if(DEFINED ENV{QT_HOST_PATH})
-        set(QT_HOST_PATH "$ENV{QT_HOST_PATH}" CACHE PATH "")
-    else(__qt_toolchain_initial_qt_host_path AND EXISTS "${__qt_toolchain_initial_qt_host_path}")
-        set(QT_HOST_PATH "${__qt_toolchain_initial_qt_host_path}" CACHE PATH "")
-    endif()
-endif()
-
-if(NOT QT_HOST_PATH STREQUAL "")
-    get_filename_component(__qt_toolchain_host_path_absolute "${QT_HOST_PATH}" ABSOLUTE)
-endif()
-
-if(__qt_toolchain_host_path_required AND
-      ("${QT_HOST_PATH}" STREQUAL "" OR NOT EXISTS "${__qt_toolchain_host_path_absolute}"))
-    message(FATAL_ERROR
-        "To use a cross-compiled Qt, please set the QT_HOST_PATH cache variable to the location "
-        "of your host Qt installation.")
-endif()
-
-# QT_HOST_PATH_CMAKE_DIR is needed to work around the rerooting issue when looking for host tools
-# See REROOT_PATH_ISSUE_MARKER.
-# Prefer initially configured path if none was explicitly set.
-if(__qt_toolchain_host_path_required AND NOT DEFINED QT_HOST_PATH_CMAKE_DIR)
-    if(__qt_toolchain_initial_qt_host_path_cmake_dir
-          AND EXISTS "${__qt_toolchain_initial_qt_host_path_cmake_dir}")
-        set(QT_HOST_PATH_CMAKE_DIR "${__qt_toolchain_initial_qt_host_path_cmake_dir}" CACHE PATH "")
-    else()
-        # First try to auto-compute the location instead of requiring to set QT_HOST_PATH_CMAKE_DIR
-        # explicitly.
-        set(__qt_candidate_host_path_cmake_dir "${QT_HOST_PATH}/lib/cmake")
-        if(__qt_candidate_host_path_cmake_dir AND EXISTS "${__qt_candidate_host_path_cmake_dir}")
-            set(QT_HOST_PATH_CMAKE_DIR
-                "${__qt_candidate_host_path_cmake_dir}" CACHE PATH "")
-        endif()
-    endif()
-endif()
-
-if(NOT QT_HOST_PATH_CMAKE_DIR STREQUAL "")
-    get_filename_component(__qt_toolchain_host_path_cmake_dir_absolute
-                           "${QT_HOST_PATH_CMAKE_DIR}" ABSOLUTE)
-endif()
-
-if(__qt_toolchain_host_path_required AND
-      ("${QT_HOST_PATH_CMAKE_DIR}" STREQUAL ""
-       OR NOT EXISTS "${__qt_toolchain_host_path_cmake_dir_absolute}"))
-    message(FATAL_ERROR
-        "To use a cross-compiled Qt, please set the QT_HOST_PATH_CMAKE_DIR cache variable to "
-        "the location of your host Qt installation lib/cmake directory.")
-endif()
-
 # Store initial build type (if any is specified) to be read by QtBuildInternals.cmake when building
 # a Qt repo, standalone tests or a single test.
 if(DEFINED CACHE{CMAKE_BUILD_TYPE})

coin/instructions/coin_module_build_template_v2.yaml

@@ -33,7 +33,7 @@ instructions:
         enable_if:
           condition: property
           property: target.osVersion
-          in_values: [Android_ANY, QEMU, INTEGRITY, QNX_710]
+          in_values: [Android_ANY, QEMU, IOS_ANY, QNX_710, INTEGRITY]
     enable_if:
       condition: or
       conditions:

coin/instructions/coin_module_test_template_v3.yaml

@@ -14,10 +14,7 @@ instructions:
               equals_property: target.os
             - condition: property
               property: target.osVersion
-              in_values: [QEMU, QNX_710]
-            - condition: property
-              property: target.osVersion
-              equals_value: IOS_ANY
+              in_values: [QEMU, QNX_710, IOS_ANY]
             - condition: property
               property: features
               contains_value: AndroidTestRun

coin/module_config.yaml

@@ -4,6 +4,12 @@ accept_configuration:
   property: features
   not_contains_value: Disable
 
+machine_type:
+  Build:
+    cores: 4
+  Test:
+    cores: 4
+
 instructions:
   Build:
     - !include "{{qt/qtbase}}/coin_qtbase_build_template_v2.yaml"

conanfile.py

@@ -8,7 +8,7 @@ import re
 import shutil
 from functools import lru_cache
 from pathlib import Path
-from typing import Dict
+from typing import Dict, Union
 
 
 class QtConanError(Exception):
@@ -128,13 +128,22 @@ class QtBase(ConanFile):
                 print("Setting 3rd party package requirement: {0}".format(requirement))
                 self.requires(requirement)
 
-    def _resolve_qt_host_path(self) -> str:
-        # When cross-building the user needs to pass 'qt_host_path' which is transformed to
-        # QT_HOST_PATH later on. Resolve the exact path.
-        qt_host_path = self.options.get_safe("qt_host_path")
-        if not qt_host_path:
-            raise QtConanError("Expected 'qt_host_path' option in cross-build context")
-        return str(Path(os.path.expandvars(str(qt_host_path))).expanduser().resolve(strict=True))
+    def _resolve_qt_host_path(self) -> Union[str, None]:
+        """
+        Attempt to resolve QT_HOST_PATH.
+
+        When cross-building the user needs to pass 'qt_host_path' which is transformed to
+        QT_HOST_PATH later on. Resolve the exact path if possible.
+
+        Returns:
+            string: The resolved QT_HOST_PATH or None if unable to determine it.
+        """
+        _host_p = self.options.get_safe("qt_host_path")
+        if _host_p:
+            return str(Path(os.path.expandvars(str(_host_p))).expanduser().resolve(strict=True))
+        else:
+            print("Warning: 'qt_host_path' option was not given in cross-build context")
+            return None
 
     def configure(self):
         if self.settings.compiler == "gcc" and tools.Version(self.settings.compiler.version) < "8":
@@ -249,7 +258,9 @@ class QtBase(ConanFile):
     def package_info(self):
         self._shared.package_info(self)
         if tools.cross_building(conanfile=self):
-            self.env_info.QT_HOST_PATH.append(self._resolve_qt_host_path())
+            qt_host_path = self._resolve_qt_host_path()
+            if qt_host_path:
+                self.env_info.QT_HOST_PATH.append(qt_host_path)
 
     def package_id(self):
         # https://docs.conan.io/en/latest/creating_packages/define_abi_compatibility.html

config.tests/direct_extern_access/CMakeLists.txt

@@ -1,9 +0,0 @@
-cmake_minimum_required(VERSION 3.16)
-project(direct_extern_access LANGUAGES CXX)
-
-# this is the test found in https://sourceware.org/bugzilla/show_bug.cgi?id=29087
-
-add_library(no_extern_access_lib SHARED lib.cpp)
-add_executable(no_extern_access_main main.cpp)
-target_compile_options(no_extern_access_lib PUBLIC "-mno-direct-extern-access")
-target_link_libraries(no_extern_access_main no_extern_access_lib)

config.tests/no_direct_extern_access/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.16)
+project(direct_extern_access LANGUAGES CXX)
+
+# this is the test found in https://sourceware.org/bugzilla/show_bug.cgi?id=29087
+# and https://sourceware.org/bugzilla/show_bug.cgi?id=29377
+
+add_library(no_extern_access_lib SHARED lib.cpp)
+add_executable(no_extern_access_main other.cpp main.cpp)
+
+target_compile_options(no_extern_access_lib PRIVATE "-Werror")
+target_compile_options(no_extern_access_lib PUBLIC "$<$<CXX_COMPILER_ID:GNU>:-mno-direct-extern-access>")
+target_compile_options(no_extern_access_lib PUBLIC "$<$<CXX_COMPILER_ID:Clang>:-fno-direct-access-external-data>")
+
+target_link_libraries(no_extern_access_main no_extern_access_lib)

config.tests/no_direct_extern_access/lib.cpp

@@ -6,5 +6,6 @@
 #define BUILD
 #include "lib.h"
 
+void *S::ptr = nullptr;
 S::~S() { }
-void S::f() { }
+void *S::f() { return ptr; }

config.tests/no_direct_extern_access/lib.h

@@ -12,5 +12,6 @@
 struct LIB_API S
 {
     virtual ~S();
-    virtual void f();
+    virtual void *f();
+    static void *ptr;
 };

config.tests/no_direct_extern_access/main.cpp

@@ -0,0 +1,20 @@
+// Copyright (C) 2022 Intel Corporation.
+// SPDX-License-Identifier: MIT
+
+// This is combining the tests found in:
+// https://sourceware.org/bugzilla/show_bug.cgi?id=29087
+// https://sourceware.org/bugzilla/show_bug.cgi?id=29377
+
+#include "lib.h"
+
+extern void foo(); // other.cpp
+void (*get_foo())()
+{
+    return foo;
+}
+
+struct Local : S { };
+int main()
+{
+    Local l;
+}

config.tests/no_direct_extern_access/other.cpp

@@ -1,12 +1,8 @@
 // Copyright (C) 2022 Intel Corporation.
 // SPDX-License-Identifier: MIT
 
-// This is the test found in https://sourceware.org/bugzilla/show_bug.cgi?id=29087
+// This is the test found in https://sourceware.org/bugzilla/show_bug.cgi?id=29377
 
-#include "lib.h"
-
-struct Local : S { };
-int main()
+__attribute__((visibility("protected"))) void foo()
 {
-    Local l;
 }

configure.cmake

@@ -54,7 +54,7 @@ qt_feature("use_bfd_linker"
     PRIVATE
     LABEL "bfd"
     AUTODETECT false
-    CONDITION NOT WIN32 AND NOT INTEGRITY AND NOT WASM AND TEST_use_bfd_linker
+    CONDITION NOT MSVC AND NOT INTEGRITY AND NOT WASM AND TEST_use_bfd_linker
     ENABLE INPUT_linker STREQUAL 'bfd'
     DISABLE INPUT_linker STREQUAL 'gold' OR INPUT_linker STREQUAL 'lld'
             OR INPUT_linker STREQUAL 'mold'
@@ -80,7 +80,7 @@ qt_feature("use_lld_linker"
     PRIVATE
     LABEL "lld"
     AUTODETECT false
-    CONDITION NOT WIN32 AND NOT INTEGRITY AND NOT WASM AND TEST_use_lld_linker
+    CONDITION NOT MSVC AND NOT INTEGRITY AND NOT WASM AND TEST_use_lld_linker
     ENABLE INPUT_linker STREQUAL 'lld'
     DISABLE INPUT_linker STREQUAL 'bfd' OR INPUT_linker STREQUAL 'gold'
             OR INPUT_linker STREQUAL 'mold'
@@ -188,9 +188,9 @@ qt_config_compiler_supports_flag_test(optimize_debug
     FLAG "-Og"
 )
 
-qt_config_compile_test(no_extern_direct_access
-    LABEL "-mno-direct-extern-access support"
-    PROJECT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/direct_extern_access"
+qt_config_compile_test(no_direct_extern_access
+    LABEL "-mno-direct-extern-access / -fno-direct-access-external-data support"
+    PROJECT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/no_direct_extern_access"
 )
 
 qt_config_linker_supports_flag_test(enable_new_dtags
@@ -701,12 +701,13 @@ qt_feature("reduce_exports" PRIVATE
 )
 qt_feature_definition("reduce_exports" "QT_VISIBILITY_AVAILABLE")
 qt_feature_config("reduce_exports" QMAKE_PUBLIC_QT_CONFIG)
-qt_feature("no_extern_direct_access" PRIVATE
+qt_feature("no_direct_extern_access" PRIVATE
     LABEL "Use protected visibility and -mno-direct-extern-access"
-    CONDITION NOT WIN32 AND TEST_no_extern_direct_access
+    CONDITION NOT WIN32 AND TEST_no_direct_extern_access
+    AUTODETECT OFF
 )
-qt_feature_definition("no_extern_direct_access" "QT_USE_PROTECTED_VISIBILITY")
-qt_feature_config("no_extern_direct_access" QMAKE_PUBLIC_QT_CONFIG)
+qt_feature_definition("no_direct_extern_access" "QT_USE_PROTECTED_VISIBILITY")
+qt_feature_config("no_direct_extern_access" QMAKE_PUBLIC_QT_CONFIG)
 qt_feature("reduce_relocations" PUBLIC
     LABEL "Reduce amount of relocations"
     CONDITION NOT WIN32 AND TEST_reduce_relocations
@@ -911,7 +912,7 @@ qt_feature("system-zlib" PRIVATE
     LABEL "Using system zlib"
     CONDITION WrapSystemZLIB_FOUND
 )
-qt_feature("zstd" PRIVATE
+qt_feature("zstd" PUBLIC
     LABEL "Zstandard support"
     CONDITION WrapZSTD_FOUND
 )
@@ -989,7 +990,6 @@ qt_feature("printsupport" PRIVATE
 )
 qt_feature("sql" PRIVATE
     LABEL "Qt Sql"
-    CONDITION QT_FEATURE_thread AND NOT WASM
 )
 qt_feature("testlib" PRIVATE
     LABEL "Qt Testlib"
@@ -1167,7 +1167,7 @@ qt_configure_add_report_entry(
 # special case begin
 # qt_configure_add_report_entry(
 #     TYPE ERROR
-#     MESSAGE "Debug build wihtout Release build is not currently supported on ios see QTBUG-71990. Use -debug-and-release."
+#     MESSAGE "Debug build without Release build is not currently supported on ios see QTBUG-71990. Use -debug-and-release."
 #     CONDITION IOS AND QT_FEATURE_debug AND NOT QT_FEATURE_debug_and_release
 # )
 # special case end

doc/config/exampleurl-qtquickcontrols2.qdocconf

@@ -1 +1 @@
-url.examples = "https://code.qt.io/cgit/qt/qtquickcontrols2.git/tree/examples/\1?h=$QT_VER"
+url.examples = "https://code.qt.io/cgit/qt/qtdeclarative.git/tree/examples/\1?h=$QT_VER"

doc/global/config.qdocconf

@@ -3,7 +3,7 @@
 dita.metadata.default.author      = Qt Project
 dita.metadata.default.permissions = all
 dita.metadata.default.publisher   = Qt Project
-dita.metadata.default.copyryear = 2022
+dita.metadata.default.copyryear = 2023
 dita.metadata.default.copyrholder = The Qt Company Ltd
 dita.metadata.default.audience = programmer
 
@@ -23,6 +23,7 @@ ignorewords += \
 ignoresince = 5.0
 
 sourcedirs += includes $$BUILDDIR
+exampledirs += snippets
 
 url = https://doc.qt.io/qt
 

doc/global/externalsites/external-resources.qdoc

@@ -563,6 +563,6 @@
 */
 
 /*!
-    \externalpage https://www.froglogic.com/testcenter/
-    \title Squish Test Center
+    \externalpage https://www.qt.io/product/quality-assurance/test-center
+    \title Test Center
 */

doc/global/html-footer-online.qdocconf

@@ -78,7 +78,7 @@ HTML.footer += \
     "    <ul id=\"menu-footer-submenu\" class=\"right clearfix\"><li id=\"menu-item-1795\" class=\"menu-item menu-item-type-custom menu-item-object-custom menu-item-1795\"><a title=\"Sign into your account.\" href=\"https://account.qt.io/login\">Sign In</a></li>\n" \
     "      <li id=\"menu-item-10375\" class=\"menu-item menu-item-type-custom menu-item-object-custom menu-item-10375\"><a href=\"mailto:feedback@theqtcompany.com?Subject=Feedback%20about%20doc.qt.io%20site\">Feedback</a></li>\n" \
     "      <li id=\"menu-item-1494\" class=\"menu-item menu-item-type-post_type menu-item-object-page menu-item-1494\"><a href=\"http://qt.io/contact-us/\">Contact us</a></li>\n" \
-    "      <li id=\"menu-item-4472\" class=\"menu-item menu-item-type-custom menu-item-object-custom menu-item-4472\"><a href=\"http://qt.io/about-us/\">© 2022 The Qt Company</a></li>\n" \
+    "      <li id=\"menu-item-4472\" class=\"menu-item menu-item-type-custom menu-item-object-custom menu-item-4472\"><a href=\"http://qt.io/about-us/\">© 2023 The Qt Company</a></li>\n" \
     "    </ul>\n" \
     "</div>\n" \
     "</div>\n" \

doc/global/html-footer.qdocconf

@@ -8,7 +8,7 @@ HTML.footer = \
     "</div>\n" \
     "<div class=\"footer\">\n" \
     "   <p>\n" \
-    "   <acronym title=\"Copyright\">&copy;</acronym> 2022 The Qt Company Ltd.\n" \
+    "   <acronym title=\"Copyright\">&copy;</acronym> 2023 The Qt Company Ltd.\n" \
     "   Documentation contributions included herein are the copyrights of\n" \
     "   their respective owners.<br/>" \
     "   The documentation provided herein is licensed under the terms of the" \

doc/global/includes/corelib/port-from-qregexp.qdocinc

@@ -0,0 +1,175 @@
+// Copyright (C) 2022 Giuseppe D'Angelo <dangelog@gmail.com>.
+// Copyright (C) 2022 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
+
+//! [porting-to-qregularexpression]
+
+    The QRegularExpression class introduced in Qt 5 implements Perl-compatible
+    regular expressions and is a big improvement upon QRegExp in terms of APIs
+    offered, supported pattern syntax, and speed of execution. The biggest
+    difference is that QRegularExpression simply holds a regular expression,
+    and it's \e{not} modified when a match is requested. Instead, a
+    QRegularExpressionMatch object is returned, to check the result of a match
+    and extract the captured substring. The same applies to global matching and
+    QRegularExpressionMatchIterator.
+
+    Other differences are outlined below.
+
+    \note QRegularExpression does not support all the features available in
+    Perl-compatible regular expressions. The most notable one is the fact that
+    duplicated names for capturing groups are not supported, and using them can
+    lead to undefined behavior. This may change in a future version of Qt.
+
+    \section3 Different pattern syntax
+
+    Porting a regular expression from QRegExp to QRegularExpression may require
+    changes to the pattern itself.
+
+    In specific scenarios, QRegExp was too lenient and accepted patterns that
+    are simply invalid when using QRegularExpression. These are easy to detect,
+    because the QRegularExpression objects built with these patterns are not
+    valid (see QRegularExpression::isValid()).
+
+    In other cases, a pattern ported from QRegExp to QRegularExpression may
+    silently change semantics. Therefore, it is necessary to review the
+    patterns used. The most notable cases of silent incompatibility are:
+
+    \list
+
+    \li Curly braces are needed to use a hexadecimal escape like \c{\xHHHH}
+        with more than 2 digits. A pattern like \c{\x2022} needs to be ported
+        to \c{\x{2022}}, or it will match a space (\c{0x20}) followed by the
+        string \c{"22"}. In general, it is highly recommended to always use
+        curly braces with the \c{\x} escape, no matter the number of digits
+        specified.
+
+    \li A 0-to-n quantification like \c{{,n}} needs to be ported to \c{{0,n}}
+        to preserve semantics. Otherwise, a pattern such as \c{\d{,3}} would
+        match a digit followed by the exact string \c{"{,3}"}.
+
+    \li QRegExp by default does Unicode-aware matching, while
+        QRegularExpression requires a separate option; see below for more
+        details.
+
+    \li c{.} in QRegExp does by default match all characters, including the
+        newline character. QRegularExpression excludes the newline character
+        by default. To include the newline character, set the
+        QRegularExpression::DotMatchesEverythingOption pattern option.
+
+    \endlist
+
+    For an overview of the regular expression syntax supported by
+    QRegularExpression, please refer to the
+    \l{https://pcre.org/original/doc/html/pcrepattern.html}{pcrepattern(3)}
+    man page, describing the pattern syntax supported by PCRE (the reference
+    implementation of Perl-compatible regular expressions).
+
+    \section3 Porting from QRegExp::exactMatch()
+
+    QRegExp::exactMatch() served two purposes: it exactly matched a regular
+    expression against a subject string, and it implemented partial matching.
+
+    \section4 Porting from QRegExp's Exact Matching
+
+    Exact matching indicates whether the regular expression matches the entire
+    subject string. For example, the classes yield on the subject string \c{"abc123"}:
+
+    \table
+    \header \li                  \li QRegExp::exactMatch() \li QRegularExpressionMatch::hasMatch()
+    \row    \li \c{"\\d+"}       \li \b false              \li \b true
+    \row    \li \c{"[a-z]+\\d+"} \li \b true               \li \b true
+    \endtable
+
+    Exact matching is not reflected in QRegularExpression. If you want
+    to be sure that the subject string matches the regular expression
+    exactly, you can wrap the pattern using the QRegularExpression::anchoredPattern()
+    function:
+
+    \snippet code/doc_src_port_from_qregexp.cpp 0
+
+    \section4 Porting from QRegExp's Partial Matching
+
+    When using QRegExp::exactMatch(), if an exact match was not found, one
+    could still find out how much of the subject string was matched by the
+    regular expression by calling QRegExp::matchedLength(). If the returned length
+    was equal to the subject string's length, then one could conclude that a partial
+    match was found.
+
+    QRegularExpression supports partial matching explicitly by means of the
+    appropriate QRegularExpression::MatchType.
+
+    \section3 Global matching
+
+    Due to limitations of the QRegExp API, it was impossible to implement global
+    matching correctly (that is, like Perl does). In particular, patterns that
+    can match 0 characters (like \c{"a*"}) are problematic.
+
+    QRegularExpression::globalMatch() implements Perl global match correctly, and
+    the returned iterator can be used to examine each result.
+
+    For example, if you have code like:
+
+    \snippet code/doc_src_port_from_qregexp.cpp 1
+
+    You can rewrite it as:
+
+    \snippet code/doc_src_port_from_qregexp.cpp 2
+
+    \section3 Unicode properties support
+
+    When using QRegExp, character classes such as \c{\w}, \c{\d}, etc. match
+    characters with the corresponding Unicode property: for instance, \c{\d}
+    matches any character with the Unicode \c{Nd} (decimal digit) property.
+
+    Those character classes only match ASCII characters by default when using
+    QRegularExpression: for instance, \c{\d} matches exactly a character in the
+    \c{0-9} ASCII range. It is possible to change this behavior by using the
+    QRegularExpression::UseUnicodePropertiesOption pattern option.
+
+    \section3 Wildcard matching
+
+    There is no direct way to do wildcard matching in QRegularExpression.
+    However, the QRegularExpression::wildcardToRegularExpression() method
+    is provided to translate glob patterns into a Perl-compatible regular
+    expression that can be used for that purpose.
+
+    For example, if you have code like:
+
+    \snippet code/doc_src_port_from_qregexp.cpp 3
+
+    You can rewrite it as:
+
+    \snippet code/doc_src_port_from_qregexp.cpp 4
+
+    Please note though that some shell-like wildcard patterns might not be
+    translated to what you expect. The following example code will silently
+    break if simply converted using the above-mentioned function:
+
+    \snippet code/doc_src_port_from_qregexp.cpp 5
+
+    This is because, by default, the regular expression returned by
+    QRegularExpression::wildcardToRegularExpression() is fully anchored.
+    To get a regular expression that is not anchored, pass
+    QRegularExpression::UnanchoredWildcardConversion as the conversion
+    options:
+
+    \snippet code/doc_src_port_from_qregexp.cpp 6
+
+    \section3 Minimal matching
+
+    QRegExp::setMinimal() implemented minimal matching by simply reversing the
+    greediness of the quantifiers (QRegExp did not support lazy quantifiers,
+    like \c{*?}, \c{+?}, etc.). QRegularExpression instead does support greedy,
+    lazy, and possessive quantifiers. The QRegularExpression::InvertedGreedinessOption
+    pattern option can be useful to emulate the effects of QRegExp::setMinimal():
+    if enabled, it inverts the greediness of quantifiers (greedy ones become
+    lazy and vice versa).
+
+    \section3 Caret modes
+
+    The QRegularExpression::AnchorAtOffsetMatchOption match option can be used to
+    emulate the QRegExp::CaretAtOffset behavior. There is no equivalent for the
+    other QRegExp::CaretMode modes.
+
+//! [porting-to-qregularexpression]

doc/global/includes/module-use.qdocinc

@@ -18,9 +18,10 @@
 //! [using qt module]
 
 //! [using the c++ api]
-    Using a Qt module requires linking against the module library, either
-    directly or through other dependencies. Several build tools have dedicated
-    support for this, including \l{CMake Documentation}{CMake} and \l{qmake}.
+    Using a Qt module's C++ API requires linking against the module library,
+    either directly or through other dependencies. Several build tools have
+    dedicated support for this, including \l{CMake Documentation}{CMake} and
+    \l{qmake}.
 //! [using the c++ api]
 
 //! [using the qml api]

doc/global/macros.qdocconf

@@ -85,3 +85,6 @@ macro.cmakevariableandroidonly = "\\note This variable is used only if targeting
 macro.versionlessCMakeCommandsNote = "If \\l{Versionless commands}{versionless commands} are disabled, use \\c{\1} instead. It supports the same set of arguments as this command."
 
 macro.cmakepropertywebassemblyonly = "\\note This property is used only if targeting the WebAssembly platform."
+
+macro.cmakepropertyiosonly = "\\note This property is used only if targeting iOS."
+macro.cmakevariableiosonly = "\\note This variable is used only if targeting iOS."

doc/global/manifest-meta.qdocconf

@@ -71,7 +71,24 @@ manifestmeta.android.names          =   "Qt3D/Qt 3D: Basic Shapes C++ Example" \
                                         "QtQML/Extending QML - Signal Support Example" \
                                         "QtQML/Qt Quick Examples - XMLHttpRequest" \
                                         "QtQml/Qt Quick Examples - XMLHttpRequest" \
-                                        "QtQuick/*" \
+                                        "QtQuick/C++ Extensions*" \
+                                        "QtQuick/Models and Views*" \
+                                        "QtQuick/QQuickRenderControl OpenGL Example" \
+                                        "QtQuick/QQuickWidget - QQuickView Comparison Example" \
+                                        "QtQuick/QML*" \
+                                        "QtQuick/Qt Quick*" \
+                                        "QtQuick/Scene Graph - Custom Geometry" \
+                                        "QtQuick/Scene Graph - Custom Material" \
+                                        "QtQuick/Scene Graph - Graph" \
+                                        "QtQuick/Scene Graph - OpenGL Under QML" \
+                                        "QtQuick/Scene Graph - Painted Item" \
+                                        "QtQuick/Scene Graph - Rendering FBOs" \
+                                        "QtQuick/Scene Graph - Two Texture Providers" \
+                                        "QtQuick/Scene Graph - Vulkan Under QML" \
+                                        "QtQuick/Scene Graph - Vulkan Texture Import" \
+                                        "QtQuick/Threaded ListModel Example" \
+                                        "QtQuick/TabWidget Example" \
+                                        "QtQuick/UI Components*" \
                                         "QtQuickControls/*" \
                                         "QtQuickControls1/Qt Quick Controls 1 - Calendar Example" \
                                         "QtQuickControls1/Qt Quick Controls 1 - Gallery" \
@@ -216,6 +233,8 @@ manifestmeta.ios.names              =  "QtCore/Contiguous Cache Example" \
                                        "QtQuick/Qt Quick Examples - MouseArea" \
                                        "QtQuick/Qt Quick Examples - Positioners" \
                                        "QtQuick/Qt Quick Examples - Right to Left" \
+                                       "QtQuick/Scene Graph - Metal Texture Import" \
+                                       "QtQuick/Scene Graph - Metal Under QML" \
                                        "QtQuick/Scene Graph - OpenGL Under QML" \
                                        "QtQuick/Qt Quick Examples - Shader Effects" \
                                        "QtQuick/Qt Quick Examples - Text" \

doc/global/qt-cpp-defines.qdocconf

@@ -1,222 +1,8 @@
 versionsym              = QT_VERSION_STR
 
-defines                += Q_QDOC \
-                          Q_CLANG_QDOC \
-                          QT_.*_SUPPORT \
-                          QT_.*_LIB \
-                          QT_COMPAT \
-                          QT_KEYPAD_NAVIGATION \
-                          QT_NO_EGL \
-                          Q_BYTE_ORDER \
-                          QT_DEPRECATED \
-                          QT_DEPRECATED_* \
-                          Q_NO_USING_KEYWORD \
-                          Q_OS_.* \
-                          Q_COMPILER_INITIALIZER_LISTS \
-                          Q_COMPILER_UNIFORM_INIT \
-                          Q_COMPILER_RVALUE_REFS
-
-clangdefines            += Q_QDOC \
-                           Q_CLANG_QDOC \
-                           QT_COMPAT \
-                           QT_BUILD_CORE_LIB \
-                           QT_BUILD_EGL_DEVICE_LIB \
-                           QT_BUILD_LOCATION_LIB \
-                           QT_BUILD_SCRIPT_LIB \
-                           QT_BUILD_TESTLIB_LIB \
-                           QT_BUILD_WIDGETS_LIB \
-                           QT_CORE_LIB \
-                           QT_DEPRECATED \
-                           QT_GUI_LIB \
-                           QT_KEYPAD_NAVIGATION \
-                           QT_LARGEFILE_SUPPORT \
-                           QT_NETWORK_LIB \
-                           QT_NO_EGL \
-                           QT_OPENGL_SUPPORT \
-                           QT_SCRIPT_LIB \
-                           QT_SHARED_POINTER_BACKTRACE_SUPPORT \
-                           QT_WIDGETS_LIB \
-                           Q_BYTE_ORDER \
-                           Q_CC_CLANG \
-                           Q_COMPILER_CONSTEXPR \
-                           Q_COMPILER_DEFAULT_MEMBERS \
-                           Q_COMPILER_DELETE_MEMBERS \
-                           Q_COMPILER_EXPLICIT_OVERRIDES \
-                           Q_COMPILER_INITIALIZER_LISTS \
-                           Q_COMPILER_MANGLES_RETURN_TYPE \
-                           Q_COMPILER_NOEXCEPT \
-                           Q_COMPILER_NULLPTR \
-                           Q_COMPILER_RVALUE_REFS \
-                           Q_COMPILER_STATIC_ASSERT \
-                           Q_COMPILER_UNIFORM_INIT \
-                           Q_COMPILER_VARIADIC_MACROS \
-                           Q_COMPILER_VARIADIC_TEMPLATES \
-                           Q_ATOMIC_INT16_IS_SUPPORTED \
-                           Q_ATOMIC_INT64_IS_SUPPORTED \
-                           Q_ATOMIC_INT8_IS_SUPPORTED
-
-# Q_COMPILER_REF_QUALIFIERS is not yet supported by all compilers
-
-Cpp.ignoretokens        += \
-                          ENGINIOCLIENT_EXPORT \
-                          PHONON_EXPORT \
-                          Q_ALWAYS_INLINE \
-                          Q_AUTOTEST_EXPORT \
-                          Q_BLUETOOTH_EXPORT \
-                          Q_COMPAT_EXPORT \
-                          Q_CORE_EXPORT \
-                          Q_CORE_EXPORT_INLINE \
-                          Q_DBUS_EXPORT \
-                          Q_DECL_CONSTEXPR \
-                          Q_DECL_RELAXED_CONSTEXPR \
-                          Q_DECL_CONST_FUNCTION \
-                          Q_DECL_DEPRECATED \
-                          Q_DECL_NOEXCEPT \
-                          Q_DECL_FINAL \
-                          Q_DECL_OVERRIDE \
-                          Q_DECL_NOTHROW \
-                          Q_DECL_PURE_FUNCTION \
-                          Q_DECL_UNUSED \
-                          Q_DECL_CF_RETURNS_RETAINED \
-                          Q_DECL_NS_RETURNS_AUTORELEASED \
-                          Q_DECL_EQ_DEFAULT \
-                          Q_DECLARATIVE_EXPORT \
-                          Q_EXPLICIT \
-                          Q_EXPORT \
-                          Q_EXPORT_PLUGIN \
-                          Q_EXPORT_PLUGIN2 \
-                          Q_GADGET \
-                          Q_GADGET_EXPORT \
-                          Q_GFX_INLINE \
-                          Q_GUI_EXPORT \
-                          Q_GUI_EXPORT_INLINE \
-                          Q_GUI_EXPORT_STYLE_CDE \
-                          Q_GUI_EXPORT_STYLE_COMPACT \
-                          Q_GUI_EXPORT_STYLE_MAC \
-                          Q_GUI_EXPORT_STYLE_MOTIF \
-                          Q_GUI_EXPORT_STYLE_MOTIFPLUS \
-                          Q_GUI_EXPORT_STYLE_PLATINUM \
-                          Q_GUI_EXPORT_STYLE_POCKETPC \
-                          Q_GUI_EXPORT_STYLE_SGI \
-                          Q_GUI_EXPORT_STYLE_WINDOWS \
-                          Q_INLINE_TEMPLATE \
-                          Q_INTERNAL_WIN_NO_THROW \
-                          Q_INVOKABLE \
-                          Q_LOCATION_EXPORT \
-                          Q_POSITIONING_EXPORT \
-                          Q_MULTIMEDIA_EXPORT \
-                          Q_NAMESPACE \
-                          Q_NAMESPACE_EXPORT \
-                          Q_NETWORK_EXPORT \
-                          Q_NEVER_INLINE \
-                          Q_NORETURN \
-                          Q_OPENGL_EXPORT \
-                          Q_OPENVG_EXPORT \
-                          Q_OUTOFLINE_TEMPLATE \
-                          Q_PRINTSUPPORT_EXPORT \
-                          Q_QML_EXPORT \
-                          Q_REQUIRED_RESULT \
-                          Q_SCRIPT_EXPORT \
-                          Q_SCRIPTTOOLS_EXPORT \
-                          Q_SERIALBUS_EXPORT \
-                          Q_SQL_EXPORT \
-                          Q_SVG_EXPORT \
-                          Q_TESTLIB_EXPORT \
-                          Q_TYPENAME \
-                          Q_WEAK_OVERLOAD \
-                          Q_WIDGETS_EXPORT \
-                          Q_WINEXTRAS_EXPORT \
-                          Q_XML_EXPORT \
-                          Q_XMLPATTERNS_EXPORT \
-                          Q_XMLSTREAM_EXPORT \
-                          QAXFACTORY_EXPORT \
-                          QDBUS_EXPORT \
-                          QDESIGNER_COMPONENTS_LIBRARY \
-                          QDESIGNER_EXTENSION_LIBRARY \
-                          QDESIGNER_SDK_LIBRARY \
-                          QDESIGNER_SHARED_LIBRARY \
-                          QDESIGNER_UILIB_LIBRARY \
-                          QHELP_EXPORT \
-                          QM_AUTOTEST_EXPORT \
-                          QM_EXPORT_CANVAS \
-                          QM_EXPORT_DNS \
-                          QM_EXPORT_DOM \
-                          QM_EXPORT_FTP \
-                          QM_EXPORT_HTTP \
-                          QM_EXPORT_ICONVIEW \
-                          QM_EXPORT_NETWORK \
-                          QM_EXPORT_OPENGL \
-                          QM_EXPORT_OPENVG \
-                          QM_EXPORT_SQL \
-                          QM_EXPORT_TABLE \
-                          QM_EXPORT_WORKSPACE \
-                          QM_EXPORT_XML \
-                          QT_ASCII_CAST_WARN \
-                          QT_ASCII_CAST_WARN_CONSTRUCTOR \
-                          QT_BEGIN_INCLUDE_NAMESPACE \
-                          QT_BEGIN_NAMESPACE \
-                          QT_BOOTSTRAPPED \
-                          QT_DESIGNER_STATIC \
-                          QT_END_INCLUDE_NAMESPACE \
-                          QT_END_NAMESPACE \
-                          QT_FASTCALL \
-                          QT_MUTEX_LOCK_NOEXCEPT \
-                          QT_POPCOUNT_CONSTEXPR \
-                          QT_POST_CXX17_API_IN_EXPORTED_CLASS \
-                          QT_SIZEPOLICY_CONSTEXPR \
-                          QT_WARNING_DISABLE_DEPRECATED \
-                          QT_WARNING_PUSH \
-                          QT_WARNING_POP \
-                          QT_WIDGET_PLUGIN_EXPORT \
-                          QWEBKIT_EXPORT
-
-Cpp.ignoredirectives    += \
-                          __attribute__ \
-                          K_DECLARE_PRIVATE \
-                          PHONON_HEIR \
-                          PHONON_OBJECT \
-                          Q_CLASSINFO \
-                          Q_DECLARE_INTERFACE \
-                          Q_DECLARE_METATYPE \
-                          QT_DECL_METATYPE_EXTERN \
-                          QT_IMPL_METATYPE_EXTERN \
-                          Q_DECLARE_OPERATORS_FOR_FLAGS \
-                          Q_DECLARE_PRIVATE \
-                          Q_DECLARE_PRIVATE_D \
-                          Q_DECLARE_PUBLIC \
-                          Q_DECLARE_SHARED \
-                          Q_DECLARE_TR_FUNCTIONS \
-                          Q_DECLARE_TYPEINFO \
-                          Q_DECL_NOEXCEPT_EXPR \
-                          QT_DEPRECATED_X \
-                          QT_SYSINFO_DEPRECATED_X \
-                          Q_DISABLE_COPY \
-                          Q_DUMMY_COMPARISON_OPERATOR \
-                          Q_ENUM \
-                          Q_ENUMS \
-                          Q_ENUM_NS \
-                          Q_FLAG \
-                          Q_FLAGS \
-                          Q_FLAG_NS \
-                          QT_HAS_INCLUDE \
-                          Q_INTERFACES \
-                          Q_PRIVATE_PROPERTY \
-                          QT_FORWARD_DECLARE_CLASS \
-                          Q_DECLARE_HANDLE \
-                          Q_REVISION \
-                          QT_WARNING_DISABLE_CLANG \
-                          QT_WARNING_DISABLE_GCC \
-                          QT_WARNING_DISABLE_INTEL \
-                          QT_WARNING_DISABLE_MSVC \
-                          Q_ATTRIBUTE_FORMAT_PRINTF \
-                          Q_MV_IOS                  \
-                          QT6_ONLY                  \
-                          QT7_ONLY
-
-# Qt 6: Remove
-falsehoods              += \
-                          "QT_VERSION >= QT_VERSION_CHECK\\(\\s*6\\s*,\\s*0\\s*,\\s*0\\s*\\)"
-
+defines                += QT_GUI_LIB \
+                          QT_WIDGETS_LIB \
+                          QT_KEYPAD_NAVIGATION
 
 excludefiles += \
                 "*_posix.cpp" \

doc/global/qt-html-templates-offline-simple.qdocconf

@@ -23,7 +23,7 @@ HTML.navigationseparator = \
     "<span class=\"naviSeparator\">  &#9702;  </span>\n"
 
 # Add some padding around code snippets, as we cannot
-# currectly style them for QTextBrowser using only CSS.
+# correctly style them for QTextBrowser using only CSS.
 codeindent         = 1
 codeprefix         = "\n"
 codesuffix         = "\n"