Merge topic 'cxxmodules-no-longer-experimental'

437280b127 cxxmodules: scan C++ sources for imports by default
3cddd11649 Ninja: message about not compiled sources explicitly
068fde1c34 cmGeneratorTarget: use `this->` for method calls
197a6bf171 cxxmodules: rework control logic for scanning regular C++ sources
5eb7bd641a Tests/RunCMake/CXXModules: remove rules file requirement
ff18acc301 CXXModules: remove `EXPERIMENTAL` from C++ module variable names
0c07f39006 cmExperimental: remove the flag for C++ modules
68caec9137 Help: add a manpage for cxxmodule support

Acked-by: Kitware Robot <[email protected]>
Acked-by: Pavel Solodovnikov <[email protected]>
Merge-request: !8828

.gitlab/ci/configure_linux_gcc_cxx_modules_ninja.cmake

@@ -1,4 +1,3 @@
 set(CMake_TEST_MODULE_COMPILATION "named,compile_commands,collation,partitions,internal_partitions,export_bmi,install_bmi,bmionly" CACHE STRING "")
-set(CMake_TEST_MODULE_COMPILATION_RULES "${CMAKE_CURRENT_LIST_DIR}/cxx_modules_rules_gcc.cmake" CACHE STRING "")
 
 include("${CMAKE_CURRENT_LIST_DIR}/configure_external_test.cmake")

.gitlab/ci/configure_linux_gcc_cxx_modules_ninja_multi.cmake

@@ -1,4 +1,3 @@
 set(CMake_TEST_MODULE_COMPILATION "named,compile_commands,collation,partitions,internal_partitions,export_bmi,install_bmi,bmionly" CACHE STRING "")
-set(CMake_TEST_MODULE_COMPILATION_RULES "${CMAKE_CURRENT_LIST_DIR}/cxx_modules_rules_gcc.cmake" CACHE STRING "")
 
 include("${CMAKE_CURRENT_LIST_DIR}/configure_external_test.cmake")

.gitlab/ci/configure_windows_msvc_cxx_modules_common.cmake

@@ -1,2 +1 @@
 set(CMake_TEST_MODULE_COMPILATION "named,compile_commands,collation,partitions,internal_partitions,shared,export_bmi,install_bmi,bmionly" CACHE STRING "")
-set(CMake_TEST_MODULE_COMPILATION_RULES "${CMAKE_CURRENT_LIST_DIR}/cxx_modules_rules_msvc.cmake" CACHE STRING "")

.gitlab/ci/cxx_modules_rules_clang.cmake

@@ -1,5 +1,3 @@
-set(CMake_TEST_CXXModules_UUID "a246741c-d067-4019-a8fb-3d16b0c9d1d3")
-
 # Default to C++ extensions being off. Clang's modules support have trouble
 # with extensions right now.
 set(CMAKE_CXX_EXTENSIONS OFF)

.gitlab/ci/cxx_modules_rules_gcc.cmake

@@ -1 +0,0 @@
-set(CMake_TEST_CXXModules_UUID "a246741c-d067-4019-a8fb-3d16b0c9d1d3")

.gitlab/ci/cxx_modules_rules_msvc.cmake

@@ -1 +0,0 @@
-set(CMake_TEST_CXXModules_UUID "a246741c-d067-4019-a8fb-3d16b0c9d1d3")

Auxiliary/vim/syntax/cmake.vim

@@ -3137,7 +3137,6 @@ syn keyword cmakeKWexecute_process contained
 syn keyword cmakeKWexport contained
             \ ANDROID_MK
             \ APPEND
-            \ CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API
             \ CONFIG
             \ CXX_MODULES_DIRECTORY
             \ EXPORT
@@ -3707,7 +3706,6 @@ syn keyword cmakeKWinstall contained
             \ BUILD_TYPE
             \ BUNDLE
             \ BUNDLE_EXECUTABLE
-            \ CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API
             \ CMAKE_INSTALL_BINDIR
             \ CMAKE_INSTALL_DATADIR
             \ CMAKE_INSTALL_DATAROOTDIR
@@ -4258,7 +4256,6 @@ syn keyword cmakeKWtarget_sources contained
             \ ALIAS
             \ BASE_DIRS
             \ BUILD_INTERFACE
-            \ CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API
             \ CONFIG
             \ CORRECT
             \ CXX_MODULES

Help/command/export.rst

@@ -54,10 +54,7 @@ The options are:
   to support consumers using CMake versions older than 2.8.12.
 
 ``CXX_MODULES_DIRECTORY <directory>``
-
-  .. note ::
-
-    Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
+  .. versionadded:: 3.28
 
   Export C++ module properties to files under the given directory. Each file
   will be named according to the target's export name (without any namespace).

Help/command/install.rst

@@ -232,10 +232,7 @@ Signatures
     would be installed to ``myproj/here.h`` below the destination.
 
   ``CXX_MODULES_BMI``
-
-    .. note ::
-
-      Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
+    .. versionadded:: 3.28
 
     Any module files from C++ modules from ``PUBLIC`` sources in a file set of
     type ``CXX_MODULES`` will be installed to the given ``DESTINATION``. All
@@ -843,10 +840,7 @@ Signatures
     and defines required to use the libraries.
 
   ``CXX_MODULES_DIRECTORY``
-
-    .. note ::
-
-      Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
+    .. versionadded:: 3.28
 
     Specify a subdirectory to store C++ module information for targets in the
     export set. This directory will be populated with files which add the

Help/command/target_sources.rst

@@ -84,10 +84,7 @@ files within those directories. The acceptable types include:
   Sources intended to be used via a language's ``#include`` mechanism.
 
 ``CXX_MODULES``
-
-  .. note ::
-
-    Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
+  .. versionadded:: 3.28
 
   Sources which contain C++ interface module or partition units (i.e., those
   using the ``export`` keyword). This file set type may not have an

Help/command/try_compile.rst

@@ -261,14 +261,11 @@ The options for the above signatures are:
     Sources are not added to any ``FILE_SET`` in the generated project.
 
   ``CXX_MODULE``
+    .. versionadded:: 3.28
+
     Sources are added to a ``FILE_SET`` of type ``CXX_MODULES`` in the
     generated project.
 
-  .. note ::
-
-    Experimental. Sources of type ``CXX_MODULE`` are gated by
-    ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
-
   The default type of sources is ``NORMAL``.
 
 ``<LANG>_STANDARD <std>``

Help/dev/experimental.rst

@@ -13,133 +13,3 @@ specific values will change over time to reinforce their experimental nature.
 When used, a warning will be generated to indicate that an experimental
 feature is in use and that the affected behavior in the project is not part of
 CMake's stability guarantees.
-
-C++20 Module APIs
-=================
-
-Variable: ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
-Value: ``ac01f462-0f5f-432a-86aa-acef252918a6``
-
-In order to support C++20 modules, there are a number of behaviors that have
-CMake APIs to provide the required features to build and export them from a
-project.
-
-Limitations
------------
-
-There are a number of known limitations of the current C++20 module support in
-CMake.  This does not document known limitations or bugs in compilers as these
-can change over time.
-
-For all generators:
-
-- Only in-project modules may be used.  While there is some support for
-  exporting module information, there is no mechanism for using it at the
-  moment.
-
-For the Ninja Generators:
-
-- ``ninja`` 1.10 or newer is required.
-
-For the Visual Studio Generators:
-
-- Only Visual Studio 2022 and toolchains newer than 19.34 (Visual Studio
-  17.4).
-- No support for exporting or installing BMI or module information.
-- No diagnosis of using modules provided by ``PRIVATE`` sources from
-  ``PUBLIC`` module sources.
-
-C++20 Module Dependencies
-=========================
-
-The Ninja generator has experimental infrastructure supporting C++20 module
-dependency scanning.  This is similar to the Fortran modules support, but
-relies on external tools to scan C++20 translation units for module
-dependencies.  The approach is described by Kitware's `D1483r1`_ paper.
-
-In order to activate CMake's experimental support for C++20 module
-dependencies, set the following variables:
-
-``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
-  Set this to the UUID documented above.
-
-Some compilers already have support for module dependency scanning:
-
-* MSVC 19.34 and newer (provided with Visual Studio 17.4 and newer)
-* LLVM/Clang 16.0 and newer
-
-For those, only the above variables need to be set by project code.
-For compilers with in-development support, additional variables must
-be set as follows.
-
-``CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE``
-  Set this to tell CMake how to invoke the C++20 module dependency
-  scanning tool.
-
-``CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT``
-  Set this for compilers that generate module maps.  See below.
-
-``CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG``
-  Set this for compilers that generate module maps.  See below.
-
-For example, add code like the following to a test project:
-
-.. code-block:: cmake
-
-  string(CONCAT CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE
-    "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> <SOURCE>"
-    " -MT <DYNDEP_FILE> -MD -MF <DEP_FILE>"
-    " ${flags_to_scan_deps} -fdep-file=<DYNDEP_FILE> -fdep-output=<OBJECT>"
-    )
-
-The tool specified by ``CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE`` is
-expected to process the translation unit, write preprocessor dependencies
-to the file specified by the ``<DEP_FILE>`` placeholder, and write module
-dependencies to the file specified by the ``<DYNDEP_FILE>`` placeholder. The
-``CMAKE_EXPERIMENTAL_CXX_SCANDEP_DEPFILE_FORMAT`` file may be set to ``msvc``
-for scandep rules which use ``msvc``-style dependency reporting.
-
-In order to support ``IMPORTED`` targets with associated C++20 module sources,
-the ``CMAKE_EXPERIMENTAL_CXX_MODULE_BMI_ONLY_FLAG`` variable must be provided
-to have the compiler only output a BMI instead of a BMI and an object file.
-
-The module dependencies should be written in the format described
-by the `P1689r5`_ paper.
-
-Compiler writers may try out their scanning functionality using
-the `cxx-modules-sandbox`_ test project, modified to set variables
-as above for their compiler.
-
-For compilers that generate module maps, tell CMake as follows:
-
-.. code-block:: cmake
-
-  set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT "gcc")
-  set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG
-    "${compiler_flags_for_module_map} -fmodule-mapper=<MODULE_MAP_FILE>")
-  set(CMAKE_EXPERIMENTAL_CXX_MODULE_BMI_ONLY_FLAG
-    "-fmodule-only")
-
-Currently, the only supported formats are, ``clang``, ``gcc``, and ``msvc``.
-The ``gcc`` format is described in the GCC documentation, but the relevant
-section for the purposes of CMake is:
-
-    A mapping file consisting of space-separated module-name, filename
-    pairs, one per line.  Only the mappings for the direct imports and any
-    module export name need be provided.  If other mappings are provided,
-    they override those stored in any imported CMI files.  A repository
-    root may be specified in the mapping file by using ``$root`` as the
-    module name in the first active line.
-
-    -- GCC module mapper documentation
-
-The ``msvc`` format is a response file containing flags required to compile
-any module interfaces properly as well as find any required files to satisfy
-``import`` statements as required for Microsoft's Visual Studio toolchains.
-
-Similarly, the ``clang`` format is a response file containing flags using
-Clang's module flags.
-
-.. _`D1483r1`: https://mathstuf.fedorapeople.org/fortran-modules/fortran-modules.html
-.. _`P1689r5`: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1689r5.html
-.. _`cxx-modules-sandbox`: https://github.com/mathstuf/cxx-modules-sandbox

Help/index.rst

@@ -58,6 +58,7 @@ Reference Manuals
    /manual/cmake-commands.7
    /manual/cmake-compile-features.7
    /manual/cmake-configure-log.7
+   /manual/cmake-cxxmodules.7
    /manual/cmake-developer.7
    /manual/cmake-env-variables.7
    /manual/cmake-file-api.7

Help/manual/cmake-cxxmodules.7.rst

@@ -0,0 +1,72 @@
+.. cmake-manual-description: CMake C++ Modules Support Reference
+
+cmake-cxxmodules(7)
+*******************
+
+.. versionadded:: 3.28
+
+C++ 20 introduced the concept of "modules" to the language.  The design
+requires build systems to order compilations among each other to satisfy
+``import`` statements reliably.  CMake's implementation asks the compiler
+to scan source files for module dependencies during the build, collates
+scanning results to infer ordering constraints, and tells the build tool
+how to dynamically update the build graph.
+
+Scanning Control
+================
+
+Whether or not sources get scanned for C++ module usage is dependent on the
+following queries. The first query that provides a yes/no answer is used.
+
+- If the source file belongs to a file set of type ``CXX_MODULES``, it will
+  be scanned.
+- If the target does not use at least C++ 20, it will not be scanned.
+- If the source file is not the language ``CXX``, it will not be scanned.
+- If the :prop_sf:`CXX_SCAN_FOR_MODULES` source file property is set, its
+  value will be used.
+- If the :prop_tgt:`CXX_SCAN_FOR_MODULES` target property is set, its value
+  will be used.  Set the :variable:`CMAKE_CXX_SCAN_FOR_MODULES` variable
+  to initialize this property on all targets as they are created.
+- Otherwise, the source file will be scanned.  See policy :policy:`CMP0155`.
+
+Compiler Support
+================
+
+Compilers which CMake natively supports module dependency scanning include:
+
+* MSVC toolset 14.34 and newer (provided with Visual Studio 17.4 and newer)
+* LLVM/Clang 16.0 and newer
+* GCC 14 (for the in-development branch, after 2023-09-20) and newer
+
+Generator Support
+=================
+
+The list of generators which support scanning sources for C++ modules include:
+
+- :generator:`Ninja`
+- :generator:`Ninja Multi-Config`
+- :generator:`Visual Studio 17 2022`
+
+Limitations
+-----------
+
+There are a number of known limitations of the current C++ module support in
+CMake.  This does not document known limitations or bugs in compilers as these
+can change over time.
+
+For all generators:
+
+- Header units are not supported.
+- No builtin support for ``import std;`` or other compiler-provided modules.
+
+For the Ninja Generators:
+
+- ``ninja`` 1.11 or newer is required.
+
+For the :ref:`Visual Studio Generators`:
+
+- Only Visual Studio 2022 and MSVC toolsets 14.34 (Visual Studio
+  17.4) and newer.
+- No support for exporting or installing BMI or module information.
+- No diagnosis of using modules provided by ``PRIVATE`` sources from
+  ``PUBLIC`` module sources.

Help/manual/cmake-policies.7.rst

@@ -57,6 +57,7 @@ Policies Introduced by CMake 3.28
 .. toctree::
    :maxdepth: 1
 
+   CMP0155: C++ sources in targets with at least C++20 are scanned for imports. </policy/CMP0155>
    CMP0154: Generated files are private by default in targets using file sets. </policy/CMP0154>
    CMP0153: The exec_program command should not be called. </policy/CMP0153>
    CMP0152: file(REAL_PATH) resolves symlinks before collapsing ../ components.  </policy/CMP0152>

Help/policy/CMP0155.rst

@@ -0,0 +1,26 @@
+CMP0155
+-------
+
+.. versionadded:: 3.28
+
+C++ sources in targets with at least C++20 are scanned for imports.
+
+CMake 3.27 and below assume that C++ sources do not ``import`` modules.
+CMake 3.28 and above prefer to assume that C++ sources in targets using C++20
+or higher might ``import`` modules, and must be scanned before compiling,
+unless explicitly disabled.  This policy provides compatibility for projects
+that use C++20 or higher, without modules, that have not been updated to turn
+off scanning, e.g., via the :variable:`CMAKE_CXX_SCAN_FOR_MODULES` variable.
+See the :manual:`cmake-cxxmodules(7)` manual for more details on C++ module
+support.
+
+The ``OLD`` behavior for this policy is to assume that C++ 20 and newer
+sources do not import modules.  The ``NEW`` behavior for this policy is to
+assume that C++ 20 and newer files may import modules, and need to be scanned.
+
+This policy was introduced in CMake version 3.28.  Use the
+:command:`cmake_policy` command to set it to ``OLD`` or ``NEW`` explicitly.
+Unlike many policies, CMake version |release| does *not* warn
+when this policy is not set and simply uses ``OLD`` behavior.
+
+.. include:: DEPRECATED.txt

Help/prop_sf/CXX_SCAN_FOR_MODULES.rst

@@ -1,7 +1,7 @@
 CXX_SCAN_FOR_MODULES
 --------------------
 
-.. versionadded:: 3.26
+.. versionadded:: 3.28
 
 ``CXX_SCAN_FOR_MODULES`` is a boolean specifying whether CMake will scan the
 source for C++ module dependencies.  See also the
@@ -16,8 +16,3 @@ consulted.
 Note that scanning is only performed if C++20 or higher is enabled for the
 target and the source uses the ``CXX`` language.  Scanning for modules in
 sources belonging to file sets of type ``CXX_MODULES`` is always performed.
-
-.. note ::
-
-  This setting is meaningful only when experimental support for C++ modules
-  has been enabled by the ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API`` gate.

Help/prop_tgt/CXX_MODULE_DIRS.rst

@@ -1,11 +1,7 @@
 CXX_MODULE_DIRS
 ---------------
 
-.. versionadded:: 3.25
-
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
+.. versionadded:: 3.28
 
 Semicolon-separated list of base directories of the target's default
 C++ module set (i.e. the file set with name and type ``CXX_MODULES``). The

Help/prop_tgt/CXX_MODULE_DIRS_NAME.rst

@@ -1,11 +1,7 @@
 CXX_MODULE_DIRS_<NAME>
 ----------------------
 
-.. versionadded:: 3.25
-
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
+.. versionadded:: 3.28
 
 Semicolon-separated list of base directories of the target's ``<NAME>`` C++
 module set, which has the set type ``CXX_MODULES``. The property supports

Help/prop_tgt/CXX_MODULE_SET.rst

@@ -1,11 +1,7 @@
 CXX_MODULE_SET
 --------------
 
-.. versionadded:: 3.25
-
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
+.. versionadded:: 3.28
 
 Semicolon-separated list of files in the target's default C++ module set,
 (i.e. the file set with name and type ``CXX_MODULES``). If any of the paths

Help/prop_tgt/CXX_MODULE_SETS.rst

@@ -1,11 +1,7 @@
 CXX_MODULE_SETS
 ---------------
 
-.. versionadded:: 3.25
-
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
+.. versionadded:: 3.28
 
 Read-only list of the target's ``PRIVATE`` and ``PUBLIC`` C++ module sets (i.e.
 all file sets with the type ``CXX_MODULES``). Files listed in these file sets

Help/prop_tgt/CXX_MODULE_SET_NAME.rst

@@ -1,11 +1,7 @@
 CXX_MODULE_SET_<NAME>
 ---------------------
 
-.. versionadded:: 3.25
-
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
+.. versionadded:: 3.28
 
 Semicolon-separated list of files in the target's ``<NAME>`` C++ module set,
 which has the set type ``CXX_MODULES``. If any of the paths are relative, they

Help/prop_tgt/CXX_SCAN_FOR_MODULES.rst

@@ -1,7 +1,7 @@
 CXX_SCAN_FOR_MODULES
 --------------------
 
-.. versionadded:: 3.26
+.. versionadded:: 3.28
 
 ``CXX_SCAN_FOR_MODULES`` is a boolean specifying whether CMake will scan C++
 sources in the target for module dependencies.  See also the
@@ -20,8 +20,3 @@ scan the target's ``CXX`` sources at build time.
 Note that scanning is only performed if C++20 or higher is enabled for the
 target.  Scanning for modules in the target's sources belonging to file sets
 of type ``CXX_MODULES`` is always performed.
-
-.. note ::
-
-  This setting is meaningful only when experimental support for C++ modules
-  has been enabled by the ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API`` gate.

Help/prop_tgt/IMPORTED_CXX_MODULES_COMPILE_DEFINITIONS.rst

@@ -3,10 +3,6 @@ IMPORTED_CXX_MODULES_COMPILE_DEFINITIONS
 
 .. versionadded:: 3.28
 
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
-
 Preprocessor definitions for compiling an ``IMPORTED`` target's C++ module
 sources.
 

Help/prop_tgt/IMPORTED_CXX_MODULES_COMPILE_FEATURES.rst

@@ -3,10 +3,6 @@ IMPORTED_CXX_MODULES_COMPILE_FEATURES
 
 .. versionadded:: 3.28
 
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
-
 Compiler features enabled for this ``IMPORTED`` target's C++ modules.
 
 The value of this property is used by the generators to set the include

Help/prop_tgt/IMPORTED_CXX_MODULES_COMPILE_OPTIONS.rst

@@ -3,10 +3,6 @@ IMPORTED_CXX_MODULES_COMPILE_OPTIONS
 
 .. versionadded:: 3.28
 
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
-
 List of options to pass to the compiler for this ``IMPORTED`` target's C++
 modules.
 

Help/prop_tgt/IMPORTED_CXX_MODULES_INCLUDE_DIRECTORIES.rst

@@ -3,10 +3,6 @@ IMPORTED_CXX_MODULES_INCLUDE_DIRECTORIES
 
 .. versionadded:: 3.28
 
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
-
 List of preprocessor include file search directories when compiling C++
 modules for ``IMPORTED`` targets.
 

Help/prop_tgt/IMPORTED_CXX_MODULES_LINK_LIBRARIES.rst

@@ -3,9 +3,5 @@ IMPORTED_CXX_MODULES_LINK_LIBRARIES
 
 .. versionadded:: 3.28
 
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
-
 List of direct dependencies to use for usage requirements for C++ modules in
 the target's C++ modules.

Help/prop_tgt/INTERFACE_CXX_MODULE_SETS.rst

@@ -1,11 +1,7 @@
 INTERFACE_CXX_MODULE_SETS
 -------------------------
 
-.. versionadded:: 3.25
-
-.. note ::
-
-  Experimental. Gated by ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API``
+.. versionadded:: 3.28
 
 Read-only list of the target's ``PUBLIC`` C++ module sets (i.e. all file sets
 with the type ``CXX_MODULES``). Files listed in these C++ module sets can be

Help/release/dev/cxxmodules-no-longer-experimental.rst

@@ -0,0 +1,8 @@
+cxxmodules-no-longer-experimental
+---------------------------------
+
+* C++ 20 named modules are now supported by :ref:`Ninja Generators`
+  and :ref:`Visual Studio Generators` for VS 2022 and newer, in combination
+  with the MSVC 14.34 toolset (provided with VS 17.4) and newer, LLVM/Clang
+  16.0 and newer, and GCC 14 (after the 2023-09-20 daily bump) and newer.
+  See :manual:`cmake-cxxmodules(7)` for details.

Help/variable/CMAKE_CXX_SCAN_FOR_MODULES.rst

@@ -1,15 +1,10 @@
 CMAKE_CXX_SCAN_FOR_MODULES
 --------------------------
 
-.. versionadded:: 3.26
+.. versionadded:: 3.28
 
 Whether to scan C++ source files for module dependencies.
 
 This variable is used to initialize the :prop_tgt:`CXX_SCAN_FOR_MODULES`
 property on all the targets.  See that target property for additional
 information.
-
-.. note ::
-
-  This setting is meaningful only when experimental support for C++ modules
-  has been enabled by the ``CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API`` gate.

Modules/Compiler/Clang-CXX.cmake

@@ -32,7 +32,7 @@ endif()
 
 if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0)
   if("x${CMAKE_CXX_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
-    string(CONCAT CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE
+    string(CONCAT CMAKE_CXX_SCANDEP_SOURCE
       "\"${CMAKE_CXX_COMPILER_CLANG_SCAN_DEPS}\""
       " -format=p1689"
       " --"
@@ -41,8 +41,8 @@ if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0)
       " -MT <DYNDEP_FILE>"
       " -MD -MF <DEP_FILE>"
       " > <DYNDEP_FILE>")
-    set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT "clang")
-    set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG "@<MODULE_MAP_FILE>")
-    set(CMAKE_EXPERIMENTAL_CXX_MODULE_BMI_ONLY_FLAG "--precompile")
+    set(CMAKE_CXX_MODULE_MAP_FORMAT "clang")
+    set(CMAKE_CXX_MODULE_MAP_FLAG "@<MODULE_MAP_FILE>")
+    set(CMAKE_CXX_MODULE_BMI_ONLY_FLAG "--precompile")
   endif()
 endif()

Modules/Compiler/GNU-CXX.cmake

@@ -74,13 +74,13 @@ endif()
 __compiler_check_default_language_standard(CXX 3.4 98 6.0 14 11.1 17)
 
 if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14.0)
-  string(CONCAT CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE
+  string(CONCAT CMAKE_CXX_SCANDEP_SOURCE
     "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E -x c++ <SOURCE>"
     " -MT <DYNDEP_FILE> -MD -MF <DEP_FILE>"
     " -fmodules-ts -fdeps-file=<DYNDEP_FILE> -fdeps-target=<OBJECT> -fdeps-format=p1689r5"
     " -o <PREPROCESSED_SOURCE>")
-  set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT "gcc")
-  string(CONCAT CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG
+  set(CMAKE_CXX_MODULE_MAP_FORMAT "gcc")
+  string(CONCAT CMAKE_CXX_MODULE_MAP_FLAG
     # Turn on modules.
     "-fmodules-ts"
     # Read the module mapper file.
@@ -91,5 +91,5 @@ if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14.0)
     " -fdeps-format=p1689r5"
     # Force C++ as a language.
     " -x c++")
-  set(CMAKE_EXPERIMENTAL_CXX_MODULE_BMI_ONLY_FLAG "-fmodule-only")
+  set(CMAKE_CXX_MODULE_BMI_ONLY_FLAG "-fmodule-only")
 endif()

Modules/Compiler/MSVC-CXX.cmake

@@ -79,13 +79,13 @@ elseif (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0)
 endif()
 
 if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "19.34")
-  string(CONCAT CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE
+  string(CONCAT CMAKE_CXX_SCANDEP_SOURCE
     "<CMAKE_CXX_COMPILER> <DEFINES> <INCLUDES> <FLAGS> <SOURCE> -nologo -TP"
     " -showIncludes"
     " -scanDependencies <DYNDEP_FILE>"
     " -Fo<OBJECT>")
-  set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_DEPFILE_FORMAT "msvc")
-  set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT "msvc")
-  set(CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG "@<MODULE_MAP_FILE>")
-  set(CMAKE_EXPERIMENTAL_CXX_MODULE_BMI_ONLY_FLAG "-ifcOnly;-ifcOutput;<OBJECT>")
+  set(CMAKE_CXX_SCANDEP_DEPFILE_FORMAT "msvc")
+  set(CMAKE_CXX_MODULE_MAP_FORMAT "msvc")
+  set(CMAKE_CXX_MODULE_MAP_FLAG "@<MODULE_MAP_FILE>")
+  set(CMAKE_CXX_MODULE_BMI_ONLY_FLAG "-ifcOnly;-ifcOutput;<OBJECT>")
 endif ()

Source/cmCoreTryCompile.cxx

@@ -235,25 +235,16 @@ ArgumentParser::Continue cmCoreTryCompile::Arguments::SetSourceType(
     this->SourceTypeContext = SourceType::Normal;
     matched = true;
   } else if (sourceType == "CXX_MODULE"_s) {
-    bool const supportCxxModuleSources = cmExperimental::HasSupportEnabled(
-      *this->Makefile, cmExperimental::Feature::CxxModuleCMakeApi);
-    if (supportCxxModuleSources) {
-      this->SourceTypeContext = SourceType::CxxModule;
-      matched = true;
-    }
+    this->SourceTypeContext = SourceType::CxxModule;
+    matched = true;
   }
 
   if (!matched && this->SourceTypeError.empty()) {
-    bool const supportCxxModuleSources = cmExperimental::HasSupportEnabled(
-      *this->Makefile, cmExperimental::Feature::CxxModuleCMakeApi);
-    auto const* message = "'SOURCE'";
-    if (supportCxxModuleSources) {
-      message = "one of 'SOURCE' or 'CXX_MODULE'";
-    }
     // Only remember one error at a time; all other errors related to argument
     // parsing are "indicate one error and return" anyways.
     this->SourceTypeError =
-      cmStrCat("Invalid 'SOURCE_TYPE' '", sourceType, "'; must be ", message);
+      cmStrCat("Invalid 'SOURCE_TYPE' '", sourceType,
+               "'; must be one of 'SOURCE' or 'CXX_MODULE'");
   }
   return ArgumentParser::Continue::Yes;
 }
@@ -880,6 +871,13 @@ cm::optional<cmTryCompileResult> cmCoreTryCompile::TryCompileCode(
               ? "NEW"
               : "OLD");
 
+    /* Set the appropriate policy information for C++ module support */
+    fprintf(fout, "cmake_policy(SET CMP0155 %s)\n",
+            this->Makefile->GetPolicyStatus(cmPolicies::CMP0155) ==
+                cmPolicies::NEW
+              ? "NEW"
+              : "OLD");
+
     // Workaround for -Wl,-headerpad_max_install_names issue until we can avoid
     // adding that flag in the platform and compiler language files
     fprintf(fout,

Source/cmExperimental.cxx

@@ -19,17 +19,6 @@ namespace {
  * up-to-date.
  */
 cmExperimental::FeatureData LookupTable[] = {
-  // CxxModuleCMakeApi
-  { "CxxModuleCMakeApi",
-    "ac01f462-0f5f-432a-86aa-acef252918a6",
-    "CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API",
-    "CMake's C++ module support is experimental. It is meant only for "
-    "experimentation and feedback to CMake developers.",
-    { "CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE",
-      "CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FORMAT",
-      "CMAKE_EXPERIMENTAL_CXX_MODULE_MAP_FLAG" },
-    cmExperimental::TryCompileCondition::SkipCompilerChecks,
-    false },
   // WindowsKernelModeDriver
   { "WindowsKernelModeDriver",
     "5c2d848d-4efa-4529-a768-efd57171bf68",

Source/cmExperimental.h

@@ -15,7 +15,6 @@ class cmExperimental
 public:
   enum class Feature
   {
-    CxxModuleCMakeApi,
     WindowsKernelModeDriver,
 
     Sentinel,

Source/cmExportCommand.cxx

@@ -16,7 +16,6 @@
 #include "cmArgumentParserTypes.h"
 #include "cmCryptoHash.h"
 #include "cmExecutionStatus.h"
-#include "cmExperimental.h"
 #include "cmExportBuildAndroidMKGenerator.h"
 #include "cmExportBuildFileGenerator.h"
 #include "cmExportSet.h"
@@ -69,15 +68,11 @@ bool cmExportCommand(std::vector<std::string> const& args,
     bool ExportOld = false;
   };
 
-  auto parser = cmArgumentParser<Arguments>{}
-                  .Bind("NAMESPACE"_s, &Arguments::Namespace)
-                  .Bind("FILE"_s, &Arguments::Filename);
-
-  bool const supportCxx20FileSetTypes = cmExperimental::HasSupportEnabled(
-    status.GetMakefile(), cmExperimental::Feature::CxxModuleCMakeApi);
-  if (supportCxx20FileSetTypes) {
-    parser.Bind("CXX_MODULES_DIRECTORY"_s, &Arguments::CxxModulesDirectory);
-  }
+  auto parser =
+    cmArgumentParser<Arguments>{}
+      .Bind("NAMESPACE"_s, &Arguments::Namespace)
+      .Bind("FILE"_s, &Arguments::Filename)
+      .Bind("CXX_MODULES_DIRECTORY"_s, &Arguments::CxxModulesDirectory);
 
   if (args[0] == "EXPORT") {
     parser.Bind("EXPORT"_s, &Arguments::ExportSetName);

Source/cmGeneratorTarget.cxx

@@ -31,7 +31,6 @@
 #include "cmCustomCommandGenerator.h"
 #include "cmCxxModuleUsageEffects.h"
 #include "cmEvaluatedTargetProperty.h"
-#include "cmExperimental.h"
 #include "cmFileSet.h"
 #include "cmFileTimes.h"
 #include "cmGeneratedFileStream.h"
@@ -9047,7 +9046,7 @@ std::string cmGeneratorTarget::GetImportedXcFrameworkPath(
 
 bool cmGeneratorTarget::HaveFortranSources(std::string const& config) const
 {
-  auto sources = cmGeneratorTarget::GetSourceFiles(config);
+  auto sources = this->GetSourceFiles(config);
   return std::any_of(sources.begin(), sources.end(),
                      [](BT<cmSourceFile*> const& sf) -> bool {
                        return sf.Value->GetLanguage() == "Fortran"_s;
@@ -9106,54 +9105,93 @@ cmGeneratorTarget::Cxx20SupportLevel cmGeneratorTarget::HaveCxxModuleSupport(
   // Else, an empty CMAKE_CXX_STANDARD_DEFAULT means CMake does not detect and
   // set a default standard level for this compiler, so assume all standards
   // are available.
-  if (!cmExperimental::HasSupportEnabled(
-        *this->Makefile, cmExperimental::Feature::CxxModuleCMakeApi)) {
-    return Cxx20SupportLevel::MissingExperimentalFlag;
+  cmValue scandepRule =
+    this->Target->GetMakefile()->GetDefinition("CMAKE_CXX_SCANDEP_SOURCE");
+  if (!scandepRule) {
+    return Cxx20SupportLevel::MissingRule;
   }
   return Cxx20SupportLevel::Supported;
 }
 
 void cmGeneratorTarget::CheckCxxModuleStatus(std::string const& config) const
 {
+  bool haveScannableSources = false;
+
   // Check for `CXX_MODULE*` file sets and a lack of support.
   if (this->HaveCxx20ModuleSources()) {
-    switch (this->HaveCxxModuleSupport(config)) {
-      case cmGeneratorTarget::Cxx20SupportLevel::MissingCxx:
-        this->Makefile->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmStrCat("The target named \"", this->GetName(),
-                   "\" has C++ sources that export modules but the \"CXX\" "
-                   "language has not been enabled"));
-        break;
-      case cmGeneratorTarget::Cxx20SupportLevel::MissingExperimentalFlag:
-        this->Makefile->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmStrCat("The target named \"", this->GetName(),
-                   "\" has C++ sources that export modules but its "
-                   "experimental support has not been requested"));
-        break;
-      case cmGeneratorTarget::Cxx20SupportLevel::NoCxx20: {
-        cmStandardLevelResolver standardResolver(this->Makefile);
-        auto effStandard =
-          standardResolver.GetEffectiveStandard(this, "CXX", config);
-        if (effStandard.empty()) {
-          effStandard = "; no C++ standard found";
-        } else {
-          effStandard = cmStrCat("; found \"cxx_std_", effStandard, '"');
-        }
-        this->Makefile->IssueMessage(
-          MessageType::FATAL_ERROR,
-          cmStrCat(
-            "The target named \"", this->GetName(),
-            "\" has C++ sources that export modules but does not include "
-            "\"cxx_std_20\" (or newer) among its `target_compile_features`",
-            effStandard));
-      } break;
-      case cmGeneratorTarget::Cxx20SupportLevel::Supported:
-        // All is well.
-        break;
+    haveScannableSources = true;
+  }
+
+  if (!haveScannableSources) {
+    // Check to see if there are regular sources that have requested scanning.
+    auto sources = this->GetSourceFiles(config);
+    for (auto const& source : sources) {
+      auto const* sf = source.Value;
+      auto const& lang = sf->GetLanguage();
+      if (lang != "CXX"_s) {
+        continue;
+      }
+      // Ignore sources which do not need dyndep.
+      if (this->NeedDyndepForSource(lang, config, sf)) {
+        haveScannableSources = true;
+      }
     }
   }
+
+  // If there isn't anything scannable, ignore it.
+  if (!haveScannableSources) {
+    return;
+  }
+
+  // If the generator doesn't support modules at all, error that we have
+  // sources that require the support.
+  if (!this->GetGlobalGenerator()->CheckCxxModuleSupport()) {
+    this->Makefile->IssueMessage(
+      MessageType::FATAL_ERROR,
+      cmStrCat(
+        "The target named \"", this->GetName(),
+        "\" contains C++ "
+        "sources that use modules which is not supported by the generator"));
+    return;
+  }
+
+  switch (this->HaveCxxModuleSupport(config)) {
+    case cmGeneratorTarget::Cxx20SupportLevel::MissingCxx:
+      this->Makefile->IssueMessage(
+        MessageType::FATAL_ERROR,
+        cmStrCat("The target named \"", this->GetName(),
+                 "\" has C++ sources that use modules but the \"CXX\" "
+                 "language has not been enabled"));
+      break;
+    case cmGeneratorTarget::Cxx20SupportLevel::NoCxx20: {
+      cmStandardLevelResolver standardResolver(this->Makefile);
+      auto effStandard =
+        standardResolver.GetEffectiveStandard(this, "CXX", config);
+      if (effStandard.empty()) {
+        effStandard = "; no C++ standard found";
+      } else {
+        effStandard = cmStrCat("; found \"cxx_std_", effStandard, '"');
+      }
+      this->Makefile->IssueMessage(
+        MessageType::FATAL_ERROR,
+        cmStrCat(
+          "The target named \"", this->GetName(),
+          "\" has C++ sources that use modules but does not include "
+          "\"cxx_std_20\" (or newer) among its `target_compile_features`",
+          effStandard));
+    } break;
+    case cmGeneratorTarget::Cxx20SupportLevel::MissingRule: {
+      this->Makefile->IssueMessage(
+        MessageType::FATAL_ERROR,
+        cmStrCat("The target named \"", this->GetName(),
+                 "\" has C++ sources that use modules but the compiler does "
+                 "not provide a way to discover the import graph "
+                 "dependencies"));
+    } break;
+    case cmGeneratorTarget::Cxx20SupportLevel::Supported:
+      // All is well.
+      break;
+  }
 }
 
 bool cmGeneratorTarget::NeedCxxModuleSupport(std::string const& lang,
@@ -9191,14 +9229,30 @@ bool cmGeneratorTarget::NeedDyndepForSource(std::string const& lang,
                                             std::string const& config,
                                             cmSourceFile const* sf) const
 {
-  bool const needDyndep = this->NeedDyndep(lang, config);
-  if (!needDyndep) {
+  // Fortran always needs to be scanned.
+  if (lang == "Fortran"_s) {
+    return true;
+  }
+  // Only C++ code needs scanned otherwise.
+  if (lang != "CXX"_s) {
     return false;
   }
+
+  // Any file in `CXX_MODULES` file sets need scanned (it being `CXX` is
+  // enforced elsewhere).
   auto const* fs = this->GetFileSetForSource(config, sf);
   if (fs && fs->GetType() == "CXX_MODULES"_s) {
     return true;
   }
+
+  switch (this->HaveCxxModuleSupport(config)) {
+    case Cxx20SupportLevel::MissingCxx:
+    case Cxx20SupportLevel::NoCxx20:
+      return false;
+    case Cxx20SupportLevel::MissingRule:
+    case Cxx20SupportLevel::Supported:
+      break;
+  }
   auto const sfProp = sf->GetProperty("CXX_SCAN_FOR_MODULES");
   if (sfProp.IsSet()) {
     return sfProp.IsOn();
@@ -9207,7 +9261,22 @@ bool cmGeneratorTarget::NeedDyndepForSource(std::string const& lang,
   if (tgtProp.IsSet()) {
     return tgtProp.IsOn();
   }
-  return true;
+
+  bool policyAnswer = false;
+  switch (this->GetPolicyStatusCMP0155()) {
+    case cmPolicies::WARN:
+    case cmPolicies::OLD:
+      // The OLD behavior is to not scan the source.
+      policyAnswer = false;
+      break;
+    case cmPolicies::REQUIRED_ALWAYS:
+    case cmPolicies::REQUIRED_IF_USED:
+    case cmPolicies::NEW:
+      // The NEW behavior is to scan the source.
+      policyAnswer = true;
+      break;
+  }
+  return policyAnswer;
 }
 
 void cmGeneratorTarget::BuildFileSetInfoCache(std::string const& config) const

Source/cmGeneratorTarget.h

@@ -1288,10 +1288,10 @@ public:
   {
     // C++ is not available.
     MissingCxx,
-    // The experimental feature is not available.
-    MissingExperimentalFlag,
     // The target does not require at least C++20.
     NoCxx20,
+    // C++20 module scanning rules are not present.
+    MissingRule,
     // C++20 modules are available and working.
     Supported,
   };

Source/cmGlobalVisualStudio7Generator.cxx

@@ -435,14 +435,6 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
       target->CheckCxxModuleStatus(c);
     }
 
-    if (target->HaveCxx20ModuleSources() && !this->SupportsCxxModuleDyndep()) {
-      root->GetMakefile()->IssueMessage(
-        MessageType::FATAL_ERROR,
-        cmStrCat("The target named \"", target->GetName(),
-                 "\" contains C++ sources that export modules which is not "
-                 "supported by the generator"));
-    }
-
     // handle external vc project files
     cmValue expath = target->GetProperty("EXTERNAL_MSPROJECT");
     if (expath) {

Source/cmGlobalXCodeGenerator.cxx

@@ -1384,14 +1384,6 @@ bool cmGlobalXCodeGenerator::CreateXCodeTarget(
     gtgt->CheckCxxModuleStatus(configName);
   }
 
-  if (gtgt->HaveCxx20ModuleSources()) {
-    gtgt->Makefile->IssueMessage(
-      MessageType::FATAL_ERROR,
-      cmStrCat("The target named \"", gtgt->GetName(),
-               "\" contains C++ sources that export modules which is not "
-               "supported by the generator"));
-  }
-
   auto& gtgt_visited = this->CommandsVisited[gtgt];
   auto const& deps = this->GetTargetDirectDepends(gtgt);
   for (auto const& d : deps) {

Source/cmInstallCommand.cxx

@@ -21,7 +21,6 @@
 #include "cmArgumentParser.h"
 #include "cmArgumentParserTypes.h"
 #include "cmExecutionStatus.h"
-#include "cmExperimental.h"
 #include "cmExportSet.h"
 #include "cmFileSet.h"
 #include "cmGeneratorExpression.h"
@@ -491,6 +490,7 @@ bool HandleTargetsMode(std::vector<std::string> const& args,
   publicHeaderArgs.Parse(argVectors.PublicHeader, &unknownArgs);
   resourceArgs.Parse(argVectors.Resource, &unknownArgs);
   includesArgs.Parse(&argVectors.Includes, &unknownArgs);
+  cxxModuleBmiArgs.Parse(argVectors.CxxModulesBmi, &unknownArgs);
   for (std::size_t i = 0; i < argVectors.FileSets.size(); i++) {
     // We have to create a separate object for the parsing because
     // cmArgumentParser<void>::Bind() binds to a specific address, but the
@@ -501,15 +501,6 @@ bool HandleTargetsMode(std::vector<std::string> const& args,
     fileSetArgs[i] = std::move(fileSetArg);
   }
 
-  bool const supportCxx20FileSetTypes = cmExperimental::HasSupportEnabled(
-    *helper.Makefile, cmExperimental::Feature::CxxModuleCMakeApi);
-  if (!supportCxx20FileSetTypes) {
-    std::copy(argVectors.CxxModulesBmi.begin(), argVectors.CxxModulesBmi.end(),
-              std::back_inserter(unknownArgs));
-  } else {
-    cxxModuleBmiArgs.Parse(argVectors.CxxModulesBmi, &unknownArgs);
-  }
-
   if (!unknownArgs.empty()) {
     // Unknown argument.
     status.SetError(
@@ -541,12 +532,10 @@ bool HandleTargetsMode(std::vector<std::string> const& args,
   success = success && privateHeaderArgs.Finalize();
   success = success && publicHeaderArgs.Finalize();
   success = success && resourceArgs.Finalize();
+  success = success && cxxModuleBmiArgs.Finalize();
   for (auto& fileSetArg : fileSetArgs) {
     success = success && fileSetArg.Finalize();
   }
-  if (supportCxx20FileSetTypes) {
-    success = success && cxxModuleBmiArgs.Finalize();
-  }
 
   if (!success) {
     return false;
@@ -1173,8 +1162,7 @@ bool HandleTargetsMode(std::vector<std::string> const& args,
       }
     }
 
-    if (supportCxx20FileSetTypes &&
-        !cxxModuleBmiArgs.GetDestination().empty()) {
+    if (!cxxModuleBmiArgs.GetDestination().empty()) {
       cxxModuleBmiGenerator = cm::make_unique<cmInstallCxxModuleBmiGenerator>(
         target.GetName(),
         helper.GetCxxModulesBmiDestination(&cxxModuleBmiArgs),
@@ -2071,12 +2059,7 @@ bool HandleExportMode(std::vector<std::string> const& args,
   ica.Bind("NAMESPACE"_s, name_space);
   ica.Bind("EXPORT_LINK_INTERFACE_LIBRARIES"_s, exportOld);
   ica.Bind("FILE"_s, filename);
-
-  bool const supportCxx20FileSetTypes = cmExperimental::HasSupportEnabled(
-    *helper.Makefile, cmExperimental::Feature::CxxModuleCMakeApi);
-  if (supportCxx20FileSetTypes) {
-    ica.Bind("CXX_MODULES_DIRECTORY"_s, cxx_modules_directory);
-  }
+  ica.Bind("CXX_MODULES_DIRECTORY"_s, cxx_modules_directory);
 
   std::vector<std::string> unknownArgs;
   ica.Parse(args, &unknownArgs);

Source/cmMakefileTargetGenerator.cxx

@@ -204,14 +204,6 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
 {
   this->GeneratorTarget->CheckCxxModuleStatus(this->GetConfigName());
 
-  if (this->GeneratorTarget->HaveCxx20ModuleSources()) {
-    this->Makefile->IssueMessage(
-      MessageType::FATAL_ERROR,
-      cmStrCat("The target named \"", this->GeneratorTarget->GetName(),
-               "\" contains C++ sources that export modules which is not "
-               "supported by the generator"));
-  }
-
   // -- Write the custom commands for this target
 
   // Evaluates generator expressions and expands prop_value

Source/cmNinjaTargetGenerator.cxx

@@ -266,7 +266,7 @@ std::string cmNinjaTargetGenerator::ComputeFlagsForObject(
 
     if (!this->GeneratorTarget->Target->IsNormal()) {
       auto flag = this->GetMakefile()->GetSafeDefinition(
-        "CMAKE_EXPERIMENTAL_CXX_MODULE_BMI_ONLY_FLAG");
+        "CMAKE_CXX_MODULE_BMI_ONLY_FLAG");
       cmRulePlaceholderExpander::RuleVariables compileObjectVars;
       compileObjectVars.Object = objectFileName.c_str();
       auto rulePlaceholderExpander =
@@ -710,7 +710,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
     }
   }
   std::string const modmapFormatVar =
-    cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_MODULE_MAP_FORMAT");
+    cmStrCat("CMAKE_", lang, "_MODULE_MAP_FORMAT");
   std::string const modmapFormat =
     this->Makefile->GetSafeDefinition(modmapFormatVar);
 
@@ -734,7 +734,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
 
   if (withScanning == WithScanning::Yes) {
     const auto& scanDepType = this->GetMakefile()->GetSafeDefinition(
-      cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_SCANDEP_DEPFILE_FORMAT"));
+      cmStrCat("CMAKE_", lang, "_SCANDEP_DEPFILE_FORMAT"));
 
     // Rule to scan dependencies of sources that need preprocessing.
     {
@@ -745,7 +745,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
         scanRuleName = this->LanguageScanRule(lang, config);
         ppFileName = "$PREPROCESSED_OUTPUT_FILE";
         std::string const& scanCommand = mf->GetRequiredDefinition(
-          cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_SCANDEP_SOURCE"));
+          cmStrCat("CMAKE_", lang, "_SCANDEP_SOURCE"));
         scanCommands.assign(scanCommand);
         for (auto& i : scanCommands) {
           i = cmStrCat(launcher, i);
@@ -893,8 +893,8 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
   }
 
   if (withScanning == WithScanning::Yes && !modmapFormat.empty()) {
-    std::string modmapFlags = mf->GetRequiredDefinition(
-      cmStrCat("CMAKE_EXPERIMENTAL_", lang, "_MODULE_MAP_FLAG"));
+    std::string modmapFlags =
+      mf->GetRequiredDefinition(cmStrCat("CMAKE_", lang, "_MODULE_MAP_FLAG"));
     cmSystemTools::ReplaceString(modmapFlags, "<MODULE_MAP_FILE>",
                                  "$DYNDEP_MODULE_MAP_FILE");
     flags += cmStrCat(' ', modmapFlags);
@@ -1143,6 +1143,30 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements(
     }
   }
 
+  // Detect sources in `CXX_MODULES` which are not compiled.
+  {
+    std::vector<cmSourceFile*> sources;
+    this->GeneratorTarget->GetSourceFiles(sources, config);
+    for (cmSourceFile const* sf : sources) {
+      cmFileSet const* fs =
+        this->GeneratorTarget->GetFileSetForSource(config, sf);
+      if (!fs) {
+        continue;
+      }
+      if (fs->GetType() != "CXX_MODULES"_s) {
+        continue;
+      }
+      if (sf->GetLanguage().empty()) {
+        this->GeneratorTarget->Makefile->IssueMessage(
+          MessageType::FATAL_ERROR,
+          cmStrCat("Target \"", this->GeneratorTarget->GetName(),
+                   "\" has source file\n  ", sf->GetFullPath(),
+                   "\nin a \"FILE_SET TYPE CXX_MODULES\" but it is not "
+                   "scheduled for compilation."));
+      }
+    }
+  }
+
   for (auto const& langScanningFiles : this->Configs[config].ScanningInfo) {
     std::string const& language = langScanningFiles.first;
     std::vector<ScanningFiles> const& scanningFiles = langScanningFiles.second;
@@ -1477,7 +1501,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
   std::string modmapFormat;
   if (needDyndep) {
     std::string const modmapFormatVar =
-      cmStrCat("CMAKE_EXPERIMENTAL_", language, "_MODULE_MAP_FORMAT");
+      cmStrCat("CMAKE_", language, "_MODULE_MAP_FORMAT");
     modmapFormat = this->Makefile->GetSafeDefinition(modmapFormatVar);
   }
 
@@ -1758,7 +1782,7 @@ void cmNinjaTargetGenerator::WriteCxxModuleBmiBuildStatement(
   std::string modmapFormat;
   if (true) {
     std::string const modmapFormatVar =
-      cmStrCat("CMAKE_EXPERIMENTAL_", language, "_MODULE_MAP_FORMAT");
+      cmStrCat("CMAKE_", language, "_MODULE_MAP_FORMAT");
     modmapFormat = this->Makefile->GetSafeDefinition(modmapFormatVar);
   }
 
@@ -1969,12 +1993,12 @@ void cmNinjaTargetGenerator::ExportObjectCompileCommand(
     bool const needDyndep =
       this->GetGeneratorTarget()->NeedDyndep(language, outputConfig);
     std::string const modmapFormatVar =
-      cmStrCat("CMAKE_EXPERIMENTAL_", language, "_MODULE_MAP_FORMAT");
+      cmStrCat("CMAKE_", language, "_MODULE_MAP_FORMAT");
     std::string const modmapFormat =
       this->Makefile->GetSafeDefinition(modmapFormatVar);
     if (needDyndep && !modmapFormat.empty()) {
       std::string modmapFlags = this->GetMakefile()->GetRequiredDefinition(
-        cmStrCat("CMAKE_EXPERIMENTAL_", language, "_MODULE_MAP_FLAG"));
+        cmStrCat("CMAKE_", language, "_MODULE_MAP_FLAG"));
       // XXX(modmap): If changing this path construction, change
       // `cmGlobalNinjaGenerator::WriteDyndep` and
       // `cmNinjaTargetGenerator::WriteObjectBuildStatement` to expect the

Source/cmPolicies.h

@@ -469,6 +469,10 @@ class cmMakefile;
   SELECT(                                                                     \
     POLICY, CMP0154,                                                          \
     "Generated files are private by default in targets using file sets.", 3,  \
+    28, 0, cmPolicies::WARN)                                                  \
+  SELECT(                                                                     \
+    POLICY, CMP0155,                                                          \
+    "C++ sources in targets with at least C++20 are scanned for imports", 3,  \
     28, 0, cmPolicies::WARN)
 
 #define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1)
@@ -508,7 +512,8 @@ class cmMakefile;
   F(CMP0119)                                                                  \
   F(CMP0131)                                                                  \
   F(CMP0142)                                                                  \
-  F(CMP0154)
+  F(CMP0154)                                                                  \
+  F(CMP0155)
 
 #define CM_FOR_EACH_CUSTOM_COMMAND_POLICY(F)                                  \
   F(CMP0116)                                                                  \

Source/cmTargetSourcesCommand.cxx

@@ -10,7 +10,6 @@
 
 #include "cmArgumentParser.h"
 #include "cmArgumentParserTypes.h"
-#include "cmExperimental.h"
 #include "cmFileSet.h"
 #include "cmGeneratorExpression.h"
 #include "cmList.h"
@@ -260,28 +259,18 @@ bool TargetSourcesImpl::HandleOneFileSet(
       this->SetError("Must specify a TYPE when creating file set");
       return false;
     }
-    bool const supportCxx20FileSetTypes = cmExperimental::HasSupportEnabled(
-      *this->Makefile, cmExperimental::Feature::CxxModuleCMakeApi);
+    if (type != "HEADERS"_s && type != "CXX_MODULES"_s) {
+      this->SetError(
+        R"(File set TYPE may only be "HEADERS" or "CXX_MODULES")");
+      return false;
+    }
 
-    if (supportCxx20FileSetTypes) {
-      if (type != "HEADERS"_s && type != "CXX_MODULES"_s) {
+    if (cmFileSetVisibilityIsForInterface(visibility) &&
+        !cmFileSetVisibilityIsForSelf(visibility) &&
+        !this->Target->IsImported()) {
+      if (type == "CXX_MODULES"_s) {
         this->SetError(
-          R"(File set TYPE may only be "HEADERS" or "CXX_MODULES")");
-        return false;
-      }
-
-      if (cmFileSetVisibilityIsForInterface(visibility) &&
-          !cmFileSetVisibilityIsForSelf(visibility) &&
-          !this->Target->IsImported()) {
-        if (type == "CXX_MODULES"_s) {
-          this->SetError(
-            R"(File set TYPE "CXX_MODULES" may not have "INTERFACE" visibility)");
-          return false;
-        }
-      }
-    } else {
-      if (type != "HEADERS"_s) {
-        this->SetError("File set TYPE may only be \"HEADERS\"");
+          R"(File set TYPE "CXX_MODULES" may not have "INTERFACE" visibility)");
         return false;
       }
     }

Source/cmVisualStudio10TargetGenerator.cxx

@@ -362,15 +362,6 @@ void cmVisualStudio10TargetGenerator::Generate()
     this->GeneratorTarget->CheckCxxModuleStatus(config);
   }
 
-  if (this->GeneratorTarget->HaveCxx20ModuleSources() &&
-      !this->GlobalGenerator->SupportsCxxModuleDyndep()) {
-    this->Makefile->IssueMessage(
-      MessageType::FATAL_ERROR,
-      cmStrCat("The target named \"", this->GeneratorTarget->GetName(),
-               "\" contains C++ sources that export modules which is not "
-               "supported by the generator"));
-  }
-
   this->ProjectType = computeProjectType(this->GeneratorTarget);
   this->Managed = this->ProjectType == VsProjectType::csproj;
   const std::string ProjectFileExtension =

Tests/RunCMake/CXXModules/CMP0155-NEW-stderr.txt

@@ -0,0 +1,8 @@
+(CMake Error in CMakeLists.txt:
+(  The target named "cmp0155-new" has C\+\+ sources that use modules but the
+  compiler does not provide a way to discover the import graph dependencies
+|  The target named "cmp0155-new" contains C\+\+ sources that use modules which
+  is not supported by the generator
+)
+)*
+CMake Generate step failed.  Build files cannot be regenerated correctly.

Tests/RunCMake/CXXModules/CMP0155-NEW.cmake

@@ -0,0 +1,11 @@
+enable_language(CXX)
+unset(CMAKE_CXX_SCANDEP_SOURCE)
+
+cmake_policy(SET CMP0155 NEW)
+
+add_executable(cmp0155-new
+  sources/module-use.cxx)
+set_target_properties(cmp0155-new
+  PROPERTIES
+    CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED ON)

Tests/RunCMake/CXXModules/CMP0155-OLD.cmake

@@ -0,0 +1,11 @@
+enable_language(CXX)
+unset(CMAKE_CXX_SCANDEP_SOURCE)
+
+cmake_policy(SET CMP0155 OLD)
+
+add_executable(cmp0155-old
+  sources/module-use.cxx)
+set_target_properties(cmp0155-old
+  PROPERTIES
+    CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED ON)

Tests/RunCMake/CXXModules/CMakeLists.txt

@@ -1,6 +1,4 @@
 cmake_minimum_required(VERSION 3.23)
 project(${RunCMake_TEST} NONE)
 
-set(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API "ac01f462-0f5f-432a-86aa-acef252918a6")
-
 include(${RunCMake_TEST}.cmake)

Tests/RunCMake/CXXModules/ExportBuildCxxModules-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at ExportBuildCxxModules.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/ExportBuildCxxModules.cmake

@@ -1,5 +1,5 @@
 enable_language(CXX)
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "")
+set(CMAKE_CXX_SCANDEP_SOURCE "")
 
 add_library(export-modules)
 target_sources(export-modules

Tests/RunCMake/CXXModules/ExportInstallCxxModules-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at ExportInstallCxxModules.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/ExportInstallCxxModules.cmake

@@ -1,5 +1,5 @@
 enable_language(CXX)
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "")
+set(CMAKE_CXX_SCANDEP_SOURCE "")
 
 add_library(export-modules)
 target_sources(export-modules

Tests/RunCMake/CXXModules/FileSetModulesInterface-stderr.txt

@@ -1,10 +1,3 @@
-CMake Warning \(dev\) at FileSetModulesInterface.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.
-
 CMake Error at FileSetModulesInterface.cmake:[0-9]+ \(target_sources\):
   target_sources File set TYPE "CXX_MODULES" may not have "INTERFACE"
   visibility

Tests/RunCMake/CXXModules/FileSetModulesInterfaceImported-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at FileSetModulesInterfaceImported.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/FileSetModulesPrivate-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at FileSetModulesPrivate.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/FileSetModulesPrivate.cmake

@@ -1,5 +1,5 @@
 enable_language(CXX)
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "")
+set(CMAKE_CXX_SCANDEP_SOURCE "")
 
 add_library(module)
 target_sources(module

Tests/RunCMake/CXXModules/FileSetModulesPublic-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at FileSetModulesPublic.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/FileSetModulesPublic.cmake

@@ -1,5 +1,5 @@
 enable_language(CXX)
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "")
+set(CMAKE_CXX_SCANDEP_SOURCE "")
 
 add_library(module)
 target_sources(module

Tests/RunCMake/CXXModules/InstallBMI-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at InstallBMI.cmake:[0-9]+ \(install\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/InstallBMIGenericArgs-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at InstallBMIGenericArgs.cmake:[0-9]+ \(install\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/InstallBMIIgnore-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at InstallBMIIgnore.cmake:[0-9]+ \(install\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/NinjaDependInfoBMIInstall-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at NinjaDependInfoBMIInstall.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/NinjaDependInfoBMIInstall.cmake

@@ -1,6 +1,6 @@
 # Fake out that we have dyndep; we only need to generate, not actually build
 # here.
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "")
+set(CMAKE_CXX_SCANDEP_SOURCE "")
 
 enable_language(CXX)
 

Tests/RunCMake/CXXModules/NinjaDependInfoExport-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at NinjaDependInfoExport.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/NinjaDependInfoExport.cmake

@@ -1,6 +1,6 @@
 # Fake out that we have dyndep; we only need to generate, not actually build
 # here.
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "")
+set(CMAKE_CXX_SCANDEP_SOURCE "")
 
 enable_language(CXX)
 

Tests/RunCMake/CXXModules/NinjaDependInfoFileSet-stderr.txt

@@ -1,6 +0,0 @@
-CMake Warning \(dev\) at NinjaDependInfoFileSet.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/NinjaDependInfoFileSet.cmake

@@ -1,6 +1,6 @@
 # Fake out that we have dyndep; we only need to generate, not actually build
 # here.
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "")
+set(CMAKE_CXX_SCANDEP_SOURCE "")
 
 enable_language(CXX)
 

Tests/RunCMake/CXXModules/NoCXX-stderr.txt

@@ -1,20 +1,8 @@
-CMake Warning \(dev\) at NoCXX.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.
-
-CMake Error in CMakeLists.txt:
-  The target named "nocxx" has C\+\+ sources that export modules but the "CXX"
-  language has not been enabled
-
-(
-CMake Error in CMakeLists.txt:
-(  The target named "nocxx" has C\+\+ sources that export modules but the "CXX"
+(CMake Error in CMakeLists.txt:
+(  The target named "nocxx" has C\+\+ sources that use modules but the "CXX"
   language has not been enabled
-|  The target named "nocxx" contains C\+\+ sources that export modules which is
-  not supported by the generator
+|  The target named "nocxx" contains C\+\+ sources that use modules which is not
+  supported by the generator
 |  Target "nocxx" has source file
 
     .*/Tests/RunCMake/CXXModules/sources/module.cxx

Tests/RunCMake/CXXModules/NoCXX20-stderr.txt

@@ -1,22 +1,9 @@
-CMake Warning \(dev\) at NoCXX20.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.
-
-CMake Error in CMakeLists.txt:
-  The target named "nocxx20" has C\+\+ sources that export modules but does not
+(CMake Error in CMakeLists.txt:
+(  The target named "nocxx20" has C\+\+ sources that use modules but does not
   include "cxx_std_20" \(or newer\) among its `target_compile_features`; found
   "cxx_std_17"
-
-(
-CMake Error in CMakeLists.txt:
-(  The target named "nocxx20" has C\+\+ sources that export modules but does not
-  include "cxx_std_20" \(or newer\) among its `target_compile_features`; found
-  "cxx_std_17"
-|  The target named "nocxx20" contains C\+\+ sources that export modules which
-  is not supported by the generator
+|  The target named "nocxx20" contains C\+\+ sources that use modules which is
+  not supported by the generator
 )
 )*
 CMake Generate step failed.  Build files cannot be regenerated correctly.

Tests/RunCMake/CXXModules/NoCXX20ModuleFlag-stderr.txt

@@ -1,20 +0,0 @@
-CMake Warning \(dev\) at NoCXX20ModuleFlag.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.
-
-CMake Error in CMakeLists.txt:
-  The target named "noexperimentalflag" has C\+\+ sources that export modules
-  but its experimental support has not been requested
-
-(
-CMake Error in CMakeLists.txt:
-(  The target named "noexperimentalflag" has C\+\+ sources that export modules
-  but its experimental support has not been requested
-|  The target named "noexperimentalflag" contains C\+\+ sources that export
-  modules which is not supported by the generator
-)
-)*
-CMake Generate step failed.  Build files cannot be regenerated correctly.

Tests/RunCMake/CXXModules/NoCXX20ModuleFlag.cmake

@@ -1,14 +0,0 @@
-enable_language(CXX)
-
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "echo")
-
-add_library(noexperimentalflag)
-target_sources(noexperimentalflag
-  PUBLIC
-    FILE_SET fs TYPE CXX_MODULES FILES
-      sources/module.cxx)
-target_compile_features(noexperimentalflag
-  PRIVATE
-    cxx_std_20)
-
-unset(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API)

Tests/RunCMake/CXXModules/NoDyndepSupport-stderr.txt

@@ -1,10 +1,3 @@
-CMake Warning \(dev\) at NoDyndepSupport.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.
-
 (CMake Error:
   The Ninja generator does not support C\+\+20 modules using Ninja version
 
@@ -13,13 +6,13 @@ This warning is for project developers.  Use -Wno-dev to suppress it.
   due to lack of required features.  Ninja 1.11 or higher is required.
 
 |CMake Error in CMakeLists.txt:
-  The target named "nodyndep" contains C\+\+ sources that export modules which
-  is not supported by the generator
+  The target named "nodyndep" contains C\+\+ sources that use modules which is
+  not supported by the generator
 
 (
 CMake Error in CMakeLists.txt:
-  The target named "nodyndep" contains C\+\+ sources that export modules which
-  is not supported by the generator
+  The target named "nodyndep" contains C\+\+ sources that use modules which is
+  not supported by the generator
 
 )*)
 CMake Generate step failed.  Build files cannot be regenerated correctly.

Tests/RunCMake/CXXModules/NoDyndepSupport.cmake

@@ -1,5 +1,5 @@
 enable_language(CXX)
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "")
+set(CMAKE_CXX_SCANDEP_SOURCE "")
 
 if (NOT CMAKE_CXX_STANDARD_DEFAULT)
   set(CMAKE_CXX_STANDARD_DEFAULT "11")

Tests/RunCMake/CXXModules/NoScanningSourceFileProperty-stderr.txt

@@ -0,0 +1,9 @@
+(CMake Error in CMakeLists.txt:
+(  The target named "noscanning-sf-property" has C\+\+ sources that use modules
+  but the compiler does not provide a way to discover the import graph
+  dependencies
+|  The target named "noscanning-sf-property" contains C\+\+ sources that use modules which
+  is not supported by the generator
+)
+)*
+CMake Generate step failed.  Build files cannot be regenerated correctly.

Tests/RunCMake/CXXModules/NoScanningSourceFileProperty.cmake

@@ -0,0 +1,13 @@
+enable_language(CXX)
+unset(CMAKE_CXX_SCANDEP_SOURCE)
+
+add_executable(noscanning-sf-property
+  sources/module-use.cxx)
+set_target_properties(noscanning-sf-property
+  PROPERTIES
+    CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED ON
+    CXX_SCAN_FOR_MODULES 0)
+set_source_files_properties(sources/module-use.cxx
+  PROPERTIES
+    CXX_SCAN_FOR_MODULES 1)

Tests/RunCMake/CXXModules/NoScanningTargetProperty-stderr.txt

@@ -0,0 +1,9 @@
+(CMake Error in CMakeLists.txt:
+(  The target named "noscanning-target-property" has C\+\+ sources that use
+  modules but the compiler does not provide a way to discover the import
+  graph dependencies
+|  The target named "noscanning-target-property" contains C\+\+ sources that use modules which
+  is not supported by the generator
+)
+)*
+CMake Generate step failed.  Build files cannot be regenerated correctly.

Tests/RunCMake/CXXModules/NoScanningTargetProperty.cmake

@@ -0,0 +1,10 @@
+enable_language(CXX)
+unset(CMAKE_CXX_SCANDEP_SOURCE)
+
+add_executable(noscanning-target-property
+  sources/module-use.cxx)
+set_target_properties(noscanning-target-property
+  PROPERTIES
+    CXX_STANDARD 20
+    CXX_STANDARD_REQUIRED ON
+    CXX_SCAN_FOR_MODULES 1)

Tests/RunCMake/CXXModules/NotCXXSourceModules-stderr.txt

@@ -1,10 +1,3 @@
-CMake Warning \(dev\) at NotCXXSourceModules.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.
-
 CMake Error in CMakeLists.txt:
   Target "not-cxx-source" contains the source
 

Tests/RunCMake/CXXModules/NotCXXSourceModules.cmake

@@ -1,6 +1,6 @@
 enable_language(C)
 enable_language(CXX)
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "")
+set(CMAKE_CXX_SCANDEP_SOURCE "")
 
 add_library(not-cxx-source)
 target_sources(not-cxx-source

Tests/RunCMake/CXXModules/NotCompiledSourceModules-stderr.txt

@@ -1,10 +1,3 @@
-CMake Warning \(dev\) at NotCompiledSourceModules.cmake:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-Call Stack \(most recent call first\):
-  CMakeLists.txt:[0-9]+ \(include\)
-This warning is for project developers.  Use -Wno-dev to suppress it.
-
 (CMake Error in CMakeLists.txt:
   Target "not-cxx-source" has source file
 

Tests/RunCMake/CXXModules/NotCompiledSourceModules.cmake

@@ -1,5 +1,5 @@
 enable_language(CXX)
-set(CMAKE_EXPERIMENTAL_CXX_SCANDEP_SOURCE "")
+set(CMAKE_CXX_SCANDEP_SOURCE "")
 
 add_library(not-cxx-source)
 target_sources(not-cxx-source

Tests/RunCMake/CXXModules/RunCMakeTest.cmake

@@ -15,9 +15,10 @@ if ("cxx_std_20" IN_LIST CMAKE_CXX_COMPILE_FEATURES)
     run_cmake(NoCXX20)
   endif ()
 
-  # This test uses C++20, but another prerequisite is missing, so forced
-  # standards don't matter.
-  run_cmake(NoCXX20ModuleFlag)
+  run_cmake(NoScanningSourceFileProperty)
+  run_cmake(NoScanningTargetProperty)
+  run_cmake(CMP0155-OLD)
+  run_cmake(CMP0155-NEW)
 endif ()
 
 if (RunCMake_GENERATOR MATCHES "Ninja")

Tests/RunCMake/CXXModules/examples/circular-stderr.txt

@@ -1,4 +0,0 @@
-CMake Warning \(dev\) at CMakeLists.txt:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/examples/circular/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.24)
+cmake_minimum_required(VERSION 3.24...3.28)
 project(cxx_modules_circular CXX)
 
 include("${CMAKE_SOURCE_DIR}/../cxx-modules-rules.cmake")

Tests/RunCMake/CXXModules/examples/cxx-modules-rules.cmake

@@ -1,17 +1,5 @@
-set(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API "ac01f462-0f5f-432a-86aa-acef252918a6")
-
-if (NOT EXISTS "${CMake_TEST_MODULE_COMPILATION_RULES}")
-  message(FATAL_ERROR
-    "The `CMake_TEST_MODULE_COMPILATION_RULES` file must be specified "
-    "for these tests to operate.")
-endif ()
-
-include("${CMake_TEST_MODULE_COMPILATION_RULES}")
-
-if (NOT CMake_TEST_CXXModules_UUID STREQUAL "a246741c-d067-4019-a8fb-3d16b0c9d1d3")
-  message(FATAL_ERROR
-    "The compilation rule file needs updated for changes in the test "
-    "suite. Please see the history for what needs to be updated.")
+if (CMake_TEST_MODULE_COMPILATION_RULES)
+  include("${CMake_TEST_MODULE_COMPILATION_RULES}")
 endif ()
 
 include(CTest)

Tests/RunCMake/CXXModules/examples/deep-chain-stderr.txt

@@ -1,4 +0,0 @@
-CMake Warning \(dev\) at CMakeLists.txt:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/examples/deep-chain/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.24)
+cmake_minimum_required(VERSION 3.24...3.28)
 project(cxx_modules_deep_chain CXX)
 
 include("${CMAKE_SOURCE_DIR}/../cxx-modules-rules.cmake")

Tests/RunCMake/CXXModules/examples/duplicate-stderr.txt

@@ -1,4 +0,0 @@
-CMake Warning \(dev\) at CMakeLists.txt:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/examples/duplicate/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.24)
+cmake_minimum_required(VERSION 3.24...3.28)
 project(cxx_modules_duplicate CXX)
 
 include("${CMAKE_SOURCE_DIR}/../cxx-modules-rules.cmake")

Tests/RunCMake/CXXModules/examples/export-bmi-and-interface-build-stderr.txt

@@ -1,4 +0,0 @@
-CMake Warning \(dev\) at CMakeLists.txt:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-This warning is for project developers.  Use -Wno-dev to suppress it.

Tests/RunCMake/CXXModules/examples/export-bmi-and-interface-build/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.24)
+cmake_minimum_required(VERSION 3.24...3.28)
 project(cxx_modules_export_bmi_and_interfaces CXX)
 
 include("${CMAKE_SOURCE_DIR}/../cxx-modules-rules.cmake")

Tests/RunCMake/CXXModules/examples/export-bmi-and-interface-build/test/CMakeLists.txt

@@ -1,8 +1,6 @@
-cmake_minimum_required(VERSION 3.24)
+cmake_minimum_required(VERSION 3.24...3.28)
 project(cxx_modules_library NONE)
 
-set(CMAKE_EXPERIMENTAL_CXX_MODULE_CMAKE_API "ac01f462-0f5f-432a-86aa-acef252918a6")
-
 find_package(export_bmi_and_interfaces REQUIRED)
 
 if (NOT TARGET CXXModules::export_bmi_and_interfaces)

Tests/RunCMake/CXXModules/examples/export-bmi-and-interface-install-stderr.txt

@@ -1,4 +0,0 @@
-CMake Warning \(dev\) at CMakeLists.txt:[0-9]+ \(target_sources\):
-  CMake's C\+\+ module support is experimental.  It is meant only for
-  experimentation and feedback to CMake developers.
-This warning is for project developers.  Use -Wno-dev to suppress it.