Purge `is_cross` and friends without changing user interfaces

In most cases instead pass `for_machine`, the name of the relevant
machines (what compilers target, what targets run on, etc). This allows
us to use the cross code path in the native case, deduplicating the
code.

As one can see, environment got bigger as more information is kept
structured there, while ninjabackend got a smaller. Overall a few amount
of lines were added, but the hope is what's added is a lot simpler than
what's removed.

1 files changed, 66 insertions, 71 deletions

diff --git a/mesonbuild/interpreter.py b/mesonbuild/interpreter.py
index 7c17e1c..5dddb22 100644
--- a/mesonbuild/interpreter.py
+++ b/mesonbuild/interpreter.py
@@ -21,7 +21,7 @@ from . import optinterpreter
 from . import compilers
 from .wrap import wrap, WrapMode
 from . import mesonlib
-from .mesonlib import FileMode, MachineChoice, Popen_safe, listify, extract_as_list, has_path_sep
+from .mesonlib import FileMode, MachineChoice, PerMachine, Popen_safe, listify, extract_as_list, has_path_sep
 from .dependencies import ExternalProgram
 from .dependencies import InternalDependency, Dependency, NotFoundDependency, DependencyException
 from .interpreterbase import InterpreterBase
@@ -738,7 +738,7 @@ class BuildTargetHolder(TargetHolder):
         return r.format(self.__class__.__name__, h.get_id(), h.filename)
 
     def is_cross(self):
-        return self.held_object.is_cross()
+        return not self.held_object.environment.machines.matches_build_machine(self.held_object.for_machine)
 
     @noPosargs
     @permittedKwargs({})
@@ -1696,8 +1696,10 @@ class ModuleHolder(InterpreterObject, ObjectHolder):
             data=self.interpreter.build.data,
             headers=self.interpreter.build.get_headers(),
             man=self.interpreter.build.get_man(),
-            global_args=self.interpreter.build.global_args,
-            project_args=self.interpreter.build.projects_args.get(self.interpreter.subproject, {}),
+            #global_args_for_build = self.interpreter.build.global_args.build,
+            global_args = self.interpreter.build.global_args.host,
+            #project_args_for_build = self.interpreter.build.projects_args.build.get(self.interpreter.subproject, {}),
+            project_args = self.interpreter.build.projects_args.host.get(self.interpreter.subproject, {}),
             build_machine=self.interpreter.builtin['build_machine'].held_object,
             host_machine=self.interpreter.builtin['host_machine'].held_object,
             target_machine=self.interpreter.builtin['target_machine'].held_object,
@@ -1847,10 +1849,7 @@ class MesonMain(InterpreterObject):
                 native = True
         if not isinstance(native, bool):
             raise InterpreterException('Type of "native" must be a boolean.')
-        if native:
-            clist = self.interpreter.coredata.compilers
-        else:
-            clist = self.interpreter.coredata.cross_compilers
+        clist = self.interpreter.coredata.compilers[MachineChoice.BUILD if native else MachineChoice.HOST]
         if cname in clist:
             return CompilerHolder(clist[cname], self.build.environment, self.interpreter.subproject)
         raise InterpreterException('Tried to access compiler for unspecified language "%s".' % cname)
@@ -2085,7 +2084,7 @@ class Interpreter(InterpreterBase):
         # have the compilers needed to gain more knowledge, so wipe out old
         # inferrence and start over.
         machines = self.build.environment.machines.miss_defaulting()
-        machines.build = environment.detect_machine_info(self.coredata.compilers)
+        machines.build = environment.detect_machine_info(self.coredata.compilers.build)
         self.build.environment.machines = machines.default_missing()
         assert self.build.environment.machines.build.cpu is not None
         assert self.build.environment.machines.host.cpu is not None
@@ -2237,10 +2236,10 @@ class Interpreter(InterpreterBase):
     def get_variables(self):
         return self.variables
 
-    def check_cross_stdlibs(self):
-        if self.build.environment.is_cross_build():
-            props = self.build.environment.properties.host
-            for l in self.coredata.cross_compilers.keys():
+    def check_stdlibs(self):
+        for for_machine in MachineChoice:
+            props = self.build.environment.properties[for_machine]
+            for l in self.coredata.compilers[for_machine].keys():
                 try:
                     di = mesonlib.stringlistify(props.get_stdlib(l))
                     if len(di) != 2:
@@ -2248,7 +2247,7 @@ class Interpreter(InterpreterBase):
                                                    % l)
                     projname, depname = di
                     subproj = self.do_subproject(projname, 'meson', {})
-                    self.build.cross_stdlibs[l] = subproj.get_variable_method([depname], {})
+                    self.build.stdlibs.host[l] = subproj.get_variable_method([depname], {})
                 except KeyError:
                     pass
                 except InvalidArguments:
@@ -2729,7 +2728,7 @@ external dependencies (including libraries) must go to "dependencies".''')
         mlog.log('Project version:', mlog.bold(self.project_version))
         self.add_languages(proj_langs, True)
         if not self.is_subproject():
-            self.check_cross_stdlibs()
+            self.check_stdlibs()
 
     @permittedKwargs(permitted_kwargs['add_languages'])
     @stringArgs
@@ -2786,37 +2785,38 @@ external dependencies (including libraries) must go to "dependencies".''')
         raise Exception()
 
     def add_languages(self, args, required):
+        success = self.add_languages_for(args, required, MachineChoice.BUILD)
+        success &= self.add_languages_for(args, required, MachineChoice.HOST)
+        return success
+
+    def add_languages_for(self, args, required, for_machine: MachineChoice):
         success = True
-        need_cross_compiler = self.environment.is_cross_build()
         for lang in sorted(args, key=compilers.sort_clink):
             lang = lang.lower()
-            if lang in self.coredata.compilers:
-                comp = self.coredata.compilers[lang]
-                cross_comp = self.coredata.cross_compilers.get(lang, None)
+            clist = self.coredata.compilers[for_machine]
+            machine_name = for_machine.get_lower_case_name()
+            if lang in clist:
+                comp = clist[lang]
             else:
                 try:
-                    (comp, cross_comp) = self.environment.detect_compilers(lang, need_cross_compiler)
+                    comp = self.environment.detect_compiler_for(lang, for_machine)
                     if comp is None:
                         raise InvalidArguments('Tried to use unknown language "%s".' % lang)
                     comp.sanity_check(self.environment.get_scratch_dir(), self.environment)
-                    if cross_comp:
-                        cross_comp.sanity_check(self.environment.get_scratch_dir(), self.environment)
                 except Exception:
                     if not required:
-                        mlog.log('Compiler for language', mlog.bold(lang), 'not found.')
+                        mlog.log('Compiler for language',
+                                 mlog.bold(lang), 'for the', machine_name,
+                                 'machine not found.')
                         success = False
                         continue
                     else:
                         raise
-            mlog.log('Native', comp.get_display_language(), 'compiler:',
+            mlog.log(comp.get_display_language(), 'compiler for the', machine_name, 'machine:',
                      mlog.bold(' '.join(comp.get_exelist())), comp.get_version_string())
             self.build.ensure_static_linker(comp)
-            if need_cross_compiler:
-                mlog.log('Cross', cross_comp.get_display_language(), 'compiler:',
-                         mlog.bold(' '.join(cross_comp.get_exelist())), cross_comp.get_version_string())
-                self.build.ensure_static_cross_linker(cross_comp)
 
-        langs = self.coredata.compilers.keys()
+        langs = self.coredata.compilers[for_machine].keys()
         if 'vala' in langs:
             if 'c' not in langs:
                 raise InterpreterException('Compiling Vala requires C. Add C to your project languages and rerun Meson.')
@@ -2935,14 +2935,9 @@ external dependencies (including libraries) must go to "dependencies".''')
                           )
 
     def _find_cached_dep(self, name, kwargs):
-        # Check if we want this as a cross-dep or a native-dep
-        # FIXME: Not all dependencies support such a distinction right now,
-        # and we repeat this check inside dependencies that do. We need to
-        # consolidate this somehow.
-        if self.environment.is_cross_build() and kwargs.get('native', False):
-            for_machine = MachineChoice.BUILD
-        else:
-            for_machine = MachineChoice.HOST
+        # Check if we want this as a build-time / build machine or runt-time /
+        # host machine dep.
+        for_machine = MachineChoice.BUILD if kwargs.get('native', False) else MachineChoice.HOST
 
         identifier = dependencies.get_dep_identifier(name, kwargs)
         cached_dep = self.coredata.deps[for_machine].get(identifier)
@@ -3097,10 +3092,7 @@ external dependencies (including libraries) must go to "dependencies".''')
             # cannot cache them. They must always be evaluated else
             # we won't actually read all the build files.
             if dep.found():
-                if self.environment.is_cross_build() and kwargs.get('native', False):
-                    for_machine = MachineChoice.BUILD
-                else:
-                    for_machine = MachineChoice.HOST
+                for_machine = MachineChoice.BUILD if kwargs.get('native', False) else MachineChoice.HOST
                 self.coredata.deps[for_machine].put(identifier, dep)
                 return DependencyHolder(dep, self.subproject)
 
@@ -3849,45 +3841,47 @@ different subdirectory.
         env = self.unpack_env_kwarg(kwargs)
         self.build.test_setups[setup_name] = build.TestSetup(exe_wrapper, gdb, timeout_multiplier, env)
 
-    def get_argdict_on_crossness(self, native_dict, cross_dict, kwargs):
+    # TODO make cross agnostic, just taking into account for_machine
+    # TODO PerMachine[T], Iterator[T]
+    def get_argdict_on_crossness(self, dicts_per_machine: PerMachine, kwargs) -> typing.Iterator:
         for_native = kwargs.get('native', not self.environment.is_cross_build())
         if not isinstance(for_native, bool):
             raise InterpreterException('Keyword native must be a boolean.')
-        if for_native:
-            return native_dict
+        if self.environment.is_cross_build():
+            if for_native:
+                return iter([dicts_per_machine[MachineChoice.BUILD]])
+            else:
+                return iter([dicts_per_machine[MachineChoice.HOST]])
         else:
-            return cross_dict
+            if for_native:
+                return iter([dicts_per_machine[MachineChoice.BUILD],
+                             dicts_per_machine[MachineChoice.HOST]])
+            else:
+                return iter([])
 
     @permittedKwargs(permitted_kwargs['add_global_arguments'])
     @stringArgs
     def func_add_global_arguments(self, node, args, kwargs):
-        argdict = self.get_argdict_on_crossness(self.build.global_args,
-                                                self.build.cross_global_args,
-                                                kwargs)
-        self.add_global_arguments(node, argdict, args, kwargs)
+        for argdict in self.get_argdict_on_crossness(self.build.global_args, kwargs):
+            self.add_global_arguments(node, argdict, args, kwargs)
 
     @permittedKwargs(permitted_kwargs['add_global_link_arguments'])
     @stringArgs
     def func_add_global_link_arguments(self, node, args, kwargs):
-        argdict = self.get_argdict_on_crossness(self.build.global_link_args,
-                                                self.build.cross_global_link_args,
-                                                kwargs)
-        self.add_global_arguments(node, argdict, args, kwargs)
+        for argdict in self.get_argdict_on_crossness(self.build.global_link_args, kwargs):
+            self.add_global_arguments(node, argdict, args, kwargs)
 
     @permittedKwargs(permitted_kwargs['add_project_arguments'])
     @stringArgs
     def func_add_project_arguments(self, node, args, kwargs):
-        argdict = self.get_argdict_on_crossness(self.build.projects_args,
-                                                self.build.cross_projects_args,
-                                                kwargs)
-        self.add_project_arguments(node, argdict, args, kwargs)
+        for argdict in self.get_argdict_on_crossness(self.build.projects_args, kwargs):
+            self.add_project_arguments(node, argdict, args, kwargs)
 
     @permittedKwargs(permitted_kwargs['add_project_link_arguments'])
     @stringArgs
     def func_add_project_link_arguments(self, node, args, kwargs):
-        argdict = self.get_argdict_on_crossness(self.build.projects_link_args,
-                                                self.build.cross_projects_link_args, kwargs)
-        self.add_project_arguments(node, argdict, args, kwargs)
+        for argdict in self.get_argdict_on_crossness(self.build.projects_link_args, kwargs):
+            self.add_project_arguments(node, argdict, args, kwargs)
 
     def add_global_arguments(self, node, argsdict, args, kwargs):
         if self.is_subproject():
@@ -3940,7 +3934,8 @@ different subdirectory.
             self.print_extra_warnings()
 
     def print_extra_warnings(self):
-        for c in self.coredata.compilers.values():
+        # TODO cross compilation
+        for c in self.coredata.compilers.host.values():
             if c.get_id() == 'clang':
                 self.check_clang_asan_lundef()
                 break
@@ -4091,13 +4086,10 @@ Try setting b_lundef to false instead.'''.format(self.coredata.base_options['b_s
         if not args:
             raise InterpreterException('Target does not have a name.')
         name, *sources = args
-        if self.environment.is_cross_build():
-            if kwargs.get('native', False):
-                is_cross = False
-            else:
-                is_cross = True
+        if kwargs.get('native', False):
+            for_machine = MachineChoice.BUILD
         else:
-            is_cross = False
+            for_machine = MachineChoice.HOST
         if 'sources' in kwargs:
             sources += listify(kwargs['sources'])
         sources = self.source_strings_to_files(sources)
@@ -4128,9 +4120,9 @@ Try setting b_lundef to false instead.'''.format(self.coredata.base_options['b_s
         kwargs = {k: v for k, v in kwargs.items() if k in targetclass.known_kwargs}
 
         kwargs['include_directories'] = self.extract_incdirs(kwargs)
-        target = targetclass(name, self.subdir, self.subproject, is_cross, sources, objs, self.environment, kwargs)
+        target = targetclass(name, self.subdir, self.subproject, for_machine, sources, objs, self.environment, kwargs)
 
-        if is_cross:
+        if not self.environment.machines.matches_build_machine(for_machine):
             self.add_cross_stdlib_info(target)
         l = targetholder(target, self)
         self.add_target(name, l.held_object)
@@ -4157,18 +4149,21 @@ This will become a hard error in the future.''', location=self.current_node)
     def get_used_languages(self, target):
         result = {}
         for i in target.sources:
-            for lang, c in self.coredata.compilers.items():
+            # TODO other platforms
+            for lang, c in self.coredata.compilers.host.items():
                 if c.can_compile(i):
                     result[lang] = True
                     break
         return result
 
     def add_cross_stdlib_info(self, target):
+        if target.for_machine != MachineChoice.HOST:
+            return
         for l in self.get_used_languages(target):
             props = self.environment.properties.host
             if props.has_stdlib(l) \
                     and self.subproject != props.get_stdlib(l)[0]:
-                target.add_deps(self.build.cross_stdlibs[l])
+                target.add_deps(self.build.stdlibs.host[l])
 
     def check_sources_exist(self, subdir, sources):
         for s in sources: