Internal IR for compiler args

mesonbuild/arguments.py

@@ -0,0 +1,126 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright © 2025 Intel Corporation
+
+"""An abstract IR for compile arguments.
+
+This provides us with a way to pass arguments around in a non-compiler specific
+way internally, and lower them into a non-abstract format when writing them in
+the backend.
+"""
+
+from __future__ import annotations
+import dataclasses
+import typing as T
+
+if T.TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    # A Union of all Argument types
+    Argument: TypeAlias = T.Union[
+        'Opaque', 'Warning', 'Error', 'Define', 'Undefine', 'LinkerSearch',
+        'LinkLibrary', 'Rpath',
+    ]
+
+
+@dataclasses.dataclass
+class Opaque:
+
+    """An opaque argument.
+
+    This is an argument of unknown type, and Meson will do nothing but proxy it
+    through, except to apply a prefix to the value if it thinks it's necessary.
+
+    :param value:
+    """
+
+    value: str
+
+
+@dataclasses.dataclass
+class Warning:
+
+    """A compiler warning.
+
+    :param target: The warning to enable or disable. This will be stored as
+        given (ie, we don't try to convert between compilers).
+    :param enable: If true then enable the warning, otherwise suppress it.
+    """
+
+    target: str
+    enable: bool
+
+
+@dataclasses.dataclass
+class Error:
+
+    """A compiler error.
+
+    :param target: The warning to enable or disable. This will be stored as
+        given (ie, we don't try to convert between compilers).
+    """
+
+    target: str
+
+
+@dataclasses.dataclass
+class Define:
+
+    """A pre-processor define.
+
+    :param target: The value to define.
+    :param value: An optional value to set the define to. If undefined them the
+        value will be defined with no value.
+    """
+
+    target: str
+    value: T.Optional[str]
+
+
+@dataclasses.dataclass
+class Undefine:
+
+    """A pre-processor undefine.
+
+    :param target: The value to define.
+    """
+
+    target: str
+
+
+@dataclasses.dataclass
+class LinkerSearch:
+
+    """A location for the linker to search for libraries.
+
+    :param path: The path to search.
+    """
+
+    path: str
+
+
+@dataclasses.dataclass
+class LinkLibrary:
+
+    """A library to link with.
+
+    :param name: The name of the library to link.
+    :param absolute: If the path is an absolute path
+    """
+
+    name: str
+    absolute: bool = False
+
+
+class Rpath:
+
+    """A runtime-path to add to a linked library.
+
+    :param path: the path to add
+    """
+
+    path: str
+
+
+# TODO: rpath
+# TODO: rust cfgs
+# TODO: other flags we might handle differently and want to convert like lto, sanitizers, etc

mesonbuild/build.py

@@ -1,5 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright 2012-2017 The Meson development team
+# Copyright © 2017-2025 Intel Corporation
 
 from __future__ import annotations
 from collections import defaultdict, deque, OrderedDict

mesonbuild/compilers/compilers.py

@@ -25,6 +25,7 @@
 
 if T.TYPE_CHECKING:
     from .. import coredata
+    from ..arguments import Argument
     from ..build import BuildTarget, DFeatures
     from ..options import MutableKeyedOptionDictType
     from ..envconfig import MachineInfo
@@ -1418,6 +1419,22 @@ def _update_language_stds(self, opts: MutableKeyedOptionDictType, value: T.List[
             value = ['none'] + value
         std.choices = value
 
+    @abc.abstractmethod
+    def make_arguments_abstract(self, args: T.List[str]) -> T.List[Argument]:
+        """Convert concrete (string) arguments into abstract ones.
+
+        :param args: The list of string arguments to convert
+        :return: A list of Arguments.
+        """
+
+    @abc.abstractmethod
+    def make_arguments_concrete(self, args: T.List[Argument]) -> T.List[str]:
+        """Convert abstract Arguments into a list of strings for this compiler.
+
+        :param args: The Arguments to convert.
+        :return: A string list of arguments.
+        """
+
 
 def get_global_options(lang: str,
                        comp: T.Type[Compiler],

mesonbuild/compilers/mixins/gnu.py

@@ -14,6 +14,7 @@
 import subprocess
 import typing as T
 
+from ... import arguments
 from ... import mesonlib
 from ... import mlog
 from ...options import OptionKey, UserStdOption
@@ -539,6 +540,59 @@ def get_preprocess_to_file_args(self) -> T.List[str]:
         lang = gnu_lang_map.get(self.language, 'assembler-with-cpp')
         return self.get_preprocess_only_args() + [f'-x{lang}']
 
+    def make_arguments_abstract(self, args: T.List[str]) -> T.List[arguments.Argument]:
+        ret: T.List[arguments.Argument] = []
+
+        for arg in args:
+            if arg.startswith('-D'):
+                v: T.Optional[str]
+                arg = arg.removeprefix('-D')
+                if '=' in arg:
+                    k, v = arg.split('=')
+                else:
+                    k, v = arg, None
+                ret.append(arguments.Define(k, v))
+            elif arg.startswith('-U'):
+                ret.append(arguments.Undefine(arg.removeprefix('-U')))
+            elif arg.startswith('-l'):
+                ret.append(arguments.LinkerSearch(arg.removeprefix('-l')))
+            elif arg.startswith('-Werror='):
+                ret.append(arguments.Error(arg.removeprefix('-Werror=')))
+            elif arg.startswith('-Wno-'):
+                ret.append(arguments.Warning(arg.removeprefix('-Wno-'), False))
+            elif arg.startswith('-W'):
+                ret.append(arguments.Warning(arg.removeprefix('-W'), True))
+            else:
+                ret.append(arguments.Opaque(arg))
+
+        return ret
+
+    def make_arguments_concrete(self, args: T.List[arguments.Argument]) -> T.List[str]:
+        ret: T.List[str] = []
+
+        for arg in args:
+            match arg:
+                case arguments.Define(name, None):
+                    ret.append(f'-D{name}')
+                case arguments.Define(name, value):
+                    ret.append(f'-D{name}={value}')
+                case arguments.Undefine(name):
+                    ret.append(f'-U{name}')
+                case arguments.Error(name):
+                    ret.append(f'-Werror={name}')
+                case arguments.Warning(name, True):
+                    ret.append(f'-W{name}')
+                case arguments.Warning(name, False):
+                    ret.append(f'-Wno-{name}')
+                case arguments.LinkerSearch(name):
+                    ret.append(f'-L{name}')
+                case arguments.LinkLibrary(name):
+                    ret.append(f'-l{name}')
+                case arguments.Opaque(value):
+                    ret.append(value)
+
+        return ret
+
 
 class GnuCompiler(GnuLikeCompiler):
     """

mesonbuild/dependencies/base.py

@@ -21,6 +21,7 @@
 #from ..interpreterbase import FeatureDeprecated, FeatureNew
 
 if T.TYPE_CHECKING:
+    from ..arguments import Argument
     from ..compilers.compilers import Compiler
     from ..environment import Environment
     from ..interpreterbase import FeatureCheckBase
@@ -66,6 +67,12 @@ def __getattr__(self, item: str) -> T.Any:
     def __bool__(self) -> bool:
         return False
 
+    def make_arguments_abstract(self, args: T.List[str]) -> T.List[Argument]:
+        return []
+
+    def make_arguments_concrete(self, args: T.List[Argument]) -> T.List[str]:
+        return []
+
 
 class DependencyMethods(Enum):
     # Auto means to use whatever dependency checking mechanisms in whatever order meson thinks is best.