Add module partitions and implementation modules.

This commit adds support for implementation partitions
and modifies file conventions for a modularized target.

The conventions are:

  - your primary interface unit for your module should always
    be called 'module.cppm'. It should export module <target-name>.

  - your interface partitions can have any name supported by a module.
    For example: MyThings.cppm. The interface partition
    should declare 'export module <target-name>:MyThings'.

  - Your *importable* interface implementation units should end with
    'Impl.cppm'. For example 'MyThingsImpl.cppm'. This should
    'module <target-name>:MyThings' (without export).

  - Your *non-importable* implementation can have any name *with an
    extension .cpp*, not a .cppm, since implementation units are
    not importable. It is highly recommended, though, that if you
    have a single implementation file, it is called moduleImpl.cpp.

  You can see the project attached in Github draft PR:
  #14989 as an example that uses
  interface partitions, primary interface units, an implementation
  module (but not an implementation module partition, though it should
  work), multiple targets and import std.

  It can run a couple of tests when fully compiled and it resolves
  dependency order via scanner with Clang.

Author: germandiagogomez

mesonbuild/backend/ninjabackend.py

@@ -26,6 +26,7 @@
 from .. import compilers
 from ..arglist import CompilerArgs
 from ..compilers import Compiler
+from ..compilers.cpp import CPPCompiler
 from ..linkers import ArLikeLinker, RSPFileSyntax
 from ..mesonlib import (
     File, LibType, MachineChoice, MesonBugException, MesonException, OrderedSet, PerMachine,
@@ -1134,12 +1135,12 @@ def should_use_dyndeps_for_target(self, target: 'build.BuildTarget') -> bool:
         if cpp.get_id() == 'clang':
             clang_version_ok = mesonlib.version_compare(cpp.version, '>=17')
             if not clang_version_ok:
-                raise MesonException('Tried to compile a library that uses modules. Modules feature is available in clang startint at version 17.')
+                raise MesonException('Tried to compile a library that uses modules. Modules feature is available in clang starting at version 17.')
             return (target_has_primary_module_interface or global_scan_enabled) and clang_version_ok and EXPERIMENTAL_CPP_MODULES_FEATURE != 'disabled'
         if cpp.get_id() == 'gcc':
             gcc_version_ok = mesonlib.version_compare(cpp.version, '>=14')
             if not gcc_version_ok:
-                raise MesonException('Tried to compile a library that uses modules. Modules feature is available in gcc startint at version 14.')
+                raise MesonException('Tried to compile a library that uses modules. Modules feature is available in gcc starting at version 14.')
             return (target_has_primary_module_interface or global_scan_enabled) and clang_version_ok and EXPERIMENTAL_CPP_MODULES_FEATURE != 'disabled'
 
         if cpp.get_id() != 'msvc':
@@ -1191,8 +1192,6 @@ def generate_global_dependency_scan_target(self) -> None:
         elem.add_dep(self._all_scan_sources)
         self.add_build(elem)
 
-
-
     # def generate_dependency_scan_target(self, target: build.BuildTarget,
     #                                     compiled_sources: T.List[str],
     #                                     source2object: T.Dict[str, str],
@@ -3166,6 +3165,35 @@ def generate_common_compile_args_per_src_type(self, target: build.BuildTarget) -
             src_type_to_args[src_type_str] = commands.to_native()
         return src_type_to_args
 
+    def _get_cpp_module_output_name(self, src_basename: str,
+                                    compiler: CPPCompiler,
+                                    target: build.BuildTarget):
+        is_module_file = src_basename.endswith('.cppm')
+        if not is_module_file:
+            # The compiler will not use this output bc it is not a module
+            return 'dummy'
+
+        # Split the filename into root and extension, and take the root part
+        src_without_extension = os.path.splitext(src_basename)[0]
+
+        # The primary interface unit should have the name 'module.cpp' in all cases. It should
+        # export as the module name the name of your target. For example, 'hello.world' target
+        # 'export module hello.world'
+        if src_without_extension == 'module':
+            return f"{target.name}{compiler.get_cpp20_module_bmi_extension()}"
+        # This is an implementation partition. by convention, it is the name that
+        # will be used as the name of the module.
+        # For example, given GreetImpl.cppm, then it should declare 'module hello.world:Greet'
+        # internally.
+        elif (src_without_extension.endswith('Impl')):
+            private_partition_name = src_without_extension.split('Impl')[0]
+            return f"{target.name}-{private_partition_name}{compiler.get_cpp20_module_bmi_extension()}"
+        # This is an interface partition. Same convention as the Impl with the difference that
+        # it does not end in 'Impl'. So for a given file 'MySalutation.cppm', the module would do
+        # 'export hello.world:MySalutation'
+        else:
+            return f"{target.name}-{src_without_extension}{compiler.get_cpp20_module_bmi_extension()}"
+
     def generate_single_compile(self, target: build.BuildTarget, src,
                                 is_generated: bool = False, header_deps=None,
                                 order_deps: T.Optional[T.List[FileOrString]] = None,
@@ -3316,8 +3344,10 @@ def quote_make_target(targetName: str) -> str:
             element.add_item('CUDA_ESCAPED_TARGET', quote_make_target(rel_obj))
 
         if self.should_use_dyndeps_for_target(target) and compiler.get_language() == 'cpp' and compiler.get_id() == 'clang':
+            src_with_extension = os.path.basename(src.fname)
+            mod_output_name = self._get_cpp_module_output_name(src_with_extension, compiler, target)
             commands.extend(['--start-no-unused-arguments',
-                             f'-fmodule-output={target.name}{compiler.get_cpp20_module_bmi_extension()}',
+                             f'-fmodule-output={mod_output_name}',
                              f'-fprebuilt-module-path={self.environment.get_build_dir()}',
                              '--end-no-unused-arguments'])
         element.add_item('ARGS', commands)

mesonbuild/scripts/depscanaccumulate.py

@@ -21,15 +21,18 @@ class ModuleProviderInfo:
 class CppDependenciesScanner:
     pass
 
+def normalize_filename(fname):
+    return fname.replace(':', '-')
+
 class DynDepRule:
     def __init__(self, out: str, imp_outs: T.Optional[T.List[str]], imp_ins: T.List[str]):
         self.output = [f'build {out}']
         if imp_outs:
-            imp_out_str = " ".join(imp_outs)
+            imp_out_str = " ".join([normalize_filename(o) for o in imp_outs])
             self.output.append(f" | {imp_out_str}")
         self.output.append(": dyndep")
         if imp_ins:
-            imp_ins_str = " ".join(imp_ins)
+            imp_ins_str = " ".join([normalize_filename(inf) for inf in imp_ins])
             self.output.append(" | " + imp_ins_str)
         self.output_str = "".join(self.output) + "\n"