Add 'import std' support for Meson

This commit adds the ability for Meson targets for clang (gcc coming
soon) to use 'import std'.

The feature can be used by setting a new option 'cpp_import_std'
globally, which can be true or false.

By default the option is conservatively set to false.

If enabled, during the configuration phase, Meson checks that
the compiler supports building the std library as a module via
compiler version checks.

At build time, it adds a custom target to build the std bmi.
This bmi is wrapped in a dependency. When build_target is invoked,
if it uses cpp_import_std feature and the target uses C++, the
dependency is added to the target (see build_target function).

A best effort has been done to align debug/release flags with
the built version of the std library, though this needs review.

Note that in order to use the feature, the minimum version is C++23,
since import std is a C++23 feature.

An example of how to use it can be found in test '1 import std'.

Smoke-tested in:

   - Clang 19 homebrew, in my Mac.

ROADMAP:

  - Add gcc support.
  - Add override to build targets to avoid using 'import std'.

Author: germandiagogomez

mesonbuild/build.py

@@ -1704,6 +1704,9 @@ def get_used_stdlib_args(self, link_language: str) -> T.List[str]:
                 stdlib_args.extend(all_compilers[dl].language_stdlib_only_link_flags(self.environment))
         return stdlib_args
 
+    def uses_cpp(self) -> bool:
+        return 'cpp' in self.compilers
+
     def uses_rust(self) -> bool:
         return 'rust' in self.compilers
 

mesonbuild/compilers/cpp.py

@@ -4,18 +4,21 @@
 from __future__ import annotations
 
 import functools
+import os
 import os.path
 import typing as T
 
 from .. import options
 from .. import mlog
-from ..mesonlib import MesonException, version_compare
+from ..mesonlib import (File, MesonException, Popen_safe_logged,
+                        version_compare)
 
 from .compilers import (
     gnu_winlibs,
     msvc_winlibs,
     Compiler,
     CompileCheckMode,
+    CompileResult
 )
 from .c_function_attributes import CXX_FUNC_ATTRIBUTES, C_FUNC_ATTRIBUTES
 from .mixins.apple import AppleCompilerMixin, AppleCPPStdsMixin
@@ -88,7 +91,57 @@ def get_no_stdlib_link_args(self) -> T.List[str]:
 
     def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
         code = 'class breakCCompiler;int main(void) { return 0; }\n'
-        return self._sanity_check_impl(work_dir, environment, 'sanitycheckcpp.cc', code)
+        self._sanity_check_impl(work_dir, environment, 'sanitycheckcpp.cc', code)
+        if environment.coredata.optstore.get_value('cpp_import_std'):
+            self._import_cpp_std_sanity_check(work_dir, environment)
+
+    def compile_import_std_module(self,
+                                  env: 'Environment',
+                                  code: File):
+        cpp_std = env.coredata.optstore.get_value('cpp_std')
+        srcname = code.fname
+        # Construct the compiler command-line
+        commands = self.compiler_args()
+        commands.append(f"-std={cpp_std}")
+        commands.extend(['-Wno-reserved-identifier', '-Wno-reserved-module-identifier'])
+        commands.append("--precompile")
+
+        all_lists_to_add = [self.get_always_args(), self.get_debug_args(env.coredata.optstore.get_value('buildtype') == 'debug'),
+                            self.get_assert_args(disable=env.coredata.optstore.get_value('b_ndebug') in ['if-release', 'true'],
+                                                 env=env)]
+        for args_list in all_lists_to_add:
+            for arg in args_list:
+                commands.append(arg)
+        commands.append(srcname)
+        tmpdirname = env.build_dir
+
+        # Preprocess mode outputs to stdout, so no output args
+        print(f"***{self.get_exelist()}")
+        output = f'std{self.get_cpp20_module_bmi_extension()}'
+        commands += self.get_output_args(output)
+        no_ccache = True
+        os_env = os.environ.copy()
+        os_env['LC_ALL'] = 'C'
+        os_env['CCACHE_DISABLE'] = '1'
+        command_list = self.get_exelist(ccache=not no_ccache) + commands.to_native()
+        p, stdo, stde = Popen_safe_logged(command_list, msg="Command line for compiling 'import std' feature", cwd=tmpdirname, env=os_env)
+        if p.returncode != 0:
+            raise MesonException("Could not compile library for use with 'import std'")
+
+    def get_import_std_lib_source_file(self) -> str:
+        raise MesonException("Your compiler does not support 'import std' feature or it has not been implemented")
+
+    def get_cpp20_module_bmi_extension(self) -> str:
+        raise MesonException("Your compiler does not support 'import std' feature or it has not been implemented")
+
+    def get_import_std_compile_args(self, environment: 'Environment'):
+        raise MesonException("Your compiler does not support 'import std' feature or it has not been implemented")
+
+    def check_cpp_import_std_support(self):
+        raise MesonException("Your compiler does not support 'import std' feature or it has not been implemented")
+
+    def _import_cpp_std_sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        self.check_cpp_import_std_support()
 
     def get_compiler_check_args(self, mode: CompileCheckMode) -> T.List[str]:
         # -fpermissive allows non-conforming code to compile which is necessary
@@ -174,9 +227,13 @@ def _find_best_cpp_std(self, cpp_std: str) -> str:
     def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         key = self.form_compileropt_key('std')
+        import_std_key = self.form_compileropt_key('import_std')
+
         opts.update({
             key: options.UserStdOption('cpp', ALL_STDS),
+            import_std_key: options.UseImportStd('cpp')
         })
+
         return opts
 
 
@@ -235,6 +292,26 @@ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_
                           '3': default_warn_args + ['-Wextra', '-Wpedantic'],
                           'everything': ['-Weverything']}
 
+    def check_cpp_import_std_support(self):
+        if int(self.version.split('.')[0]) < 17:
+            raise MesonException('Your compiler does not support import std feature. Clang support starts at version >= 17')
+
+    def get_import_std_compile_args(self, env: 'Environment'):
+        bmi_path = f'{env.get_build_dir()}/std{self.get_cpp20_module_bmi_extension()}'
+        return f'-fmodule-file=std={bmi_path}'
+
+    def get_cpp20_module_bmi_extension(self) -> str:
+        return '.pcm'
+
+    #def get_compile_only_args(self) -> T.List[str]:
+    #    return [self.get_import_std_compile_args()].extend(CPPCompiler.get_compile_only_args(self))
+
+    def get_import_std_lib_source_file(self) -> str:
+        comp = self.get_exelist(False)[0]
+        bin_parent_dir = os.path.dirname(comp)
+        llvm_dir = os.path.dirname(bin_parent_dir)
+        return f'{llvm_dir}/share/libc++/v1/std.cppm'
+
     def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
 

mesonbuild/compilers/mixins/clike.py

@@ -287,6 +287,9 @@ def _sanity_check_impl(self, work_dir: str, environment: 'Environment',
                 mode = CompileCheckMode.COMPILE
         cargs, largs = self._get_basic_compiler_args(environment, mode)
         extra_flags = cargs + self.linker_to_compiler_args(largs)
+        if environment.coredata.optstore.get_value('cpp_import_std'):
+            # extra_flags.extend(self.get_import_std)
+            pass
 
         # Is a valid executable output for all toolchains and platforms
         binname += '.exe'

mesonbuild/interpreter/interpreter.py

@@ -309,6 +309,58 @@ def __init__(
         self.compilers: PerMachine[T.Dict[str, 'compilers.Compiler']] = PerMachine({}, {})
         self.parse_project()
         self._redetect_machines()
+        self._cpp_import_std_bmi_dep = None
+
+        if self.coredata.optstore.get_value('cpp_import_std') and self.subproject == "":
+            self._cpp_import_std_bmi_dep = self._create_cpp_import_std_dep(self.environment)
+
+    def _create_cpp_import_std_dep(self, env: environment.Environment):
+        cpp_std = env.coredata.optstore.get_value('cpp_std')
+        compiler_to_use: T.Optional[compilers.cpp.CPPCompiler] = None
+        for comp_lang, compiler in self.compilers.host.items():
+            if comp_lang == 'cpp':
+                compiler_to_use = T.cast(compilers.cpp.CPPCompiler, compiler)
+        if not compiler_to_use:
+            raise MesonException('cpp_import_std option is set to true but no cpp compiler could be found.'
+                                 ' Enable cpp language in your project to use this feature.')
+        cpp_std = env.coredata.optstore.get_value('cpp_std')
+        # Construct the compiler command-line
+        commands = compiler_to_use.compiler_args()
+        commands.append(f"-std={cpp_std}")
+        commands.extend(['-Wno-reserved-identifier', '-Wno-reserved-module-identifier'])
+        commands.append("--precompile")
+
+        all_lists_to_add = [compiler_to_use.get_always_args(), compiler_to_use.get_debug_args(env.coredata.optstore.get_value('buildtype') == 'debug'),
+                            compiler_to_use.get_assert_args(disable=env.coredata.optstore.get_value('b_ndebug') in ['if-release', 'true'],
+                                                            env=env)]
+        for args_list in all_lists_to_add:
+            for arg in args_list:
+                commands.append(arg)
+        commands.append("-o")
+        commands.append("@OUTPUT@")
+        commands.append("@INPUT@")
+        no_ccache = True
+        command_list = compiler_to_use.get_exelist(ccache=not no_ccache) + commands.to_native()
+        tgt = build.CustomTarget('',
+                                 '', '', self.environment, command_list,
+                                 sources=[compiler_to_use.get_import_std_lib_source_file()],
+                                 outputs=[f'std{compiler_to_use.get_cpp20_module_bmi_extension()}'])
+        self.add_target('_cpp_import_std_bmi', tgt)
+        bmi_dep = dependencies.InternalDependency(
+            version='0.0',
+            incdirs=[],
+            compile_args=[compiler_to_use.get_import_std_compile_args(self.environment)],
+            link_args=[],
+            libraries=[],
+            whole_libraries=[],
+            sources=[tgt],
+            extra_files=[],
+            ext_deps=[],
+            variables=[],
+            d_module_versions=[],
+            d_import_dirs=[],
+            objects=[])
+        return bmi_dep
 
     def __getnewargs_ex__(self) -> T.Tuple[T.Tuple[object], T.Dict[str, object]]:
         raise MesonBugException('This class is unpicklable')
@@ -3411,6 +3463,7 @@ def build_target(self, node: mparser.BaseNode, args: T.Tuple[str, SourcesVarargs
         if targetclass not in {build.Executable, build.SharedLibrary, build.SharedModule, build.StaticLibrary, build.Jar}:
             mlog.debug('Unknown target type:', str(targetclass))
             raise RuntimeError('Unreachable code')
+
         self.__process_language_args(kwargs)
         if targetclass is build.StaticLibrary:
             for lang in compilers.all_languages - {'java'}:
@@ -3492,6 +3545,10 @@ def build_target(self, node: mparser.BaseNode, args: T.Tuple[str, SourcesVarargs
 
         target = targetclass(name, self.subdir, self.subproject, for_machine, srcs, struct, objs,
                              self.environment, self.compilers[for_machine], kwargs)
+        if target.uses_cpp():
+            if self.coredata.optstore.get_value('cpp_import_std') and self.subproject == '':
+                target.add_deps([self._cpp_import_std_bmi_dep])
+
         if objs and target.uses_rust():
             FeatureNew.single_use('objects in Rust targets', '1.8.0', self.subproject)
 

mesonbuild/options.py

@@ -581,6 +581,12 @@ def choices_are_different(a: _U, b: _U) -> bool:
     return False
 
 
+class UseImportStd(UserBooleanOption):
+    def __init__(self, lang):
+        self.lang = lang.lower()
+        opt_name =f'{self.lang}_import_std'
+        super().__init__(opt_name, 'Whether to use import std; module in your targets', False)
+
 class UserStdOption(UserComboOption):
     '''
     UserOption specific to c_std and cpp_std options. User can set a list of

test cases/cpp/1 import std/import_std.cpp

@@ -0,0 +1,12 @@
+import std;
+
+constexpr char const * const PROJECT_NAME  = "import std";
+
+int main(int argc, char **argv) {
+    if (argc != 1) {
+        std::cout << argv[0] << " takes no arguments.\n";
+        return 1;
+    }
+    std::cout << "This is project " << PROJECT_NAME << ".\n";
+    return 0;
+}

test cases/cpp/1 import std/meson.build

@@ -0,0 +1,14 @@
+project(
+  'import std',
+  'cpp',
+  version : '0.1',
+  meson_version : '>= 1.3.0',
+  default_options : ['warning_level=3', 'cpp_std=c++23',
+                     'cpp_import_std=true'],
+)
+
+
+exe = executable(
+  'import std',
+  'import_std.cpp'
+)

test cases/cpp/1 import std/meson.build.clang

@@ -0,0 +1,42 @@
+project(
+  'import std',
+  'cpp',
+  version : '0.1',
+  meson_version : '>= 1.3.0',
+  default_options : ['warning_level=3', 'cpp_std=c++23'],
+)
+
+
+cpp_comp = find_program('clang++', dirs: '/usr/local/Cellar/llvm/20.1.1/bin/')
+
+cpp20_std_module = custom_target(
+  'cpp20-std-module',
+  command: [
+    cpp_comp,
+    '-std=c++23',
+    '-Wno-reserved-identifier',
+    '-Wno-reserved-module-identifier',
+    '--precompile',
+    '-o',
+    '@OUTPUT@',
+    '@INPUT@',
+  ],
+  input: '/usr/local/Cellar/llvm/20.1.1/share/libc++/v1/std.cppm',
+  output: 'std.pcm',
+)
+
+cpp20_std_module_dep = declare_dependency(
+  compile_args: ['-fmodule-file=std=@0@'.format(cpp20_std_module.full_path())],
+)
+
+
+dependencies = [cpp20_std_module_dep]
+
+exe = executable(
+  'import std',
+  'import_std.cpp',
+  install : true,
+  dependencies : dependencies,
+)
+
+test('basic', exe)

test cases/cpp/1 import std/meson/native/clang19_modules.ini

@@ -0,0 +1,10 @@
+[binaries]
+c   = '/usr/local/Cellar/llvm/20.1.1/bin/clang'
+cpp = '/usr/local/Cellar/llvm/20.1.1/bin/clang++'
+objc = '/usr/local/Cellar/llvm/20.1.1/bin/clang'
+objcpp = '/usr/local/Cellar/llvm/20.1.1/bin/clang++'
+
+[built-in options]
+cpp_link_args='-L/usr/local/opt/llvm/lib/c++ -L/usr/local/opt/llvm/lib/unwind -lunwind -L/usr/local/opt/llvm/lib'
+cpp_args = '-I/usr/local/opt/llvm/include'
+c_args = '-I/usr/local/opt/llvm/include'