backend: refactor: set self.interpreter in the constructor

author: Daniel Mensinger <daniel@mensinger-ka.de> 2020-01-06 12:11:19 +0100
committer: Jussi Pakkanen <jpakkane@gmail.com> 2020-01-28 21:18:25 +0200
commit: 668610c0d2b0f3a66d96022eb57afe5b09c3a2b7 (patch)
tree: b35d68d125f7ae9b9df7bfc122236a4c922511f5 /mesonbuild
parent: 3f8d6af9c2110bc1b3c94dd7b638d5b7eb1208c0 (diff)
download: meson-668610c0d2b0f3a66d96022eb57afe5b09c3a2b7.zip
meson-668610c0d2b0f3a66d96022eb57afe5b09c3a2b7.tar.gz
meson-668610c0d2b0f3a66d96022eb57afe5b09c3a2b7.tar.bz2
9 files changed, 47 insertions, 34 deletions
diff --git a/mesonbuild/backend/backends.py b/mesonbuild/backend/backends.py
index d75b7a4..dfbc8be 100644
--- a/mesonbuild/backend/backends.py
+++ b/mesonbuild/backend/backends.py
@@ -24,6 +24,7 @@ from ..mesonlib import MachineChoice, MesonException, OrderedSet, OptionOverride
 from ..mesonlib import classify_unity_sources
 from ..mesonlib import File
 from ..compilers import CompilerArgs, VisualStudioLikeCompiler
+from ..interpreter import Interpreter
 from collections import OrderedDict
 import shlex
 from functools import lru_cache
@@ -106,40 +107,41 @@ class TestSerialisation:
         self.priority = priority
         self.needs_exe_wrapper = needs_exe_wrapper
 
-def get_backend_from_name(backend, build):
+def get_backend_from_name(backend: str, build: T.Optional[build.Build] = None, interpreter: T.Optional[Interpreter] = None) -> T.Optional['Backend']:
     if backend == 'ninja':
         from . import ninjabackend
-        return ninjabackend.NinjaBackend(build)
+        return ninjabackend.NinjaBackend(build, interpreter)
     elif backend == 'vs':
         from . import vs2010backend
-        return vs2010backend.autodetect_vs_version(build)
+        return vs2010backend.autodetect_vs_version(build, interpreter)
     elif backend == 'vs2010':
         from . import vs2010backend
-        return vs2010backend.Vs2010Backend(build)
+        return vs2010backend.Vs2010Backend(build, interpreter)
     elif backend == 'vs2015':
         from . import vs2015backend
-        return vs2015backend.Vs2015Backend(build)
+        return vs2015backend.Vs2015Backend(build, interpreter)
     elif backend == 'vs2017':
         from . import vs2017backend
-        return vs2017backend.Vs2017Backend(build)
+        return vs2017backend.Vs2017Backend(build, interpreter)
     elif backend == 'vs2019':
         from . import vs2019backend
-        return vs2019backend.Vs2019Backend(build)
+        return vs2019backend.Vs2019Backend(build, interpreter)
     elif backend == 'xcode':
         from . import xcodebackend
-        return xcodebackend.XCodeBackend(build)
+        return xcodebackend.XCodeBackend(build, interpreter)
     return None
 
 # This class contains the basic functionality that is needed by all backends.
 # Feel free to move stuff in and out of it as you see fit.
 class Backend:
-    def __init__(self, build):
+    def __init__(self, build: T.Optional[build.Build], interpreter: T.Optional[Interpreter]):
         # 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 = {}
         self.build_dir = self.environment.get_build_dir()
diff --git a/mesonbuild/backend/ninjabackend.py b/mesonbuild/backend/ninjabackend.py
index 31a7a43..bcb916c 100644
--- a/mesonbuild/backend/ninjabackend.py
+++ b/mesonbuild/backend/ninjabackend.py
@@ -37,6 +37,7 @@ from ..mesonlib import (
 from ..mesonlib import get_compiler_for_source, has_path_sep
 from .backends import CleanTrees
 from ..build import InvalidArguments
+from ..interpreter import Interpreter
 
 FORTRAN_INCLUDE_PAT = r"^\s*#?include\s*['\"](\w+\.\w+)['\"]"
 FORTRAN_MODULE_PAT = r"^\s*\bmodule\b\s+(\w+)\s*(?:!+.*)*$"
@@ -203,8 +204,8 @@ class NinjaBuildElement:
 
 class NinjaBackend(backends.Backend):
 
-    def __init__(self, build):
-        super().__init__(build)
+    def __init__(self, build: T.Optional[build.Build], interpreter: T.Optional[Interpreter]):
+        super().__init__(build, interpreter)
         self.name = 'ninja'
         self.ninja_filename = 'build.ninja'
         self.fortran_deps = {}
@@ -283,8 +284,7 @@ int dummy;
 
         raise MesonException('Could not determine vs dep dependency prefix string.')
 
-    def generate(self, interp):
-        self.interpreter = interp
+    def generate(self):
         ninja = environment.detect_ninja_command_and_version(log=True)
         if ninja is None:
             raise MesonException('Could not detect Ninja v1.5 or newer')
diff --git a/mesonbuild/backend/vs2010backend.py b/mesonbuild/backend/vs2010backend.py
index 6d83ff9..177e715 100644
--- a/mesonbuild/backend/vs2010backend.py
+++ b/mesonbuild/backend/vs2010backend.py
@@ -18,6 +18,7 @@ import pickle
 import xml.dom.minidom
 import xml.etree.ElementTree as ET
 import uuid
+import typing as T
 from pathlib import Path, PurePath
 
 from . import backends
@@ -26,12 +27,13 @@ from .. import dependencies
 from .. import mlog
 from .. import compilers
 from ..compilers import CompilerArgs
+from ..interpreter import Interpreter
 from ..mesonlib import (
     MesonException, File, python_command, replace_if_different
 )
 from ..environment import Environment, build_filename
 
-def autodetect_vs_version(build):
+def autodetect_vs_version(build: T.Optional[build.Build], interpreter: T.Optional[Interpreter]):
     vs_version = os.getenv('VisualStudioVersion', None)
     vs_install_dir = os.getenv('VSINSTALLDIR', None)
     if not vs_install_dir:
@@ -41,17 +43,17 @@ def autodetect_vs_version(build):
     # vcvarsall.bat doesn't set it, so also use VSINSTALLDIR
     if vs_version == '14.0' or 'Visual Studio 14' in vs_install_dir:
         from mesonbuild.backend.vs2015backend import Vs2015Backend
-        return Vs2015Backend(build)
+        return Vs2015Backend(build, interpreter)
     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)
+        return Vs2017Backend(build, interpreter)
     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)
+        return Vs2019Backend(build, interpreter)
     if 'Visual Studio 10.0' in vs_install_dir:
-        return Vs2010Backend(build)
+        return Vs2010Backend(build, interpreter)
     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))
 
@@ -86,8 +88,8 @@ class RegenInfo:
         self.depfiles = depfiles
 
 class Vs2010Backend(backends.Backend):
-    def __init__(self, build):
-        super().__init__(build)
+    def __init__(self, build: T.Optional[build.Build], interpreter: T.Optional[Interpreter]):
+        super().__init__(build, interpreter)
         self.name = 'vs2010'
         self.project_file_version = '10.0.30319.1'
         self.platform_toolset = None
@@ -163,8 +165,7 @@ class Vs2010Backend(backends.Backend):
                     ET.SubElement(cbs, 'AdditionalInputs').text = ';'.join(deps)
         return generator_output_files, custom_target_output_files, custom_target_include_dirs
 
-    def generate(self, interp):
-        self.interpreter = interp
+    def generate(self):
         target_machine = self.interpreter.builtin['target_machine'].cpu_family_method(None, None)
         if target_machine.endswith('64'):
             # amd64 or x86_64
diff --git a/mesonbuild/backend/vs2015backend.py b/mesonbuild/backend/vs2015backend.py
index 1e5e171..bdc1675 100644
--- a/mesonbuild/backend/vs2015backend.py
+++ b/mesonbuild/backend/vs2015backend.py
@@ -14,11 +14,14 @@
 
 from .vs2010backend import Vs2010Backend
 from ..mesonlib import MesonException
+from ..interpreter import Interpreter
+from ..build import Build
+import typing as T
 
 
 class Vs2015Backend(Vs2010Backend):
-    def __init__(self, build):
-        super().__init__(build)
+    def __init__(self, build: T.Optional[Build], interpreter: T.Optional[Interpreter]):
+        super().__init__(build, interpreter)
         self.name = 'vs2015'
         self.vs_version = '2015'
         if self.environment is not None:
diff --git a/mesonbuild/backend/vs2017backend.py b/mesonbuild/backend/vs2017backend.py
index 9308233..fa21606 100644
--- a/mesonbuild/backend/vs2017backend.py
+++ b/mesonbuild/backend/vs2017backend.py
@@ -13,15 +13,18 @@
 # limitations under the License.
 
 import os
+import typing as T
 import xml.etree.ElementTree as ET
 
 from .vs2010backend import Vs2010Backend
 from ..mesonlib import MesonException
+from ..interpreter import Interpreter
+from ..build import Build
 
 
 class Vs2017Backend(Vs2010Backend):
-    def __init__(self, build):
-        super().__init__(build)
+    def __init__(self, build: T.Optional[Build], interpreter: T.Optional[Interpreter]):
+        super().__init__(build, interpreter)
         self.name = 'vs2017'
         self.vs_version = '2017'
         # We assume that host == build
diff --git a/mesonbuild/backend/vs2019backend.py b/mesonbuild/backend/vs2019backend.py
index c0ff5c3..e089cb4 100644
--- a/mesonbuild/backend/vs2019backend.py
+++ b/mesonbuild/backend/vs2019backend.py
@@ -13,14 +13,17 @@
 # limitations under the License.
 
 import os
+import typing as T
 import xml.etree.ElementTree as ET
 
 from .vs2010backend import Vs2010Backend
+from ..interpreter import Interpreter
+from ..build import Build
 
 
 class Vs2019Backend(Vs2010Backend):
-    def __init__(self, build):
-        super().__init__(build)
+    def __init__(self, build: T.Optional[Build], interpreter: T.Optional[Interpreter]):
+        super().__init__(build, interpreter)
         self.name = 'vs2019'
         if self.environment is not None:
             comps = self.environment.coredata.compilers.host
diff --git a/mesonbuild/backend/xcodebackend.py b/mesonbuild/backend/xcodebackend.py
index 15a4705..3fe6574 100644
--- a/mesonbuild/backend/xcodebackend.py
+++ b/mesonbuild/backend/xcodebackend.py
@@ -18,12 +18,14 @@ from .. import dependencies
 from .. import mesonlib
 from .. import mlog
 import uuid, os, operator
+import typing as T
 
 from ..mesonlib import MesonException
+from ..interpreter import Interpreter
 
 class XCodeBackend(backends.Backend):
-    def __init__(self, build):
-        super().__init__(build)
+    def __init__(self, build: T.Optional[build.Build], interpreter: T.Optional[Interpreter]):
+        super().__init__(build, interpreter)
         self.name = 'xcode'
         self.project_uid = self.environment.coredata.lang_guids['default'].replace('-', '')[:24]
         self.project_conflist = self.gen_id()
@@ -74,8 +76,7 @@ class XCodeBackend(backends.Backend):
         if not text.endswith('\n'):
             self.ofile.write('\n')
 
-    def generate(self, interp):
-        self.interpreter = interp
+    def generate(self):
         test_data = self.serialize_tests()[0]
         self.generate_filemap()
         self.generate_buildmap()
diff --git a/mesonbuild/interpreter.py b/mesonbuild/interpreter.py
index 908a555..9cb5621 100644
--- a/mesonbuild/interpreter.py
+++ b/mesonbuild/interpreter.py
@@ -2771,7 +2771,7 @@ external dependencies (including libraries) must go to "dependencies".''')
             return
         backend = self.coredata.get_builtin_option('backend')
         from .backend import backends
-        self.backend = backends.get_backend_from_name(backend, self.build)
+        self.backend = backends.get_backend_from_name(backend, self.build, self)
 
         if self.backend is None:
             raise InterpreterException('Unknown backend "%s".' % backend)
diff --git a/mesonbuild/msetup.py b/mesonbuild/msetup.py
index d8b79b2..ad9c92f 100644
--- a/mesonbuild/msetup.py
+++ b/mesonbuild/msetup.py
@@ -212,7 +212,7 @@ class MesonApp:
                 fname = os.path.join(self.build_dir, 'meson-private', fname)
                 profile.runctx('intr.backend.generate(intr)', globals(), locals(), filename=fname)
             else:
-                intr.backend.generate(intr)
+                intr.backend.generate()
             build.save(b, dumpfile)
             if env.first_invocation:
                 coredata.write_cmd_line_file(self.build_dir, self.options)
author	Daniel Mensinger <daniel@mensinger-ka.de>	2020-01-06 12:11:19 +0100
committer	Jussi Pakkanen <jpakkane@gmail.com>	2020-01-28 21:18:25 +0200
commit	668610c0d2b0f3a66d96022eb57afe5b09c3a2b7 (patch)
tree	b35d68d125f7ae9b9df7bfc122236a4c922511f5 /mesonbuild
parent	3f8d6af9c2110bc1b3c94dd7b638d5b7eb1208c0 (diff)
download	meson-668610c0d2b0f3a66d96022eb57afe5b09c3a2b7.zip meson-668610c0d2b0f3a66d96022eb57afe5b09c3a2b7.tar.gz meson-668610c0d2b0f3a66d96022eb57afe5b09c3a2b7.tar.bz2