build: move per-project data to a separate dataclass

This makes things easier to understand, with the project_args
and project_link_args having the same structure as Build.global_args
and Build.global_link_args.

The difference is that the new member always includes an entry
for the root project, so adjust those cases that need to look at
subprojects only.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

Author: bonzini

mesonbuild/build.py

@@ -327,6 +327,14 @@ def to_json(self) -> T.Dict[str, T.Union[str, T.List[str]]]:
         }
 
 
+@dataclass(eq=False)
+class BuildProject:
+    name: str
+    version: str
+    project_args: PerMachine[T.Dict[str, T.List[str]]] = field(default_factory=lambda: PerMachine({}, {}))
+    project_link_args: PerMachine[T.Dict[str, T.List[str]]] = field(default_factory=lambda: PerMachine({}, {}))
+
+
 # literally everything isn't dataclass stuff
 class Build:
     """A class that holds the status of one build including
@@ -339,13 +347,11 @@ def __init__(self, environment: Environment):
         self.project_name = 'name of master project'
         self.project_version: T.Optional[str] = None
         self.environment = environment
-        self.projects: T.Dict[SubProject, str] = {}
+        self.projects: T.Dict[SubProject, BuildProject] = {}
         self.targets: 'T.OrderedDict[str, T.Union[CustomTarget, BuildTarget]]' = OrderedDict()
         self.targetnames: T.Set[T.Tuple[str, str]] = set() # Set of executable names and their subdir
         self.global_args: PerMachine[T.Dict[str, T.List[str]]] = PerMachine({}, {})
         self.global_link_args: PerMachine[T.Dict[str, T.List[str]]] = PerMachine({}, {})
-        self.projects_args: PerMachine[T.Dict[str, T.Dict[str, T.List[str]]]] = PerMachine({}, {})
-        self.projects_link_args: PerMachine[T.Dict[str, T.Dict[str, T.List[str]]]] = PerMachine({}, {})
         self.tests: T.List['Test'] = []
         self.benchmarks: T.List['Test'] = []
         self.headers: T.List[Headers] = []
@@ -354,7 +360,6 @@ def __init__(self, environment: Environment):
         self.data: T.List[Data] = []
         self.symlinks: T.List[SymlinkData] = []
         self.static_linker: PerMachine[T.Optional[StaticLinker]] = PerMachine(None, None)
-        self.subprojects: T.Dict[SubProject, str] = {}
         self.subproject_dir = ''
         self.install_scripts: T.List['ExecutableSerialisation'] = []
         self.postconf_scripts: T.List['ExecutableSerialisation'] = []
@@ -445,7 +450,7 @@ def ensure_static_linker(self, compiler: Compiler) -> None:
             self.static_linker[for_machine] = detect_static_linker(self.environment, compiler)
 
     def get_project(self) -> str:
-        return self.projects[SubProject('')]
+        return self.projects[SubProject('')].name
 
     def get_subproject_dir(self):
         return self.subproject_dir
@@ -482,8 +487,7 @@ def get_global_args(self, compiler: 'Compiler', for_machine: 'MachineChoice') ->
         return d.get(compiler.get_language(), [])
 
     def get_project_args(self, compiler: 'Compiler', target: BuildTarget) -> T.List[str]:
-        d = self.projects_args[target.for_machine]
-        args = d.get(target.subproject)
+        args = self.projects[target.subproject].project_args[target.for_machine]
         if not args:
             return []
         return args.get(compiler.get_language(), [])
@@ -493,9 +497,7 @@ def get_global_link_args(self, compiler: 'Compiler', for_machine: 'MachineChoice
         return d.get(compiler.get_language(), [])
 
     def get_project_link_args(self, compiler: 'Compiler', target: BuildTarget) -> T.List[str]:
-        d = self.projects_link_args[target.for_machine]
-
-        link_args = d.get(target.subproject)
+        link_args = self.projects[target.subproject].project_link_args[target.for_machine]
         if not link_args:
             return []
 

mesonbuild/interpreter/interpreter.py

@@ -902,7 +902,7 @@ def do_subproject(self, subp_name: SubProject, kwargs: kwtypes.DoSubproject, for
             if required and not subproject.found():
                 raise InterpreterException(f'Subproject "{subproject.subdir}" required but not found.')
             if kwargs['version']:
-                pv = self.build.subprojects[subp_name]
+                pv = self.build.projects[subp_name].version
                 wanted = kwargs['version']
                 if pv == 'undefined' or not mesonlib.version_compare_many(pv, wanted)[0]:
                     raise InterpreterException(f'Subproject {subp_name} version is {pv} but {wanted} required.')
@@ -1016,7 +1016,6 @@ def _do_subproject_meson(self, subp_name: SubProject, subdir: str,
         # We always need the subi.build_def_files, to propagate sub-sub-projects
         self.build_def_files.update(subi.get_build_def_files())
         self.build.merge(subi.build)
-        self.build.subprojects[subp_name] = subi.project_version
         return self.subprojects[subp_name]
 
     def _do_subproject_cmake(self, subp_name: SubProject, subdir: str,
@@ -1276,7 +1275,7 @@ def func_project(self, node: mparser.FunctionNode, args: T.Tuple[str, T.List[str
         if self.cargo is None:
             self.load_root_cargo_lock_file()
 
-        self.build.projects[self.subproject] = proj_name
+        self.build.projects[self.subproject] = build.BuildProject(proj_name, self.project_version)
         mlog.log('Project name:', mlog.bold(proj_name))
         mlog.log('Project version:', mlog.bold(self.project_version))
 
@@ -2934,12 +2933,17 @@ def func_add_global_link_arguments(self, node: mparser.FunctionNode, args: T.Tup
     @typed_pos_args('add_project_arguments', varargs=str)
     @typed_kwargs('add_project_arguments', NATIVE_KW, LANGUAGE_KW)
     def func_add_project_arguments(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
-        self._add_project_arguments(node, self.build.projects_args[kwargs['native']], args[0], kwargs)
+        self._add_project_arguments(node, self.current_build_project().project_args[kwargs['native']],
+                                    args[0], kwargs)
 
     @typed_pos_args('add_project_link_arguments', varargs=str)
     @typed_kwargs('add_global_arguments', NATIVE_KW, LANGUAGE_KW)
     def func_add_project_link_arguments(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
-        self._add_project_arguments(node, self.build.projects_link_args[kwargs['native']], args[0], kwargs)
+        self._add_project_arguments(node, self.current_build_project().project_link_args[kwargs['native']],
+                                    args[0], kwargs)
+
+    def current_build_project(self) -> build.BuildProject:
+        return self.build.projects[self.subproject]
 
     @FeatureNew('add_project_dependencies', '0.63.0')
     @typed_pos_args('add_project_dependencies', varargs=dependencies.Dependency)
@@ -2959,8 +2963,10 @@ def func_add_project_dependencies(self, node: mparser.FunctionNode, args: T.Tupl
                     for idir in i.to_string_list(self.environment.get_source_dir(), self.environment.get_build_dir()):
                         compile_args.extend(comp.get_include_args(idir, system_incdir))
 
-            self._add_project_arguments(node, self.build.projects_args[for_machine], compile_args, kwargs)
-            self._add_project_arguments(node, self.build.projects_link_args[for_machine], d.get_link_args(), kwargs)
+            self._add_project_arguments(node, self.current_build_project().project_args[for_machine],
+                                        compile_args, kwargs)
+            self._add_project_arguments(node, self.current_build_project().project_link_args[for_machine],
+                                        d.get_link_args(), kwargs)
 
     def _warn_about_builtin_args(self, args: T.List[str]) -> None:
         # -Wpedantic is deliberately not included, since some people want to use it but not use -Wextra
@@ -3005,10 +3011,7 @@ def _add_global_arguments(self, node: mparser.FunctionNode, argsdict: T.Dict[str
 
     def _add_project_arguments(self, node: mparser.FunctionNode, argsdict: T.Dict[str, T.Dict[str, T.List[str]]],
                                args: T.List[str], kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
-        if self.subproject not in argsdict:
-            argsdict[self.subproject] = {}
-        self._add_arguments(node, argsdict[self.subproject],
-                            self.project_args_frozen, args, kwargs)
+        self._add_arguments(node, argsdict, self.project_args_frozen, args, kwargs)
 
     def _add_arguments(self, node: mparser.FunctionNode, argsdict: T.Dict[str, T.List[str]],
                        args_frozen: bool, args: T.List[str], kwargs: 'kwtypes.FuncAddProjectArgs') -> None:

mesonbuild/mdist.py

@@ -393,9 +393,10 @@ def run(options: argparse.Namespace) -> int:
     extra_meson_args = []
     if options.include_subprojects:
         subproject_dir = os.path.join(src_root, b.subproject_dir)
-        for sub in b.subprojects:
-            directory = wrap.get_directory(subproject_dir, sub)
-            subprojects[sub] = os.path.join(b.subproject_dir, directory)
+        for sub in b.projects:
+            if sub:
+                directory = wrap.get_directory(subproject_dir, sub)
+                subprojects[sub] = os.path.join(b.subproject_dir, directory)
         extra_meson_args.append('-Dwrap_mode=nodownload')
 
     cls: T.Type[Dist]

mesonbuild/mintro.py

@@ -22,7 +22,7 @@
 from . import build, environment, mesonlib, options, coredata as cdata
 from .ast import IntrospectionInterpreter, AstConditionLevel, AstIDGenerator, AstIndentationGenerator, AstJSONPrinter
 from .backend import backends
-from .interpreterbase import SubProject, UnknownValue
+from .interpreterbase import UnknownValue
 from .options import OptionKey
 
 if T.TYPE_CHECKING:
@@ -457,12 +457,13 @@ def list_projinfo(builddata: build.Build) -> T.Dict[str, T.Union[str, T.List[str
         'subproject_dir': builddata.subproject_dir,
     }
     subprojects = []
-    for k, v in builddata.subprojects.items():
-        subp = SubProject(k)
+    for k, build_proj in builddata.projects.items():
+        if not k:
+            continue
         c: T.Dict[str, str] = {
             'name': k,
-            'version': v,
-            'descriptive_name': builddata.projects.get(subp),
+            'version': build_proj.version,
+            'descriptive_name': build_proj.name,
         }
         subprojects.append(c)
     result['subprojects'] = subprojects

mesonbuild/modules/__init__.py

@@ -51,7 +51,7 @@ def __init__(self, interpreter: 'Interpreter') -> None:
         self.headers = interpreter.build.get_headers()
         self.man = interpreter.build.get_man()
         self.global_args = interpreter.build.global_args.host
-        self.project_args = interpreter.build.projects_args.host.get(interpreter.subproject, {})
+        self.project_args = interpreter.current_build_project().project_args.host
         self.current_node = interpreter.current_node
 
     def get_include_args(self, include_dirs: T.Iterable[T.Union[str, build.IncludeDirs]], prefix: str = '-I') -> T.List[str]: