Revert "CMake: Make generated pkgconfig files relocatable"

This reverts commit 5b6527c35a5d86fbaac02ed1881134a921e38323.

Reason for revert: ${pcfiledir} cannot be used, because this
leads to wrong prefix values if PKG_CONFIG_SYSROOT_DIR is set.

Change-Id: Ie22607b2c4195dc197f1058d6b0fc1407427e7ac
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

.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.11.0")
+set(QT_REPO_MODULE_VERSION "6.9.1")
 set(QT_REPO_MODULE_PRERELEASE_VERSION_SEGMENT "alpha1")
 
 set(QT_COPYRIGHT "Copyright (C) The Qt Company Ltd. and other contributors.")
@@ -51,13 +51,13 @@ set(QT_MAX_NEW_POLICY_CMAKE_VERSION_QT_APPLE "3.21")
 set(QT_SUPPORTED_MIN_MACOS_SDK_VERSION "14")
 set(QT_SUPPORTED_MAX_MACOS_SDK_VERSION "15")
 set(QT_SUPPORTED_MIN_MACOS_XCODE_VERSION "15")
-set(QT_SUPPORTED_MIN_MACOS_VERSION "13")
+set(QT_SUPPORTED_MIN_MACOS_VERSION "12")
 set(QT_SUPPORTED_MAX_MACOS_VERSION_TESTED "15")
 
 set(QT_SUPPORTED_MIN_IOS_SDK_VERSION "17")
 set(QT_SUPPORTED_MAX_IOS_SDK_VERSION "18")
 set(QT_SUPPORTED_MIN_IOS_XCODE_VERSION "15")
-set(QT_SUPPORTED_MIN_IOS_VERSION "17")
+set(QT_SUPPORTED_MIN_IOS_VERSION "16")
 set(QT_SUPPORTED_MAX_IOS_VERSION_TESTED "18")
 
 set(QT_SUPPORTED_MIN_VISIONOS_SDK_VERSION "1")

.lgtm.yml

@@ -0,0 +1,33 @@
+extraction:
+  cpp:
+    prepare:
+      packages:
+        - libgl-dev
+        - libglu-dev
+        - libpcre2-dev
+        - libz-dev
+        - libfreetype6-dev
+        - libpng-dev
+        - libjpeg-dev
+        - libsqlite3-dev
+    after_prepare:
+      - mkdir $HOME/cmake-3.17 \
+          \ && wget -qO- "https://cmake.org/files/v3.17/cmake-3.17.3-Linux-x86_64.tar.gz" \
+            \ | tar -xzf - --strip-components=1 -C $HOME/cmake-3.17
+      - export PATH=$HOME/cmake-3.17/bin:$PATH
+
+    # Pre-analysis step.
+    configure:
+      command:
+        - "./configure -cmake -opensource -confirm-license -debug -no-pch \
+          \ -nomake tests -nomake examples -no-harfbuzz \
+          \ -system-pcre -system-zlib -system-freetype -system-libpng \
+          \ -system-libjpeg -system-sqlite"
+        # We skip analyzing the bootstrap library, since the same code is
+        # built with non-standard flags and false-positives are flagged.
+        - ninja bootstrap_tools
+
+    # Actual analysis.
+    index:
+      build_command:
+        - ninja

LICENSES/LGPL-2.1-or-later.txt

@@ -1,468 +0,0 @@
-GNU LESSER GENERAL PUBLIC LICENSE
-
-Version 2.1, February 1999
-
-Copyright (C) 1991, 1999 Free Software Foundation, Inc.
-
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-Everyone is permitted to copy and distribute verbatim copies of this license
-document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL. It also counts as the
-successor of the GNU Library Public License, version 2, hence the version
-number 2.1.]
-
-Preamble
-
-The licenses for most software are designed to take away your freedom to share
-and change it. By contrast, the GNU General Public Licenses are intended to
-guarantee your freedom to share and change free software--to make sure the
-software is free for all its users.
-
-This license, the Lesser General Public License, applies to some specially
-designated software packages--typically libraries--of the Free Software Foundation
-and other authors who decide to use it. You can use it too, but we suggest
-you first think carefully about whether this license or the ordinary General
-Public License is the better strategy to use in any particular case, based
-on the explanations below.
-
-When we speak of free software, we are referring to freedom of use, not price.
-Our General Public Licenses are designed to make sure that you have the freedom
-to distribute copies of free software (and charge for this service if you
-wish); that you receive source code or can get it if you want it; that you
-can change the software and use pieces of it in new free programs; and that
-you are informed that you can do these things.
-
-To protect your rights, we need to make restrictions that forbid distributors
-to deny you these rights or to ask you to surrender these rights. These restrictions
-translate to certain responsibilities for you if you distribute copies of
-the library or if you modify it.
-
-For example, if you distribute copies of the library, whether gratis or for
-a fee, you must give the recipients all the rights that we gave you. You must
-make sure that they, too, receive or can get the source code. If you link
-other code with the library, you must provide complete object files to the
-recipients, so that they can relink them with the library after making changes
-to the library and recompiling it. And you must show them these terms so they
-know their rights.
-
-We protect your rights with a two-step method: (1) we copyright the library,
-and (2) we offer you this license, which gives you legal permission to copy,
-distribute and/or modify the library.
-
-To protect each distributor, we want to make it very clear that there is no
-warranty for the free library. Also, if the library is modified by someone
-else and passed on, the recipients should know that what they have is not
-the original version, so that the original author's reputation will not be
-affected by problems that might be introduced by others.
-
-Finally, software patents pose a constant threat to the existence of any free
-program. We wish to make sure that a company cannot effectively restrict the
-users of a free program by obtaining a restrictive license from a patent holder.
-Therefore, we insist that any patent license obtained for a version of the
-library must be consistent with the full freedom of use specified in this
-license.
-
-Most GNU software, including some libraries, is covered by the ordinary GNU
-General Public License. This license, the GNU Lesser General Public License,
-applies to certain designated libraries, and is quite different from the ordinary
-General Public License. We use this license for certain libraries in order
-to permit linking those libraries into non-free programs.
-
-When a program is linked with a library, whether statically or using a shared
-library, the combination of the two is legally speaking a combined work, a
-derivative of the original library. The ordinary General Public License therefore
-permits such linking only if the entire combination fits its criteria of freedom.
-The Lesser General Public License permits more lax criteria for linking other
-code with the library.
-
-We call this license the "Lesser" General Public License because it does Less
-to protect the user's freedom than the ordinary General Public License. It
-also provides other free software developers Less of an advantage over competing
-non-free programs. These disadvantages are the reason we use the ordinary
-General Public License for many libraries. However, the Lesser license provides
-advantages in certain special circumstances.
-
-For example, on rare occasions, there may be a special need to encourage the
-widest possible use of a certain library, so that it becomes a de-facto standard.
-To achieve this, non-free programs must be allowed to use the library. A more
-frequent case is that a free library does the same job as widely used non-free
-libraries. In this case, there is little to gain by limiting the free library
-to free software only, so we use the Lesser General Public License.
-
-In other cases, permission to use a particular library in non-free programs
-enables a greater number of people to use a large body of free software. For
-example, permission to use the GNU C Library in non-free programs enables
-many more people to use the whole GNU operating system, as well as its variant,
-the GNU/Linux operating system.
-
-Although the Lesser General Public License is Less protective of the users'
-freedom, it does ensure that the user of a program that is linked with the
-Library has the freedom and the wherewithal to run that program using a modified
-version of the Library.
-
-The precise terms and conditions for copying, distribution and modification
-follow. Pay close attention to the difference between a "work based on the
-library" and a "work that uses the library". The former contains code derived
-from the library, whereas the latter must be combined with the library in
-order to run.
-
-TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-0. This License Agreement applies to any software library or other program
-which contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Lesser General
-Public License (also called "this License"). Each licensee is addressed as
-"you".
-
-A "library" means a collection of software functions and/or data prepared
-so as to be conveniently linked with application programs (which use some
-of those functions and data) to form executables.
-
-The "Library", below, refers to any such software library or work which has
-been distributed under these terms. A "work based on the Library" means either
-the Library or any derivative work under copyright law: that is to say, a
-work containing the Library or a portion of it, either verbatim or with modifications
-and/or translated straightforwardly into another language. (Hereinafter, translation
-is included without limitation in the term "modification".)
-
-"Source code" for a work means the preferred form of the work for making modifications
-to it. For a library, complete source code means all the source code for all
-modules it contains, plus any associated interface definition files, plus
-the scripts used to control compilation and installation of the library.
-
-Activities other than copying, distribution and modification are not covered
-by this License; they are outside its scope. The act of running a program
-using the Library is not restricted, and output from such a program is covered
-only if its contents constitute a work based on the Library (independent of
-the use of the Library in a tool for writing it). Whether that is true depends
-on what the Library does and what the program that uses the Library does.
-
-1. You may copy and distribute verbatim copies of the Library's complete source
-code as you receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice and disclaimer
-of warranty; keep intact all the notices that refer to this License and to
-the absence of any warranty; and distribute a copy of this License along with
-the Library.
-
-You may charge a fee for the physical act of transferring a copy, and you
-may at your option offer warranty protection in exchange for a fee.
-
-2. You may modify your copy or copies of the Library or any portion of it,
-thus forming a work based on the Library, and copy and distribute such modifications
-or work under the terms of Section 1 above, provided that you also meet all
-of these conditions:
-
-      a) The modified work must itself be a software library.
-
-b) You must cause the files modified to carry prominent notices stating that
-you changed the files and the date of any change.
-
-c) You must cause the whole of the work to be licensed at no charge to all
-third parties under the terms of this License.
-
-d) If a facility in the modified Library refers to a function or a table of
-data to be supplied by an application program that uses the facility, other
-than as an argument passed when the facility is invoked, then you must make
-a good faith effort to ensure that, in the event an application does not supply
-such function or table, the facility still operates, and performs whatever
-part of its purpose remains meaningful.
-
-(For example, a function in a library to compute square roots has a purpose
-that is entirely well-defined independent of the application. Therefore, Subsection
-2d requires that any application-supplied function or table used by this function
-must be optional: if the application does not supply it, the square root function
-must still compute square roots.)
-
-These requirements apply to the modified work as a whole. If identifiable
-sections of that work are not derived from the Library, and can be reasonably
-considered independent and separate works in themselves, then this License,
-and its terms, do not apply to those sections when you distribute them as
-separate works. But when you distribute the same sections as part of a whole
-which is a work based on the Library, the distribution of the whole must be
-on the terms of this License, whose permissions for other licensees extend
-to the entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest your
-rights to work written entirely by you; rather, the intent is to exercise
-the right to control the distribution of derivative or collective works based
-on the Library.
-
-In addition, mere aggregation of another work not based on the Library with
-the Library (or with a work based on the Library) on a volume of a storage
-or distribution medium does not bring the other work under the scope of this
-License.
-
-3. You may opt to apply the terms of the ordinary GNU General Public License
-instead of this License to a given copy of the Library. To do this, you must
-alter all the notices that refer to this License, so that they refer to the
-ordinary GNU General Public License, version 2, instead of to this License.
-(If a newer version than version 2 of the ordinary GNU General Public License
-has appeared, then you can specify that version instead if you wish.) Do not
-make any other change in these notices.
-
-Once this change is made in a given copy, it is irreversible for that copy,
-so the ordinary GNU General Public License applies to all subsequent copies
-and derivative works made from that copy.
-
-This option is useful when you wish to copy part of the code of the Library
-into a program that is not a library.
-
-4. You may copy and distribute the Library (or a portion or derivative of
-it, under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you accompany it with the complete corresponding
-machine-readable source code, which must be distributed under the terms of
-Sections 1 and 2 above on a medium customarily used for software interchange.
-
-If distribution of object code is made by offering access to copy from a designated
-place, then offering equivalent access to copy the source code from the same
-place satisfies the requirement to distribute the source code, even though
-third parties are not compelled to copy the source along with the object code.
-
-5. A program that contains no derivative of any portion of the Library, but
-is designed to work with the Library by being compiled or linked with it,
-is called a "work that uses the Library". Such a work, in isolation, is not
-a derivative work of the Library, and therefore falls outside the scope of
-this License.
-
-However, linking a "work that uses the Library" with the Library creates an
-executable that is a derivative of the Library (because it contains portions
-of the Library), rather than a "work that uses the library". The executable
-is therefore covered by this License. Section 6 states terms for distribution
-of such executables.
-
-When a "work that uses the Library" uses material from a header file that
-is part of the Library, the object code for the work may be a derivative work
-of the Library even though the source code is not. Whether this is true is
-especially significant if the work can be linked without the Library, or if
-the work is itself a library. The threshold for this to be true is not precisely
-defined by law.
-
-If such an object file uses only numerical parameters, data structure layouts
-and accessors, and small macros and small inline functions (ten lines or less
-in length), then the use of the object file is unrestricted, regardless of
-whether it is legally a derivative work. (Executables containing this object
-code plus portions of the Library will still fall under Section 6.)
-
-Otherwise, if the work is a derivative of the Library, you may distribute
-the object code for the work under the terms of Section 6. Any executables
-containing that work also fall under Section 6, whether or not they are linked
-directly with the Library itself.
-
-6. As an exception to the Sections above, you may also combine or link a "work
-that uses the Library" with the Library to produce a work containing portions
-of the Library, and distribute that work under terms of your choice, provided
-that the terms permit modification of the work for the customer's own use
-and reverse engineering for debugging such modifications.
-
-You must give prominent notice with each copy of the work that the Library
-is used in it and that the Library and its use are covered by this License.
-You must supply a copy of this License. If the work during execution displays
-copyright notices, you must include the copyright notice for the Library among
-them, as well as a reference directing the user to the copy of this License.
-Also, you must do one of these things:
-
-a) Accompany the work with the complete corresponding machine-readable source
-code for the Library including whatever changes were used in the work (which
-must be distributed under Sections 1 and 2 above); and, if the work is an
-executable linked with the Library, with the complete machine-readable "work
-that uses the Library", as object code and/or source code, so that the user
-can modify the Library and then relink to produce a modified executable containing
-the modified Library. (It is understood that the user who changes the contents
-of definitions files in the Library will not necessarily be able to recompile
-the application to use the modified definitions.)
-
-b) Use a suitable shared library mechanism for linking with the Library. A
-suitable mechanism is one that (1) uses at run time a copy of the library
-already present on the user's computer system, rather than copying library
-functions into the executable, and (2) will operate properly with a modified
-version of the library, if the user installs one, as long as the modified
-version is interface-compatible with the version that the work was made with.
-
-c) Accompany the work with a written offer, valid for at least three years,
-to give the same user the materials specified in Subsection 6a, above, for
-a charge no more than the cost of performing this distribution.
-
-d) If distribution of the work is made by offering access to copy from a designated
-place, offer equivalent access to copy the above specified materials from
-the same place.
-
-e) Verify that the user has already received a copy of these materials or
-that you have already sent this user a copy.
-
-For an executable, the required form of the "work that uses the Library" must
-include any data and utility programs needed for reproducing the executable
-from it. However, as a special exception, the materials to be distributed
-need not include anything that is normally distributed (in either source or
-binary form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component itself
-accompanies the executable.
-
-It may happen that this requirement contradicts the license restrictions of
-other proprietary libraries that do not normally accompany the operating system.
-Such a contradiction means you cannot use both them and the Library together
-in an executable that you distribute.
-
-7. You may place library facilities that are a work based on the Library side-by-side
-in a single library together with other library facilities not covered by
-this License, and distribute such a combined library, provided that the separate
-distribution of the work based on the Library and of the other library facilities
-is otherwise permitted, and provided that you do these two things:
-
-a) Accompany the combined library with a copy of the same work based on the
-Library, uncombined with any other library facilities. This must be distributed
-under the terms of the Sections above.
-
-b) Give prominent notice with the combined library of the fact that part of
-it is a work based on the Library, and explaining where to find the accompanying
-uncombined form of the same work.
-
-8. You may not copy, modify, sublicense, link with, or distribute the Library
-except as expressly provided under this License. Any attempt otherwise to
-copy, modify, sublicense, link with, or distribute the Library is void, and
-will automatically terminate your rights under this License. However, parties
-who have received copies, or rights, from you under this License will not
-have their licenses terminated so long as such parties remain in full compliance.
-
-9. You are not required to accept this License, since you have not signed
-it. However, nothing else grants you permission to modify or distribute the
-Library or its derivative works. These actions are prohibited by law if you
-do not accept this License. Therefore, by modifying or distributing the Library
-(or any work based on the Library), you indicate your acceptance of this License
-to do so, and all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-10. Each time you redistribute the Library (or any work based on the Library),
-the recipient automatically receives a license from the original licensor
-to copy, distribute, link with or modify the Library subject to these terms
-and conditions. You may not impose any further restrictions on the recipients'
-exercise of the rights granted herein. You are not responsible for enforcing
-compliance by third parties with this License.
-
-11. If, as a consequence of a court judgment or allegation of patent infringement
-or for any other reason (not limited to patent issues), conditions are imposed
-on you (whether by court order, agreement or otherwise) that contradict the
-conditions of this License, they do not excuse you from the conditions of
-this License. If you cannot distribute so as to satisfy simultaneously your
-obligations under this License and any other pertinent obligations, then as
-a consequence you may not distribute the Library at all. For example, if a
-patent license would not permit royalty-free redistribution of the Library
-by all those who receive copies directly or indirectly through you, then the
-only way you could satisfy both it and this License would be to refrain entirely
-from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any patents
-or other property right claims or to contest validity of any such claims;
-this section has the sole purpose of protecting the integrity of the free
-software distribution system which is implemented by public license practices.
-Many people have made generous contributions to the wide range of software
-distributed through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing to
-distribute software through any other system and a licensee cannot impose
-that choice.
-
-This section is intended to make thoroughly clear what is believed to be a
-consequence of the rest of this License.
-
-12. If the distribution and/or use of the Library is restricted in certain
-countries either by patents or by copyrighted interfaces, the original copyright
-holder who places the Library under this License may add an explicit geographical
-distribution limitation excluding those countries, so that distribution is
-permitted only in or among countries not thus excluded. In such case, this
-License incorporates the limitation as if written in the body of this License.
-
-13. The Free Software Foundation may publish revised and/or new versions of
-the Lesser General Public License from time to time. Such new versions will
-be similar in spirit to the present version, but may differ in detail to address
-new problems or concerns.
-
-Each version is given a distinguishing version number. If the Library specifies
-a version number of this License which applies to it and "any later version",
-you have the option of following the terms and conditions either of that version
-or of any later version published by the Free Software Foundation. If the
-Library does not specify a license version number, you may choose any version
-ever published by the Free Software Foundation.
-
-14. If you wish to incorporate parts of the Library into other free programs
-whose distribution conditions are incompatible with these, write to the author
-to ask for permission. For software which is copyrighted by the Free Software
-Foundation, write to the Free Software Foundation; we sometimes make exceptions
-for this. Our decision will be guided by the two goals of preserving the free
-status of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-   NO WARRANTY
-
-15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
-THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE
-STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY
-"AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
-OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
-THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
-OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA
-OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES
-OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH
-HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-END OF TERMS AND CONDITIONS
-
-How to Apply These Terms to Your New Libraries
-
-If you develop a new library, and you want it to be of the greatest possible
-use to the public, we recommend making it free software that everyone can
-redistribute and change. You can do so by permitting redistribution under
-these terms (or, alternatively, under the terms of the ordinary General Public
-License).
-
-To apply these terms, attach the following notices to the library. It is safest
-to attach them to the start of each source file to most effectively convey
-the exclusion of warranty; and each file should have at least the "copyright"
-line and a pointer to where the full notice is found.
-
-<one line to give the library's name and an idea of what it does.>
-
-Copyright (C) <year> <name of author>
-
-This library is free software; you can redistribute it and/or modify it under
-the terms of the GNU Lesser General Public License as published by the Free
-Software Foundation; either version 2.1 of the License, or (at your option)
-any later version.
-
-This library is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
-details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with this library; if not, write to the Free Software Foundation, Inc., 51
-Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your school,
-if any, to sign a "copyright disclaimer" for the library, if necessary. Here
-is a sample; alter the names:
-
-Yoyodyne, Inc., hereby disclaims all copyright interest in
-
-the library `Frob' (a library for tweaking knobs) written
-
-by James Random Hacker.
-
-< signature of Ty Coon > , 1 April 1990
-
-Ty Coon, President of Vice
-
-That's all there is to it!

REUSE.toml

@@ -68,12 +68,6 @@ precedence = "closest"
 SPDX-FileCopyrightText = "Copyright (C) 2024 The Qt Company Ltd."
 SPDX-License-Identifier = "LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only"
 
-[[annotations]]
-path = ["src/corelib/global/patches/tlexpected/**", "src/corelib/global/qexpected_p.h"]
-precedence = "closest"
-SPDX-FileCopyrightText = "To the extent possible under law, Sy Brand has waived all copyright and related or neighboring rights to the expected library. This work is published from: United Kingdom."
-SPDX-License-Identifier = "CC0-1.0"
-
 [[annotations]]
 path = ["src/gui/doc/snippets/textdocument-images/images.qrc"]
 precedence = "closest"

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

@@ -145,7 +145,7 @@ endforeach()
 set(XCB_XCB_component_deps)
 set(XCB_COMPOSITE_component_deps XCB XFIXES)
 set(XCB_DAMAGE_component_deps XCB XFIXES)
-set(XCB_IMAGE_component_deps XCB SHM AUX)
+set(XCB_IMAGE_component_deps XCB SHM)
 set(XCB_RENDERUTIL_component_deps XCB RENDER)
 set(XCB_XFIXES_component_deps XCB RENDER SHAPE)
 set(XCB_XVMC_component_deps XCB XV)

cmake/FindDB2.cmake

@@ -21,31 +21,25 @@
 # ``DB2::DB2``
 #     The db2 client library
 
-if(NOT DEFINED DB2_ROOT)
-    if(DEFINED ENV{DB2_ROOT})
-        set(DB2_ROOT "$ENV{DB2_ROOT}")
-    endif()
-endif()
-
 if (NOT DEFINED DB2_INCLUDE_DIR)
   find_path(DB2_INCLUDE_DIR
     NAMES sqlcli1.h
-    HINTS "${DB2_ROOT}" ENV DB2_HOME
+    HINTS ENV DB2_HOME
     PATH_SUFFIXES include)
 else()
   find_path(DB2_INCLUDE_DIR
     NAMES sqlcli1.h
-    HINTS "${DB2_INCLUDE_DIR}")
+    HINTS ${DB2_INCLUDE_DIR})
 endif()
 
 if (NOT DEFINED DB2_LIBRARY_DIR)
   find_library(DB2_LIBRARY
-    NAMES db2 db2cli64
+    NAMES db2
-    HINTS "${DB2_ROOT}" ENV DB2LIB)
+    HINTS ENV DB2LIB)
 else()
   find_library(DB2_LIBRARY
     NAMES db2
-    HINTS "${DB2_LIBRARY_DIR}")
+    HINTS ${DB2_LIBRARY_DIR})
 endif()
 
 include(FindPackageHandleStandardArgs)

cmake/FindJeMalloc.cmake

@@ -1,10 +0,0 @@
-# Copyright (C) 2025 The Qt Company Ltd.
-# SPDX-License-Identifier: BSD-3-Clause
-
-find_package(PkgConfig QUIET)
-
-pkg_check_modules(JeMalloc IMPORTED_TARGET "jemalloc")
-
-if (NOT TARGET PkgConfig::JeMalloc)
-    set(JeMalloc_FOUND 0)
-endif()

cmake/FindWrapOpenGL.cmake

@@ -37,7 +37,16 @@ if (OpenGL_FOUND)
             set(__opengl_fw_path "-framework OpenGL")
         endif()
 
+        find_library(WrapOpenGL_AGL NAMES AGL)
+        if(WrapOpenGL_AGL)
+            set(__opengl_agl_fw_path "${WrapOpenGL_AGL}")
+        endif()
+        if(NOT __opengl_agl_fw_path)
+            set(__opengl_agl_fw_path "-framework AGL")
+        endif()
+
         target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE ${__opengl_fw_path})
+        target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE ${__opengl_agl_fw_path})
     else()
         target_link_libraries(WrapOpenGL::WrapOpenGL INTERFACE OpenGL::GL)
     endif()

cmake/Qt3rdPartyLibraryConfig.cmake.in

@@ -7,6 +7,9 @@ cmake_minimum_required(VERSION @min_new_policy_version@...@max_new_policy_versio
 
 include(CMakeFindDependencyMacro)
 
+get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_import_prefix "${_import_prefix}" REALPATH)
+
 # Extra cmake code begin
 @extra_cmake_code@
 # Extra cmake code end

cmake/Qt3rdPartyLibraryHelpers.cmake

@@ -105,30 +105,27 @@ function(qt_internal_add_cmake_library target)
         )
     endif()
 
-    _qt_internal_forward_function_args(
-        FORWARD_PREFIX arg
-        FORWARD_OUT_VAR extend_target_args
-        FORWARD_MULTI
-            SOURCES
-            NO_PCH_SOURCES
-            INCLUDE_DIRECTORIES
-            SYSTEM_INCLUDE_DIRECTORIES
-            PUBLIC_INCLUDE_DIRECTORIES
-            PUBLIC_DEFINES
-            DEFINES
-            PUBLIC_LIBRARIES
-            COMPILE_OPTIONS
-            PUBLIC_COMPILE_OPTIONS
-            LINK_OPTIONS
-            PUBLIC_LINK_OPTIONS
-            MOC_OPTIONS
-            ENABLE_AUTOGEN_TOOLS
-            DISABLE_AUTOGEN_TOOLS
-    )
-
     qt_internal_extend_target("${target}"
-        ${extend_target_args}
+        SOURCES ${arg_SOURCES}
+        INCLUDE_DIRECTORIES
+            ${arg_INCLUDE_DIRECTORIES}
+        SYSTEM_INCLUDE_DIRECTORIES
+            ${arg_SYSTEM_INCLUDE_DIRECTORIES}
+        PUBLIC_INCLUDE_DIRECTORIES
+            ${arg_PUBLIC_INCLUDE_DIRECTORIES}
+        PUBLIC_DEFINES
+            ${arg_PUBLIC_DEFINES}
+        DEFINES
+            ${arg_DEFINES}
+        PUBLIC_LIBRARIES ${arg_PUBLIC_LIBRARIES}
         LIBRARIES ${arg_LIBRARIES} Qt::PlatformCommonInternal
+        COMPILE_OPTIONS ${arg_COMPILE_OPTIONS}
+        PUBLIC_COMPILE_OPTIONS ${arg_PUBLIC_COMPILE_OPTIONS}
+        LINK_OPTIONS ${arg_LINK_OPTIONS}
+        PUBLIC_LINK_OPTIONS ${arg_PUBLIC_LINK_OPTIONS}
+        MOC_OPTIONS ${arg_MOC_OPTIONS}
+        ENABLE_AUTOGEN_TOOLS ${arg_ENABLE_AUTOGEN_TOOLS}
+        DISABLE_AUTOGEN_TOOLS ${arg_DISABLE_AUTOGEN_TOOLS}
         NO_UNITY_BUILD # Disabled by default
     )
 endfunction()

cmake/QtAndroidHelpers.cmake

@@ -287,189 +287,3 @@ function(qt_internal_android_dependencies target)
         COMPONENT
             Devel)
 endfunction()
-
-function(qt_internal_set_up_build_host_java_docs)
-    if("${ANDROID_SDK_ROOT}" STREQUAL "")
-        message(FATAL_ERROR
-            "QT_HOST_DOCUMENT_JAVA_SOURCES=ON requires setting ANDROID_SDK_ROOT."
-        )
-    endif()
-
-    _qt_internal_locate_android_jar()
-    set(QT_ANDROID_JAR "${QT_ANDROID_JAR}" PARENT_SCOPE)
-    set(QT_ANDROID_API_USED_FOR_JAVA "${QT_ANDROID_API_USED_FOR_JAVA}" PARENT_SCOPE)
-endfunction()
-
-# Collect the Java source files that were recorded by qt_internal_add_jar.
-# If we're not building for Android, qt_internal_add_jar is not called, and we simple collect
-# all java files under the current directory.
-function(qt_internal_collect_jar_sources out_var)
-    if(NOT ANDROID)
-        file(GLOB_RECURSE sources LIST_DIRECTORIES FALSE "*.java")
-        set("${out_var}" "${sources}" PARENT_SCOPE)
-        return()
-    endif()
-
-    set(no_value_options "")
-    set(single_value_options DIRECTORY)
-    set(multi_value_options "")
-    cmake_parse_arguments(PARSE_ARGV 1 arg
-        "${no_value_options}" "${single_value_options}" "${multi_value_options}"
-    )
-    _qt_internal_validate_all_args_are_parsed(arg)
-
-    set(directory_arg "")
-    if(DEFINED arg_DIRECTORY)
-        set(directory_arg DIRECTORY ${arg_DIRECTORY})
-    endif()
-
-    get_directory_property(result ${directory_arg} _qt_jar_sources)
-    get_directory_property(subdirs ${directory_arg} SUBDIRECTORIES)
-    foreach(subdir IN LISTS subdirs)
-        qt_internal_collect_jar_sources(subdir_result DIRECTORY ${subdir})
-        if(NOT "${subdir_result}" STREQUAL "")
-            list(APPEND result ${subdir_result})
-        endif()
-    endforeach()
-    set("${out_var}" "${result}" PARENT_SCOPE)
-endfunction()
-
-function(qt_internal_add_javadoc_target)
-    set(no_value_options "")
-    set(single_value_options
-        MODULE
-        OUTPUT_DIR
-    )
-    set(multi_value_options
-        SOURCES
-    )
-    cmake_parse_arguments(PARSE_ARGV 0 arg
-        "${no_value_options}" "${single_value_options}" "${multi_value_options}"
-    )
-    _qt_internal_validate_all_args_are_parsed(arg)
-
-    if(TARGET ${arg_MODULE})
-        get_target_property(skip ${arg_MODULE} _qt_skip_javadoc)
-        if(skip)
-            message(VERBOSE "Skipping generation of Android HTML docs for ${arg_MODULE}.")
-            return()
-        endif()
-    endif()
-
-    # Collect source directories from source file paths.
-    set(source_dirs "")
-    foreach(source_path IN LISTS arg_SOURCES)
-        get_filename_component(dir_path "${source_path}" DIRECTORY)
-        list(APPEND source_dirs "${dir_path}")
-    endforeach()
-    list(REMOVE_DUPLICATES source_dirs)
-
-    # Retrieve package names from source dirs.
-    set(package_names "")
-    foreach(source_dir IN LISTS source_dirs)
-        string(REGEX MATCH "/(org/qtproject/qt/android(/.*|$))" package_dir "${source_dir}")
-        if(package_dir STREQUAL "")
-            message(VERBOSE "Java source dir is not a package directory: ${source_dir}")
-            continue()
-        endif()
-
-        # Store package_dir without leading slash.
-        set(package_dir "${CMAKE_MATCH_1}")
-
-        # Use dots instead of slashes for the package name.
-        string(REPLACE "/" "." package_name "${package_dir}")
-
-        list(APPEND package_names "${package_name}")
-    endforeach()
-
-    # Strip package paths from the source dirs.
-    list(TRANSFORM source_dirs REPLACE "/org/qtproject/qt/android.*" "")
-    list(REMOVE_DUPLICATES source_dirs)
-
-    # Use the correct separator for the --source-path argument.
-    if(NOT CMAKE_HOST_WIN32)
-        string(REPLACE ";" ":" source_dirs "${source_dirs}")
-    endif()
-
-    # Use a response file to avoid quoting issues with the space-separated package names.
-    set(javadoc_output_dir "${arg_OUTPUT_DIR}/android")
-    set(response_file "${CMAKE_CURRENT_BINARY_DIR}/doc/.javadocargs")
-    string(REPLACE ";" " " package_names_space_separated "${package_names}")
-    file(CONFIGURE
-        OUTPUT "${response_file}"
-        CONTENT "${package_names_space_separated}
---class-path \"${QT_ANDROID_JAR}\"
--d \"${javadoc_output_dir}\"
---source-path \"${source_dirs}\""
-    )
-
-    set(module ${arg_MODULE})
-    set(javadoc_target android_html_docs_${module})
-    add_custom_target(${javadoc_target} ${command_args}
-        COMMAND ${Java_JAVADOC_EXECUTABLE} "@${response_file}"
-        COMMENT "Generating Java documentation"
-        VERBATIM
-    )
-    add_dependencies(docs_android ${javadoc_target})
-
-    if (QT_WILL_INSTALL)
-        install(DIRECTORY "${arg_OUTPUT_DIR}/"
-            DESTINATION "${INSTALL_DOCDIR}/${module}"
-            COMPONENT _install_docs_android_${module}
-            EXCLUDE_FROM_ALL
-        )
-
-        add_custom_target(install_docs_android_${module}
-            COMMAND ${CMAKE_COMMAND}
-                --install "${CMAKE_BINARY_DIR}"
-                --component _install_docs_android_${module}
-            COMMENT "Installing Android html docs for ${module}"
-        )
-    else()
-        add_custom_target(install_docs_android_${module})
-    endif()
-
-    add_dependencies(install_docs_android_${module} ${javadoc_target})
-    add_dependencies(install_docs_android install_docs_android_${module})
-endfunction()
-
-function(qt_internal_create_source_jar)
-    set(no_value_options "")
-    set(single_value_options MODULE)
-    set(multi_value_options SOURCES)
-    cmake_parse_arguments(PARSE_ARGV 0 arg
-        "${no_value_options}" "${single_value_options}" "${multi_value_options}"
-    )
-    _qt_internal_validate_all_args_are_parsed(arg)
-
-    set(module ${arg_MODULE})
-    set(jar_target android_source_jar_${module})
-    set(jar_name ${CMAKE_INSTALL_NAMESPACE}AndroidSources${module})
-    add_jar(${jar_target}
-        SOURCES ${arg_SOURCES}
-        VERSION ${PROJECT_VERSION}
-        INCLUDE_JARS "${QT_ANDROID_JAR}"
-        OUTPUT_NAME ${jar_name}
-    )
-    set_target_properties(${jar_target} PROPERTIES EXCLUDE_FROM_ALL ON)
-    add_dependencies(android_source_jars ${jar_target})
-
-    if(QT_WILL_INSTALL)
-        install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${jar_name}-${PROJECT_VERSION}.jar"
-            DESTINATION "${INSTALL_DATADIR}/android/${module}"
-            COMPONENT _install_android_source_jar_${module}
-            EXCLUDE_FROM_ALL
-        )
-        add_custom_target(install_android_source_jar_${module}
-            COMMAND ${CMAKE_COMMAND}
-                --install "${CMAKE_BINARY_DIR}"
-                --component _install_android_source_jar_${module}
-            COMMENT "Installing Android source jar for ${module}"
-        )
-    else()
-        add_custom_target(install_android_source_jar_${module})
-    endif()
-
-    add_dependencies(install_android_source_jar_${module} ${jar_target})
-    add_dependencies(install_android_source_jars install_android_source_jar_${module})
-endfunction()

cmake/QtAutoDetectHelpers.cmake

@@ -65,11 +65,6 @@ function(qt_auto_detect_wasm)
 endfunction()
 
 function(qt_auto_detect_android)
-    # Don't assume an Android build if we're requesting to build Java documentation on the host.
-    if(QT_BUILD_HOST_JAVA_DOCS)
-        return()
-    endif()
-
     # We assume an Android build if any of the ANDROID_* cache variables are set.
     if(DEFINED ANDROID_SDK_ROOT
             OR DEFINED ANDROID_NDK_ROOT

cmake/QtAutogenHelpers.cmake

@@ -166,9 +166,6 @@ function(qt_manual_moc result)
             set(metatypes_byproducts "${outfile}.json")
         endif()
 
-        _qt_internal_get_moc_compiler_flavor_flags(flavor_flags)
-        list(APPEND moc_parameters ${flavor_flags})
-
         if (TARGET Qt::Platform)
            get_target_property(_abi_tag Qt::Platform qt_libcpp_abi_tag)
            if (_abi_tag)
@@ -199,8 +196,8 @@ function(qt_make_output_file infile prefix suffix source_dir binary_dir result)
     get_filename_component(outfilename "${infile}" NAME_WE)
 
     set(base_dir "${source_dir}")
-    _qt_internal_path_is_prefix(binary_dir "${infile}" in_binary)
+    string(FIND "${infile}" "${binary_dir}/" in_binary)
-    if(in_binary)
+    if (in_binary EQUAL 0)
         set(base_dir "${binary_dir}")
     endif()
 

cmake/QtBaseGlobalTargets.cmake

@@ -55,40 +55,13 @@ qt_install(FILES
     DESTINATION "${__build_internals_install_dir}"
     COMPONENT Devel
 )
-
-qt_path_join(__build_internals_standalone_test_template_path
-    "${CMAKE_CURRENT_SOURCE_DIR}"
-    "cmake/QtBuildInternals/${__build_internals_standalone_test_template_dir}")
-
 qt_copy_or_install(
-    DIRECTORY "${__build_internals_standalone_test_template_path}"
+    DIRECTORY
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/QtBuildInternals/${__build_internals_standalone_test_template_dir}"
     DESTINATION "${__build_internals_install_dir}")
 
-# In prefix builds we also need to copy the files into the build dir.
+set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS
-if(QT_WILL_INSTALL)
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/QtBuildInternals/${__build_internals_standalone_test_template_dir}/CMakeLists.txt")
-    file(COPY "${__build_internals_standalone_test_template_path}"
-        DESTINATION "${__build_internals_install_dir}")
-endif()
-
-set(__build_internals_extra_files
-    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/QtBuildInternals/QtBuildInternalsHelpers.cmake"
-)
-
-qt_copy_or_install(
-    FILES ${__build_internals_extra_files}
-    DESTINATION "${__build_internals_install_dir}")
-
-# In prefix builds we also need to copy the files into the build dir.
-if(QT_WILL_INSTALL)
-    foreach(__build_internals_file ${__build_internals_extra_files})
-        file(COPY "${__build_internals_file}" DESTINATION "${__build_internals_install_dir}")
-    endforeach()
-endif()
-
-_qt_internal_append_cmake_configure_depends(
-    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/QtBuildInternals/${__build_internals_standalone_test_template_dir}/CMakeLists.txt"
-    ${__build_internals_extra_files}
-)
 
 qt_internal_create_toolchain_file()
 

cmake/QtBaseHelpers.cmake

@@ -97,8 +97,6 @@ macro(qt_internal_qtbase_pre_project_setup)
         include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/QtPublicCMakeVersionHelpers.cmake")
         qt_internal_check_and_warn_about_unsuitable_cmake_version()
 
-        include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/QtPublicCMakeEarlyPolicyHelpers.cmake")
-
         ## Add some paths to check for cmake modules:
         list(PREPEND CMAKE_MODULE_PATH
             "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
@@ -137,7 +135,7 @@ macro(qt_internal_qtbase_install_mkspecs)
         LIST_DIRECTORIES TRUE
         "${PROJECT_SOURCE_DIR}/mkspecs/*")
     foreach(entry IN LISTS mkspecs_subdirs)
-        if(IS_DIRECTORY ${entry})
+        if (IS_DIRECTORY ${entry})
             qt_copy_or_install(DIRECTORY "${entry}"
                                DESTINATION ${mkspecs_install_dir}
                                USE_SOURCE_PERMISSIONS)
@@ -145,70 +143,9 @@ macro(qt_internal_qtbase_install_mkspecs)
             qt_copy_or_install(FILES "${entry}"
                                DESTINATION ${mkspecs_install_dir})
         endif()
-
-        # In prefix builds we also need to copy the files into the build dir.
-        if(QT_WILL_INSTALL)
-            file(COPY "${entry}" DESTINATION "${mkspecs_install_dir}")
-        endif()
     endforeach()
 endmacro()
 
-function(qt_internal_qtbase_install_wayland_files)
-    qt_path_join(wlprotocols_build_dir
-                 ${QT_BUILD_DIR}
-                 ${INSTALL_QT_SHAREDIR}/wayland/protocols)
-    qt_path_join(wlprotocols_install_dir
-                 ${QT_INSTALL_DIR}
-                 ${INSTALL_QT_SHAREDIR}/wayland/protocols)
-
-    file(GLOB wlprotocols_subdirs
-        LIST_DIRECTORIES TRUE
-        "${PROJECT_SOURCE_DIR}/src/3rdparty/wayland/protocols/*")
-    foreach(entry IN LISTS wlprotocols_subdirs)
-        if (IS_DIRECTORY "${entry}")
-            qt_copy_or_install(DIRECTORY "${entry}"
-                               DESTINATION "${wlprotocols_install_dir}"
-                               USE_SOURCE_PERMISSIONS)
-            if(QT_WILL_INSTALL)
-                file(COPY "${entry}" DESTINATION "${wlprotocols_build_dir}")
-            endif()
-        else()
-            qt_copy_or_install(FILES "${entry}"
-                               DESTINATION "${wlprotocols_install_dir}")
-            if(QT_WILL_INSTALL)
-                file(COPY "${entry}" DESTINATION "${wlprotocols_build_dir}")
-            endif()
-        endif()
-    endforeach()
-
-    qt_path_join(wlextensions_build_dir
-                 ${QT_BUILD_DIR}
-                 ${INSTALL_QT_SHAREDIR}/wayland/extensions)
-    qt_path_join(wlextensions_install_dir
-                 ${QT_INSTALL_DIR}
-                 ${INSTALL_QT_SHAREDIR}/wayland/extensions)
-
-    file(GLOB wlextensions_subdirs
-        LIST_DIRECTORIES TRUE
-        "${PROJECT_SOURCE_DIR}/src/3rdparty/wayland/extensions/*")
-    foreach(entry IN LISTS wlextensions_subdirs)
-        if (IS_DIRECTORY "${entry}")
-            qt_copy_or_install(DIRECTORY "${entry}"
-                               DESTINATION "${wlextensions_install_dir}"
-                               USE_SOURCE_PERMISSIONS)
-            if(QT_WILL_INSTALL)
-                file(COPY "${entry}" DESTINATION "${wlextensions_build_dir}")
-            endif()
-        else()
-            qt_copy_or_install(FILES "${entry}"
-                               DESTINATION "${wlextensions_install_dir}")
-            if(QT_WILL_INSTALL)
-                file(COPY "${entry}" DESTINATION "${wlextensions_build_dir}")
-            endif()
-        endif()
-    endforeach()
-endfunction()
-
 macro(qt_internal_qtbase_build_repo)
     qt_internal_qtbase_pre_project_setup()
 
@@ -245,8 +182,6 @@ macro(qt_internal_qtbase_build_repo)
             include(src/corelib/Qt6WasmMacros.cmake)
         endif()
 
-        include(src/tools/qtwaylandscanner/Qt6WaylandCompositorMacros.cmake)
-
         ## Targets for global features, etc.:
         include(QtBaseGlobalTargets)
 
@@ -282,7 +217,6 @@ macro(qt_internal_qtbase_build_repo)
         endif()
 
         qt_internal_qtbase_install_mkspecs()
-        qt_internal_qtbase_install_wayland_files()
     endif()
 
     qt_build_repo_post_process()

cmake/QtBaseTopLevelHelpers.cmake

@@ -34,23 +34,6 @@ endmacro()
 
 macro(qt_internal_top_level_setup_after_project)
     qt_internal_top_level_setup_testing()
-    qt_internal_top_level_setup_cmake_and_export_namespace()
-endmacro()
-
-# Setting QT_CMAKE_EXPORT_NAMESPACE in the top-level scope is needed for any deferred call that is
-# run on the top-level scope (CMAKE_BINARY_DIR).
-macro(qt_internal_top_level_setup_cmake_and_export_namespace)
-    # Include the file that defines qt_internal_setup_cmake_and_export_namespace.
-    # We don't try to call find_package(QtBuildInternals) because that has a lot more side
-    # effects.
-    set(__qt6_build_internals_helpers_path
-        "${__qt6_qtbase_src_path}/cmake/QtBuildInternals/QtBuildInternalsHelpers.cmake")
-    if(NOT EXISTS "${__qt6_build_internals_helpers_path}")
-        message(FATAL_ERROR "Required file does not exist: '${__qt6_build_internals_helpers_path}'")
-    endif()
-    include("${__qt6_build_internals_helpers_path}")
-
-    qt_internal_setup_cmake_and_export_namespace()
 endmacro()
 
 macro(qt_internal_top_level_setup_testing)

cmake/QtBuildHelpers.cmake

@@ -227,7 +227,6 @@ function(qt_internal_get_qt_build_private_files_to_install out_var)
         ModuleDescription.json.in
         PkgConfigLibrary.pc.in
         Qt3rdPartyLibraryConfig.cmake.in
-        QtTransitiveExtras.cmake.in
         QtBaseTopLevelHelpers.cmake
         QtBuild.cmake
         QtBuildHelpers.cmake
@@ -322,7 +321,6 @@ function(qt_internal_get_qt_build_public_files_to_install out_var)
     set(${out_var}
         QtCopyFileIfDifferent.cmake
         QtInitProject.cmake
-        QtPublicCMakeEarlyPolicyHelpers.cmake
 
         # Public CMake files that are installed next Qt6Config.cmake, but are NOT included by it.
         # Instead they are included by the generated CMake toolchain file.
@@ -446,10 +444,8 @@ macro(qt_internal_setup_build_and_global_variables)
     qt_internal_setup_build_examples()
 
     qt_internal_set_qt_host_path()
-    qt_internal_setup_find_host_info_package()
 
     qt_internal_setup_build_docs()
-    qt_internal_setup_build_java_docs_on_host()
 
     qt_internal_include_qt_platform_android()
 
@@ -469,6 +465,7 @@ macro(qt_internal_setup_build_and_global_variables)
     qt_internal_check_msvc_versions()
     qt_internal_check_host_path_set_for_cross_compiling()
     qt_internal_setup_android_platform_specifics()
+    qt_internal_setup_find_host_info_package()
     qt_internal_setup_tool_path_command()
     qt_internal_setup_default_target_function_options()
     qt_internal_set_default_rpath_settings()

cmake/QtBuildInformation.cmake

@@ -555,54 +555,11 @@ function(qt_configure_add_report_error error)
     qt_configure_add_report_entry(TYPE ERROR MESSAGE "${error}" CONDITION TRUE ${ARGN})
 endfunction()
 
-# Goes through each token in given in `CONDITION` or `COMPILE_TESTS_TO_SHOW_ON_ERROR`, checks if
-# the token starts with TEST_ which means it represents a Qt compile test, queries its
-# compile output if available, and appends it to `out_var`.
-# The compile output for a test is only available on first configuration, because we don't cache it
-# across cmake invocations.
-function(qt_internal_get_try_compile_output_from_tests_in_condition out_var)
-    set(opt_args "")
-    set(single_args "")
-    set(multi_args
-        CONDITION
-        COMPILE_TESTS_TO_SHOW_ON_ERROR
-    )
-    cmake_parse_arguments(PARSE_ARGV 1 arg "${opt_args}" "${single_args}" "${multi_args}")
-    _qt_internal_validate_all_args_are_parsed(arg)
-
-    set(content "")
-
-    foreach(token IN LISTS arg_CONDITION arg_COMPILE_TESTS_TO_SHOW_ON_ERROR)
-        if(token MATCHES "TEST_(.+)")
-            set(name "${CMAKE_MATCH_1}")
-            get_cmake_property(try_compile_output _qt_run_config_compile_test_output_${name})
-
-            if(try_compile_output)
-                string(APPEND content "\n   TEST_${name} output: \n\n${try_compile_output}")
-            endif()
-        else()
-            continue()
-        endif()
-    endforeach()
-
-    if(content)
-        string(PREPEND content "\n Compile test outputs:\n")
-    endif()
-
-    set(${out_var} "${content}" PARENT_SCOPE)
-endfunction()
-
 function(qt_configure_process_add_report_entry)
-    set(opt_args "")
+    cmake_parse_arguments(PARSE_ARGV 0 arg
-    set(single_args
+        ""
-        TYPE
+        "TYPE;MESSAGE"
-        MESSAGE
+        "CONDITION")
-    )
-    set(multi_args
-        CONDITION
-        COMPILE_TESTS_TO_SHOW_ON_ERROR
-    )
-    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
     _qt_internal_validate_all_args_are_parsed(arg)
 
     set(possible_types NOTE WARNING ERROR FATAL_ERROR)
@@ -634,23 +591,6 @@ function(qt_configure_process_add_report_entry)
 
     if("${arg_CONDITION}" STREQUAL "" OR condition_result)
         set(new_report "${prefix}${arg_MESSAGE}")
-
-        set(compile_test_args "")
-        if(arg_CONDITION)
-            list(APPEND compile_test_args CONDITION ${arg_CONDITION})
-        endif()
-        if(arg_COMPILE_TESTS_TO_SHOW_ON_ERROR)
-            list(APPEND compile_test_args
-                COMPILE_TESTS_TO_SHOW_ON_ERROR ${arg_COMPILE_TESTS_TO_SHOW_ON_ERROR})
-        endif()
-
-        qt_internal_get_try_compile_output_from_tests_in_condition(extra_output
-            ${compile_test_args}
-        )
-        if(extra_output)
-            string(APPEND new_report "\n${extra_output}")
-        endif()
-
         string(APPEND "${contents_var}" "\n${new_report}")
 
         if(arg_TYPE STREQUAL "ERROR" OR arg_TYPE STREQUAL "FATAL_ERROR")

cmake/QtBuildInternals/QtBuildInternalsConfig.cmake

@@ -11,7 +11,18 @@ if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsExtra.cmake")
     include(${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsExtra.cmake)
 endif()
 
-include(${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsHelpers.cmake)
+macro(qt_internal_setup_cmake_and_export_namespace)
+    # The variables might have already been set in QtBuildInternalsExtra.cmake if the file is
+    # included while building a new module and not QtBase. In that case, stop overriding the value.
+    if(NOT INSTALL_CMAKE_NAMESPACE)
+        set(INSTALL_CMAKE_NAMESPACE "Qt${PROJECT_VERSION_MAJOR}"
+            CACHE STRING "CMake namespace [Qt${PROJECT_VERSION_MAJOR}]")
+    endif()
+    if(NOT QT_CMAKE_EXPORT_NAMESPACE)
+        set(QT_CMAKE_EXPORT_NAMESPACE "Qt${PROJECT_VERSION_MAJOR}"
+            CACHE STRING "CMake namespace used when exporting targets [Qt${PROJECT_VERSION_MAJOR}]")
+    endif()
+endmacro()
 
 macro(qt_set_up_build_internals_paths)
     # Set up the paths for the cmake modules located in the prefix dir. Prepend, so the paths are

cmake/QtBuildInternals/QtBuildInternalsHelpers.cmake

@@ -1,15 +0,0 @@
-# Copyright (C) 2025 The Qt Company Ltd.
-# SPDX-License-Identifier: BSD-3-Clause
-
-macro(qt_internal_setup_cmake_and_export_namespace)
-    # The variables might have already been set in QtBuildInternalsExtra.cmake if the file is
-    # included while building a new module and not QtBase. In that case, stop overriding the value.
-    if(NOT INSTALL_CMAKE_NAMESPACE)
-        set(INSTALL_CMAKE_NAMESPACE "Qt${PROJECT_VERSION_MAJOR}"
-            CACHE STRING "CMake namespace [Qt${PROJECT_VERSION_MAJOR}]")
-    endif()
-    if(NOT QT_CMAKE_EXPORT_NAMESPACE)
-        set(QT_CMAKE_EXPORT_NAMESPACE "Qt${PROJECT_VERSION_MAJOR}"
-            CACHE STRING "CMake namespace used when exporting targets [Qt${PROJECT_VERSION_MAJOR}]")
-    endif()
-endmacro()

cmake/QtBuildInternals/QtStandaloneTestTemplateProject/Main.cmake

@@ -4,9 +4,6 @@
 # Includes QtSetup and friends for private CMake API.
 set(QT_INTERNAL_IS_STANDALONE_TEST TRUE)
 
-# Make find_package(Qt6 COMPONENTS Foo) pull in FooPrivate too.
-set(QT_FIND_PRIVATE_MODULES TRUE)
-
 # Checks minimum CMake version and upgrades policies.
 qt_internal_project_setup()
 

cmake/QtBuildOptionsHelpers.cmake

@@ -403,16 +403,6 @@ macro(qt_internal_setup_build_docs)
     option(QT_BUILD_DOCS "Generate Qt documentation targets" ON)
 endmacro()
 
-macro(qt_internal_setup_build_java_docs_on_host)
-    option(QT_BUILD_HOST_JAVA_DOCS "Generate Java documentation targets on host" OFF)
-    if(QT_BUILD_HOST_JAVA_DOCS)
-        find_package(Java)
-        if(Java_FOUND)
-            include(UseJava)
-        endif()
-    endif()
-endmacro()
-
 macro(qt_internal_set_use_ccache)
     option(QT_USE_CCACHE "Enable the use of ccache")
     if(QT_USE_CCACHE)

cmake/QtBuildPathsHelpers.cmake

@@ -160,9 +160,6 @@ macro(qt_internal_setup_configure_install_paths)
     qt_configure_process_path(INSTALL_INCLUDEDIR "include" "Header files [PREFIX/include]")
     qt_configure_process_path(INSTALL_LIBDIR "lib" "Libraries [PREFIX/lib]")
     qt_configure_process_path(INSTALL_MKSPECSDIR "mkspecs" "Mkspecs files [PREFIX/mkspecs]")
-    qt_configure_process_path(INSTALL_SHAREDIR "share" "Share files [PREFIX/share]")
-    qt_configure_process_path(INSTALL_QT_SHAREDIR "${INSTALL_SHAREDIR}/qt6"
-        "Qt namespaced sharedir [SHAREDIR/qt6]")
     qt_configure_process_path(INSTALL_ARCHDATADIR "." "Arch-dependent data [PREFIX]")
     qt_configure_process_path(INSTALL_PLUGINSDIR
                               "${INSTALL_ARCHDATADIR}/plugins"
@@ -266,20 +263,3 @@ macro(qt_internal_setup_paths_and_prefixes)
 
     qt_internal_set_qt_apple_support_files_path()
 endmacro()
-
-# Returns the prefix for the variables defined by HostInfo package. The prefix
-# is based on version information provided by HostInfo. Falls back to current
-# project version if ${INSTALL_CMAKE_NAMESPACE}HostInfo_VERSION_MAJOR is not
-# defined.
-function(qt_internal_get_host_info_var_prefix out_var)
-    if(${INSTALL_CMAKE_NAMESPACE}HostInfo_VERSION_MAJOR)
-        set(${out_var} "QT${${INSTALL_CMAKE_NAMESPACE}HostInfo_VERSION_MAJOR}_HOST_INFO"
-            PARENT_SCOPE)
-    else()
-        # This is not a valid way to define the host info versioned prefix, but
-        # it's backward compatible with Qt versions older than 6.10.
-        #
-        # TODO: remove once Qt LTS versions older than 6.10 reach end of life.
-        set(${out_var} "QT${PROJECT_VERSION_MAJOR}_HOST_INFO" PARENT_SCOPE)
-    endif()
-endfunction()

cmake/QtBuildRepoExamplesHelpers.cmake

@@ -224,7 +224,7 @@ function(qt_internal_get_example_install_prefix out_var)
     # Allow customizing the installation path of the examples. Will be used in CI.
     if(QT_INTERNAL_EXAMPLES_INSTALL_PREFIX)
         set(qt_example_install_prefix "${QT_INTERNAL_EXAMPLES_INSTALL_PREFIX}")
-    elseif(QT_BUILD_STANDALONE_EXAMPLES AND NOT QT_NO_FAKE_STANDALONE_EXAMPLE_INSTALL_PREFIX)
+    elseif(QT_BUILD_STANDALONE_EXAMPLES)
         # TODO: We might need to reset and pipe through an empty CMAKE_STAGING_PREFIX if we ever
         # try to run standalone examples in the CI when cross-compiling, similar how it's done in
         # qt_internal_set_up_fake_standalone_parts_install_prefix.

cmake/QtBuildRepoHelpers.cmake

@@ -756,13 +756,6 @@ macro(qt_build_tests)
     # Indicates that we are configuring tests now
     set(QT_INTERNAL_CONFIGURING_TESTS TRUE)
 
-    # Set this as a directory scoped variable, so we can easily check the variable in child
-    # directories, to prevent certain code from running, like sbom file checks for all targets
-    # created in tests subdir.
-    if(NOT QT_BUILD_TESTS_BY_DEFAULT)
-        set(QT_INTERNAL_TEST_TARGETS_EXCLUDE_FROM_ALL TRUE)
-    endif()
-
     # Tests are not unity-ready.
     set(CMAKE_UNITY_BUILD OFF)
 

cmake/QtCompilerFlags.cmake

@@ -12,27 +12,12 @@ set(_qt_compiler_warning_flags_off -w)
 
 if (MSVC)
     list(APPEND _qt_compiler_warning_flags_on /W3)
-    # MSVC warns about macros expanding to `defined` when using the
-    # new preprocessor (so far, default for C11 code, but not C++).
-    # Suppress the warning, see also the comment below for GCC.
-    list(APPEND _qt_compiler_warning_flags_on /wd5105)
 else()
     if(CMAKE_CXX_COMPILER_ID STREQUAL "GHS") # There is no -Wextra flag for GHS compiler.
         list(APPEND _qt_compiler_warning_flags_on -Wall)
     else()
         list(APPEND _qt_compiler_warning_flags_on -Wall -Wextra)
     endif()
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-        if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS "17.0.0")
-            # GCC warns if a macro is expanded to `defined`, but doesn't
-            # differentiate between object-like and function-like macros.
-            # The latter generally work everywhere. We don't have fine-grained
-            # control, so disable the warning (tst_qglobal tests for this
-            # behavior.)
-            # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=118542
-            list(APPEND _qt_compiler_warning_flags_on -Wno-expansion-to-defined)
-        endif()
-    endif()
 endif()
 
 set(_qt_compiler_warning_flags_condition

cmake/QtConfig.cmake.in

@@ -3,10 +3,6 @@
 
 @PACKAGE_INIT@
 
-# This is included before the cmake_minimum_required on purpose.
-include("${CMAKE_CURRENT_LIST_DIR}/QtPublicCMakeEarlyPolicyHelpers.cmake")
-__qt_internal_save_directory_scope_policy_cmp0156()
-
 cmake_minimum_required(VERSION @min_new_policy_version@...@max_new_policy_version@)
 
 include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@ConfigExtras.cmake")
@@ -165,18 +161,7 @@ foreach(module ${__qt_umbrella_find_components})
 
     _qt_internal_save_find_package_context_for_debugging(@INSTALL_CMAKE_NAMESPACE@${module})
 
-    if(@INSTALL_CMAKE_NAMESPACE@${module}_FOUND)
+    if(NOT @INSTALL_CMAKE_NAMESPACE@${module}_FOUND)
-        # Tools packages don't usually provide a qt module, so there's no target.
-        if(TARGET @INSTALL_CMAKE_NAMESPACE@::${module})
-            get_target_property(__qt_${module}_is_private @INSTALL_CMAKE_NAMESPACE@::${module}
-                _qt_is_private_module
-            )
-            if(__qt_${module}_is_private)
-                _qt_internal_show_private_module_warning(${module})
-            endif()
-            unset(__qt_${module}_is_private)
-        endif()
-    else()
         find_package(@INSTALL_CMAKE_NAMESPACE@${module}
             ${@INSTALL_CMAKE_NAMESPACE@_FIND_VERSION}
             ${_@INSTALL_CMAKE_NAMESPACE@_FIND_PARTS_QUIET}

cmake/QtDocsHelpers.cmake

@@ -79,7 +79,6 @@ function(qt_internal_add_docs)
 
     set(opt_args
         SHOW_INTERNAL
-        SKIP_JAVADOC
     )
     set(single_args "")
     set(multi_args
@@ -132,9 +131,8 @@ function(qt_internal_add_docs)
     set(tool_dependencies_enabled TRUE)
     if(NOT "${QT_HOST_PATH}" STREQUAL "")
         set(tool_dependencies_enabled FALSE)
-        qt_internal_get_host_info_var_prefix(host_info_var_prefix)
+        set(doc_tools_bin "${QT_HOST_PATH}/${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR}")
-        set(doc_tools_bin "${QT_HOST_PATH}/${${host_info_var_prefix}_BINDIR}")
+        set(doc_tools_libexec "${QT_HOST_PATH}/${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR}")
-        set(doc_tools_libexec "${QT_HOST_PATH}/${${host_info_var_prefix}_LIBEXECDIR}")
     elseif(NOT "${QT_OPTIONAL_TOOLS_PATH}" STREQUAL "")
         set(tool_dependencies_enabled FALSE)
         set(doc_tools_bin "${QT_OPTIONAL_TOOLS_PATH}/${INSTALL_BINDIR}")
@@ -210,7 +208,6 @@ function(qt_internal_add_docs)
         --basedir "${PROJECT_SOURCE_DIR}/.."
         --filter "QDocModule=${doc_target}"
         -o "${target_bin_dir}/codeattributions.qdoc"
-        COMMENT "Scanning attributions for ${target}..."
     )
 
     # prepare docs target
@@ -272,7 +269,6 @@ function(qt_internal_add_docs)
         COMMAND ${CMAKE_COMMAND} -E env ${qdoc_env_args}
         ${qdoc_bin}
         ${prepare_qdoc_args}
-        COMMENT "Running qdoc for ${target}..."
     )
 
     add_dependencies(prepare_docs_${target} qattributionsscanner_${target})
@@ -315,9 +311,7 @@ function(qt_internal_add_docs)
         endif()
         add_custom_target(${target_prefix}_${target}
             ${depends_arg}
-            COMMAND ${CMAKE_COMMAND} -E env ${qdoc_env_args} ${qdoc_bin} ${generate_qdoc_args}
+            COMMAND ${CMAKE_COMMAND} -E env ${qdoc_env_args} ${qdoc_bin} ${generate_qdoc_args})
-            COMMENT "Generating documentation for ${target}..."
-        )
     endforeach()
 
     add_dependencies(generate_docs_${target} prepare_docs_${target})
@@ -343,7 +337,6 @@ function(qt_internal_add_docs)
             COMMAND ${qhelpgenerator_bin}
             "${qdoc_output_dir}/${doc_target}.qhp"
             -o "${qch_file_path}"
-            COMMENT "Building QtHelp files for ${target}..."
         )
     endforeach()
     add_dependencies(qch_docs_${target} generate_docs_${target})
@@ -404,73 +397,4 @@ function(qt_internal_add_docs)
         qt_internal_add_doc_tool_dependency(prepare_docs_${target} qdoc)
         qt_internal_add_doc_tool_dependency(qch_docs_${target} qhelpgenerator)
     endif()
-
-    _qt_internal_forward_function_args(
-        FORWARD_PREFIX arg
-        FORWARD_OUT_VAR add_java_documentation_args
-        FORWARD_OPTIONS
-            SKIP_JAVADOC
-    )
-    qt_internal_add_java_documentation(${target} ${add_java_documentation_args}
-        OUTPUT_DIR "${qdoc_output_dir}"
-    )
-endfunction()
-
-function(qt_internal_add_java_documentation target)
-    if(NOT ANDROID AND NOT QT_BUILD_HOST_JAVA_DOCS)
-        return()
-    endif()
-
-    set(no_value_options
-        SKIP_JAVADOC
-    )
-    set(single_value_options
-        OUTPUT_DIR
-    )
-    set(multi_value_options "")
-    cmake_parse_arguments(PARSE_ARGV 1 arg
-        "${no_value_options}" "${single_value_options}" "${multi_value_options}"
-    )
-    _qt_internal_validate_all_args_are_parsed(arg)
-
-    # Use a default output directory based on the project name.
-    if(NOT DEFINED arg_OUTPUT_DIR)
-        if (QT_WILL_INSTALL)
-            set(arg_OUTPUT_DIR "${CMAKE_BINARY_DIR}/${INSTALL_DOCDIR}")
-        else()
-            set(arg_OUTPUT_DIR "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_DOCDIR}")
-        endif()
-        string(APPEND arg_OUTPUT_DIR "/${PROJECT_NAME}")
-    endif()
-
-    qt_internal_collect_jar_sources(sources)
-
-    # Bail out if we haven't found relevant sources.
-    if(sources STREQUAL "")
-        return()
-    endif()
-
-    if(NOT TARGET docs_android)
-        add_custom_target(docs_android)
-        add_custom_target(install_docs_android)
-        add_dependencies(install_docs_android docs_android)
-
-        add_custom_target(android_source_jars)
-        add_custom_target(install_android_source_jars)
-        add_dependencies(install_android_source_jars android_source_jars)
-    endif()
-
-    if(NOT ANDROID)
-        qt_internal_set_up_build_host_java_docs()
-    endif()
-
-    if(NOT arg_SKIP_JAVADOC)
-        qt_internal_add_javadoc_target(
-            MODULE ${target}
-            SOURCES ${sources}
-            OUTPUT_DIR "${arg_OUTPUT_DIR}"
-        )
-    endif()
-
-    qt_internal_create_source_jar(SOURCES ${sources} MODULE ${target})
 endfunction()

cmake/QtExecutableHelpers.cmake

@@ -184,17 +184,10 @@ function(qt_internal_add_executable name)
     set_target_properties("${name}" PROPERTIES
         RUNTIME_OUTPUT_DIRECTORY "${arg_OUTPUT_DIRECTORY}"
         LIBRARY_OUTPUT_DIRECTORY "${arg_OUTPUT_DIRECTORY}"
+        WIN32_EXECUTABLE "${arg_GUI}"
+        MACOSX_BUNDLE "${arg_GUI}"
     )
 
-    if(arg_GUI)
-        # Only override if GUI is set. Otherwise leave up to
-        # CMake defaults, which may be set by the user elsewhere.
-        set_target_properties("${name}" PROPERTIES
-            MACOSX_BUNDLE ON
-            WIN32_EXECUTABLE ON
-    )
-    endif()
-
     if(NOT arg_EXCEPTIONS)
         qt_internal_set_exceptions_flags("${name}" "DEFAULT")
     else()
@@ -206,9 +199,8 @@ function(qt_internal_add_executable name)
     set(exclude_from_all FALSE)
     if(__qt_exclude_tool_directories)
         foreach(absolute_dir ${__qt_exclude_tool_directories})
-            _qt_internal_path_is_prefix(absolute_dir "${CMAKE_CURRENT_SOURCE_DIR}"
+            string(FIND "${CMAKE_CURRENT_SOURCE_DIR}" "${absolute_dir}" dir_starting_pos)
-                in_current_source)
+            if(dir_starting_pos EQUAL 0)
-            if(in_current_source)
                 set(exclude_from_all TRUE)
                 set_target_properties("${name}" PROPERTIES
                     EXCLUDE_FROM_ALL TRUE

cmake/QtFeature.cmake

@@ -115,263 +115,6 @@ function(qt_feature feature)
     set(__QtFeature_internal_features ${__QtFeature_internal_features} PARENT_SCOPE)
 endfunction()
 
-# Define an alternative alias for the main feature definition.
-#
-# If the main feature is defined, it takes precedence and all others are ignored. Otherwise
-# only one alias may be defined.
-#
-# Currently, we need this to be a dedicated function because we are gathering all aliases of
-# the main feature and check its real value as part of
-# `qt_feature_check_and_save_user_provided_value`
-#
-# TODO: See how to move this into the main `qt_feature` definition flow.
-# TODO: How to add `CONDITION` and how does it interact with the main feature's `EMIT_IF`
-#
-# Synopsis
-#
-#   qt_feature_alias(<alias_feature>
-#       {ALIAS_OF_FEATURE <real_feature> | ALIAS_OF_CACHE <cache>}
-#       [PRIVATE | PUBLIC]
-#       [LABEL <string>]
-#       [PURPOSE <string>]
-#       [SECTION <string>]
-#       [NEGATE]
-#   )
-#
-# Arguments
-#
-# `<alias_feature>`
-#   The feature alias to be created.
-#
-# `ALIAS_OF_FEATURE`
-#   The true canonical feature to consider.
-#
-# `ALIAS_OF_CACHE`
-#   The true cache variable that this value must synchronize with.
-#
-# `NEGATE`
-#   Populate the main FEATURE variable with the opposite of the alias's value
-#
-# `LABEL`, `PURPOSE`, `SECTION`
-#   Same as in `qt_feature`
-#
-# `PRIVATE`, `PUBLIC`
-#   Same as in `qt_feature`. When `ALIAS_OF_FEATURE` is used, these have no effect, instead the
-#   value of the the true feature is used.
-function(qt_feature_alias alias_feature)
-    set(option_args
-        NEGATE
-        PRIVATE
-        PUBLIC
-    )
-    set(single_args
-        ALIAS_OF_FEATURE
-        ALIAS_OF_CACHE
-        LABEL
-        PURPOSE
-        SECTION
-    )
-    set(multi_args "")
-
-    cmake_parse_arguments(PARSE_ARGV 1 arg "${option_args}" "${single_args}" "${multi_args}")
-    _qt_internal_validate_all_args_are_parsed(arg)
-
-    if(NOT arg_ALIAS_OF_FEATURE AND NOT arg_ALIAS_OF_CACHE)
-        message(FATAL_ERROR "One of ALIAS_OF_FEATURE,ALIAS_OF_CACHE must be passed.")
-    endif()
-    if(arg_ALIAS_OF_FEATURE AND arg_ALIAS_OF_CACHE)
-        message(FATAL_ERROR "ALIAS_OF_FEATURE and ALIAS_OF_CACHE are mutually exclusive.")
-    endif()
-
-    set(original_name "${alias_feature}")
-    qt_feature_normalize_name("${alias_feature}" alias_feature)
-    set_property(GLOBAL PROPERTY QT_FEATURE_ORIGINAL_NAME_${alias_feature} "${original_name}")
-
-    set(forward_args "")
-    if(arg_ALIAS_OF_FEATURE)
-        qt_feature_normalize_name("${arg_ALIAS_OF_FEATURE}" arg_ALIAS_OF_FEATURE)
-        if(NOT DEFINED _QT_FEATURE_DEFINITION_${arg_ALIAS_OF_FEATURE})
-            message(FATAL_ERROR "Primary feature ${arg_ALIAS_OF_FEATURE} was not defined yet.")
-        endif()
-        list(APPEND _QT_FEATURE_ALIASES_${arg_ALIAS_OF_FEATURE} "${alias_feature}")
-        list(APPEND forward_args ALIAS_OF_FEATURE "${arg_ALIAS_OF_FEATURE}")
-    endif()
-    if(arg_ALIAS_OF_CACHE)
-        list(APPEND forward_args ALIAS_OF_CACHE "${arg_ALIAS_OF_CACHE}")
-    endif()
-    if(arg_NEGATE)
-        list(APPEND forward_args ALIAS_NEGATE)
-    endif()
-    if(arg_LABEL)
-        list(APPEND forward_args LABEL "${arg_LABEL}")
-    endif()
-    if(arg_PURPOSE)
-        list(APPEND forward_args PURPOSE "${arg_PURPOSE}")
-    endif()
-    if(arg_SECTION)
-        list(APPEND forward_args SECTION "${arg_SECTION}")
-    endif()
-
-    set(_QT_FEATURE_DEFINITION_${alias_feature} ${forward_args} PARENT_SCOPE)
-
-    if(arg_ALIAS_OF_FEATURE)
-        # Register alias as a feature type similar to the true one
-        foreach(type IN ITEMS public private internal)
-            if(arg_ALIAS_OF_FEATURE IN_LIST __QtFeature_${type}_features)
-                list(APPEND __QtFeature_${type}_features "${alias_feature}")
-                set(__QtFeature_${type}_features ${__QtFeature_${type}_features} PARENT_SCOPE)
-
-            endif()
-        endforeach()
-        set(_QT_FEATURE_ALIASES_${arg_ALIAS_OF_FEATURE}
-            "${_QT_FEATURE_ALIASES_${arg_ALIAS_OF_FEATURE}}" PARENT_SCOPE)
-    else()
-        # Otherwise use the same logic as qt_feature
-        if (arg_PUBLIC)
-            list(APPEND __QtFeature_public_features "${alias_feature}")
-        endif()
-        if (arg_PRIVATE)
-            list(APPEND __QtFeature_private_features "${alias_feature}")
-        endif()
-        if (NOT arg_PUBLIC AND NOT arg_PRIVATE)
-            list(APPEND __QtFeature_internal_features "${alias_feature}")
-        endif()
-
-        set(__QtFeature_public_features ${__QtFeature_public_features} PARENT_SCOPE)
-        set(__QtFeature_private_features ${__QtFeature_private_features} PARENT_SCOPE)
-        set(__QtFeature_internal_features ${__QtFeature_internal_features} PARENT_SCOPE)
-    endif()
-endfunction()
-
-# Create a deprecated feature
-#
-# Synopsis
-#
-#   qt_feature_deprecated(<feature>
-#       REMOVE_BY <version>
-#       [MESSAGE <string>] [VALUE <val>]
-#       [PRIVATE | PUBLIC]
-#       [LABEL <string>] [PURPOSE <string>] [SECTION <string>]
-#   )
-#
-# Arguments
-#
-# `<feature>`
-#   The feature to be created.
-#
-# `REMOVE_BY`
-#   Qt version when this feature is going to be removed
-#
-# `MESSAGE`
-#   Additional deprecation message to be printed.
-#
-# `VALUE`
-#   Value of the `QT_FEATURE_<feature>` that this is forced to. If undefined,
-#   `QT_FEATURE_<feature>` is not populated
-#
-# `LABEL`, `PURPOSE`, `SECTION`, `PRIVATE`, `PUBLIC`
-#   Same as in `qt_feature`
-function(qt_feature_deprecated feature)
-    set(option_args
-        PRIVATE
-        PUBLIC
-    )
-    set(single_args
-        REMOVE_BY
-        MESSAGE
-        VALUE
-        LABEL
-        PURPOSE
-        SECTION
-    )
-    set(multi_args "")
-
-    cmake_parse_arguments(PARSE_ARGV 1 arg "${option_args}" "${single_args}" "${multi_args}")
-    _qt_internal_validate_all_args_are_parsed(arg)
-
-    if(NOT arg_REMOVE_BY)
-        message(FATAL_ERROR "qt_feature_deprecated requires REMOVE_BY keyword")
-    elseif(PROJECT_VERSION VERSION_GREATER_EQUAL arg_REMOVE_BY)
-        message(FATAL_ERROR
-            "Deprecated feature ${feature} must be removed before Qt version ${arg_REMOVE_BY}"
-        )
-    endif()
-
-    set(original_name "${feature}")
-    qt_feature_normalize_name("${feature}" feature)
-
-    # Check if the values were manually passed
-    if(DEFINED FEATURE_${feature})
-        set(deprecation_msg "FEATURE_${feature} is deprecated. ")
-        if(arg_VALUE)
-            string(APPEND deprecation_msg "The value is always: ${arg_VALUE}")
-        else()
-            string(APPEND deprecation_msg "The value is not used.")
-        endif()
-        if(arg_MESSAGE)
-            string(APPEND deprecation_msg "\n${arg_MESSAGE}")
-        endif()
-        qt_configure_add_report_entry(RECORD_ON_FEATURE_EVALUATION TYPE WARNING
-            MESSAGE "${deprecation_msg}")
-        unset(FEATURE_${feature} CACHE)
-    endif()
-
-    # Make sure the `QT_FEATURE_*` value is set/unset accordingly
-    unset(err_msg)
-    if(arg_VALUE)
-        if(DEFINED QT_FEATURE_${feature} AND NOT QT_FEATURE_${feature} STREQUAL arg_VALUE)
-            string(CONCAT err_msg
-                "QT_FEATURE_${feature} was manually set to ${QT_FEATURE_${feature}}, but"
-                "the only supported value is: ${arg_VALUE}\n"
-                "Overwriting QT_FEATURE_${feature} cache to ${arg_VALUE}"
-            )
-        endif()
-        set(QT_FEATURE_${feature} "${arg_VALUE}" CACHE INTERNAL
-            "Deprecated: Always ${arg_VALUE}. ${arg_MESSAGE}"
-        )
-    else()
-        if(DEFINED QT_FEATURE_${feature})
-            string(CONCAT msg
-                "QT_FEATURE_${feature} was manually set to ${QT_FEATURE_${feature}}, but"
-                "the value must **NOT** be set.\n"
-                "Unsetting QT_FEATURE_${feature} cache"
-            )
-            unset(QT_FEATURE_${feature} CACHE)
-        endif()
-    endif()
-
-    # Emit the error message if we have an unexpected `QT_FEATURE_*`
-    if(err_msg)
-        if(arg_MESSAGE)
-            string(APPEND err_msg "\n${arg_MESSAGE}")
-        endif()
-        qt_configure_add_report_error("${err_msg}")
-    endif()
-
-    # Register the feature as a normal feature
-    set(forward_args "")
-    foreach(arg IN ITEMS LABEL PURPOSE SECTION)
-        if(arg_${arg})
-            list(APPEND forward_args ${arg} "${arg_${arg}}")
-        endif()
-    endforeach()
-    set(_QT_FEATURE_DEFINITION_${feature} ${forward_args} PARENT_SCOPE)
-
-    # Do the feature register
-    if (arg_PUBLIC)
-        list(APPEND __QtFeature_public_features "${feature}")
-        set(__QtFeature_public_features ${__QtFeature_public_features} PARENT_SCOPE)
-    endif()
-    if (arg_PRIVATE)
-        list(APPEND __QtFeature_private_features "${feature}")
-        set(__QtFeature_private_features ${__QtFeature_private_features} PARENT_SCOPE)
-    endif()
-    if (NOT arg_PUBLIC AND NOT arg_PRIVATE)
-        list(APPEND __QtFeature_internal_features "${feature}")
-        set(__QtFeature_internal_features ${__QtFeature_internal_features} PARENT_SCOPE)
-    endif()
-endfunction()
-
 function(qt_evaluate_to_boolean expressionVar)
     if(${${expressionVar}})
         set(${expressionVar} ON PARENT_SCOPE)
@@ -549,146 +292,6 @@ function(_qt_internal_dump_expression_values expression_dump expression)
     set(${expression_dump} "${${expression_dump}}" PARENT_SCOPE)
 endfunction()
 
-# Check the actual value of a given feature/alias.
-# The value can come from `FEATURE_<alias>` being set or from another alias.
-# The out_var is sanitized to 0/1 and it is not set if the feature was not defined.
-function(_qt_feature_evaluate_alias out_var alias)
-    # Evaluate the alias against the aliases of the alias
-    _qt_feature_check_feature_alias(${alias})
-    if(NOT DEFINED FEATURE_${alias})
-        # If the alias was not defined, don't set value
-        return()
-    endif()
-    # Check if we need to negate the value to be set or not
-    set(not_kw)
-    _qt_internal_parse_feature_definition("${alias}")
-    if(arg_ALIAS_NEGATE)
-        set(not_kw "NOT")
-    endif()
-    # Evaluate the value and return it
-    qt_set01(${out_var} ${not_kw} FEATURE_${alias})
-    set(${out_var} "${${out_var}}" PARENT_SCOPE)
-    # Also set `not_kw` since it would be reused by the caller
-    set(not_kw "${not_kw}" PARENT_SCOPE)
-endfunction()
-
-# Check that the feature value is consistent with any of its aliases.
-# If the feature was not set via `FEATURE_<feature>`, it may be set by the aliases.
-function(_qt_feature_check_feature_alias feature)
-    if(DEFINED "FEATURE_${feature}")
-        # The main feature was already defined, use the current value.
-        # Just check if the other aliases have agreeing values.
-        qt_set01(expected_value FEATURE_${feature})
-        unset(alias_value)
-        foreach(alias IN LISTS _QT_FEATURE_ALIASES_${feature})
-            _qt_feature_evaluate_alias(alias_value ${alias})
-            if(DEFINED alias_value)
-                if(NOT expected_value EQUAL alias_value)
-                    string(CONCAT msg
-                        "Alias FEATURE_${alias}(${FEATURE_${alias}}) is an alias of ${not_kw} "
-                        "FEATURE_${feature}(${FEATURE_${alias}}), and their values conflict"
-                    )
-                    qt_configure_add_report_error(${msg})
-                endif()
-                unset(alias_value)
-            endif()
-        endforeach()
-        return()
-    endif()
-    # Otherwise try to set the `feature` value from the aliases
-    set(aliases_set "")
-    set(expected_value "")
-    set(alias_not_kws "")
-    unset(value)
-    foreach(alias IN LISTS _QT_FEATURE_ALIASES_${feature})
-        _qt_feature_evaluate_alias(value ${alias})
-        if(DEFINED value)
-            list(APPEND aliases_set "${alias}")
-            list(APPEND expected_value "${value}")
-            list(APPEND alias_not_kws "${not_kw}")
-            unset(value)
-        endif()
-    endforeach()
-    # If there were no aliases set, do not set the feature either
-    if(NOT aliases_set)
-        return()
-    endif()
-    # Check if all values are consistent
-    list(REMOVE_DUPLICATES expected_value)
-    list(LENGTH expected_value expected_value_length)
-    if(expected_value_length GREATER 1)
-        string(CONCAT msg
-            "Multiple aliases of FEATURE_${feature} were defined, with conflicting values.\n"
-            "Aliases:"
-        )
-        while(aliases_set)
-            list(POP_FRONT aliases_set alias)
-            list(POP_FRONT alias_not_kws not_kw)
-            string(CONCAT msg
-                "${msg}\n"
-                "  - ${not_kw} FEATURE_${alias}(${FEATURE_${alias}})"
-            )
-        endwhile()
-        qt_configure_add_report_error(${msg})
-        return()
-    endif()
-    # All aliased values are agreeing
-    set("FEATURE_${feature}" ${expected_value} PARENT_SCOPE)
-endfunction()
-
-# Check that the alias value is consistent with its cache source
-function(_qt_feature_check_cache_alias feature)
-    _qt_internal_parse_feature_definition("${feature}")
-    if(NOT arg_ALIAS_OF_CACHE)
-        # Not an alias of a cache variable, skip this check
-        return()
-    endif()
-    if(DEFINED "${arg_ALIAS_OF_CACHE}")
-        # Check if the feature is set by another alias
-        unset(expected_value)
-        _qt_feature_evaluate_alias(expected_value "${feature}")
-        qt_set01(cache_sanitized ${arg_ALIAS_OF_CACHE})
-        if(NOT DEFINED expected_value)
-            # If nothing else set the alias value, use the primary cache value
-            set("FEATURE_${feature}" "${${arg_ALIAS_OF_CACHE}}" PARENT_SCOPE)
-            return()
-        endif()
-        # Otherwise, just check for consistency
-        if(NOT cache_sanitized EQUAL expected_value)
-            string(CONCAT msg
-                "FEATURE_${feature}(${FEATURE_${feature}}) is an alias of ${not_kw} "
-                "${arg_ALIAS_OF_CACHE}(${${arg_ALIAS_OF_CACHE}}), and their values conflict."
-            )
-            qt_configure_add_report_error(${msg})
-        endif()
-    endif()
-endfunction()
-
-# Make sure all the direct alias values are set after the final evaluation of the feature value.
-# Must be run after `_qt_feature_check_feature_alias` which checks for user-defined values and
-# any inconsistencies
-function(_qt_feature_save_alias feature)
-    foreach(alias IN LISTS _QT_FEATURE_ALIASES_${feature})
-        # We only need to set the alias values if they were not explicitly set. The consistency
-        # check for those was done prior to this function call.
-        if(NOT DEFINED FEATURE_${alias})
-            # Evaluate the alias value based on the original
-            set(not_kw)
-            _qt_internal_parse_feature_definition("${alias}")
-            if(arg_ALIAS_NEGATE)
-                set(not_kw "NOT")
-            endif()
-            qt_set01(value ${not_kw} FEATURE_${feature})
-            qt_evaluate_to_boolean(value)
-            # Set the values based on the main feature's value
-            set(FEATURE_${alias} ${value} CACHE BOOL
-                # Using a temporary docstring that should be overwritten if everything works well
-                "(temporarily set by _qt_feature_save_alias)"
-            )
-        endif()
-    endforeach()
-endfunction()
-
 # Stores the user provided value to FEATURE_${feature} if provided.
 # If not provided, stores ${computed} instead.
 # ${computed} is also stored when reconfiguring and the condition does not align with the user
@@ -696,8 +299,6 @@ endfunction()
 #
 function(qt_feature_check_and_save_user_provided_value
         resultVar feature condition condition_expression computed label)
-    _qt_feature_check_cache_alias(${feature})
-    _qt_feature_check_feature_alias(${feature})
     if (DEFINED "FEATURE_${feature}")
         # Revisit new user provided value
         set(user_value "${FEATURE_${feature}}")
@@ -750,10 +351,6 @@ function(qt_feature_check_and_save_user_provided_value
         # Initial setup:
         set(result "${computed}")
         set("FEATURE_${feature}" "${result}" CACHE BOOL "${label}")
-        # Update the HELPSTRING if needed
-        set_property(CACHE "FEATURE_${feature}" PROPERTY
-            HELPSTRING "${label}"
-        )
     endif()
 
     # Check for potential typo
@@ -765,9 +362,6 @@ function(qt_feature_check_and_save_user_provided_value
         )
     endif()
 
-    # Set the values of each direct alias
-    _qt_feature_save_alias("${feature}")
-
     set("${resultVar}" "${result}" PARENT_SCOPE)
 endfunction()
 
@@ -799,8 +393,8 @@ endmacro()
 
 macro(_qt_internal_parse_feature_definition feature)
     cmake_parse_arguments(arg
-        "PRIVATE;PUBLIC;ALIAS_NEGATE"
+        "PRIVATE;PUBLIC"
-        "LABEL;PURPOSE;SECTION;ALIAS_OF_FEATURE;ALIAS_OF_CACHE"
+        "LABEL;PURPOSE;SECTION;"
         "AUTODETECT;CONDITION;ENABLE;DISABLE;EMIT_IF"
         ${_QT_FEATURE_DEFINITION_${feature}})
 endmacro()
@@ -842,12 +436,6 @@ function(qt_evaluate_feature feature)
 
     _qt_internal_parse_feature_definition("${feature}")
 
-    if(arg_ALIAS_OF)
-        # If the current feature is an alias of another, we have to check the original source first
-        # in order to be consistent with the original source if set
-        qt_evaluate_feature("${arg_ALIAS_OF}")
-    endif()
-
     if("${arg_ENABLE}" STREQUAL "")
         set(arg_ENABLE OFF)
     endif()
@@ -886,17 +474,6 @@ function(qt_evaluate_feature feature)
         qt_evaluate_config_expression(emit_if ${arg_EMIT_IF})
     endif()
 
-    set(actual_label "${arg_LABEL}")
-    if(arg_ALIAS_OF_FEATURE OR arg_ALIAS_OF_CACHE)
-        set(not_kw)
-        if(arg_ALIAS_NEGATE)
-            set(not_kw "NOT")
-        endif()
-        # Only one of ALIAS_OF_FEATURE/ALIAS_OF_CACHE will be set, so we can just combine them
-        set(alias_source "${not_kw} ${arg_ALIAS_OF_FEATURE}${arg_ALIAS_OF_CACHE}")
-        string(APPEND actual_label " (alias of ${alias_source})")
-    endif()
-
     # Warn about a feature which is not emitted, but the user explicitly provided a value for it.
     if(NOT emit_if AND DEFINED FEATURE_${feature})
         set(msg "")
@@ -914,17 +491,17 @@ function(qt_evaluate_feature feature)
     if(emit_if)
         qt_feature_check_and_save_user_provided_value(
             saved_user_value
-            "${feature}" "${condition}" "${arg_CONDITION}" "${computed}" "${actual_label}")
+            "${feature}" "${condition}" "${arg_CONDITION}" "${computed}" "${arg_LABEL}")
     else()
         # Make sure the feature internal value is OFF if not emitted.
         set(saved_user_value OFF)
     endif()
 
     qt_feature_check_and_save_internal_value(
-        "${feature}" "${saved_user_value}" "${condition}" "${actual_label}" "${arg_CONDITION}")
+        "${feature}" "${saved_user_value}" "${condition}" "${arg_LABEL}" "${arg_CONDITION}")
 
     # Store each feature's label for summary info.
-    set(QT_FEATURE_LABEL_${feature} "${actual_label}" CACHE INTERNAL "")
+    set(QT_FEATURE_LABEL_${feature} "${arg_LABEL}" CACHE INTERNAL "")
 endfunction()
 
 # Collect feature names that ${feature} depends on, by inspecting the given expression.
@@ -1233,7 +810,6 @@ function(qt_feature_module_end)
 
     foreach(feature ${all_features})
         unset(_QT_FEATURE_DEFINITION_${feature} PARENT_SCOPE)
-        unset(_QT_FEATURE_ALIASES_${feature} PARENT_SCOPE)
     endforeach()
 
     if(NOT arg_ONLY_EVALUATE_FEATURES)
@@ -1601,9 +1177,17 @@ function(qt_run_config_compile_test name)
             set(_save_CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}")
             set(CMAKE_REQUIRED_LIBRARIES "${arg_LIBRARIES}")
 
-            _qt_internal_get_check_cxx_source_compiles_out_var(try_compile_output extra_args)
+            # OUTPUT_VARIABLE is an internal undocumented variable of check_cxx_source_compiles
+            # since 3.23. Allow an opt out in case this breaks in the future.
+            set(try_compile_output "")
+            set(output_var "")
+            if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.23"
+                    AND NOT QT_INTERNAL_NO_TRY_COMPILE_OUTPUT_VARIABLE)
+                set(output_var OUTPUT_VARIABLE try_compile_output)
+            endif()
+
             check_cxx_source_compiles(
-                "${arg_UNPARSED_ARGUMENTS} ${arg_CODE}" HAVE_${name} ${extra_args}
+                "${arg_UNPARSED_ARGUMENTS} ${arg_CODE}" HAVE_${name} ${output_var}
             )
             set(CMAKE_REQUIRED_LIBRARIES "${_save_CMAKE_REQUIRED_LIBRARIES}")
 
@@ -1616,14 +1200,7 @@ function(qt_run_config_compile_test name)
         endif()
     endif()
 
-    # Note this is assigned to the parent scope, and is not a CACHE var, which means the value is
-    # only available on first configuration.
     set(TEST_${name}_OUTPUT "${try_compile_output}" PARENT_SCOPE)
-
-    # Story the compile output for a test in a global property. It will only be available on first
-    # configuration, because we don't cache it across cmake invocations.
-    set_property(GLOBAL PROPERTY _qt_run_config_compile_test_output_${name} "${try_compile_output}")
-
     set(TEST_${name} "${HAVE_${name}}" CACHE INTERNAL "${arg_LABEL}")
 endfunction()
 

cmake/QtFindWrapHelper.cmake

@@ -66,27 +66,8 @@ macro(qt_find_package_system_or_bundled _unique_prefix)
     endif()
 
     if(NOT TARGET "${${_unique_prefix}_qt_package_target_to_use}")
-        if(QT_USE_BUNDLED_${_qfwrap_${_unique_prefix}_BUNDLED_PACKAGE_TARGET})
-            set(${_unique_prefix}_qt_use_no_default_path_for_qt_packages "NO_DEFAULT_PATH")
-            if(QT_DISABLE_NO_DEFAULT_PATH_IN_QT_PACKAGES)
-                set(${_unique_prefix}_qt_use_no_default_path_for_qt_packages "")
-            endif()
-
-            # For bundled targets, we want to limit search paths to the relevant Qt search paths.
-            find_package("${${_unique_prefix}_qt_package_name_to_use}"
-                PATHS
-                    ${QT_BUILD_CMAKE_PREFIX_PATH}
-                    "${CMAKE_CURRENT_LIST_DIR}/.."
-                    ${_qt_cmake_dir}
-                    ${_qt_additional_packages_prefix_paths}
-                ${${_unique_prefix}_qt_use_no_default_path_for_qt_packages}
-            )
-        else()
-            # For the non-bundled case we will look for FindWrapSystemFoo.cmake module files,
-            # which means we should not specify any PATHS.
         find_package("${${_unique_prefix}_qt_package_name_to_use}")
     endif()
-    endif()
 
     if(TARGET "${${_unique_prefix}_qt_package_target_to_use}")
         set(${_qfwrap_${_unique_prefix}_WRAP_PACKAGE_FOUND_VAR_NAME} ON)

cmake/QtFlagHandlingHelpers.cmake

@@ -160,21 +160,19 @@ function(qt_internal_add_link_flags_no_undefined target)
         return()
     endif()
     if ((GCC OR CLANG) AND NOT MSVC)
-        if((GCC OR CLANG) AND QT_FEATURE_sanitizer)
+        if(CLANG AND QT_FEATURE_sanitizer)
             return()
         endif()
         set(previous_CMAKE_REQUIRED_LINK_OPTIONS ${CMAKE_REQUIRED_LINK_OPTIONS})
 
         set(CMAKE_REQUIRED_LINK_OPTIONS "-Wl,-undefined,error")
-        _qt_internal_get_check_cxx_source_compiles_out_var(test_output_undefined_error extra_args)
+        check_cxx_source_compiles("int main() {}" HAVE_DASH_UNDEFINED_SYMBOLS)
-        check_cxx_source_compiles("int main() {}" HAVE_DASH_UNDEFINED_SYMBOLS ${extra_args})
         if(HAVE_DASH_UNDEFINED_SYMBOLS)
             set(no_undefined_flag "-Wl,-undefined,error")
         endif()
 
         set(CMAKE_REQUIRED_LINK_OPTIONS "-Wl,--no-undefined")
-        _qt_internal_get_check_cxx_source_compiles_out_var(test_output_no_undefined extra_args)
+        check_cxx_source_compiles("int main() {}" HAVE_DASH_DASH_NO_UNDEFINED)
-        check_cxx_source_compiles("int main() {}" HAVE_DASH_DASH_NO_UNDEFINED ${extra_args})
         if(HAVE_DASH_DASH_NO_UNDEFINED)
             set(no_undefined_flag "-Wl,--no-undefined")
         endif()
@@ -182,10 +180,7 @@ function(qt_internal_add_link_flags_no_undefined target)
         set(CMAKE_REQUIRED_LINK_OPTIONS ${previous_CMAKE_REQUIRED_LINK_OPTIONS})
 
         if (NOT HAVE_DASH_UNDEFINED_SYMBOLS AND NOT HAVE_DASH_DASH_NO_UNDEFINED)
-            message(FATAL_ERROR
+            message(FATAL_ERROR "Platform linker doesn't support erroring upon encountering undefined symbols. Target:\"${target}\".")
-                "Platform linker doesn't support erroring upon encountering undefined symbols. "
-                "Target:\"${target}\". "
-                "Test errors: \n ${test_output_undefined_error} \n ${test_output_no_undefined}")
         endif()
         target_link_options("${target}" PRIVATE "${no_undefined_flag}")
     endif()

cmake/QtFrameworkHelpers.cmake

@@ -34,12 +34,10 @@ macro(qt_find_apple_system_frameworks)
         qt_internal_find_apple_system_framework(FWGameController GameController)
         qt_internal_find_apple_system_framework(FWCoreBluetooth CoreBluetooth)
         qt_internal_find_apple_system_framework(FWAVFoundation AVFoundation)
-        qt_internal_find_apple_system_framework(FWPhotos Photos)
         qt_internal_find_apple_system_framework(FWContacts Contacts)
         qt_internal_find_apple_system_framework(FWEventKit EventKit)
         qt_internal_find_apple_system_framework(FWHealthKit HealthKit)
         qt_internal_find_apple_system_framework(FWUniformTypeIdentifiers UniformTypeIdentifiers)
-        qt_internal_find_apple_system_framework(FWNetwork Network)
         qt_internal_find_apple_system_framework(FWOpenGL OpenGL)
     endif()
 endmacro()

cmake/QtHeadersClean.cmake

@@ -239,8 +239,8 @@ function(qt_internal_add_headersclean_target module_target module_headers)
 
         set(possible_base_dirs "${CMAKE_BINARY_DIR}" "${CMAKE_SOURCE_DIR}")
         foreach(dir IN LISTS possible_base_dirs)
-            _qt_internal_path_is_prefix(dir "${input_path}" dir_is_prefix)
+            string(FIND "${input_path}" "${dir}" idx)
-            if(dir_is_prefix)
+            if(idx EQUAL "0")
                 set(input_base_dir "${dir}")
                 break()
             endif()

cmake/QtHostInfoConfig.cmake.in

@@ -18,8 +18,6 @@ set(@var_prefix@SYSCONFDIR "@INSTALL_SYSCONFDIR@")
 set(@var_prefix@EXAMPLESDIR "@INSTALL_EXAMPLESDIR@")
 set(@var_prefix@TESTSDIR "@INSTALL_TESTSDIR@")
 set(@var_prefix@DESCRIPTIONSDIR "@INSTALL_DESCRIPTIONSDIR@")
-set(@var_prefix@SHAREDIR "@INSTALL_SHAREDIR@")
-set(@var_prefix@QT_SHAREDIR "@INSTALL_QT_SHAREDIR@")
 set(@var_prefix@QMAKE_MKSPEC "@QT_QMAKE_TARGET_MKSPEC@")
 set(@var_prefix@ARCH "@TEST_architecture_arch@")
 set(@var_prefix@SUBARCHS "@TEST_subarch_result@")

cmake/QtInstallPaths.cmake.in

@@ -15,5 +15,3 @@ set(QT@PROJECT_VERSION_MAJOR@_INSTALL_QML "@INSTALL_QMLDIR@")
 set(QT@PROJECT_VERSION_MAJOR@_INSTALL_TESTS "@INSTALL_TESTSDIR@")
 set(QT@PROJECT_VERSION_MAJOR@_INSTALL_TRANSLATIONS "@INSTALL_TRANSLATIONSDIR@")
 set(QT@PROJECT_VERSION_MAJOR@_INSTALL_DESCRIPTIONSDIR "@INSTALL_DESCRIPTIONSDIR@")
-set(QT@PROJECT_VERSION_MAJOR@_INSTALL_SHAREDIR "@INSTALL_SHAREDIR@")
-set(QT@PROJECT_VERSION_MAJOR@_INSTALL_QT_SHAREDIR "@INSTALL_QT_SHAREDIR@")

cmake/QtInternalTargets.cmake

@@ -287,13 +287,6 @@ if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
         "$<$<AND:${not_disabled},${is_xcode15}>:LINKER:-no_warn_duplicate_libraries>")
 endif()
 
-if(CYGWIN)
-    # CYGWIN doesn't define _GNU_SOURCE by default for better support with W32API
-    target_compile_definitions(PlatformCommonInternal INTERFACE
-        "_GNU_SOURCE"
-    )
-endif()
-
 if(MSVC)
     target_compile_definitions(PlatformCommonInternal INTERFACE
         "_CRT_SECURE_NO_WARNINGS"
@@ -374,22 +367,6 @@ if (GCC AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "9.2")
     target_compile_options(PlatformCommonInternal INTERFACE $<$<COMPILE_LANGUAGE:CXX>:-Wsuggest-override>)
 endif()
 
-if(QT_FEATURE_stdlib_libcpp)
-    # Disable transitive C++ inclusions when using libc++, on all
-    # language versions. See
-    # https://libcxx.llvm.org/DesignDocs/HeaderRemovalPolicy.html
-    target_compile_definitions(PlatformCommonInternal INTERFACE _LIBCPP_REMOVE_TRANSITIVE_INCLUDES)
-endif()
-
-if(QT_USE_CCACHE AND CLANG AND BUILD_WITH_PCH)
-    # The ccache man page says we must compile with -fno-pch-timestamp when using clang and pch.
-    foreach(language IN ITEMS C CXX OBJC OBJCXX)
-        target_compile_options(PlatformCommonInternal INTERFACE
-            "$<$<COMPILE_LANGUAGE:${language}>:SHELL:-Xclang -fno-pch-timestamp>"
-        )
-    endforeach()
-endif()
-
 # Hardening options
 
 qt_internal_apply_intel_cet_harderning(PlatformCommonInternal)

cmake/QtJavaHelpers.cmake

@@ -28,7 +28,6 @@ function(qt_internal_add_jar target)
         get_filename_component(absolute_path "${path}" ABSOLUTE)
         list(APPEND absolute_sources "${absolute_path}")
     endforeach()
-    set_property(DIRECTORY APPEND PROPERTY _qt_jar_sources "${absolute_sources}")
 
     add_jar(${target} SOURCES ${absolute_sources} ${ARGV})
 

cmake/QtMkspecHelpers.cmake

@@ -114,8 +114,7 @@ macro(qt_internal_setup_platform_definitions_and_mkspec)
     endif()
 
     if(CMAKE_CROSSCOMPILING)
-        qt_internal_get_host_info_var_prefix(host_info_var_prefix)
+        set(QT_QMAKE_HOST_MKSPEC "${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_QMAKE_MKSPEC}")
-        set(QT_QMAKE_HOST_MKSPEC "${${host_info_var_prefix}_QMAKE_MKSPEC}")
     else()
         set(QT_QMAKE_HOST_MKSPEC "${QT_QMAKE_TARGET_MKSPEC}")
     endif()

cmake/QtModuleConfig.cmake.in

@@ -7,6 +7,9 @@ cmake_minimum_required(VERSION @min_new_policy_version@...@max_new_policy_versio
 
 include(CMakeFindDependencyMacro)
 
+get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_import_prefix "${_import_prefix}" REALPATH)
+
 # Extra cmake code begin
 @extra_cmake_code@
 # Extra cmake code end
@@ -33,7 +36,11 @@ if (NOT QT_NO_CREATE_TARGETS AND @INSTALL_CMAKE_NAMESPACE@@target@_FOUND)
 endif()
 
 # Find the private module counterpart.
-set(__qt_@target@_always_load_private_module @always_load_private_module@)
+# For now, always load the private module. In a future Qt version we plan to require users to
+# find_package the private module explicitly.
+set(__qt_@target@_always_load_private_module ON)
+set(__qt_@target@_save_QT_NO_PRIVATE_MODULE_WARNING ${QT_NO_PRIVATE_MODULE_WARNING})
+set(QT_NO_PRIVATE_MODULE_WARNING ON)
 include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@-build.cmake" OPTIONAL)
 if (@INSTALL_CMAKE_NAMESPACE@@target@_FOUND
         AND NOT @INSTALL_CMAKE_NAMESPACE@@target_private@_FOUND
@@ -78,6 +85,8 @@ if (@INSTALL_CMAKE_NAMESPACE@@target@_FOUND
         endif()
     endif()
 endif()
+set(QT_NO_PRIVATE_MODULE_WARNING ${__qt_@target@_save_QT_NO_PRIVATE_MODULE_WARNING})
+unset(__qt_@target@_save_QT_NO_PRIVATE_MODULE_WARNING)
 unset(__qt_@target@_always_load_private_module)
 
 if (NOT QT_NO_CREATE_TARGETS AND @INSTALL_CMAKE_NAMESPACE@@target@_FOUND)

cmake/QtModuleConfigPrivate.cmake.in

@@ -20,8 +20,17 @@ if(NOT DEFINED "@INSTALL_CMAKE_NAMESPACE@@target_private@_FOUND")
     set("@INSTALL_CMAKE_NAMESPACE@@target_private@_FOUND" TRUE)
 endif()
 
-if(NOT __qt_@target@_always_load_private_module)
+if(NOT DEFINED QT_REPO_MODULE_VERSION
-    _qt_internal_show_private_module_warning(@target_private@)
+        AND NOT QT_NO_PRIVATE_MODULE_WARNING
+        AND NOT __qt_private_module_@target_private@_warning_shown)
+    message(WARNING
+        "This project is using headers of the @target_private@ module and will therefore be tied "
+        "to this specific Qt module build version. "
+        "Running this project against other versions of the Qt modules may crash at any arbitrary "
+        "point. This is not a bug, but a result of using Qt internals. You have been warned! "
+        "\nYou can disable this warning by setting QT_NO_PRIVATE_MODULE_WARNING to ON."
+    )
+    set(__qt_private_module_@target_private@_warning_shown TRUE)
 endif()
 
 if(NOT QT_NO_CREATE_TARGETS AND @INSTALL_CMAKE_NAMESPACE@@target_private@_FOUND)

cmake/QtModuleHelpers.cmake

@@ -5,7 +5,6 @@ macro(qt_internal_get_internal_add_module_keywords option_args single_args multi
     set(${option_args}
         STATIC
         EXCEPTIONS
-        FIND_PRIVATE_MODULE
         INTERNAL_MODULE
         HEADER_MODULE
         DISABLE_TOOLS_EXPORT
@@ -131,9 +130,6 @@ endfunction()
 #     ignored by syncqt. The specifying this directory allows to skip the parsing of the whole
 #     CMAKE_CURRENT_SOURCE_DIR for the header files that needs to be synced and only parse the
 #     single subdirectory, that meanwhile can be outside the CMAKE_CURRENT_SOURCE_DIR tree.
-#
-#   FIND_PRIVATE_MODULE
-#     A call to find_package(Qt6Foo) will imply a call to find_package(Qt6FooPrivate).
 function(qt_internal_add_module target)
     qt_internal_get_internal_add_module_keywords(
         module_option_args
@@ -216,17 +212,6 @@ function(qt_internal_add_module target)
         "_qt_package_version"
         "_qt_package_name"
     )
-
-    if(CMAKE_VERSION VERSION_LESS 3.30)
-        # For the CMake versions higher than 3.30 the corresponding INTERFACE_
-        # properties will be in Qt<Module>Targets.cmake without extra code
-        # needed.
-        list(APPEND export_properties
-            "_qt_transitive_compile_properties"
-            "_qt_transitive_link_properties"
-        )
-    endif()
-
     if(NOT is_internal_module)
         set_target_properties(${target} PROPERTIES
             _qt_is_public_module TRUE
@@ -465,24 +450,6 @@ function(qt_internal_add_module target)
             set(module_header "${module_build_interface_include_dir}/${module_include_name}")
             set_property(TARGET "${target}" PROPERTY MODULE_HEADER
                     "${module_header}")
-
-            if(QT_FEATURE_no_prefix)
-                file(RELATIVE_PATH relative_include_dir
-                    "/${QT_CONFIG_INSTALL_DIR}/${module_include_name}"
-                    "/${module_build_interface_include_dir}"
-                )
-            else()
-                file(RELATIVE_PATH relative_include_dir
-                    "/${QT_CONFIG_INSTALL_DIR}/${module_include_name}"
-                    "/${module_install_interface_include_dir}"
-                )
-            endif()
-            set_property(TARGET "${target}" PROPERTY
-                _qt_module_relative_include_dir "${relative_include_dir}"
-            )
-            set_property(TARGET ${target} APPEND PROPERTY
-                EXPORT_PROPERTIES _qt_module_relative_include_dir
-            )
         endif()
 
         set(qpa_filter_regex "")
@@ -739,21 +706,6 @@ function(qt_internal_add_module target)
         list(APPEND extra_cmake_includes "${INSTALL_CMAKE_NAMESPACE}${target}Macros.cmake")
     endif()
 
-    if(CMAKE_VERSION VERSION_LESS 3.30)
-        # For the CMake versions higher than 3.30 the corresponding INTERFACE_
-        # properties will be in Qt<Module>Targets.cmake without extra code
-        # needed.
-        configure_file(
-            "${QT_CMAKE_DIR}/QtTransitiveExtras.cmake.in"
-            "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}TransitiveExtras.cmake"
-            @ONLY
-        )
-        list(APPEND extra_cmake_files
-            "${config_build_dir}/${INSTALL_CMAKE_NAMESPACE}${target}TransitiveExtras.cmake")
-        list(APPEND extra_cmake_includes
-            "${INSTALL_CMAKE_NAMESPACE}${target}TransitiveExtras.cmake")
-    endif()
-
     if (EXISTS "${CMAKE_CURRENT_LIST_DIR}/${INSTALL_CMAKE_NAMESPACE}${target}ConfigExtras.cmake.in")
         if(target STREQUAL Core)
             if(NOT "${QT_NAMESPACE}" STREQUAL "")
@@ -807,7 +759,7 @@ set(QT_ALLOW_MISSING_TOOLS_PACKAGES TRUE)")
         )
 
         # Make sure touched extra cmake files cause a reconfigure, so they get re-copied.
-        _qt_internal_append_cmake_configure_depends("${cmake_file}")
+        set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${cmake_file}")
     endforeach()
     list(APPEND extra_cmake_includes ${arg_EXTRA_CMAKE_INCLUDES})
 
@@ -850,16 +802,8 @@ set(QT_ALLOW_MISSING_TOOLS_PACKAGES TRUE)")
     else()
         set(write_basic_module_package_args "")
     endif()
-
-    if(arg_FIND_PRIVATE_MODULE)
-        set(write_basic_public_module_package_args FIND_PRIVATE_MODULE)
-    else()
-        set(write_basic_public_module_package_args "")
-    endif()
-
     qt_internal_write_basic_module_package("${target}" "${target_private}"
         ${write_basic_module_package_args}
-        ${write_basic_public_module_package_args}
         CONFIG_BUILD_DIR ${config_build_dir}
         CONFIG_INSTALL_DIR ${config_install_dir}
     )
@@ -888,6 +832,11 @@ set(QT_ALLOW_MISSING_TOOLS_PACKAGES TRUE)")
 
     file(COPY ${extra_cmake_files} DESTINATION "${config_build_dir}")
 
+    set(targets_to_export ${target})
+    if(NOT ${arg_NO_PRIVATE_MODULE})
+        list(APPEND targets_to_export ${target_private})
+    endif()
+
     _qt_internal_forward_function_args(
         FORWARD_PREFIX arg
         FORWARD_OUT_VAR export_module_args
@@ -1048,7 +997,6 @@ endfunction()
 # Otherwise write its public counterpart.
 function(qt_internal_write_basic_module_package target target_private)
     set(no_value_options
-        FIND_PRIVATE_MODULE
         IS_STATIC_LIB
         PRIVATE
     )
@@ -1061,27 +1009,20 @@ function(qt_internal_write_basic_module_package target target_private)
         "${no_value_options}" "${single_value_options}" "${multi_value_options}"
     )
 
-    set(always_load_private_module OFF)
     if(arg_PRIVATE)
         set(package_name "${INSTALL_CMAKE_NAMESPACE}${target_private}")
         set(module_config_input_file "QtModuleConfigPrivate.cmake.in")
     else()
         set(package_name "${INSTALL_CMAKE_NAMESPACE}${target}")
         set(module_config_input_file "QtModuleConfig.cmake.in")
-        if(arg_FIND_PRIVATE_MODULE)
-            set(always_load_private_module ON)
-        endif()
     endif()
 
-    if((QT_FEATURE_no_prefix OR arg_IS_STATIC_LIB)
+    if(arg_IS_STATIC_LIB AND NOT arg_PRIVATE AND CMAKE_VERSION VERSION_LESS "3.26")
-            AND NOT arg_PRIVATE
+        # We auto-load the private module package from the public module package if we have a static
-            AND CMAKE_VERSION VERSION_LESS "3.26")
+        # Qt module and CMake's version is < 3.26. This is needed for the case "Qt6Foo links against
-        # We auto-load the private module package from the public module package if we have a
+        # Qt6BarPrivate", because CMake generates a check for the target Qt6::BarPrivate in
-        # statically built module or a non-prefix build and CMake's version is < 3.26. This is
+        # Qt6FooTargets.cmake. Once we can require CMake 3.26, we can simply link against
-        # needed for the case "Qt6Foo links against Qt6BarPrivate", because CMake generates a check
+        # $<BUILD_LOCAL_INTERFACE:Qt6BarPrivate> in qt_internal_extend_target.
-        # for the target Qt6::BarPrivate in Qt6FooTargets.cmake. Once we can require CMake 3.26, we
-        # can simply link against $<BUILD_LOCAL_INTERFACE:Qt6BarPrivate> in
-        # qt_internal_extend_target.
         #
         # For older CMake versions, we create an additional CMake file that's optionally included by
         # Qt6FooConfig.cmake to work around the lack of BUILD_LOCAL_INTERFACE.
@@ -1186,37 +1127,8 @@ function(qt_internal_apply_apple_privacy_manifest target)
 endfunction()
 
 function(qt_finalize_module target)
-    set(no_value_options
-        INTERNAL_MODULE
-        NO_PRIVATE_MODULE
-    )
-    set(single_value_options "")
-    set(multi_value_options "")
-    cmake_parse_arguments(PARSE_ARGV 1 arg
-        "${no_value_options}" "${single_value_options}" "${multi_value_options}"
-    )
-    _qt_internal_validate_all_args_are_parsed(arg)
-
     qt_internal_collect_module_headers(module_headers ${target})
 
-    # Issue a warning if we
-    # - suppressed creation of the private module but have private headers
-    # - created a private module but don't have any private headers
-    if(NOT arg_INTERNAL_MODULE)
-        get_target_property(has_private_headers ${target} _qt_module_has_private_headers)
-        if(arg_NO_PRIVATE_MODULE AND has_private_headers)
-            message(AUTHOR_WARNING
-                "Module ${target} has private headers. "
-                "Please remove NO_PRIVATE_MODULE from its creation flags."
-            )
-        elseif(NOT arg_NO_PRIVATE_MODULE AND NOT has_private_headers)
-            message(AUTHOR_WARNING
-                "Module ${target} does not have private headers. "
-                "Please add NO_PRIVATE_MODULE to its creation flags."
-            )
-        endif()
-    endif()
-
     # qt_internal_install_module_headers needs to be called before
     # qt_finalize_framework_headers_copy, because the last uses the QT_COPIED_FRAMEWORK_HEADERS
     # property which supposed to be updated inside every qt_internal_install_module_headers
@@ -1597,8 +1509,8 @@ function(qt_internal_generate_cpp_global_exports target module_define_infix)
         SOURCES "${generated_header_path}"
         CONFIGURE_GENERATED
     )
-    # Make sure the file is installed when processed by `qt_internal_collect_module_headers`
+    # `GENERATED` property is set in order to be processed by `qt_internal_collect_module_headers`
-    set_source_files_properties("${generated_header_path}" PROPERTIES _qt_syncqt_force_include TRUE)
+    set_source_files_properties("${generated_header_path}" PROPERTIES GENERATED TRUE)
 endfunction()
 
 function(qt_internal_install_module_headers target)
@@ -1697,13 +1609,16 @@ function(qt_internal_collect_module_headers out_var target)
 
         get_filename_component(file_path "${file_path}" ABSOLUTE)
 
-        _qt_internal_path_is_prefix(source_dir "${file_path}" is_inside_module_source_dir)
+        string(FIND "${file_path}" "${source_dir}" source_dir_pos)
+        if(source_dir_pos EQUAL 0)
+            set(is_outside_module_source_dir FALSE)
+        else()
+            set(is_outside_module_source_dir TRUE)
+        endif()
 
-        get_source_file_property(forced_include "${file_path}" _qt_syncqt_force_include)
         get_source_file_property(is_generated "${file_path}" GENERATED)
-        # Skip all header files outside the module source directory, except the generated files,
+        # Skip all header files outside the module source directory, except the generated files.
-        # or files explicitly marked to be included for syncqt.
+        if(is_outside_module_source_dir AND NOT is_generated)
-        if(NOT (forced_include OR is_inside_module_source_dir OR is_generated))
             continue()
         endif()
 
@@ -1715,10 +1630,10 @@ function(qt_internal_collect_module_headers out_var target)
                 "\nCondition:\n    ${condition_string}")
         endif()
 
-        if(is_inside_module_source_dir)
+        if(is_outside_module_source_dir)
-            set(base_dir "${source_dir}")
-        else()
             set(base_dir "${binary_dir}")
+        else()
+            set(base_dir "${source_dir}")
         endif()
 
         file(RELATIVE_PATH file_path_rel "${base_dir}" "${file_path}")
@@ -1790,100 +1705,3 @@ function(qt_internal_collect_module_headers out_var target)
             _qt_module_has_ssg_headers
     )
 endfunction()
-
-# Set the value of the respective module properties and make the properties
-# transitive. The property is not stored as target property, but is set as
-# INTERFACE property, so its value is not considered by target itself, but only
-# by depending targets. Also this require all properties have the
-# INTERFACE_<property_name> name format.
-#
-# Synopsis
-#   qt_internal_set_module_transitive_properties(<target>
-#       PROPERTIES <prop1> <value1> [<prop2> <value2>] ...
-#   )
-#
-# Arguments
-#
-# `target` Qt module target. Unlike CMake set_target_properties this function
-#   accepts only one target as argument.
-#
-# `PROPERTIES` List of the property name-value pairs.
-#
-# `TYPE` The transitive property type: COMPILE or LINK.
-function(qt_internal_set_module_transitive_properties target)
-    cmake_parse_arguments(PARSE_ARGV 1 arg "" "TYPE" "PROPERTIES")
-
-    if(NOT arg_PROPERTIES)
-        message(FATAL_ERROR "PROPERTIES argument is missing.")
-    endif()
-
-    if(NOT arg_TYPE)
-        message(FATAL_ERROR "TYPE argument is missing.")
-    endif()
-
-    list(LENGTH arg_PROPERTIES count)
-    math(EXPR even_args_count "${count} % 2")
-    if(NOT even_args_count EQUAL 0)
-        message(FATAL_ERROR "Insufficient number of PROPERTIES values.")
-    endif()
-
-    _qt_internal_dealias_target(target)
-
-    set(property_names "")
-    set(internal_property_names "")
-
-    math(EXPR last "${count} - 1")
-    foreach(name_idx RANGE 0 ${last} 2)
-        list(GET arg_PROPERTIES ${name_idx} interface_property_name)
-        if(interface_property_name MATCHES "^INTERFACE_(.+)$")
-            set(property_name "${CMAKE_MATCH_1}")
-        else()
-            message(FATAL_ERROR "Incorrect property name ${interface_property_name}. The property"
-            " name must have the INTERFACE_ prefix. Use regular set_target_properties call to set"
-            " the non-transitive property.")
-        endif()
-
-        string(TOLOWER "${property_name}" property_name_lower)
-        list(APPEND property_names ${property_name})
-
-        math(EXPR value_idx "${name_idx} + 1")
-        list(GET arg_PROPERTIES ${value_idx} property_value)
-
-        if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.30)
-            # The collected interface properties exposed in module build tree and have the
-            # same transitive capabilities as after the module is installed. Supported for
-            # CMake version >= 3.30
-            set_property(TARGET ${target} PROPERTY ${interface_property_name} "${property_value}")
-        else()
-            # Internal properties are exported within the Qt module. They have limitations that
-            # EXPORT_PROPERTIES apply. These properties are exported even if we are building Qt
-            # with CMake versions that do not support transitive properties. It allows using
-            # them as transitive properties in user projects if CMake allows this.
-            list(APPEND internal_property_names _qt_internal_${property_name_lower})
-            set_property(TARGET ${target} PROPERTY
-                _qt_internal_${property_name_lower} "${property_value}")
-        endif()
-
-        _qt_internal_add_transitive_property(${target} ${arg_TYPE} ${property_name})
-    endforeach()
-
-    get_target_property(transitive_properties ${target} _qt_transitive_${type_lower}_properties)
-    if(NOT transitive_properties)
-        set(transitive_properties "")
-    endif()
-    list(APPEND transitive_properties ${property_names})
-    list(REMOVE_DUPLICATES transitive_properties)
-
-    get_target_property(export_properties ${target} EXPORT_PROPERTIES)
-    if(NOT export_properties)
-        set(export_properties "")
-    endif()
-    list(APPEND export_properties ${internal_property_names})
-    list(REMOVE_DUPLICATES export_properties)
-
-    string(TOLOWER "${arg_TYPE}" type_lower)
-    set_target_properties(${target} PROPERTIES
-        EXPORT_PROPERTIES "${export_properties}"
-        _qt_transitive_${type_lower}_properties "${transitive_properties}"
-    )
-endfunction()

cmake/QtPlatformAndroid.cmake

@@ -23,7 +23,32 @@ if (NOT IS_DIRECTORY "${ANDROID_SDK_ROOT}")
     message(FATAL_ERROR "Could not find ANDROID_SDK_ROOT or path is not a directory: ${ANDROID_SDK_ROOT}")
 endif()
 
-_qt_internal_locate_android_jar()
+# This variable specifies the API level used for building Java code, it can be the same as Qt for
+# Android's maximum supported Android version or higher.
+if(NOT QT_ANDROID_API_USED_FOR_JAVA)
+    set(QT_ANDROID_API_USED_FOR_JAVA "android-35")
+endif()
+
+set(jar_location "${ANDROID_SDK_ROOT}/platforms/${QT_ANDROID_API_USED_FOR_JAVA}/android.jar")
+if(NOT EXISTS "${jar_location}")
+    _qt_internal_detect_latest_android_platform(android_platform_latest)
+    if(android_platform_latest)
+        message(NOTICE "The default platform SDK ${QT_ANDROID_API_USED_FOR_JAVA} not found, "
+                        "using the latest installed ${android_platform_latest} instead.")
+        set(QT_ANDROID_API_USED_FOR_JAVA ${android_platform_latest})
+    endif()
+endif()
+
+set(QT_ANDROID_JAR "${ANDROID_SDK_ROOT}/platforms/${QT_ANDROID_API_USED_FOR_JAVA}/android.jar")
+if(NOT EXISTS "${QT_ANDROID_JAR}")
+    message(FATAL_ERROR
+        "No suitable Android SDK platform found in '${ANDROID_SDK_ROOT}/platforms'."
+        " The minimum version required for building Java code is ${QT_ANDROID_API_USED_FOR_JAVA}"
+    )
+endif()
+
+message(STATUS "Using Android SDK API ${QT_ANDROID_API_USED_FOR_JAVA} from "
+               "${ANDROID_SDK_ROOT}/platforms")
 
 # Locate Java
 include(UseJava)
@@ -111,10 +136,8 @@ define_property(TARGET
 
 # Returns test execution arguments for Android targets
 function(qt_internal_android_test_runner_arguments target out_test_runner out_test_arguments)
-    qt_internal_get_host_info_var_prefix(host_info_var_prefix)
+    set(${out_test_runner} "${QT_HOST_PATH}/${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR}/androidtestrunner" PARENT_SCOPE)
-    set(host_bin_dir "${QT_HOST_PATH}/${${host_info_var_prefix}_BINDIR}")
+    set(deployment_tool "${QT_HOST_PATH}/${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR}/androiddeployqt")
-    set(${out_test_runner} "${host_bin_dir}/androidtestrunner" PARENT_SCOPE)
-    set(deployment_tool "${host_bin_dir}/androiddeployqt")
 
     _qt_internal_android_get_target_android_build_dir(android_build_dir ${target})
     set(${out_test_arguments}

cmake/QtPluginConfig.cmake.in

@@ -22,6 +22,9 @@ cmake_minimum_required(VERSION @min_new_policy_version@...@max_new_policy_versio
 
 include(CMakeFindDependencyMacro)
 
+get_filename_component(_import_prefix "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_import_prefix "${_import_prefix}" REALPATH)
+
 if (NOT QT_NO_CREATE_TARGETS)
     # Find required dependencies, if any.
     if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Dependencies.cmake")

cmake/QtPluginHelpers.cmake

@@ -115,12 +115,6 @@ function(qt_internal_add_plugin target)
 
     qt_get_sanitized_plugin_type("${plugin_type}" plugin_type_escaped)
 
-    if(NOT TARGET qt_${plugin_type_escaped}_plugins_all)
-        add_custom_target(qt_${plugin_type_escaped}_plugins_all)
-    endif()
-    add_dependencies(qt_${plugin_type_escaped}_plugins_all ${target})
-
-
     set(output_directory_default "${QT_BUILD_DIR}/${INSTALL_PLUGINSDIR}/${plugin_type}")
     set(install_directory_default "${INSTALL_PLUGINSDIR}/${plugin_type}")
 
@@ -343,7 +337,6 @@ function(qt_internal_add_plugin target)
         list(APPEND qt_register_target_dependencies_args PUBLIC ${arg_PUBLIC_LIBRARIES})
     endif()
     if(qt_libs_private)
-        qt_internal_wrap_private_modules(qt_libs_private ${qt_libs_private})
         list(APPEND qt_register_target_dependencies_args PRIVATE ${qt_libs_private})
     endif()
     qt_internal_register_target_dependencies("${target}"

cmake/QtPrecompiledHeadersHelpers.cmake

@@ -8,50 +8,13 @@ function(qt_update_precompiled_header target precompiled_header)
 endfunction()
 
 function(qt_update_precompiled_header_with_library target library)
-    if(NOT TARGET "${library}")
+    if (TARGET "${library}")
-        return()
+        get_target_property(TARGET_TYPE "${library}" TYPE)
-    endif()
+        if (NOT TARGET_TYPE STREQUAL "INTERFACE_LIBRARY")
-
+            get_target_property(HEADER "${library}" MODULE_HEADER)
-    get_target_property(target_type "${library}" TYPE)
+            qt_update_precompiled_header("${target}" "${HEADER}")
-    if(target_type STREQUAL "INTERFACE_LIBRARY")
-        return()
-    endif()
-
-    get_target_property(header_file_path "${library}" MODULE_HEADER)
-    if(NOT header_file_path)
-        # The Qt module is imported from the Qt installation prefix.
-        # Calculate the module header location.
-        get_target_property(include_name "${library}" _qt_module_include_name)
-        if(NOT include_name)
-            message(DEBUG "Property _qt_module_include_name is not set on ${library}.")
-            return()
-        endif()
-
-        get_target_property(relative_include_dir "${library}" _qt_module_relative_include_dir)
-        if(NOT relative_include_dir)
-            message(DEBUG "Property _qt_module_relative_include_dir is not set on ${library}.")
-            return()
-        endif()
-
-        get_target_property(package_name ${library} _qt_package_name)
-        if(NOT package_name)
-            message(DEBUG "No package name found for ${library}.")
-            return()
-        endif()
-        set(package_location "${${package_name}_DIR}")
-        get_filename_component(absolute_include_dir
-            "${package_location}/${relative_include_dir}"
-            ABSOLUTE
-        )
-
-        set(header_file_path "${absolute_include_dir}/${include_name}")
-        if(NOT EXISTS "${header_file_path}")
-            message(DEBUG "Module header '${header_file_path}' does not exist.")
-            return()
         endif()
     endif()
-
-    qt_update_precompiled_header("${target}" "${header_file_path}")
 endfunction()
 
 function(qt_update_ignore_pch_source target sources)

cmake/QtPriHelpers.cmake

@@ -738,10 +738,9 @@ function(qt_generate_global_config_pri_file)
     endif()
 
     if(CMAKE_CROSSCOMPILING)
-        qt_internal_get_host_info_var_prefix(host_info_var_prefix)
         string(APPEND content "host_build {
-    QT_ARCH = ${${host_info_var_prefix}_ARCH}
+    QT_ARCH = ${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_ARCH}
-    QT_BUILDABI = ${${host_info_var_prefix}_BUILDABI}
+    QT_BUILDABI = ${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BUILDABI}
     QT_TARGET_ARCH = ${TEST_architecture_arch}
     QT_TARGET_BUILDABI = ${TEST_buildAbi}
 } else {
@@ -966,9 +965,8 @@ function(qt_generate_global_module_pri_file)
     set(arch "${TEST_architecture_arch}")
     list(JOIN TEST_subarch_result " " subarchs)
     if(CMAKE_CROSSCOMPILING)
-        qt_internal_get_host_info_var_prefix(host_info_var_prefix)
+        set(host_arch "${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_ARCH}")
-        set(host_arch "${${host_info_var_prefix}_ARCH}")
+        list(JOIN QT${PROJECT_VERSION_MAJOR}_HOST_INFO_SUBARCHS " " host_subarchs)
-        list(JOIN ${host_info_var_prefix}_SUBARCHS " " host_subarchs)
         string(APPEND content "host_build {
     QT_CPU_FEATURES.${host_arch} = ${host_subarchs}
 } else {

cmake/QtPrlHelpers.cmake

@@ -65,17 +65,9 @@ function(qt_generate_prl_file target install_dir)
         set(prefix_for_final_prl_name "$<TARGET_FILE_PREFIX:${target}>")
     endif()
 
-    # For macOS frameworks, the prl file should be placed under the Resources subdir.
+    # For frameworks, the prl file should be placed under the Resources subdir.
-    # For iOS, visionOS, watchOS, tvOS, there is no Resources subdir, and the contents needs to
-    # be placed directly in the framework root, as described at
-    # https://developer.apple.com/documentation/bundleresources/placing-content-in-a-bundle?language=objc
     get_target_property(is_framework ${target} FRAMEWORK)
-    if(APPLE AND (NOT CMAKE_SYSTEM_NAME OR CMAKE_SYSTEM_NAME STREQUAL "Darwin"))
+    if(is_framework)
-        set(is_macos TRUE)
-    else()
-        set(is_macos FALSE)
-    endif()
-    if(is_framework AND is_macos)
         get_target_property(fw_version ${target} FRAMEWORK_VERSION)
         string(APPEND prefix_for_final_prl_name "Versions/${fw_version}/Resources/")
     endif()

cmake/QtProcessConfigureArgs.cmake

@@ -230,34 +230,6 @@ function(qt_feature feature)
     set_property(GLOBAL PROPERTY COMMANDLINE_FEATURE_SECTION_${feature} "${arg_SECTION}")
 endfunction()
 
-function(qt_feature_alias feature)
-    cmake_parse_arguments(arg "NEGATE" "PURPOSE;SECTION;MESSAGE;ALIAS_OF_FEATURE;ALIAS_OF_CACHE" ""
-        ${ARGN})
-    set_property(GLOBAL APPEND PROPERTY COMMANDLINE_KNOWN_FEATURES "${feature}")
-    # Mark the feature as aliased
-    set(alias_note "alias of ")
-    if(arg_NEGATE)
-        string(APPEND alias_note "NOT ")
-    endif()
-    if(arg_ALIAS_OF_FEATURE)
-        string(APPEND alias_note "${arg_ALIAS_OF_FEATURE} Feature")
-    else()
-        string(APPEND alias_note "${arg_ALIAS_OF_CACHE} Cache")
-    endif()
-    set(arg_PURPOSE "(${alias_note}) ${arg_PURPOSE}")
-    set_property(GLOBAL PROPERTY COMMANDLINE_FEATURE_PURPOSE_${feature} "${arg_PURPOSE}")
-    set_property(GLOBAL PROPERTY COMMANDLINE_FEATURE_SECTION_${feature} "${arg_SECTION}")
-endfunction()
-
-function(qt_feature_deprecated feature)
-    cmake_parse_arguments(arg "" "PURPOSE;SECTION;MESSAGE" "" ${ARGN})
-    set_property(GLOBAL APPEND PROPERTY COMMANDLINE_KNOWN_FEATURES "${feature}")
-    # Mark the feature as deprecated
-    set(arg_PURPOSE "(DEPRECATED) ${arg_PURPOSE} ${arg_MESSAGE}")
-    set_property(GLOBAL PROPERTY COMMANDLINE_FEATURE_PURPOSE_${feature} "${arg_PURPOSE}")
-    set_property(GLOBAL PROPERTY COMMANDLINE_FEATURE_SECTION_${feature} "${arg_SECTION}")
-endfunction()
-
 function(find_package)
     message(FATAL_ERROR "find_package must not be used directly in configure.cmake. "
         "Use qt_find_package or guard the call with an if(NOT QT_CONFIGURE_RUNNING) block.")
@@ -316,7 +288,7 @@ endmacro()
 
 function(qt_commandline_option name)
     set(options CONTROLS_FEATURE)
-    set(oneValueArgs TYPE NAME VALUE CMAKE_VARIABLE)
+    set(oneValueArgs TYPE NAME VALUE)
     set(multiValueArgs VALUES MAPPING)
     cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
@@ -327,9 +299,6 @@ function(qt_commandline_option name)
         set(input_name ${arg_NAME})
         set(commandline_option_${name}_variable "${arg_NAME}" PARENT_SCOPE)
     endif()
-    if(DEFINED arg_CMAKE_VARIABLE)
-        set_property(GLOBAL PROPERTY INPUTCMAKEVAR_${input_name} "${arg_CMAKE_VARIABLE}")
-    endif()
     set(mapping_type "${arg_TYPE}")
     if(arg_CONTROLS_FEATURE)
         set(mapping_type "boolean")
@@ -348,13 +317,11 @@ endfunction()
 # Add the common command line options for every qt repo.
 macro(qt_add_common_commandline_options)
     qt_commandline_option(headersclean TYPE boolean)
-    qt_commandline_option(sbom TYPE boolean CMAKE_VARIABLE QT_GENERATE_SBOM)
+    qt_commandline_option(sbom TYPE boolean)
-    qt_commandline_option(sbom-json TYPE boolean CMAKE_VARIABLE QT_SBOM_GENERATE_JSON)
+    qt_commandline_option(sbom-json TYPE boolean)
-    qt_commandline_option(sbom-json-required TYPE boolean
+    qt_commandline_option(sbom-json-required TYPE boolean)
-        CMAKE_VARIABLE QT_SBOM_REQUIRE_GENERATE_JSON
+    qt_commandline_option(sbom-verify TYPE boolean)
-    )
+    qt_commandline_option(sbom-verify-required TYPE boolean)
-    qt_commandline_option(sbom-verify TYPE boolean CMAKE_VARIABLE QT_SBOM_VERIFY)
-    qt_commandline_option(sbom-verify-required TYPE boolean CMAKE_VARIABLE QT_SBOM_REQUIRE_VERIFY)
 endmacro()
 
 function(qt_commandline_prefix arg var)
@@ -538,18 +505,6 @@ function(qt_commandline_string arg val nextok)
     endif()
 endfunction()
 
-# Handle command line arguments of type "path" exactly like strings.
-# They are treated differently by translate_input, however.
-function(qt_commandline_path arg val nextok)
-    qt_commandline_string("${arg}" "${val}" "${nextok}")
-endfunction()
-
-# Handle command line arguments of type "stringList" exactly like strings.
-# They are treated differently by translate_input, however.
-function(qt_commandline_stringList arg val nextok)
-    qt_commandline_string("${arg}" "${val}" "${nextok}")
-endfunction()
-
 function(qt_commandline_optionalString arg val nextok)
     if("${val}" STREQUAL "")
         if(nextok)
@@ -843,10 +798,9 @@ get_property(config_inputs GLOBAL PROPERTY CONFIG_INPUTS)
 list(REMOVE_DUPLICATES config_inputs)
 foreach(var ${config_inputs})
     get_property(INPUT_${var} GLOBAL PROPERTY INPUT_${var})
-    if("${commandline_input_${var}_type}" STREQUAL "")
+    if("${commandline_input_type}" STREQUAL "")
         get_property(commandline_input_${var}_type GLOBAL PROPERTY INPUTTYPE_${var})
     endif()
-    get_property(commandline_input_${var}_cmake_variable GLOBAL PROPERTY INPUTCMAKEVAR_${var})
 endforeach()
 
 macro(drop_input name)
@@ -888,24 +842,6 @@ macro(translate_list_input name cmake_var)
     endif()
 endmacro()
 
-macro(translate_input name cmake_var)
-    if("${commandline_input_${name}_type}" STREQUAL "boolean")
-        translate_boolean_input(${name} ${cmake_var})
-    elseif("${commandline_input_${name}_type}" STREQUAL "path")
-        translate_path_input(${name} ${cmake_var})
-    elseif("${commandline_input_${name}_type}" STREQUAL "string")
-        translate_string_input(${name} ${cmake_var})
-    elseif("${commandline_input_${name}_type}" STREQUAL "addString"
-            OR "${commandline_input_${name}_type}" STREQUAL "stringList")
-        translate_list_input(${name} ${cmake_var})
-    else()
-        message(FATAL_ERROR
-            "translate_input cannot handle input '${name}' "
-            "of type '${commandline_input_${name}_type}'."
-        )
-    endif()
-endmacro()
-
 # Check whether to guess the compiler for the given language.
 #
 # Sets ${out_var} to FALSE if one of the following holds:
@@ -987,23 +923,47 @@ function(check_qt_build_parts type)
     set(cmake_args "${cmake_args}" PARENT_SCOPE)
 endfunction()
 
-# Translate command line arguments that have CMAKE_VARIABLE set.
-foreach(input IN LISTS config_inputs)
-    if(NOT "${commandline_input_${input}_cmake_variable}" STREQUAL "")
-        translate_input("${input}" "${commandline_input_${input}_cmake_variable}")
-    endif()
-endforeach()
-
 drop_input(commercial)
 drop_input(confirm-license)
+translate_boolean_input(precompile_header BUILD_WITH_PCH)
+translate_boolean_input(unity_build QT_UNITY_BUILD)
+translate_string_input(unity_build_batch_size QT_UNITY_BUILD_BATCH_SIZE)
+translate_boolean_input(ccache QT_USE_CCACHE)
+translate_boolean_input(vcpkg QT_USE_VCPKG)
+translate_boolean_input(sbom QT_GENERATE_SBOM)
+translate_boolean_input(sbom-json QT_SBOM_GENERATE_JSON)
+translate_boolean_input(sbom-json-required QT_SBOM_REQUIRE_GENERATE_JSON)
+translate_boolean_input(sbom-verify QT_SBOM_VERIFY)
+translate_boolean_input(sbom-verify-required QT_SBOM_REQUIRE_VERIFY)
 translate_boolean_input(shared BUILD_SHARED_LIBS)
+translate_boolean_input(warnings_are_errors WARNINGS_ARE_ERRORS)
+translate_boolean_input(qtinlinenamespace QT_INLINE_NAMESPACE)
+translate_string_input(qt_namespace QT_NAMESPACE)
+translate_string_input(qt_libinfix QT_LIBINFIX)
+translate_string_input(qreal QT_COORD_TYPE)
+translate_path_input(prefix CMAKE_INSTALL_PREFIX)
+translate_path_input(extprefix CMAKE_STAGING_PREFIX)
+foreach(kind bin lib archdata libexec qml data doc sysconf examples tests)
+    string(TOUPPER ${kind} uc_kind)
+    translate_path_input(${kind}dir INSTALL_${uc_kind}DIR)
+endforeach()
+translate_path_input(headerdir INSTALL_INCLUDEDIR)
+translate_path_input(plugindir INSTALL_PLUGINSDIR)
+translate_path_input(translationdir INSTALL_TRANSLATIONSDIR)
+translate_path_input(sbomdir INSTALL_SBOMDIR)
 
 if(NOT "${INPUT_device}" STREQUAL "")
     push("-DQT_QMAKE_TARGET_MKSPEC=devices/${INPUT_device}")
     drop_input(device)
 endif()
+translate_string_input(platform QT_QMAKE_TARGET_MKSPEC)
+translate_string_input(xplatform QT_QMAKE_TARGET_MKSPEC)
 guess_compiler_from_mkspec()
+translate_string_input(qpa_default_platform QT_QPA_DEFAULT_PLATFORM)
+translate_list_input(qpa_platforms QT_QPA_PLATFORMS)
 
+translate_path_input(android-sdk ANDROID_SDK_ROOT)
+translate_path_input(android-ndk ANDROID_NDK_ROOT)
 if(DEFINED INPUT_android-ndk-platform)
     drop_input(android-ndk-platform)
     push("-DANDROID_PLATFORM=${INPUT_android-ndk-platform}")
@@ -1015,9 +975,14 @@ if(DEFINED INPUT_android-abis)
     endif()
     translate_string_input(android-abis ANDROID_ABI)
 endif()
+translate_string_input(android-javac-source QT_ANDROID_JAVAC_SOURCE)
+translate_string_input(android-javac-target QT_ANDROID_JAVAC_TARGET)
+
+translate_string_input(sdk QT_APPLE_SDK)
 
 drop_input(make)
 drop_input(nomake)
+translate_boolean_input(install-examples-sources QT_INSTALL_EXAMPLES_SOURCES)
 
 check_qt_build_parts(nomake)
 check_qt_build_parts(make)
@@ -1082,7 +1047,10 @@ if("${INPUT_ltcg}" STREQUAL "yes")
     endforeach()
 endif()
 
-# Handle -D, -I and friends.
+translate_path_input(ffmpeg-dir FFMPEG_DIR)
+translate_boolean_input(ffmpeg-deploy QT_DEPLOY_FFMPEG)
+
+translate_list_input(device-option QT_QMAKE_DEVICE_OPTIONS)
 translate_list_input(defines QT_EXTRA_DEFINES)
 translate_list_input(fpaths QT_EXTRA_FRAMEWORKPATHS)
 translate_list_input(includes QT_EXTRA_INCLUDEPATHS)

cmake/QtPublicAndroidHelpers.cmake

@@ -45,36 +45,3 @@ function(_qt_internal_sort_android_platforms out_var)
     endif()
     set("${out_var}" "${platforms}" PARENT_SCOPE)
 endfunction()
-
-function(_qt_internal_locate_android_jar)
-    # This variable specifies the API level used for building Java code, it can be the same as Qt
-    # for Android's maximum supported Android version or higher.
-    if(NOT QT_ANDROID_API_USED_FOR_JAVA)
-        set(QT_ANDROID_API_USED_FOR_JAVA "android-35")
-    endif()
-
-    set(jar_location "${ANDROID_SDK_ROOT}/platforms/${QT_ANDROID_API_USED_FOR_JAVA}/android.jar")
-    if(NOT EXISTS "${jar_location}")
-        _qt_internal_detect_latest_android_platform(android_platform_latest)
-        if(android_platform_latest)
-            message(NOTICE "The default platform SDK ${QT_ANDROID_API_USED_FOR_JAVA} not found, "
-                "using the latest installed ${android_platform_latest} instead.")
-            set(QT_ANDROID_API_USED_FOR_JAVA ${android_platform_latest})
-        endif()
-    endif()
-
-    set(QT_ANDROID_JAR "${ANDROID_SDK_ROOT}/platforms/${QT_ANDROID_API_USED_FOR_JAVA}/android.jar")
-    if(NOT EXISTS "${QT_ANDROID_JAR}")
-        message(FATAL_ERROR
-            "No suitable Android SDK platform found in '${ANDROID_SDK_ROOT}/platforms'."
-            " The minimum version required for building Java code is ${QT_ANDROID_API_USED_FOR_JAVA}"
-        )
-    endif()
-
-    message(STATUS "Using Android SDK API ${QT_ANDROID_API_USED_FOR_JAVA} from "
-        "${ANDROID_SDK_ROOT}/platforms")
-
-    set(QT_ANDROID_JAR "${QT_ANDROID_JAR}" PARENT_SCOPE)
-    set(QT_ANDROID_API_USED_FOR_JAVA "${QT_ANDROID_API_USED_FOR_JAVA}" PARENT_SCOPE)
-endfunction()
-

cmake/QtPublicAppleHelpers.cmake

@@ -811,50 +811,19 @@ endif()")
     set(${out_var} "${assignments}" PARENT_SCOPE)
 endfunction()
 
-# Returns the active apple sdk name that was either explicitly set by the user via QT_APPLE_SDK or
-# or CMAKE_OSX_SYSROOT, or return the default approximated value, based on what CMake does
-# internally.
-#
-# TODO: Handle case when CMAKE_OSX_SYSROOT is set to an sdk path, from which we need to retrieve the
-# sdk name.
 function(_qt_internal_get_apple_sdk_name out_var)
-    if(NOT APPLE)
+    set(sdk_name "")
-        set(${out_var} "" PARENT_SCOPE)
+    if(APPLE)
-        return()
-    endif()
-
-    # If CMake or the user has set an explicit sdk name, consider it.
-    if(QT_APPLE_SDK)
-        set(explicit_sdk_name "${QT_APPLE_SDK}")
-    elseif(CMAKE_OSX_SYSROOT)
-        set(explicit_sdk_name "${CMAKE_OSX_SYSROOT}")
-    else()
-        set(explicit_sdk_name "")
-    endif()
-
-    set(output_sdk_name "")
-
-    # Detect (or check if already set) that the sdk name is one that Qt knows about.
         if(CMAKE_SYSTEM_NAME STREQUAL iOS)
-        if(explicit_sdk_name STREQUAL "iphoneos" OR explicit_sdk_name STREQUAL "iphonesimulator")
+            set(sdk_name "iphoneos")
-            set(output_sdk_name "${explicit_sdk_name}")
-        else()
-            # Default case.
-            set(output_sdk_name "iphoneos")
-        endif()
         elseif(CMAKE_SYSTEM_NAME STREQUAL visionOS)
-        if(explicit_sdk_name STREQUAL "xros" OR explicit_sdk_name STREQUAL "xrsimulator")
+            set(sdk_name "xros")
-            set(output_sdk_name "${explicit_sdk_name}")
         else()
-            # Default case.
+            # Default to macOS
-            set(output_sdk_name "xros")
+            set(sdk_name "macosx")
         endif()
-    else()
-        # Default case.
-        set(output_sdk_name "macosx")
     endif()
-
+    set(${out_var} "${sdk_name}" PARENT_SCOPE)
-    set(${out_var} "${output_sdk_name}" PARENT_SCOPE)
 endfunction()
 
 function(_qt_internal_execute_xcrun out_var)

cmake/QtPublicCMakeEarlyPolicyHelpers.cmake

@@ -1,24 +0,0 @@
-# Copyright (C) 2025 The Qt Company Ltd.
-# SPDX-License-Identifier: BSD-3-Clause
-
-# Save the current value of the CMP0156 policy in a propert of the current directory scope.
-function(__qt_internal_save_directory_scope_policy_cmp0156)
-    if(NOT POLICY CMP0156)
-        return()
-    endif()
-
-    # Exit early if we already saved the policy value for this directory scope.
-    get_property(policy_value_set DIRECTORY PROPERTY _qt_internal_policy_cmp0156_value_set)
-    if(policy_value_set)
-        return()
-    endif()
-
-    cmake_policy(GET CMP0156 policy_value)
-    set_property(DIRECTORY PROPERTY _qt_internal_policy_cmp0156_value "${policy_value}")
-    set_property(DIRECTORY PROPERTY _qt_internal_policy_cmp0156_value_set "TRUE")
-endfunction()
-
-function(__qt_internal_get_directory_scope_policy_cmp0156 out_var)
-    get_property(policy_value DIRECTORY PROPERTY _qt_internal_policy_cmp0156_value)
-    set(${out_var} "${policy_value}" PARENT_SCOPE)
-endfunction()

cmake/QtPublicCMakeHelpers.cmake

@@ -153,7 +153,7 @@ function(__qt_internal_collect_additional_module_paths)
         if(is_path_to_cmake)
             list(APPEND CMAKE_MODULE_PATH "${prefix_path}/${QT_CMAKE_EXPORT_NAMESPACE}")
         else()
-            __qt_internal_get_possible_cmake_dirs(additional_cmake_dirs "${prefix_path}")
+            __qt_internal_get_possible_cmake_dirs(additional_cmake_dirs "${additional_path}")
             list(TRANSFORM additional_cmake_dirs APPEND "/${QT_CMAKE_EXPORT_NAMESPACE}")
             list(APPEND CMAKE_MODULE_PATH ${additional_cmake_dirs})
         endif()
@@ -174,21 +174,6 @@ function(__qt_internal_prefix_paths_to_roots out_var prefix_paths)
     set("${out_var}" "${result}" PARENT_SCOPE)
 endfunction()
 
-function(_qt_internal_get_check_cxx_source_compiles_out_var out_output_var out_func_args)
-    # This just resets the output var in the parent scope to an empty string.
-    set(${out_output_var} "" PARENT_SCOPE)
-
-    # OUTPUT_VARIABLE is an internal undocumented variable of check_cxx_source_compiles
-    # since 3.23. Allow an opt out in case this breaks in the future.
-    set(extra_func_args "")
-    if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.23"
-            AND NOT QT_INTERNAL_NO_TRY_COMPILE_OUTPUT_VARIABLE)
-        set(extra_func_args OUTPUT_VARIABLE ${out_output_var})
-    endif()
-
-    set(${out_func_args} "${extra_func_args}" PARENT_SCOPE)
-endfunction()
-
 # This function gets all targets below this directory
 #
 # Multi-value Arguments:
@@ -813,55 +798,6 @@ function(_qt_internal_relative_path path_var)
     set(${arg_OUTPUT_VARIABLE} "${${arg_OUTPUT_VARIABLE}}" PARENT_SCOPE)
 endfunction()
 
-# Compatibility of `cmake_path(IS_PREFIX)`
-#
-# NORMALIZE keyword is not supported
-#
-# Synopsis
-#
-#   _qt_internal_path_is_prefix(<path-var> <input> <out-var>)
-#
-# Arguments
-#
-# `path-var`
-#   Equivalent to `cmake_path(IS_PREFIX <path-var>)`.
-#
-# `input`
-#   Equivalent to `cmake_path(IS_PREFIX <input>)`.
-#
-# `out-var`
-#   Equivalent to `cmake_path(IS_PREFIX <out-var>)`.
-function(_qt_internal_path_is_prefix path_var input out_var)
-
-    # Make sure the path ends with `/`
-    if(NOT ${path_var} MATCHES "/$")
-        set(${path_var} "${${path_var}}/")
-    endif()
-    # For the case input == path_var, we need to also include a trailing `/` to match the
-    # previous change. We discard the actual path for input so we can add it unconditionally
-    set(input "${input}/")
-    if(CMAKE_VERSION VERSION_LESS 3.20)
-        string(FIND "${input}" "${${path_var}}" find_pos)
-        if(find_pos EQUAL 0)
-            # input starts_with path_var
-            set(${out_var} ON)
-        else()
-            set(${out_var} OFF)
-        endif()
-    else()
-        cmake_path(IS_PREFIX ${path_var} ${input} ${out_var})
-    endif()
-    set(${out_var} "${${out_var}}" PARENT_SCOPE)
-endfunction()
-
-function(qt_set01 result)
-    if (${ARGN})
-        set("${result}" 1 PARENT_SCOPE)
-    else()
-        set("${result}" 0 PARENT_SCOPE)
-    endif()
-endfunction()
-
 # Configures the file using either the input template or the CONTENT.
 # Behaves as either file(CONFIGURE or configure_file( command, but do not depend
 # on CMake version.
@@ -933,50 +869,3 @@ function(_qt_internal_configure_file mode)
 
     configure_file("${input_file}" "${arg_OUTPUT}" @ONLY)
 endfunction()
-
-# The function checks if `value` is a valid C indentifier.
-#
-# Synopsis
-#
-#  _qt_internal_is_c_identifier(<out_var> <value>)
-#
-# Arguments
-#
-#  `out_var`
-#    Variable name for the evaluation result.
-#
-#  `value`
-#    The string for the evaluation.
-function(_qt_internal_is_c_identifier out_var value)
-    string(MAKE_C_IDENTIFIER "${value}" value_valid)
-
-    if(value AND "${value}" STREQUAL "${value_valid}")
-        set(${out_var} "TRUE" PARENT_SCOPE)
-    else()
-        set(${out_var} "FALSE" PARENT_SCOPE)
-    endif()
-endfunction()
-
-# Makes appending of the CMake configure time dependencies unique.
-function(_qt_internal_append_cmake_configure_depends)
-    get_property(configure_depends DIRECTORY PROPERTY CMAKE_CONFIGURE_DEPENDS)
-    foreach(path IN LISTS ARGN)
-        get_filename_component(abs_path "${path}" REALPATH)
-        if(NOT "${abs_path}" IN_LIST configure_depends)
-            list(APPEND configure_depends "${abs_path}")
-        endif()
-    endforeach()
-    set_property(DIRECTORY PROPERTY CMAKE_CONFIGURE_DEPENDS "${configure_depends}")
-endfunction()
-
-function(_qt_internal_get_moc_compiler_flavor_flags out_var)
-    set(flags "")
-    if(WIN32)
-        list(APPEND flags -DWIN32)
-    endif()
-    if(MSVC)
-        list(APPEND flags --compiler-flavor=msvc)
-    endif()
-
-    set(${out_var} "${flags}" PARENT_SCOPE)
-endfunction()

cmake/QtPublicCMakeVersionHelpers.cmake

@@ -104,88 +104,21 @@ function(__qt_internal_require_suitable_cmake_version_for_using_qt)
     endif()
 endfunction()
 
-# Handle force-assignment of CMP0156 policy when using CMake 3.29+.
-#
-# For Apple-platforms we set it to NEW, to avoid duplicate linker issues when using -ObjC flag.
-#
-# For non-Apple platforms we set it to OLD, because we haven't done the necessary testing to
-# see which platforms / linkers can handle the new deduplication behavior, without breaking the
-# various linking techniques that Qt uses for object library propagation.
 function(__qt_internal_set_cmp0156)
-    # Exit early if not using CMake 3.29+
+    if(POLICY CMP0156)
-    if(NOT POLICY CMP0156)
-        return()
-    endif()
-
-    # Honor this variable if it's set and TRUE. It was previously introduced to allow working around
-    # the forced OLD value.
         if(QT_FORCE_CMP0156_TO_NEW)
-        get_cmake_property(debug_message_shown _qt_internal_cmp0156_debug_message_shown)
-        if(NOT debug_message_shown)
-            message(DEBUG "Force setting the CMP0156 policy to user provided value: NEW")
-            set_property(GLOBAL PROPERTY _qt_internal_cmp0156_debug_message_shown TRUE)
-        endif()
-
             cmake_policy(SET CMP0156 "NEW")
-        return()
-    endif()
-
-    # Allow forcing to OLD / NEW or empty behavior due the default being NEW for Apple platforms.
-    if(QT_FORCE_CMP0156_TO_VALUE)
-        cmake_policy(SET CMP0156 "${QT_FORCE_CMP0156_TO_VALUE}")
-        message(DEBUG "Force setting the CMP0156 policy to user provided value: "
-            "${QT_FORCE_CMP0156_TO_VALUE}")
-        return()
-    endif()
-
-    # Get the current value of the policy, as saved by the Qt6 package as soon as it is found.
-    # We can't just do cmake_policy(GET CMP0156 policy_value) here, because our Qt6Config.cmake and
-    # Qt6FooConfig.cmake files use cmake_minimum_required, which reset the policy value that
-    # might have been set by the project developer or the user.
-    # And a function uses the policy values that were set when the function was defined, not when
-    # it is called.
-    __qt_internal_get_directory_scope_policy_cmp0156(policy_value)
-
-    # Apple linkers (legacy Apple ld64, as well as the new ld-prime) don't care about the
-    # link line order when linking static libraries, compared to Linux GNU ld.
-    # But they care about duplicate static frameworks (not libraries) when used in conjunction with
-    # the -ObjC flag, which force loads all static libraries / frameworks that contain Objective-C
-    # categories or classes. This can cause duplicate symbol errors.
-    # To avoid the issue, we want to enable the policy, so we de-duplicate the libraries.
-    if(APPLE)
-        set(default_policy_value NEW)
-        set(unsupported_policy_value OLD)
-        set(platform_string "Apple")
         else()
-        # For non-Apple linkers, we keep the previous behavior of not deduplicating libraries,
+            cmake_policy(GET CMP0156 policy_value)
-        # because we haven't done the necessary testing to identify on which platforms
+            if(NOT "${policy_value}" STREQUAL "OLD")
-        # it is safe to deduplicate.
+                if("${policy_value}" STREQUAL "NEW" AND NOT QT_BUILDING_QT)
-        set(default_policy_value OLD)
+                    message(WARNING "CMP0156 is set to '${policy_value}'. Qt forces the 'OLD'"
-        set(unsupported_policy_value NEW)
+                        " behavior of this policy by default. Set QT_FORCE_CMP0156_TO_NEW=ON to"
-        set(platform_string "non-Apple")
+                        " force the 'NEW' behavior for the Qt commands that create either"
-    endif()
-
-    # Force set the default policy value for the given platform, even if the policy value is
-    # the same or empty. That's because in the calling function scope, the value can be empty
-    # due to the cmake_minimum_required call in Qt6Config.cmake resetting the policy value.
-    get_cmake_property(debug_message_shown _qt_internal_cmp0156_debug_message_shown)
-    if(NOT debug_message_shown)
-        message(DEBUG "Force setting the CMP0156 policy to '${default_policy_value}' "
-            "for ${platform_string} platforms.")
-        set_property(GLOBAL PROPERTY _qt_internal_cmp0156_debug_message_shown TRUE)
-    endif()
-
-    cmake_policy(SET CMP0156 "${default_policy_value}")
-
-    # If the policy is explicitly set to a value other than the default, issue a warning.
-    # Don't show the warning if the policy is unset, which would be the default for most
-    # projects, because it's too much noise. Also don't show it for Qt builds.
-    if("${policy_value}" STREQUAL "${unsupported_policy_value}" AND NOT QT_BUILDING_QT)
-        message(WARNING
-            "CMP0156 is set to '${policy_value}'. Qt forces the '${default_policy_value}'"
-            " behavior of this policy for ${platform_string} platforms by default."
-            " Set QT_FORCE_CMP0156_TO_VALUE=${unsupported_policy_value} to force"
-            " the '${unsupported_policy_value}' behavior for Qt commands that create"
                         " library or executable targets.")
                 endif()
+                cmake_policy(SET CMP0156 "OLD")
+            endif()
+        endif()
+    endif()
 endfunction()

cmake/QtPublicDependencyHelpers.cmake

@@ -127,11 +127,6 @@ endmacro()
 # contain preformed dependencies. See foreach block for reference.
 # The same applies for find_dependency_path_list.
 macro(_qt_internal_find_qt_dependencies target target_dep_list find_dependency_path_list)
-    list(APPEND __qt_${target}_find_qt_dependencies_save_QT_NO_PRIVATE_MODULE_WARNING
-        ${QT_NO_PRIVATE_MODULE_WARNING}
-    )
-    set(QT_NO_PRIVATE_MODULE_WARNING ON)
-
     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)
@@ -151,10 +146,6 @@ macro(_qt_internal_find_qt_dependencies target target_dep_list find_dependency_p
             endif()
         endif()
     endforeach()
-
-    list(POP_BACK __qt_${target}_find_qt_dependencies_save_QT_NO_PRIVATE_MODULE_WARNING
-        QT_NO_PRIVATE_MODULE_WARNING
-    )
 endmacro()
 
 # If a dependency package was not found, provide some hints in the error message on how to debug
@@ -321,23 +312,3 @@ macro(_qt_internal_setup_qt_host_path
         endif()
     endif()
 endmacro()
-
-function(_qt_internal_show_private_module_warning module)
-    if(DEFINED QT_REPO_MODULE_VERSION OR QT_NO_PRIVATE_MODULE_WARNING OR QT_FIND_PRIVATE_MODULES)
-        return()
-    endif()
-
-    get_cmake_property(warning_shown __qt_private_module_${module}_warning_shown)
-    if(warning_shown)
-        return()
-    endif()
-
-    message(WARNING
-        "This project is using headers of the ${module} module and will therefore be tied "
-        "to this specific Qt module build version. "
-        "Running this project against other versions of the Qt modules may crash at any arbitrary "
-        "point. This is not a bug, but a result of using Qt internals. You have been warned! "
-        "\nYou can disable this warning by setting QT_NO_PRIVATE_MODULE_WARNING to ON."
-    )
-    set_property(GLOBAL PROPERTY __qt_private_module_${module}_warning_shown TRUE)
-endfunction()

cmake/QtPublicPluginHelpers.cmake

@@ -413,6 +413,46 @@ function(__qt_internal_collect_plugin_targets_from_dependencies_of_plugins targe
     set("${out_var}" "${plugin_targets}" PARENT_SCOPE)
 endfunction()
 
+# Generate plugin information files for deployment
+#
+# Arguments:
+# OUT_PLUGIN_TARGETS - Variable name to store the plugin targets that were collected with
+#                      __qt_internal_collect_plugin_targets_from_dependencies.
+function(__qt_internal_generate_plugin_deployment_info target)
+    set(no_value_options "")
+    set(single_value_options "OUT_PLUGIN_TARGETS")
+    set(multi_value_options "")
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "${no_value_options}" "${single_value_options}" "${multi_value_options}"
+    )
+
+    __qt_internal_collect_plugin_targets_from_dependencies("${target}" plugin_targets)
+    if(NOT "${arg_OUT_PLUGIN_TARGETS}" STREQUAL "")
+        set("${arg_OUT_PLUGIN_TARGETS}" "${plugin_targets}" PARENT_SCOPE)
+    endif()
+
+    get_target_property(marked_for_deployment ${target} _qt_marked_for_deployment)
+    if(NOT marked_for_deployment)
+        return()
+    endif()
+
+    __qt_internal_collect_plugin_library_files(${target} "${plugin_targets}" plugins_files)
+    set(plugins_files "$<FILTER:${plugins_files},EXCLUDE,^$>")
+
+    _qt_internal_get_deploy_impl_dir(deploy_impl_dir)
+    set(file_path "${deploy_impl_dir}/${target}-plugins")
+    get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG)
+    if(is_multi_config)
+        string(APPEND file_path "-$<CONFIG>")
+    endif()
+    string(APPEND file_path ".cmake")
+
+    file(GENERATE
+        OUTPUT ${file_path}
+        CONTENT "set(__QT_DEPLOY_PLUGINS ${plugins_files})"
+    )
+endfunction()
+
 # Main logic of finalizer mode.
 function(__qt_internal_apply_plugin_imports_finalizer_mode target)
     # Process a target only once.
@@ -421,6 +461,9 @@ function(__qt_internal_apply_plugin_imports_finalizer_mode target)
         return()
     endif()
 
+    __qt_internal_generate_plugin_deployment_info(${target}
+        OUT_PLUGIN_TARGETS plugin_targets)
+
     # By default if the project hasn't explicitly opted in or out, use finalizer mode.
     # The precondition for this is that qt_finalize_target was called (either explicitly by the user
     # or auto-deferred by CMake 3.19+).
@@ -434,7 +477,6 @@ function(__qt_internal_apply_plugin_imports_finalizer_mode target)
         return()
     endif()
 
-    __qt_internal_collect_plugin_targets_from_dependencies("${target}" plugin_targets)
     __qt_internal_collect_plugin_init_libraries("${plugin_targets}" init_libraries)
     __qt_internal_collect_plugin_libraries("${plugin_targets}" plugin_libraries)
 

cmake/QtPublicSbomFileHelpers.cmake

@@ -93,8 +93,8 @@ function(_qt_internal_sbom_handle_target_binary_files target)
         return()
     endif()
 
-    get_target_property(excluded_via_property ${target} _qt_internal_excluded_from_default_target)
+    get_target_property(excluded ${target} _qt_internal_excluded_from_default_target)
-    if(excluded_via_property OR QT_INTERNAL_TEST_TARGETS_EXCLUDE_FROM_ALL)
+    if(excluded)
         message(DEBUG "Target ${target} has no binary files to reference in the SBOM "
             "because it was excluded from the default 'all' target.")
         return()
@@ -814,9 +814,13 @@ function(_qt_internal_sbom_map_path_to_reproducible_relative_path out_var)
         if(IS_ABSOLUTE "${path}")
             set(path_in "${path}")
 
-            _qt_internal_path_is_prefix(PROJECT_SOURCE_DIR "${path}" is_in_source_dir)
+            string(FIND "${path}" "${PROJECT_SOURCE_DIR}/" src_idx)
-            if(NOT is_in_source_dir)
+            string(FIND "${path}" "${PROJECT_BINARY_DIR}/" dest_idx)
-                _qt_internal_path_is_prefix(PROJECT_BINARY_DIR "${path}" is_in_build_dir)
+
+            if(src_idx EQUAL "0")
+                set(is_in_source_dir TRUE)
+            elseif(dest_idx EQUAL "0")
+                set(is_in_build_dir TRUE)
             endif()
         else()
             # We consider relative paths to be relative to the current source dir.

cmake/QtPublicSbomHelpers.cmake

@@ -432,7 +432,8 @@ function(_qt_internal_sbom_end_project)
 
     # Add configure-time dependency on project attribution files.
     get_property(attribution_files GLOBAL PROPERTY _qt_internal_project_attribution_files)
-    _qt_internal_append_cmake_configure_depends(${attribution_files})
+    list(REMOVE_DUPLICATES attribution_files)
+    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${attribution_files}")
 endfunction()
 
 # Automatically begins sbom generation for a qt git repo unless QT_SKIP_SBOM_AUTO_PROJECT is TRUE.

cmake/QtPublicSbomOpsHelpers.cmake

@@ -612,7 +612,7 @@ function(_qt_internal_sbom_verify_ntia_compliant)
             RESULT_VARIABLE res
         )
         if(NOT res EQUAL 0)
-            message(FATAL_ERROR \"SBOM NTIA verification failed: \${res}\")
+            message(FATAL_ERROR \"SBOM NTIA verification failed: \{res}\")
         endif()
 ")
 

cmake/QtQmakeHelpers.cmake

@@ -125,7 +125,6 @@ Prefix=${prefix}
         endif()
     endif()
 
-    qt_internal_get_host_info_var_prefix(host_info_var_prefix)
     string(APPEND content
         "[Paths]
 Prefix=${ext_prefix_relative_to_conf_file}
@@ -143,9 +142,9 @@ Examples=${INSTALL_EXAMPLESDIR}
 Tests=${INSTALL_TESTSDIR}
 Settings=${INSTALL_SYSCONFDIR}
 HostPrefix=${host_prefix_relative_to_conf_file}
-HostBinaries=${${host_info_var_prefix}_BINDIR}
+HostBinaries=${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR}
-HostLibraries=${${host_info_var_prefix}_LIBDIR}
+HostLibraries=${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBDIR}
-HostLibraryExecutables=${${host_info_var_prefix}_LIBEXECDIR}
+HostLibraryExecutables=${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR}
 HostData=${ext_datadir_relative_to_host_prefix}
 Sysroot=${sysroot}
 SysrootifyPrefix=${sysrootify_prefix}
@@ -170,7 +169,7 @@ HostSpec=${QT_QMAKE_HOST_MKSPEC}
         set(wrapper_prefix "host-")
     endif()
 
-    set(host_qt_bindir "${host_prefix}/${${host_info_var_prefix}_BINDIR}")
+    set(host_qt_bindir "${host_prefix}/${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_BINDIR}")
     file(TO_NATIVE_PATH "${host_qt_bindir}" host_qt_bindir)
 
     if(QT_CREATE_VERSIONED_HARD_LINK AND QT_WILL_INSTALL)

cmake/QtTargetHelpers.cmake

@@ -195,11 +195,9 @@ function(qt_internal_extend_target target)
                             ${private_visibility_option} ${arg_LINK_OPTIONS})
 
         if(NOT is_interface_lib)
-            _qt_internal_get_moc_compiler_flavor_flags(flavor_flags)
             set_property(TARGET "${target}" APPEND PROPERTY
-                AUTOMOC_MOC_OPTIONS "${arg_MOC_OPTIONS}" ${flavor_flags}
+                AUTOMOC_MOC_OPTIONS "${arg_MOC_OPTIONS}"
             )
-
             # Plugin types associated to a module
             if(NOT "x${arg_PLUGIN_TYPES}" STREQUAL "x")
                 qt_internal_add_plugin_types("${target}" "${arg_PLUGIN_TYPES}")
@@ -1241,10 +1239,9 @@ function(qt_internal_create_tracepoints name tracepoints_file)
         endif()
 
         if(NOT "${QT_HOST_PATH}" STREQUAL "")
-            qt_internal_get_host_info_var_prefix(host_info_var_prefix)
             qt_path_join(tracegen
                 "${QT_HOST_PATH}"
-                "${${host_info_var_prefix}_LIBEXECDIR}"
+                "${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR}"
                 "tracegen")
         else()
             set(tracegen "${QT_CMAKE_EXPORT_NAMESPACE}::tracegen")
@@ -1279,10 +1276,9 @@ function(qt_internal_generate_tracepoints name provider)
         endforeach()
 
         if(NOT "${QT_HOST_PATH}" STREQUAL "")
-            qt_internal_get_host_info_var_prefix(host_info_var_prefix)
             qt_path_join(tracepointgen
                 "${QT_HOST_PATH}"
-                "${${host_info_var_prefix}_LIBEXECDIR}"
+                "${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR}"
                 "tracepointgen")
         else()
             set(tracepointgen "${QT_CMAKE_EXPORT_NAMESPACE}::tracepointgen")
@@ -1313,10 +1309,9 @@ function(qt_internal_generate_tracepoints name provider)
         endif()
 
         if(NOT "${QT_HOST_PATH}" STREQUAL "")
-            qt_internal_get_host_info_var_prefix(host_info_var_prefix)
             qt_path_join(tracegen
                 "${QT_HOST_PATH}"
-                "${${host_info_var_prefix}_LIBEXECDIR}"
+                "${QT${PROJECT_VERSION_MAJOR}_HOST_INFO_LIBEXECDIR}"
                 "tracegen")
         else()
             set(tracegen "${QT_CMAKE_EXPORT_NAMESPACE}::tracegen")

cmake/QtTestHelpers.cmake

@@ -100,10 +100,6 @@ function(qt_internal_add_manual_test target)
     qt_internal_add_test(${ARGV} MANUAL)
 endfunction()
 
-macro(qt_internal_skip_docker_compose)
-    set(QT_SKIP_DOCKER_COMPOSE ON CACHE BOOL "Skip setting docker on Linux." FORCE)
-endmacro()
-
 # This function will configure the fixture for the network tests that require docker network services
 # qmake counterpart: qtbase/mkspecs/features/unsupported/testserver.prf
 function(qt_internal_setup_docker_test_fixture name)
@@ -123,7 +119,6 @@ function(qt_internal_setup_docker_test_fixture name)
     find_program(QT_DOCKER_COMPOSE docker-compose)
     if (NOT QT_DOCKER_COMPOSE)
         message(WARNING "docker-compose was not found. Docker network tests will not be run.")
-        qt_internal_skip_docker_compose()
         return()
     endif()
     if (NOT DEFINED QT_DOCKER_COMPOSE_VERSION)
@@ -135,7 +130,6 @@ function(qt_internal_setup_docker_test_fixture name)
     find_program(QT_DOCKER docker)
     if (NOT QT_DOCKER)
         message(WARNING "docker was not found. Docker network tests will not be run.")
-        qt_internal_skip_docker_compose()
         return()
     endif()
     if (NOT DEFINED QT_DOCKER_TEST_SERVER)
@@ -145,7 +139,6 @@ function(qt_internal_setup_docker_test_fixture name)
                 "Docker image qt-test-server-* not found.\n"
                 "Run the provisioning script (coin/provisioning/.../testserver/docker_testserver.sh) in advance\n"
                 "Docker network tests will not be run.")
-            qt_internal_skip_docker_compose()
             return()
         endif()
         set(QT_DOCKER_TEST_SERVER "ON" CACHE BOOL "docker qt-test-server-* present")
@@ -576,18 +569,14 @@ function(qt_internal_add_test name)
 
         # Manual tests can be bundle apps
         if(NOT arg_MANUAL)
-            if(NOT DEFINED CMAKE_MACOSX_BUNDLE)
             # Tests should not be bundles on macOS even if arg_GUI is true, because some tests make
             # assumptions about the location of helper processes, and those paths would be different
             # if a test is built as a bundle.
             set_property(TARGET "${name}" PROPERTY MACOSX_BUNDLE FALSE)
-            endif()
-            if(NOT DEFINED CMAKE_WIN32_EXECUTABLE)
             # The same goes for WIN32_EXECUTABLE, but because it will detach from the console window
             # and not print anything.
             set_property(TARGET "${name}" PROPERTY WIN32_EXECUTABLE FALSE)
         endif()
-        endif()
 
         # Tests on iOS must be app bundles.
         if(IOS)
@@ -753,40 +742,8 @@ function(qt_internal_add_test name)
         endif()
     else()
         if(arg_QMLTEST AND NOT arg_SOURCES)
-            set(qt_additional_libexec_paths "")
-
-            if(DEFINED QT_ADDITIONAL_PACKAGES_PREFIX_PATH)
-                foreach(additional_prefix IN LISTS QT_ADDITIONAL_PACKAGES_PREFIX_PATH)
-                    set(additional_libexec "${additional_prefix}/${QT6_INSTALL_LIBEXECS}")
-                    list(PREPEND qt_additional_libexec_paths "${additional_libexec}")
-                endforeach()
-            endif()
-
-            # First look for the scanner in the target qt libexec dir. We prefer this one
-            # over the tool target which might be for the host platform.
-            find_program(qmltestrunner_executable
-                NAMES qmltestrunner qmltestrunner.exe
-                PATHS "${QT6_INSTALL_PREFIX}/${QT6_INSTALL_LIBEXECS}"
-                    ${qt_additional_libexec_paths}
-                NO_DEFAULT_PATH
-            )
-
-            # If we don't find it in the paths, fallback to using target names.
-            if(NOT qmltestrunner_executable
-                    AND TARGET "${QT_CMAKE_EXPORT_NAMESPACE}::qmltestrunner")
-                set(qmltestrunner_executable ${QT_CMAKE_EXPORT_NAMESPACE}::qmltestrunner)
-            endif()
-
-            if(NOT qmltestrunner_executable AND TARGET qmltestrunner)
-                set(qmltestrunner_executable qmltestrunner)
-            endif()
-
-            if(NOT qmltestrunner_executable)
-                message(FATAL_ERROR "qmltestrunner not found.")
-            endif()
-
             set(test_working_dir "${CMAKE_CURRENT_SOURCE_DIR}")
-            set(test_executable "${qmltestrunner_executable}")
+            set(test_executable ${QT_CMAKE_EXPORT_NAMESPACE}::qmltestrunner)
         else()
             if (arg_WORKING_DIRECTORY)
                 set(test_working_dir "${arg_WORKING_DIRECTORY}")

cmake/QtTransitiveExtras.cmake.in

@@ -1,38 +0,0 @@
-# Copyright (C) 2025 The Qt Company Ltd.
-# SPDX-License-Identifier: BSD-3-Clause
-
-# This file sets the transitive properties supported by Qt Libraries.
-if(NOT QT_NO_CREATE_TARGETS AND CMAKE_VERSION VERSION_GREATER_EQUAL 3.30)
-    foreach(_qt_@target@_transitive_property_type COMPILE LINK)
-        string(TOLOWER "${_qt_@target@_transitive_property_type}"
-            _qt_@target@_transitive_property_type_lower)
-
-        get_target_property(_qt_@target@_transitive_properties @QT_CMAKE_EXPORT_NAMESPACE@::@target@
-            _qt_transitive_${_qt_@target@_transitive_property_type_lower}_properties)
-        if(NOT _qt_@target@_transitive_properties)
-            continue()
-        endif()
-
-        foreach(_qt_@target@_transitive_property IN LISTS _qt_@target@_transitive_properties)
-            string(TOLOWER "_qt_internal_${_qt_@target@_transitive_property}"
-                _qt_@target@_transitive_property_internal)
-            get_target_property(_qt_@target@_transitive_property_value
-                @QT_CMAKE_EXPORT_NAMESPACE@::@target@ ${_qt_@target@_transitive_property_internal})
-
-            if(_qt_@target@_transitive_property_value)
-                _qt_internal_add_transitive_property(@QT_CMAKE_EXPORT_NAMESPACE@::@target@
-                    ${_qt_@target@_transitive_property_type} ${_qt_@target@_transitive_property})
-
-                set_property(TARGET @QT_CMAKE_EXPORT_NAMESPACE@::@target@ PROPERTY
-                    INTERFACE_${_qt_@target@_transitive_property}
-                    "${_qt_@target@_transitive_property_value}")
-            endif()
-        endforeach()
-    endforeach()
-    unset(_qt_@target@_transitive_property_value)
-    unset(_qt_@target@_transitive_property_internal)
-    unset(_qt_@target@_transitive_property)
-    unset(_qt_@target@_transitive_properties)
-    unset(_qt_@target@_transitive_property_type_lower)
-    unset(_qt_@target@_transitive_property_type)
-endif()

cmake/modulecppexports.h.in

@@ -22,7 +22,6 @@
 /* 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@_CONSTEXPR_INLINE_SINCE(major, minor) constexpr
 #  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:
@@ -31,8 +30,6 @@
  * 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@_CONSTEXPR_INLINE_SINCE(major, minor) \
-    QT_IF_DEPRECATED_SINCE(major, minor, constexpr, /* not inline */)
 #  define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) 1
 #else
 /* inside library, outside removed_api.cpp:
@@ -40,8 +37,6 @@
  * 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@_CONSTEXPR_INLINE_SINCE(major, minor) \
-    QT_IF_DEPRECATED_SINCE(major, minor, constexpr, /* not inline */)
 #  define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) \
     QT_IF_DEPRECATED_SINCE(major, minor, 1, 0)
 #endif

coin/instructions/cmake_cross_compilation_module_build_instructions.yaml

@@ -93,19 +93,6 @@ instructions:
   - type: EnvironmentVariable
     variableName: DESTDIR
     variableValue: ""
-  - type: SignPackage
-    directory: "{{.InstallRoot}}/{{.AgentWorkingDir}}"
-    maxTimeInSeconds: 1200
-    maxTimeBetweenOutput: 1200
-    enable_if:
-      condition: and
-      conditions:
-        - condition: property
-          property: host.os
-          equals_value: Windows
-        - condition: property
-          property: features
-          contains_value: Packaging
   - type: UploadArtifact
     archiveDirectory: "{{.InstallRoot}}/{{.AgentWorkingDir}}"
     transferType: UploadModuleBuildArtifact

coin/instructions/cmake_cross_compilation_qtbase_build_instructions.yaml

@@ -83,19 +83,6 @@ instructions:
   - type: EnvironmentVariable
     variableName: DESTDIR
     variableValue: ""
-  - type: SignPackage
-    directory: "{{.InstallRoot}}/{{.AgentWorkingDir}}"
-    maxTimeInSeconds: 1200
-    maxTimeBetweenOutput: 1200
-    enable_if:
-      condition: and
-      conditions:
-        - condition: property
-          property: host.os
-          equals_value: Windows
-        - condition: property
-          property: features
-          contains_value: Packaging
   - type: UploadArtifact
     archiveDirectory: "{{.InstallRoot}}/{{.AgentWorkingDir}}"
     transferType: UploadModuleBuildArtifact

coin/instructions/cmake_regular_test_instructions.yaml

@@ -16,30 +16,4 @@ instructions:
   - type: ChangeDirectory
     directory: "{{.SourceDir}}_standalone_tests"
 
-  # For configurations with granular test significance,
-  # make the tests significant by default, unless a module
-  # explicitly overrides it.
-  - type: Group
-    enable_if:
-      condition: and
-      conditions:
-        - condition: property
-          property: features
-          not_contains_value: "InsignificantTests"
-        - condition: runtime
-          env_var: COIN_CTEST_IGNORE_EXIT_CODE
-          equals_value: "1"
-        - condition: or
-          conditions:
-            - condition: property
-              property: id
-              contains_value: "macos-15"
-        - condition: runtime
-          env_var: COIN_CTEST_FORCE_IGNORE_EXIT_CODE
-          equals_value: null
-    instructions:
-      - type: EnvironmentVariable
-        variableName: COIN_CTEST_IGNORE_EXIT_CODE
-        variableValue: "0"
-
   - !include "{{qt/qtbase}}/cmake_run_ctest.yaml"

coin/instructions/coin_module_build_template_v2.yaml

@@ -52,9 +52,6 @@ instructions:
         - condition: runtime
           env_var: TESTED_MODULE_COIN
           not_equals_value: "qtwebengine"
-        - condition: runtime
-          env_var: TESTED_MODULE_COIN
-          not_equals_value: "qtactiveqt"
   - type: Group
     instructions:
       - !include "{{qt/qtbase}}/cmake_cross_compilation_module_build_instructions.yaml"

config.tests/precompile_header/CMakeLists.txt

@@ -0,0 +1,8 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+cmake_minimum_required(VERSION 3.16)
+project(precompile_header LANGUAGES CXX)
+
+add_executable(precompile_header main.cpp)
+target_precompile_headers(precompile_header PRIVATE header.h)

config.tests/precompile_header/header.h

@@ -0,0 +1,8 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: BSD-3-Clause
+#ifndef HEADER_H
+#define HEADER_H
+
+// Nothing to see here. We just want the HEADER_H define.
+
+#endif

config.tests/precompile_header/main.cpp

@@ -0,0 +1,7 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: BSD-3-Clause
+#ifndef HEADER_H
+#    error no go
+#endif
+
+int main() {}

config_help.txt

@@ -272,7 +272,6 @@ Core options:
   -glib ................ Enable Glib support [no; auto on Unix]
   -inotify ............. Enable inotify support
   -icu ................. Enable ICU support [auto]
-  -jemalloc ............ Enable jemalloc support and cooperation [no]
   -pcre ................ Select used libpcre2 [system/qt/no]
   -zlib ................ Select used zlib [system/qt]
 

configure.cmake

@@ -288,6 +288,12 @@ int main(void)
     CXX_STANDARD 23
 )
 
+# precompile_header
+qt_config_compile_test(precompile_header
+    LABEL "precompiled header support"
+    PROJECT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/precompile_header"
+)
+
 qt_config_compiler_supports_flag_test(optimize_debug
     LABEL "-Og support"
     FLAG "-Og"
@@ -513,16 +519,15 @@ qt_feature("android-style-assets" PRIVATE
     LABEL "Android Style Assets"
     CONDITION ANDROID
 )
-qt_feature_alias("shared" PUBLIC
+qt_feature("shared" PUBLIC
     LABEL "Building shared libraries"
-    ALIAS_OF_CACHE BUILD_SHARED_LIBS
+    CONDITION BUILD_SHARED_LIBS
 )
 qt_feature_definition("shared" "QT_STATIC" NEGATE PREREQUISITE "!defined(QT_SHARED) && !defined(QT_STATIC)")
 qt_feature_config("shared" QMAKE_PUBLIC_QT_CONFIG)
 qt_feature_config("shared" QMAKE_PUBLIC_CONFIG)
-qt_feature_alias("static"
+qt_feature("static" PUBLIC
-    ALIAS_OF_FEATURE "shared"
+    CONDITION NOT QT_FEATURE_shared
-    NEGATE
 )
 qt_feature_config("static" QMAKE_PUBLIC_QT_CONFIG)
 qt_feature_config("static" QMAKE_PUBLIC_CONFIG)
@@ -726,6 +731,12 @@ qt_feature("c++2b" PUBLIC
     CONDITION QT_FEATURE_cxx20 AND (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20") AND TEST_cxx2b
 )
 qt_feature_config("c++2b" QMAKE_PUBLIC_QT_CONFIG)
+qt_feature("precompile_header"
+    LABEL "Using precompiled headers"
+    CONDITION BUILD_WITH_PCH AND TEST_precompile_header
+    AUTODETECT NOT WASM
+)
+qt_feature_config("precompile_header" QMAKE_PRIVATE_CONFIG)
 set(__qt_ltcg_detected FALSE)
 if(CMAKE_INTERPROCEDURAL_OPTIMIZATION)
     set(__qt_ltcg_detected TRUE)
@@ -1088,13 +1099,12 @@ qt_feature("network" PRIVATE
 )
 qt_feature("printsupport" PRIVATE
     LABEL "Qt PrintSupport"
-    CONDITION QT_FEATURE_widgets AND NOT WASM
+    CONDITION QT_FEATURE_widgets
     SECTION "Module"
     PURPOSE "Provides the Qt PrintSupport module."
 )
 qt_feature("sql" PRIVATE
     LABEL "Qt Sql"
-    CONDITION NOT WASM
     SECTION "Module"
     PURPOSE "Provides the Sql module."
 )
@@ -1265,7 +1275,6 @@ qt_configure_add_summary_entry(
 qt_configure_add_summary_entry(
     ARGS "optimize_full"
 )
-qt_configure_add_summary_entry(ARGS "force_asserts" CONDITION QT_FEATURE_force_asserts)
 qt_configure_add_summary_entry(ARGS "shared")
 qt_configure_add_summary_entry(
     ARGS "ccache"
@@ -1299,6 +1308,7 @@ qt_configure_add_summary_entry(
     CONDITION GCC AND NOT CLANG AND ( QT_FEATURE_debug OR QT_FEATURE_force_debug_info OR QT_FEATURE_debug_and_release )
 )
 qt_configure_add_summary_entry(ARGS "relocatable")
+qt_configure_add_summary_entry(ARGS "precompile_header")
 qt_configure_add_summary_entry(ARGS "ltcg")
 qt_configure_add_summary_entry(ARGS "intelcet")
 qt_configure_add_summary_entry(ARGS "glibc_fortify_source")
@@ -1441,16 +1451,17 @@ https://github.com/llvm/llvm-project/issues/53520
 ]=]
         )
     else()
-        string(CONCAT x86_intrin_error_message
+        string(CONCAT error_message
             "x86 intrinsics support missing. Check your compiler settings.\n"
-            "If this is a problem for you, report at https://bugreports.qt.io with your compiler ID and "
+            "If this is an error, report at https://bugreports.qt.io with your compiler ID and "
-            "version, and the TEST_x86intrin compile test output.\n"
+            "version, and this output:\n"
+            "\n"
+            "${TEST_x86intrin_OUTPUT}"
         )
         qt_configure_add_report_entry(
             TYPE ERROR
             CONDITION (NOT QT_FEATURE_x86intrin)
-            COMPILE_TESTS_TO_SHOW_ON_ERROR TEST_x86intrin
+            MESSAGE "${error_message}"
-            MESSAGE "${x86_intrin_error_message}"
         )
     endif()
 endif()
@@ -1471,8 +1482,8 @@ qt_configure_add_report_entry(
 )
 qt_configure_add_report_entry(
     TYPE WARNING
-    MESSAGE "Using Emscripten version ${EMCC_VERSION} with this Qt
+    MESSAGE "Using Emscripten version ${QT_EMCC_RECOMMENDED_VERSION} with this Qt
-    may have issues. The recommended version is ${QT_EMCC_RECOMMENDED_VERSION}."
+    may have issues. You have ${EMCC_VERSION}."
     CONDITION WASM AND ${EMCC_VERSION} VERSION_GREATER ${QT_EMCC_RECOMMENDED_VERSION}
 )
 qt_configure_add_report_entry(
@@ -1513,11 +1524,3 @@ qt_feature_definition("test_gui" "QT_GUI_TEST" VALUE "1")
 qt_feature("test_gui" PUBLIC
     LABEL "Build QtGuiTest namespace"
 )
-
-qt_configure_add_report_entry(
-    TYPE WARNING
-    MESSAGE "Starting with Qt 6.10, a -no-prefix or -developer-build
-Qt build might not find all necessary Qt packages when using CMake < 3.26.
-Please use a newer CMake version."
-    CONDITION QT_FEATURE_no_prefix AND CMAKE_VERSION VERSION_LESS "3.26"
-)

doc/CMakeLists.txt

@@ -19,7 +19,7 @@ foreach(dir global config)
             # dependencies should be set up in that case (coarsness, use install vs build dirs,
             # etc).
             file(GLOB_RECURSE files LIST_DIRECTORIES FALSE "${dir}/*")
-            _qt_internal_append_cmake_configure_depends(${files})
+            set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${files})
         endif()
     endif()
 endforeach()

doc/config/exampleurl-qt3d.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qt3d.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qt3d.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtactiveqt.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtactiveqt.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtactiveqt.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtbase.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtbase.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtbase.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtconnectivity.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtconnectivity.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtconnectivity.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtdatavis3d.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtdatavis3d.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtdatavis3d.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtdeclarative.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtdeclarative.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtdeclarative.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtlocation.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtlocation.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtlocation.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtmultimedia.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtmultimedia.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtmultimedia.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtnetworkauth.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtnetworkauth.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtnetworkauth.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtpositioning.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtpositioning.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtpositioning.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtremoteobjects.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtremoteobjects.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtremoteobjects.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtscxml.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtscxml.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtscxml.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtsensors.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtsensors.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtsensors.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtserialbus.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtserialbus.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtserialbus.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtserialport.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtserialport.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtserialport.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtspeech.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtspeech.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtspeech.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtsvg.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtsvg.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtsvg.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qttools.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qttools.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qttools.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtvirtualkeyboard.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtvirtualkeyboard.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtvirtualkeyboard.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtwayland.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtwayland.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtwayland.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtwebchannel.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtwebchannel.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtwebchannel.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtwebengine.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtwebengine.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtwebengine.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtwebsockets.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtwebsockets.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtwebsockets.git/tree/\1?h=$QT_VER#n\2"

doc/config/exampleurl-qtwebview.qdocconf

@@ -1,4 +1 @@
 url.examples = "https://code.qt.io/cgit/qt/qtwebview.git/tree/examples/\1?h=$QT_VER"
-
-# Automatic linking to declarations of C++ APIs
-url.sources  = "https://code.qt.io/cgit/qt/qtwebview.git/tree/\1?h=$QT_VER#n\2"

doc/global/externalsites/qtcreator.qdoc

@@ -1,24 +1,8 @@
 // Copyright (C) 2025 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
 
-// Up-to-date with Qt Creator 16.0.0
+// Up-to-date with Qt Creator 14.0.0
 
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-qtaiassistant.html
-    \title \QC: Use Qt AI Assistant
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-create-vxworks-kits.html
-    \title \QC: Create kits for VxWorks devices
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-create-lua-scripts.html
-    \title \QC: Create Lua scripts
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-manage-winappsdk.html
-    \title \QC: Manage Windows App SDK packages
-*/
 /*!
     \externalpage https://doc.qt.io/qtcreator/creator-deployment-qnx.html
     \title \QC: QNX Neutrino Deploy Configuration
@@ -85,12 +69,8 @@
     \title \QC: Developing for MCUs
 */
 /*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-add-mcu-devices.html
+    \externalpage https://doc.qt.io/qtcreator/creator-how-to-create-mcu-kits.html
-    \title \QC: Add MCU devices
+    \title \QC: Connect MCU devices
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-add-mcu-kits.html
-    \title \QC: Add MCU SDKs
 */
 /*!
     \externalpage https://doc.qt.io/qtcreator/creator-how-to-manage-mcu-kits.html
@@ -385,110 +365,6 @@
     \externalpage https://doc.qt.io/qtcreator/creator-vcs-git.html
     \title \QC: Git
 */
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-first-commit.html
-    \title \QC: Commit your first change
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-tools.html
-    \title \QC: Git Tools
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-initialize-git-repo.html
-    \title \QC: Initialize Git repositories
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-use-git-on-windows.html
-    \title \QC: Use Git for Windows
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-with-subversion.html
-    \title \QC: Use Git with Subversion
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-instant-blame.html
-    \title \QC: Show instant blame
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-stage-changes.html
-    \title \QC: Stage changes
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-blame.html
-    \title \QC: git blame
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-clean.html
-    \title \QC: git clean
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-diff.html
-    \title \QC: git diff
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-log.html
-    \title \QC: git log
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-reset.html
-    \title \QC: git reset
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-apply-patch.html
-    \title \QC: Apply patches
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-interactive-rebase.html
-    \title \QC: Interactive rebase
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-am.html
-    \title \QC: git am
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-branch.html
-    \title \QC: git branch
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-commit.html
-    \title \QC: git commit
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-merge.html
-    \title \QC: git merge
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-reflog.html
-    \title \QC: git reflog
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-stash.html
-    \title \QC: git stash
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-status.html
-    \title \QC: git status
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-commits.html
-    \title \QC: Apply actions to commits
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-gerrit.html
-    \title \QC: Review code with Gerrit
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-fetch.html
-    \title \QC: git fetch
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-pull.html
-    \title \QC: git pull
-*/
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-git-push.html
-    \title \QC: git push
-*/
 /*!
     \externalpage https://doc.qt.io/qtcreator/creator-vcs-gitlab.html
     \title \QC: GitLab
@@ -1460,19 +1336,19 @@
 */
 /*!
     \externalpage https://doc.qt.io/qtcreator/creator-axivion.html
-    \title \QC: View Axivion static code analysis results
+    \title \QC: Prevent code erosion
 */
 /*!
     \externalpage https://doc.qt.io/qtcreator/creator-preferences-axivion.html
     \title \QC: Axivion
 */
 /*!
-    \externalpage https://doc.qt.io/qtcreator/creator-coco.html
+    \externalpage https://doc.qt.io/qtcreator/creator-link-axivion-dashboards.html
-    \title \QC: Set up code coverage from Coco
+    \title \QC: Link projects to Axivion dashboards
 */
 /*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-view-code-coverage-with-coco.html
+    \externalpage https://doc.qt.io/qtcreator/creator-coco.html
-    \title \QC: View code coverage reports from Coco
+    \title \QC: Check code coverage
 */
 /*!
     \externalpage https://doc.qt.io/qtcreator/creator-how-to-run-in-app-manager.html
@@ -1542,18 +1418,10 @@
     \externalpage https://doc.qt.io/qtcreator/creator-how-to-find-settings-files.html
     \title \QC: Reset \QC settings
 */
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-install-extensions.html
-    \title \QC: Install extensions
-*/
 /*!
     \externalpage https://doc.qt.io/qtcreator/creator-how-to-load-extensions.html
     \title \QC: Load extensions
 */
-/*!
-    \externalpage https://doc.qt.io/qtcreator/creator-how-to-manage-extensions.html
-    \title \QC: Manage extensions
-*/
 /*!
     \externalpage https://doc.qt.io/qtcreator/creator-how-to-install-plugins.html
     \title \QC: Install plugins

doc/global/htmltabs.qdocconf

@@ -13,10 +13,9 @@
 
 # The {checked} argument ensures that the tab is selected
 # by default when the HTML page is loaded. For the other
-# tabs that are not selected, pass an empty argument {}.
+# tabs that are not selected, pass and empty argument {}.
 #
-# Note that these macros work with the online template and
+# Note that these macros work with the online template only.
-# DocBook only.
 #
 # Example:
 # \if defined(onlinedocs)
@@ -38,13 +37,9 @@
 #   \endtabcontent
 # \endif
 
-macro.tab.HTML = "<input translate=\"no\" type=\"radio\" name=\"tabs_\1\" id=\"\2\" \4/>\n<label for=\"\2\">\3</label>\n<style translate=\"no\">#\2:checked ~ .\2{display: block;}</style>\n"
+macro.tab.HTML = "<input type=\"radio\" name=\"tabs_\1\" id=\"\2\" \4/><label for=\"\2\">\3</label>\n<style>#\2:checked ~ .\2{display: block;}</style>\n"
-macro.tabcontent.HTML = "<div class=\"tabcontent \1\">\n"
+macro.tabcontent = "\\div {class=\"tabcontent \1\"}"
-macro.endtabcontent.HTML = "</div>\n"
+macro.endtabcontent = "\\enddiv"
-
-macro.tab.DocBook = "<db:bridgehead xml:id="\2" renderas="sect5" role="tabbed \4 tab-group_\1" xlink:href="#\2_contents">\3</db:bridgehead>"
-macro.tabcontent.DocBook = "<db:sidebar xml:id="\1_contents">"
-macro.endtabcontent.DocBook = "</db:sidebar>"
 
 HTML.extraimages += template/style/htmltabs.css