Detach the Interpreter from the Backend

mesonbuild/backend/backends.py

@@ -39,7 +39,7 @@
     from ..arglist import CompilerArgs
     from ..compilers import Compiler
     from ..environment import Environment
-    from ..interpreter import Interpreter, Test
+    from ..interpreter import Test
     from ..linkers.linkers import StaticLinker
     from ..mesonlib import FileMode, FileOrString
     from ..options import ElementaryOptionValues
@@ -217,47 +217,47 @@ def __post_init__(self) -> None:
             assert isinstance(self.exe_wrapper, programs.ExternalProgram)
 
 
-def get_backend_from_name(backend: str, build: T.Optional[build.Build] = None, interpreter: T.Optional['Interpreter'] = None) -> T.Optional['Backend']:
+def get_backend_from_name(backend: str, build: T.Optional[build.Build] = None) -> T.Optional['Backend']:
     if backend == 'ninja':
         from . import ninjabackend
-        return ninjabackend.NinjaBackend(build, interpreter)
+        return ninjabackend.NinjaBackend(build)
     elif backend == 'vs':
         from . import vs2010backend
-        return vs2010backend.autodetect_vs_version(build, interpreter)
+        return vs2010backend.autodetect_vs_version(build)
     elif backend == 'vs2010':
         from . import vs2010backend
-        return vs2010backend.Vs2010Backend(build, interpreter)
+        return vs2010backend.Vs2010Backend(build)
     elif backend == 'vs2012':
         from . import vs2012backend
-        return vs2012backend.Vs2012Backend(build, interpreter)
+        return vs2012backend.Vs2012Backend(build)
     elif backend == 'vs2013':
         from . import vs2013backend
-        return vs2013backend.Vs2013Backend(build, interpreter)
+        return vs2013backend.Vs2013Backend(build)
     elif backend == 'vs2015':
         from . import vs2015backend
-        return vs2015backend.Vs2015Backend(build, interpreter)
+        return vs2015backend.Vs2015Backend(build)
     elif backend == 'vs2017':
         from . import vs2017backend
-        return vs2017backend.Vs2017Backend(build, interpreter)
+        return vs2017backend.Vs2017Backend(build)
     elif backend == 'vs2019':
         from . import vs2019backend
-        return vs2019backend.Vs2019Backend(build, interpreter)
+        return vs2019backend.Vs2019Backend(build)
     elif backend == 'vs2022':
         from . import vs2022backend
-        return vs2022backend.Vs2022Backend(build, interpreter)
+        return vs2022backend.Vs2022Backend(build)
     elif backend == 'xcode':
         from . import xcodebackend
-        return xcodebackend.XCodeBackend(build, interpreter)
+        return xcodebackend.XCodeBackend(build)
     elif backend == 'none':
         from . import nonebackend
-        return nonebackend.NoneBackend(build, interpreter)
+        return nonebackend.NoneBackend(build)
     return None
 
 
-def get_genvslite_backend(genvsname: str, build: T.Optional[build.Build] = None, interpreter: T.Optional['Interpreter'] = None) -> T.Optional['Backend']:
+def get_genvslite_backend(genvsname: str, build: T.Optional[build.Build] = None) -> T.Optional['Backend']:
     if genvsname == 'vs2022':
         from . import vs2022backend
-        return vs2022backend.Vs2022Backend(build, interpreter, gen_lite = True)
+        return vs2022backend.Vs2022Backend(build, gen_lite = True)
     return None
 
 # This class contains the basic functionality that is needed by all backends.
@@ -267,14 +267,13 @@ class Backend:
     environment: T.Optional['Environment']
     name = '<UNKNOWN>'
 
-    def __init__(self, build: T.Optional[build.Build], interpreter: T.Optional['Interpreter']):
+    def __init__(self, build: T.Optional[build.Build]):
         # Make it possible to construct a dummy backend
         # This is used for introspection without a build directory
         if build is None:
             self.environment = None
             return
         self.build = build
-        self.interpreter = interpreter
         self.environment = build.environment
         self.processed_targets: T.Set[str] = set()
         self.build_dir = self.environment.get_build_dir()
@@ -1303,7 +1302,7 @@ def get_regen_filelist(self) -> T.List[str]:
         '''List of all files whose alteration means that the build
         definition needs to be regenerated.'''
         deps = OrderedSet([str(Path(self.build_to_src) / df)
-                           for df in self.interpreter.get_build_def_files()])
+                           for df in self.build.def_files])
         if self.environment.is_cross_build():
             deps.update(self.environment.coredata.cross_files)
         deps.update(self.environment.coredata.config_files)
@@ -2034,10 +2033,11 @@ def compiler_to_generator(self, target: build.BuildTarget,
         exe = programs.ExternalProgram(compiler.get_exe())
         args = compiler.get_exe_args()
         commands = self.compiler_to_generator_args(target, compiler)
-        generator = build.Generator(exe, args + commands.to_native(),
+        generator = build.Generator(self.environment,
+                                    exe, args + commands.to_native(),
                                     [output_templ], depfile='@[email protected]',
                                     depends=depends)
-        return generator.process_files(sources, self.interpreter)
+        return generator.process_files(sources)
 
     def compile_target_to_generator(self, target: build.CompileTarget) -> build.GeneratedList:
         all_sources = T.cast('_ALL_SOURCES_TYPE', target.sources) + T.cast('_ALL_SOURCES_TYPE', target.generated)

mesonbuild/backend/ninjabackend.py

@@ -41,7 +41,6 @@
 
     from .._typing import ImmutableListProtocol
     from ..build import ExtractedObjects, LibTypes
-    from ..interpreter import Interpreter
     from ..linkers.linkers import DynamicLinker, StaticLinker
     from ..compilers.cs import CsCompiler
     from ..compilers.fortran import FortranCompiler
@@ -479,8 +478,8 @@ def to_json(self) -> T.Dict[str, object]:
 
 class NinjaBackend(backends.Backend):
 
-    def __init__(self, build: T.Optional[build.Build], interpreter: T.Optional[Interpreter]):
-        super().__init__(build, interpreter)
+    def __init__(self, build: T.Optional[build.Build]):
+        super().__init__(build)
         self.name = 'ninja'
         self.ninja_filename = 'build.ninja'
         self.fortran_deps: T.Dict[str, T.Dict[str, File]] = {}

mesonbuild/backend/vs2010backend.py

@@ -28,11 +28,10 @@
 
 if T.TYPE_CHECKING:
     from ..arglist import CompilerArgs
-    from ..interpreter import Interpreter
 
     Project = T.Tuple[str, Path, str, MachineChoice]
 
-def autodetect_vs_version(build: T.Optional[build.Build], interpreter: T.Optional[Interpreter]) -> backends.Backend:
+def autodetect_vs_version(build: T.Optional[build.Build]) -> backends.Backend:
     vs_version = os.getenv('VisualStudioVersion', None)
     vs_install_dir = os.getenv('VSINSTALLDIR', None)
     if not vs_install_dir:
@@ -42,27 +41,27 @@ def autodetect_vs_version(build: T.Optional[build.Build], interpreter: T.Optiona
     # vcvarsall.bat doesn't set it, so also use VSINSTALLDIR
     if vs_version == '11.0' or 'Visual Studio 11' in vs_install_dir:
         from mesonbuild.backend.vs2012backend import Vs2012Backend
-        return Vs2012Backend(build, interpreter)
+        return Vs2012Backend(build)
     if vs_version == '12.0' or 'Visual Studio 12' in vs_install_dir:
         from mesonbuild.backend.vs2013backend import Vs2013Backend
-        return Vs2013Backend(build, interpreter)
+        return Vs2013Backend(build)
     if vs_version == '14.0' or 'Visual Studio 14' in vs_install_dir:
         from mesonbuild.backend.vs2015backend import Vs2015Backend
-        return Vs2015Backend(build, interpreter)
+        return Vs2015Backend(build)
     if vs_version == '15.0' or 'Visual Studio 17' in vs_install_dir or \
        'Visual Studio\\2017' in vs_install_dir:
         from mesonbuild.backend.vs2017backend import Vs2017Backend
-        return Vs2017Backend(build, interpreter)
+        return Vs2017Backend(build)
     if vs_version == '16.0' or 'Visual Studio 19' in vs_install_dir or \
        'Visual Studio\\2019' in vs_install_dir:
         from mesonbuild.backend.vs2019backend import Vs2019Backend
-        return Vs2019Backend(build, interpreter)
+        return Vs2019Backend(build)
     if vs_version == '17.0' or 'Visual Studio 22' in vs_install_dir or \
        'Visual Studio\\2022' in vs_install_dir:
         from mesonbuild.backend.vs2022backend import Vs2022Backend
-        return Vs2022Backend(build, interpreter)
+        return Vs2022Backend(build)
     if 'Visual Studio 10.0' in vs_install_dir:
-        return Vs2010Backend(build, interpreter)
+        return Vs2010Backend(build)
     raise MesonException('Could not detect Visual Studio using VisualStudioVersion: {!r} or VSINSTALLDIR: {!r}!\n'
                          'Please specify the exact backend to use.'.format(vs_version, vs_install_dir))
 
@@ -135,8 +134,8 @@ class Vs2010Backend(backends.Backend):
 
     name = 'vs2010'
 
-    def __init__(self, build: T.Optional[build.Build], interpreter: T.Optional[Interpreter], gen_lite: bool = False):
-        super().__init__(build, interpreter)
+    def __init__(self, build: T.Optional[build.Build], gen_lite: bool = False):
+        super().__init__(build)
         self.project_file_version = '10.0.30319.1'
         self.sln_file_version = '11.00'
         self.sln_version_comment = '2010'

mesonbuild/backend/vs2012backend.py

@@ -10,14 +10,13 @@
 
 if T.TYPE_CHECKING:
     from ..build import Build
-    from ..interpreter import Interpreter
 
 class Vs2012Backend(Vs2010Backend):
 
     name = 'vs2012'
 
-    def __init__(self, build: T.Optional[Build], interpreter: T.Optional[Interpreter]):
-        super().__init__(build, interpreter)
+    def __init__(self, build: T.Optional[Build]):
+        super().__init__(build)
         self.vs_version = '2012'
         self.sln_file_version = '12.00'
         self.sln_version_comment = '2012'

mesonbuild/backend/vs2013backend.py

@@ -9,14 +9,13 @@
 
 if T.TYPE_CHECKING:
     from ..build import Build
-    from ..interpreter import Interpreter
 
 class Vs2013Backend(Vs2010Backend):
 
     name = 'vs2013'
 
-    def __init__(self, build: T.Optional[Build], interpreter: T.Optional[Interpreter]):
-        super().__init__(build, interpreter)
+    def __init__(self, build: T.Optional[Build]):
+        super().__init__(build)
         self.vs_version = '2013'
         self.sln_file_version = '12.00'
         self.sln_version_comment = '2013'

mesonbuild/backend/vs2015backend.py

@@ -10,14 +10,12 @@
 
 if T.TYPE_CHECKING:
     from ..build import Build
-    from ..interpreter import Interpreter
 
 class Vs2015Backend(Vs2010Backend):
 
     name = 'vs2015'
 
-    def __init__(self, build: T.Optional[Build], interpreter: T.Optional[Interpreter]):
-        super().__init__(build, interpreter)
+    def __init__(self, build: T.Optional[Build]):
         self.vs_version = '2015'
         self.sln_file_version = '12.00'
         self.sln_version_comment = '14'

mesonbuild/backend/vs2017backend.py

@@ -12,15 +12,14 @@
 
 if T.TYPE_CHECKING:
     from ..build import Build
-    from ..interpreter import Interpreter
 
 
 class Vs2017Backend(Vs2010Backend):
 
     name = 'vs2017'
 
-    def __init__(self, build: T.Optional[Build], interpreter: T.Optional[Interpreter]):
-        super().__init__(build, interpreter)
+    def __init__(self, build: T.Optional[Build]):
+        super().__init__(build)
         self.vs_version = '2017'
         self.sln_file_version = '12.00'
         self.sln_version_comment = '15'

mesonbuild/backend/vs2019backend.py

@@ -11,15 +11,14 @@
 
 if T.TYPE_CHECKING:
     from ..build import Build
-    from ..interpreter import Interpreter
 
 
 class Vs2019Backend(Vs2010Backend):
 
     name = 'vs2019'
 
-    def __init__(self, build: T.Optional[Build], interpreter: T.Optional[Interpreter]):
-        super().__init__(build, interpreter)
+    def __init__(self, build: T.Optional[Build]):
+        super().__init__(build)
         self.sln_file_version = '12.00'
         self.sln_version_comment = 'Version 16'
 

mesonbuild/backend/vs2022backend.py

@@ -11,15 +11,14 @@
 
 if T.TYPE_CHECKING:
     from ..build import Build
-    from ..interpreter import Interpreter
 
 
 class Vs2022Backend(Vs2010Backend):
 
     name = 'vs2022'
 
-    def __init__(self, build: T.Optional[Build], interpreter: T.Optional[Interpreter], gen_lite: bool = False):
-        super().__init__(build, interpreter, gen_lite=gen_lite)
+    def __init__(self, build: T.Optional[Build], gen_lite: bool = False):
+        super().__init__(build, gen_lite=gen_lite)
         self.sln_file_version = '12.00'
         self.sln_version_comment = 'Version 17'
 

mesonbuild/backend/xcodebackend.py

@@ -17,7 +17,6 @@
 if T.TYPE_CHECKING:
     from ..build import BuildTarget
     from ..compilers import Compiler
-    from ..interpreter import Interpreter
 
 INDENT = '\t'
 XCODETYPEMAP = {'c': 'sourcecode.c.c',
@@ -236,8 +235,8 @@ class XCodeBackend(backends.Backend):
 
     name = 'xcode'
 
-    def __init__(self, build: T.Optional[build.Build], interpreter: T.Optional[Interpreter]):
-        super().__init__(build, interpreter)
+    def __init__(self, build: T.Optional[build.Build]):
+        super().__init__(build)
         self.project_uid = self.environment.coredata.lang_guids['default'].replace('-', '')[:24]
         self.buildtype = T.cast('str', self.environment.coredata.optstore.get_value_for(OptionKey('buildtype')))
         self.project_conflist = self.gen_id()
@@ -629,7 +628,7 @@ def generate_target_file_maps_impl(self, targets) -> None:
                     self.fileref_ids[k] = self.gen_id()
 
     def generate_build_file_maps(self) -> None:
-        for buildfile in self.interpreter.get_build_def_files():
+        for buildfile in self.build.def_files:
             assert isinstance(buildfile, str)
             self.buildfile_ids[buildfile] = self.gen_id()
             self.fileref_ids[buildfile] = self.gen_id()
@@ -1025,7 +1024,7 @@ def generate_pbx_file_reference(self, objects_dict: PbxDict) -> None:
                 custom_dict.add_item('sourceTree', 'SOURCE_ROOT')
                 objects_dict.add_item(self.custom_target_output_fileref[o], custom_dict)
 
-        for buildfile in self.interpreter.get_build_def_files():
+        for buildfile in self.build.def_files:
             basename = os.path.split(buildfile)[1]
             buildfile_dict = PbxDict()
             typestr = self.get_xcodetype(buildfile)