diff options
| -rw-r--r-- | mesonbuild/compilers/asm.py | 18 | ||||
| -rw-r--r-- | mesonbuild/compilers/c.py | 98 | ||||
| -rw-r--r-- | mesonbuild/compilers/compilers.py | 13 | ||||
| -rw-r--r-- | mesonbuild/compilers/cpp.py | 87 | ||||
| -rw-r--r-- | mesonbuild/compilers/cs.py | 9 | ||||
| -rw-r--r-- | mesonbuild/compilers/cuda.py | 6 | ||||
| -rw-r--r-- | mesonbuild/compilers/d.py | 16 | ||||
| -rw-r--r-- | mesonbuild/compilers/detect.py | 127 | ||||
| -rw-r--r-- | mesonbuild/compilers/fortran.py | 62 | ||||
| -rw-r--r-- | mesonbuild/compilers/java.py | 5 | ||||
| -rw-r--r-- | mesonbuild/compilers/mixins/apple.py | 5 | ||||
| -rw-r--r-- | mesonbuild/compilers/objc.py | 13 | ||||
| -rw-r--r-- | mesonbuild/compilers/objcpp.py | 13 | ||||
| -rw-r--r-- | mesonbuild/compilers/rust.py | 13 | ||||
| -rw-r--r-- | mesonbuild/compilers/swift.py | 5 | ||||
| -rw-r--r-- | mesonbuild/compilers/vala.py | 5 | ||||
| -rw-r--r-- | unittests/internaltests.py | 16 |
17 files changed, 230 insertions, 281 deletions
diff --git a/mesonbuild/compilers/asm.py b/mesonbuild/compilers/asm.py index 052e83329..01915bc3e 100644 --- a/mesonbuild/compilers/asm.py +++ b/mesonbuild/compilers/asm.py @@ -13,7 +13,6 @@ from .mixins.ti import TICompiler if T.TYPE_CHECKING: from ..linkers.linkers import DynamicLinker from ..mesonlib import MachineChoice - from ..envconfig import MachineInfo from ..environment import Environment nasm_optimization_args: T.Dict[str, T.List[str]] = { @@ -34,12 +33,13 @@ class ASMCompiler(Compiler): _SUPPORTED_ARCHES: T.Set[str] = set() def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, - for_machine: MachineChoice, info: MachineInfo, + for_machine: MachineChoice, env: Environment, linker: T.Optional[DynamicLinker] = None, full_version: T.Optional[str] = None, is_cross: bool = False): + info = env.machines[for_machine] if self._SUPPORTED_ARCHES and info.cpu_family not in self._SUPPORTED_ARCHES: raise EnvironmentException(f'ASM Compiler {self.id} does not support building for {info.cpu_family} CPU family.') - super().__init__(ccache, exelist, version, for_machine, info, linker, full_version, is_cross) + super().__init__(ccache, exelist, version, for_machine, env, linker, full_version, is_cross) def sanity_check(self, work_dir: str, environment: Environment) -> None: return None @@ -61,10 +61,10 @@ class NasmCompiler(ASMCompiler): _SUPPORTED_ARCHES = {'x86', 'x86_64'} def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, - for_machine: 'MachineChoice', info: 'MachineInfo', + for_machine: 'MachineChoice', env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None, is_cross: bool = False): - super().__init__(ccache, exelist, version, for_machine, info, linker, full_version, is_cross) + super().__init__(ccache, exelist, version, for_machine, env, linker, full_version, is_cross) if isinstance(self.linker, VisualStudioLikeLinkerMixin): self.base_options.add(OptionKey('b_vscrt')) @@ -279,10 +279,10 @@ class TILinearAsmCompiler(TICompiler, ASMCompiler): _SUPPORTED_ARCHES = {'c6000'} def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, - for_machine: MachineChoice, info: MachineInfo, + for_machine: MachineChoice, env: Environment, linker: T.Optional[DynamicLinker] = None, full_version: T.Optional[str] = None, is_cross: bool = False): - ASMCompiler.__init__(self, ccache, exelist, version, for_machine, info, linker, full_version, is_cross) + ASMCompiler.__init__(self, ccache, exelist, version, for_machine, env, linker, full_version, is_cross) TICompiler.__init__(self) def needs_static_linker(self) -> bool: @@ -302,10 +302,10 @@ class MetrowerksAsmCompiler(MetrowerksCompiler, ASMCompiler): language = 'nasm' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, - for_machine: 'MachineChoice', info: 'MachineInfo', + for_machine: 'MachineChoice', env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None, is_cross: bool = False): - ASMCompiler.__init__(self, ccache, exelist, version, for_machine, info, linker, full_version, is_cross) + ASMCompiler.__init__(self, ccache, exelist, version, for_machine, env, linker, full_version, is_cross) MetrowerksCompiler.__init__(self) self.warn_args: T.Dict[str, T.List[str]] = { diff --git a/mesonbuild/compilers/c.py b/mesonbuild/compilers/c.py index 53ef28e13..4f505852e 100644 --- a/mesonbuild/compilers/c.py +++ b/mesonbuild/compilers/c.py @@ -39,7 +39,6 @@ from .compilers import ( if T.TYPE_CHECKING: from ..options import MutableKeyedOptionDictType from ..dependencies import Dependency - from ..envconfig import MachineInfo from ..environment import Environment from ..linkers.linkers import DynamicLinker from ..mesonlib import MachineChoice @@ -65,11 +64,10 @@ class CCompiler(CLikeCompiler, Compiler): language = 'c' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): # If a child ObjC or CPP class has already set it, don't set it ourselves - Compiler.__init__(self, ccache, exelist, version, for_machine, info, + Compiler.__init__(self, ccache, exelist, version, for_machine, env, is_cross=is_cross, full_version=full_version, linker=linker) CLikeCompiler.__init__(self) @@ -109,11 +107,10 @@ class CCompiler(CLikeCompiler, Compiler): class ClangCCompiler(ClangCStds, ClangCompiler, CCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, defines: T.Optional[T.Dict[str, str]] = None, full_version: T.Optional[str] = None): - CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, info, linker=linker, full_version=full_version) + CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, env, linker=linker, full_version=full_version) ClangCompiler.__init__(self, defines) default_warn_args = ['-Wall', '-Winvalid-pch'] self.warn_args = {'0': [], @@ -180,8 +177,7 @@ class EmscriptenCCompiler(EmscriptenMixin, ClangCCompiler): _C23_VERSION = '>=3.1.45' # 3.1.45 used Clang 18.0.0 def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, defines: T.Optional[T.Dict[str, str]] = None, full_version: T.Optional[str] = None): if not is_cross: @@ -189,7 +185,7 @@ class EmscriptenCCompiler(EmscriptenMixin, ClangCCompiler): if not version_compare(version, '>=1.39.19'): raise MesonException('Meson requires Emscripten >= 1.39.19') ClangCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, + env, linker=linker, defines=defines, full_version=full_version) @@ -199,11 +195,10 @@ class ArmclangCCompiler(ArmclangCompiler, CCompiler): ''' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) ArmclangCompiler.__init__(self) default_warn_args = ['-Wall', '-Winvalid-pch'] self.warn_args = {'0': [], @@ -237,11 +232,10 @@ class GnuCCompiler(GnuCStds, GnuCompiler, CCompiler): _INVALID_PCH_VERSION = ">=3.4.0" def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, defines: T.Optional[T.Dict[str, str]] = None, full_version: T.Optional[str] = None): - CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, info, linker=linker, full_version=full_version) + CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, env, linker=linker, full_version=full_version) GnuCompiler.__init__(self, defines) default_warn_args = ['-Wall'] if version_compare(self.version, self._INVALID_PCH_VERSION): @@ -291,11 +285,10 @@ class GnuCCompiler(GnuCStds, GnuCompiler, CCompiler): class PGICCompiler(PGICompiler, CCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) PGICompiler.__init__(self) @@ -304,11 +297,10 @@ class NvidiaHPC_CCompiler(PGICompiler, CCompiler): id = 'nvidia_hpc' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) PGICompiler.__init__(self) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -322,12 +314,11 @@ class NvidiaHPC_CCompiler(PGICompiler, CCompiler): class ElbrusCCompiler(ElbrusCompiler, CCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, defines: T.Optional[T.Dict[str, str]] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) ElbrusCompiler.__init__(self) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -363,11 +354,10 @@ class ElbrusCCompiler(ElbrusCompiler, CCompiler): class IntelCCompiler(IntelGnuLikeCompiler, CCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) IntelGnuLikeCompiler.__init__(self) self.lang_header = 'c-header' default_warn_args = ['-Wall', '-w3'] @@ -430,12 +420,11 @@ class VisualStudioCCompiler(MSVCCompiler, VisualStudioLikeCCompilerMixin, CCompi _C17_VERSION = '>=19.28' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', target: str, + is_cross: bool, env: Environment, target: str, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, - full_version=full_version) + env, linker=linker, full_version=full_version) MSVCCompiler.__init__(self, target) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -465,12 +454,11 @@ class VisualStudioCCompiler(MSVCCompiler, VisualStudioLikeCCompilerMixin, CCompi class ClangClCCompiler(ClangCStds, ClangClCompiler, VisualStudioLikeCCompilerMixin, CCompiler): def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', target: str, + is_cross: bool, env: Environment, target: str, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, [], exelist, version, for_machine, is_cross, - info, linker=linker, - full_version=full_version) + env, linker=linker, full_version=full_version) ClangClCompiler.__init__(self, target) def get_option_std_args(self, target: BuildTarget, env: Environment, subproject: T.Optional[str] = None) -> T.List[str]: @@ -486,11 +474,11 @@ class IntelClCCompiler(IntelVisualStudioLikeCompiler, VisualStudioLikeCCompilerM """Intel "ICL" compiler abstraction.""" def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', target: str, + is_cross: bool, env: Environment, target: str, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, [], exelist, version, for_machine, is_cross, - info, linker=linker, + env, linker=linker, full_version=full_version) IntelVisualStudioLikeCompiler.__init__(self, target) @@ -520,12 +508,11 @@ class IntelLLVMClCCompiler(IntelClCCompiler): class ArmCCompiler(ArmCompiler, CCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, - full_version=full_version) + env, linker=linker, full_version=full_version) ArmCompiler.__init__(self) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -547,11 +534,11 @@ class ArmCCompiler(ArmCompiler, CCompiler): class CcrxCCompiler(CcrxCompiler, CCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) CcrxCompiler.__init__(self) # Override CCompiler.get_always_args @@ -599,11 +586,11 @@ class CcrxCCompiler(CcrxCompiler, CCompiler): class Xc16CCompiler(Xc16Compiler, CCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) Xc16Compiler.__init__(self) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -649,22 +636,21 @@ class Xc32CCompiler(Xc32CStds, Xc32Compiler, GnuCCompiler): """Microchip XC32 C compiler.""" def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: MachineInfo, - linker: T.Optional[DynamicLinker] = None, + env: Environment, linker: T.Optional[DynamicLinker] = None, defines: T.Optional[T.Dict[str, str]] = None, full_version: T.Optional[str] = None): GnuCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version, defines=defines) + env, linker=linker, full_version=full_version, defines=defines) Xc32Compiler.__init__(self) class CompCertCCompiler(CompCertCompiler, CCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) CompCertCompiler.__init__(self) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -691,11 +677,11 @@ class CompCertCCompiler(CompCertCompiler, CCompiler): class TICCompiler(TICompiler, CCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) TICompiler.__init__(self) # Override CCompiler.get_always_args @@ -732,11 +718,11 @@ class MetrowerksCCompilerARM(MetrowerksCompiler, CCompiler): id = 'mwccarm' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) MetrowerksCompiler.__init__(self) def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]: @@ -760,11 +746,11 @@ class MetrowerksCCompilerEmbeddedPowerPC(MetrowerksCompiler, CCompiler): id = 'mwcceppc' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) MetrowerksCompiler.__init__(self) def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]: @@ -787,9 +773,9 @@ class TaskingCCompiler(TaskingCompiler, CCompiler): id = 'tasking' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) TaskingCompiler.__init__(self) diff --git a/mesonbuild/compilers/compilers.py b/mesonbuild/compilers/compilers.py index 3105adb19..9ae48bfab 100644 --- a/mesonbuild/compilers/compilers.py +++ b/mesonbuild/compilers/compilers.py @@ -472,7 +472,7 @@ class Compiler(HoldableObject, metaclass=abc.ABCMeta): mode = 'COMPILER' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, - for_machine: MachineChoice, info: 'MachineInfo', + for_machine: MachineChoice, environment: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None, is_cross: bool = False): self.exelist = ccache + exelist @@ -485,10 +485,17 @@ class Compiler(HoldableObject, metaclass=abc.ABCMeta): self.for_machine = for_machine self.base_options: T.Set[OptionKey] = set() self.linker = linker - self.info = info - self.is_cross = is_cross + self.environment = environment + self.is_cross = environment.is_cross_build(for_machine) self.modes: T.List[Compiler] = [] + @property + def info(self) -> MachineInfo: + # This must be fetched dynamically because it may be re-evaluated later, + # and we could end up with a stale copy + # see :class:`Interpreter._redetect_machines()` + return self.environment.machines[self.for_machine] + def __repr__(self) -> str: repr_str = "<{0}: v{1} `{2}`>" return repr_str.format(self.__class__.__name__, self.version, diff --git a/mesonbuild/compilers/cpp.py b/mesonbuild/compilers/cpp.py index bfcb924f9..d9facb721 100644 --- a/mesonbuild/compilers/cpp.py +++ b/mesonbuild/compilers/cpp.py @@ -37,7 +37,6 @@ from .mixins.microchip import Xc32Compiler, Xc32CPPStds if T.TYPE_CHECKING: from ..options import MutableKeyedOptionDictType from ..dependencies import Dependency - from ..envconfig import MachineInfo from ..environment import Environment from ..linkers.linkers import DynamicLinker from ..mesonlib import MachineChoice @@ -68,11 +67,10 @@ class CPPCompiler(CLikeCompiler, Compiler): language = 'cpp' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): # If a child ObjCPP class has already set it, don't set it ourselves - Compiler.__init__(self, ccache, exelist, version, for_machine, info, + Compiler.__init__(self, ccache, exelist, version, for_machine, env, is_cross=is_cross, linker=linker, full_version=full_version) CLikeCompiler.__init__(self) @@ -222,12 +220,11 @@ class _StdCPPLibMixin(CompilerMixinBase): class ClangCPPCompiler(_StdCPPLibMixin, ClangCPPStds, ClangCompiler, CPPCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, defines: T.Optional[T.Dict[str, str]] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) ClangCompiler.__init__(self, defines) default_warn_args = ['-Wall', '-Winvalid-pch'] self.warn_args = {'0': [], @@ -357,8 +354,7 @@ class EmscriptenCPPCompiler(EmscriptenMixin, ClangCPPCompiler): _CPP26_VERSION = '>=3.1.39' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, defines: T.Optional[T.Dict[str, str]] = None, full_version: T.Optional[str] = None): if not is_cross: @@ -366,7 +362,7 @@ class EmscriptenCPPCompiler(EmscriptenMixin, ClangCPPCompiler): if not version_compare(version, '>=1.39.19'): raise MesonException('Meson requires Emscripten >= 1.39.19') ClangCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, + env, linker=linker, defines=defines, full_version=full_version) def get_option_std_args(self, target: BuildTarget, env: Environment, subproject: T.Optional[str] = None) -> T.List[str]: @@ -384,11 +380,10 @@ class ArmclangCPPCompiler(ArmclangCompiler, CPPCompiler): ''' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) ArmclangCompiler.__init__(self) default_warn_args = ['-Wall', '-Winvalid-pch'] self.warn_args = {'0': [], @@ -432,12 +427,11 @@ class ArmclangCPPCompiler(ArmclangCompiler, CPPCompiler): class GnuCPPCompiler(_StdCPPLibMixin, GnuCPPStds, GnuCompiler, CPPCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, defines: T.Optional[T.Dict[str, str]] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) GnuCompiler.__init__(self, defines) default_warn_args = ['-Wall', '-Winvalid-pch'] self.warn_args = {'0': [], @@ -548,11 +542,10 @@ class GnuCPPCompiler(_StdCPPLibMixin, GnuCPPStds, GnuCompiler, CPPCompiler): class PGICPPCompiler(PGICompiler, CPPCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) PGICompiler.__init__(self) @@ -561,11 +554,10 @@ class NvidiaHPC_CPPCompiler(PGICompiler, CPPCompiler): id = 'nvidia_hpc' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) PGICompiler.__init__(self) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -582,12 +574,11 @@ class NvidiaHPC_CPPCompiler(PGICompiler, CPPCompiler): class ElbrusCPPCompiler(ElbrusCompiler, CPPCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, defines: T.Optional[T.Dict[str, str]] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) ElbrusCompiler.__init__(self) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -665,11 +656,10 @@ class ElbrusCPPCompiler(ElbrusCompiler, CPPCompiler): class IntelCPPCompiler(IntelGnuLikeCompiler, CPPCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) IntelGnuLikeCompiler.__init__(self) self.lang_header = 'c++-header' default_warn_args = ['-Wall', '-w3', '-Wpch-messages'] @@ -884,11 +874,11 @@ class VisualStudioCPPCompiler(CPP11AsCPP14Mixin, VisualStudioLikeCPPCompilerMixi id = 'msvc' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', target: str, + is_cross: bool, env: Environment, target: str, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) MSVCCompiler.__init__(self, target) # By default, MSVC has a broken __cplusplus define that pretends to be c++98: @@ -929,11 +919,11 @@ class ClangClCPPCompiler(CPP11AsCPP14Mixin, VisualStudioLikeCPPCompilerMixin, Cl id = 'clang-cl' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', target: str, + is_cross: bool, env: Environment, target: str, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, [], exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) ClangClCompiler.__init__(self, target) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -944,11 +934,11 @@ class ClangClCPPCompiler(CPP11AsCPP14Mixin, VisualStudioLikeCPPCompilerMixin, Cl class IntelClCPPCompiler(VisualStudioLikeCPPCompilerMixin, IntelVisualStudioLikeCompiler, CPPCompiler): def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', target: str, + is_cross: bool, env: Environment, target: str, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, [], exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) IntelVisualStudioLikeCompiler.__init__(self, target) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -973,11 +963,10 @@ class IntelLLVMClCPPCompiler(IntelClCPPCompiler): class ArmCPPCompiler(ArmCompiler, CPPCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) ArmCompiler.__init__(self) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -1006,11 +995,10 @@ class ArmCPPCompiler(ArmCompiler, CPPCompiler): class CcrxCPPCompiler(CcrxCompiler, CPPCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) CcrxCompiler.__init__(self) # Override CCompiler.get_always_args @@ -1031,11 +1019,10 @@ class CcrxCPPCompiler(CcrxCompiler, CPPCompiler): class TICPPCompiler(TICompiler, CPPCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) TICompiler.__init__(self) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -1071,11 +1058,10 @@ class MetrowerksCPPCompilerARM(MetrowerksCompiler, CPPCompiler): id = 'mwccarm' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) MetrowerksCompiler.__init__(self) def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]: @@ -1099,11 +1085,11 @@ class MetrowerksCPPCompilerEmbeddedPowerPC(MetrowerksCompiler, CPPCompiler): id = 'mwcceppc' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) MetrowerksCompiler.__init__(self) def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]: @@ -1128,10 +1114,9 @@ class Xc32CPPCompiler(Xc32CPPStds, Xc32Compiler, GnuCPPCompiler): """Microchip XC32 C++ compiler.""" def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: MachineInfo, - linker: T.Optional[DynamicLinker] = None, + env: Environment, linker: T.Optional[DynamicLinker] = None, defines: T.Optional[T.Dict[str, str]] = None, full_version: T.Optional[str] = None): GnuCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version, defines=defines) + env, linker=linker, full_version=full_version, defines=defines) Xc32Compiler.__init__(self) diff --git a/mesonbuild/compilers/cs.py b/mesonbuild/compilers/cs.py index 4bbddeb20..37aa0f98b 100644 --- a/mesonbuild/compilers/cs.py +++ b/mesonbuild/compilers/cs.py @@ -15,7 +15,6 @@ from .mixins.islinker import BasicLinkerIsCompilerMixin if T.TYPE_CHECKING: from ..dependencies import Dependency - from ..envconfig import MachineInfo from ..environment import Environment from ..mesonlib import MachineChoice @@ -35,8 +34,8 @@ class CsCompiler(BasicLinkerIsCompilerMixin, Compiler): language = 'cs' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - info: 'MachineInfo', runner: T.Optional[str] = None): - super().__init__([], exelist, version, for_machine, info) + env: Environment, runner: T.Optional[str] = None): + super().__init__([], exelist, version, for_machine, env) self.runner = runner @classmethod @@ -119,8 +118,8 @@ class MonoCompiler(CsCompiler): id = 'mono' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - info: 'MachineInfo'): - super().__init__(exelist, version, for_machine, info, runner='mono') + env: Environment): + super().__init__(exelist, version, for_machine, env, runner='mono') def rsp_file_syntax(self) -> 'RSPFileSyntax': return RSPFileSyntax.GCC diff --git a/mesonbuild/compilers/cuda.py b/mesonbuild/compilers/cuda.py index bf80a42ad..be92dfbc8 100644 --- a/mesonbuild/compilers/cuda.py +++ b/mesonbuild/compilers/cuda.py @@ -22,7 +22,6 @@ if T.TYPE_CHECKING: from ..options import MutableKeyedOptionDictType from ..dependencies import Dependency from ..environment import Environment # noqa: F401 - from ..envconfig import MachineInfo from ..linkers.linkers import DynamicLinker from ..mesonlib import MachineChoice @@ -183,11 +182,10 @@ class CudaCompiler(Compiler): id = 'nvcc' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, - host_compiler: Compiler, info: 'MachineInfo', + is_cross: bool, host_compiler: Compiler, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): - super().__init__(ccache, exelist, version, for_machine, info, linker=linker, full_version=full_version, is_cross=is_cross) + super().__init__(ccache, exelist, version, for_machine, env, linker=linker, full_version=full_version, is_cross=is_cross) self.host_compiler = host_compiler self.base_options = host_compiler.base_options # -Wpedantic generates useless churn due to nvcc's dual compilation model producing diff --git a/mesonbuild/compilers/d.py b/mesonbuild/compilers/d.py index 9f662add3..c37bb679a 100644 --- a/mesonbuild/compilers/d.py +++ b/mesonbuild/compilers/d.py @@ -430,11 +430,11 @@ class DCompiler(Compiler): language = 'd' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - info: 'MachineInfo', arch: str, *, + env: Environment, arch: str, *, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None, is_cross: bool = False): - super().__init__([], exelist, version, for_machine, info, linker=linker, + super().__init__([], exelist, version, for_machine, env, linker=linker, full_version=full_version, is_cross=is_cross) self.arch = arch @@ -639,11 +639,11 @@ class GnuDCompiler(GnuCompiler, DCompiler): id = 'gcc' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - info: 'MachineInfo', arch: str, *, + env: Environment, arch: str, *, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None, is_cross: bool = False): - DCompiler.__init__(self, exelist, version, for_machine, info, arch, + DCompiler.__init__(self, exelist, version, for_machine, env, arch, linker=linker, full_version=full_version, is_cross=is_cross) GnuCompiler.__init__(self, {}) @@ -722,11 +722,11 @@ class LLVMDCompiler(DmdLikeCompilerMixin, DCompiler): id = 'llvm' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - info: 'MachineInfo', arch: str, *, + env: Environment, arch: str, *, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None, is_cross: bool = False, version_output: T.Optional[str] = None): - DCompiler.__init__(self, exelist, version, for_machine, info, arch, + DCompiler.__init__(self, exelist, version, for_machine, env, arch, linker=linker, full_version=full_version, is_cross=is_cross) DmdLikeCompilerMixin.__init__(self, dmd_frontend_version=find_ldc_dmd_frontend_version(version_output)) @@ -785,11 +785,11 @@ class DmdDCompiler(DmdLikeCompilerMixin, DCompiler): id = 'dmd' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - info: 'MachineInfo', arch: str, *, + env: Environment, arch: str, *, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None, is_cross: bool = False): - DCompiler.__init__(self, exelist, version, for_machine, info, arch, + DCompiler.__init__(self, exelist, version, for_machine, env, arch, linker=linker, full_version=full_version, is_cross=is_cross) DmdLikeCompilerMixin.__init__(self, version) diff --git a/mesonbuild/compilers/detect.py b/mesonbuild/compilers/detect.py index bf72d347c..f1910df70 100644 --- a/mesonbuild/compilers/detect.py +++ b/mesonbuild/compilers/detect.py @@ -285,7 +285,6 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin if override_compiler is not None: compilers = [override_compiler] is_cross = env.is_cross_build(for_machine) - info = env.machines[for_machine] cls: T.Union[T.Type[CCompiler], T.Type[CPPCompiler]] lnk: T.Union[T.Type[StaticLinker], T.Type[DynamicLinker]] @@ -373,7 +372,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin return cls( ccache, compiler, version, for_machine, is_cross, - info, defines=defines, full_version=full_version, + env, defines=defines, full_version=full_version, linker=linker) if 'Emscripten' in out: @@ -391,7 +390,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin compiler, for_machine, cls.LINKER_PREFIX, [], version=search_version(o)) return cls( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, linker=linker, full_version=full_version) if 'Arm C/C++/Fortran Compiler' in out: @@ -404,7 +403,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin cls = cpp.ArmLtdClangCPPCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, linker=linker) if 'armclang' in out: # The compiler version is not present in the first line of output, @@ -424,7 +423,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin linker = linkers.ArmClangDynamicLinker(for_machine, version=version) env.add_lang_args(cls.language, cls, for_machine) return cls( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'CL.EXE COMPATIBILITY' in out: # if this is clang-cl masquerading as cl, detect it as cl, not @@ -443,7 +442,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin cls = c.ClangClCCompiler if lang == 'c' else cpp.ClangClCPPCompiler linker = guess_win_linker(env, ['lld-link'], cls, version, for_machine) return cls( - compiler, version, for_machine, is_cross, info, target, + compiler, version, for_machine, is_cross, env, target, linker=linker) # must be detected here before clang because TI compilers contain 'clang' in their output and so that they can be detected as 'clang' @@ -460,7 +459,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin env.add_lang_args(cls.language, cls, for_machine) linker = lnk(compiler, for_machine, version=version) return cls( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'clang' in out or 'Clang' in out: @@ -487,7 +486,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, defines=defines, full_version=full_version, linker=linker) if 'Intel(R) C++ Intel(R)' in err: @@ -497,7 +496,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin env.add_lang_args(cls.language, cls, for_machine) linker = linkers.XilinkDynamicLinker(for_machine, [], version=version) return cls( - compiler, version, for_machine, is_cross, info, target, + compiler, version, for_machine, is_cross, env, target, linker=linker) if 'Intel(R) oneAPI DPC++/C++ Compiler for applications' in err: version = search_version(err) @@ -506,7 +505,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin env.add_lang_args(cls.language, cls, for_machine) linker = linkers.XilinkDynamicLinker(for_machine, [], version=version) return cls( - compiler, version, for_machine, is_cross, info, target, + compiler, version, for_machine, is_cross, env, target, linker=linker) if 'Microsoft' in out or 'Microsoft' in err: # Latest versions of Visual Studio print version @@ -533,7 +532,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin mlog.warning('Visual Studio support requires ccache 4.6 or higher. You have ccache {}. '.format(ccache_exe.get_version()), once=True) ccache = [] return cls( - ccache, compiler, version, for_machine, is_cross, info, target, + ccache, compiler, version, for_machine, is_cross, env, target, full_version=cl_signature, linker=linker) if 'PGI Compilers' in out: cls = c.PGICCompiler if lang == 'c' else cpp.PGICPPCompiler @@ -541,25 +540,25 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin linker = linkers.PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( ccache, compiler, version, for_machine, is_cross, - info, linker=linker) + env, linker=linker) if 'NVIDIA Compilers and Tools' in out: cls = c.NvidiaHPC_CCompiler if lang == 'c' else cpp.NvidiaHPC_CPPCompiler env.add_lang_args(cls.language, cls, for_machine) linker = linkers.NvidiaHPC_DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( ccache, compiler, version, for_machine, is_cross, - info, linker=linker) + env, linker=linker) if '(ICC)' in out: cls = c.IntelCCompiler if lang == 'c' else cpp.IntelCPPCompiler l = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, full_version=full_version, linker=l) if 'Intel(R) oneAPI' in out: cls = c.IntelLLVMCCompiler if lang == 'c' else cpp.IntelLLVMCPPCompiler l = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, full_version=full_version, linker=l) if 'ARM' in out and not ('Metrowerks' in out or 'Freescale' in out): cls = c.ArmCCompiler if lang == 'c' else cpp.ArmCPPCompiler @@ -567,13 +566,13 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin linker = linkers.ArmDynamicLinker(for_machine, version=version) return cls( ccache, compiler, version, for_machine, is_cross, - info, full_version=full_version, linker=linker) + env, full_version=full_version, linker=linker) if 'RX Family' in out: cls = c.CcrxCCompiler if lang == 'c' else cpp.CcrxCPPCompiler env.add_lang_args(cls.language, cls, for_machine) linker = linkers.CcrxDynamicLinker(for_machine, version=version) return cls( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'Microchip' in out: @@ -594,7 +593,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin return cls( ccache, compiler, version, for_machine, is_cross, - info, defines=defines, full_version=full_version, + env, defines=defines, full_version=full_version, linker=linker) else: cls = c.Xc16CCompiler @@ -602,7 +601,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin linker = linkers.Xc16DynamicLinker(for_machine, version=version) return cls( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'CompCert' in out: @@ -610,7 +609,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin env.add_lang_args(cls.language, cls, for_machine) linker = linkers.CompCertDynamicLinker(for_machine, version=version) return cls( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'Metrowerks C/C++' in out or 'Freescale C/C++' in out: @@ -640,7 +639,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin raise EnvironmentException(f'Failed to detect linker for {cls.id!r} compiler. Please update your cross file(s).') return cls( - ccache, compiler, compiler_version, for_machine, is_cross, info, + ccache, compiler, compiler_version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'TASKING VX-toolset' in err: cls = c.TaskingCCompiler @@ -657,7 +656,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin linker = lnk(ld, for_machine, version=tasking_version) return cls( - ccache, compiler, tasking_version, for_machine, is_cross, info, + ccache, compiler, tasking_version, for_machine, is_cross, env, full_version=full_version, linker=linker) _handle_exceptions(popen_exceptions, compilers) @@ -677,7 +676,6 @@ def detect_cuda_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp is_cross = env.is_cross_build(for_machine) compilers, ccache_exe = _get_compilers(env, 'cuda', for_machine) ccache = ccache_exe.get_command() if (ccache_exe and ccache_exe.found()) else [] - info = env.machines[for_machine] for compiler in compilers: arg = '--version' try: @@ -713,7 +711,7 @@ def detect_cuda_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp assert isinstance(val, list) env.coredata.optstore.set_option(key, cls.to_host_flags_base(val, Phase.LINKER)) linker = CudaLinker(compiler, for_machine, CudaCompiler.LINKER_PREFIX, [], version=CudaLinker.parse_version()) - return cls(ccache, compiler, version, for_machine, is_cross, host_compiler=cpp_compiler, info=info, linker=linker) + return cls(ccache, compiler, version, for_machine, is_cross, cpp_compiler, env, linker=linker) raise EnvironmentException(f'Could not find suitable CUDA compiler: "{"; ".join([" ".join(c) for c in compilers])}"') def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: @@ -722,7 +720,6 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C popen_exceptions: T.Dict[str, T.Union[Exception, str]] = {} compilers, ccache = _get_compilers(env, 'fortran', for_machine) is_cross = env.is_cross_build(for_machine) - info = env.machines[for_machine] cls: T.Type[FortranCompiler] for compiler in compilers: # capture help text for possible fallback @@ -758,14 +755,14 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C cls = fortran.ElbrusFortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, defines, full_version=full_version, linker=linker) else: version = _get_gnu_version_from_defines(defines) cls = fortran.GnuFortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, defines, full_version=full_version, linker=linker) if 'Arm C/C++/Fortran Compiler' in out: @@ -775,13 +772,13 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C version = '.'.join([x for x in arm_ver_match.groups() if x is not None]) linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, linker=linker) if 'G95' in out: cls = fortran.G95FortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'Sun Fortran' in err: @@ -789,7 +786,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C cls = fortran.SunFortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'Intel(R) Fortran Compiler for applications' in err: @@ -799,7 +796,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C env.add_lang_args(cls.language, cls, for_machine) linker = linkers.XilinkDynamicLinker(for_machine, [], version=version) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, target, linker=linker) if 'Intel(R) Visual Fortran' in err or 'Intel(R) Fortran' in err: @@ -809,26 +806,26 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C env.add_lang_args(cls.language, cls, for_machine) linker = linkers.XilinkDynamicLinker(for_machine, [], version=version) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, target, linker=linker) if 'ifort (IFORT)' in out: cls = fortran.IntelFortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'ifx (IFORT)' in out or 'ifx (IFX)' in out: cls = fortran.IntelLLVMFortranCompiler linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'PathScale EKOPath(tm)' in err: return fortran.PathScaleFortranCompiler( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version) if 'PGI Compilers' in out: @@ -837,7 +834,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C linker = linkers.PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'NVIDIA Compilers and Tools' in out: @@ -846,7 +843,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C linker = linkers.PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) def _get_linker_try_windows(cls: T.Type['Compiler']) -> T.Optional['DynamicLinker']: @@ -871,14 +868,14 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C cls = fortran.LlvmFlangFortranCompiler linker = _get_linker_try_windows(cls) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'flang' in out or 'clang' in out: cls = fortran.ClassicFlangFortranCompiler linker = _get_linker_try_windows(cls) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'Open64 Compiler Suite' in err: @@ -886,7 +883,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C linker = guess_nix_linker(env, compiler, cls, version, for_machine) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) if 'NAG Fortran' in err: @@ -898,7 +895,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C compiler, for_machine, cls.LINKER_PREFIX, [], version=version) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, full_version=full_version, linker=linker) _handle_exceptions(popen_exceptions, compilers) @@ -916,7 +913,6 @@ def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine: compilers, ccache_exe = _get_compilers(env, lang, for_machine) ccache = ccache_exe.get_command() if (ccache_exe and ccache_exe.found()) else [] is_cross = env.is_cross_build(for_machine) - info = env.machines[for_machine] comp: T.Union[T.Type[objc.ObjCCompiler], T.Type[objcpp.ObjCPPCompiler]] for compiler in compilers: @@ -936,7 +932,7 @@ def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine: comp = objc.GnuObjCCompiler if lang == 'objc' else objcpp.GnuObjCPPCompiler linker = guess_nix_linker(env, compiler, comp, version, for_machine) c = comp( - ccache, compiler, version, for_machine, is_cross, info, + ccache, compiler, version, for_machine, is_cross, env, defines, linker=linker) if not c.compiles('int main(void) { return 0; }', env)[0]: popen_exceptions[join_args(compiler)] = f'GCC was not built with support for {"objective-c" if lang == "objc" else "objective-c++"}' @@ -963,14 +959,13 @@ def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine: linker = guess_nix_linker(env, compiler, comp, version, for_machine) return comp( ccache, compiler, version, for_machine, - is_cross, info, linker=linker, defines=defines) + is_cross, env, linker=linker, defines=defines) _handle_exceptions(popen_exceptions, compilers) raise EnvironmentException('Unreachable code (exception to make mypy happy)') def detect_java_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: from .java import JavaCompiler exelist = env.lookup_binary_entry(for_machine, 'java') - info = env.machines[for_machine] if exelist is None: # TODO support fallback exelist = [defaults['java'][0]] @@ -987,14 +982,13 @@ def detect_java_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp version = parts[1] comp_class = JavaCompiler env.add_lang_args(comp_class.language, comp_class, for_machine) - return comp_class(exelist, version, for_machine, info) + return comp_class(exelist, version, for_machine, env) raise EnvironmentException('Unknown compiler: ' + join_args(exelist)) def detect_cs_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: from . import cs compilers, ccache = _get_compilers(env, 'cs', for_machine) popen_exceptions = {} - info = env.machines[for_machine] for comp in compilers: try: p, out, err = Popen_safe_logged(comp + ['--version'], msg='Detecting compiler via') @@ -1011,7 +1005,7 @@ def detect_cs_compiler(env: 'Environment', for_machine: MachineChoice) -> Compil else: continue env.add_lang_args(cls.language, cls, for_machine) - return cls(comp, version, for_machine, info) + return cls(comp, version, for_machine, env) _handle_exceptions(popen_exceptions, compilers) raise EnvironmentException('Unreachable code (exception to make mypy happy)') @@ -1021,7 +1015,6 @@ def detect_cython_compiler(env: 'Environment', for_machine: MachineChoice) -> Co from .cython import CythonCompiler compilers, _ = _get_compilers(env, 'cython', MachineChoice.BUILD) is_cross = env.is_cross_build(for_machine) - info = env.machines[for_machine] popen_exceptions: T.Dict[str, Exception] = {} for comp in compilers: @@ -1041,7 +1034,7 @@ def detect_cython_compiler(env: 'Environment', for_machine: MachineChoice) -> Co if version is not None: comp_class = CythonCompiler env.add_lang_args(comp_class.language, comp_class, for_machine) - return comp_class([], comp, version, for_machine, info, is_cross=is_cross) + return comp_class([], comp, version, for_machine, env, is_cross=is_cross) _handle_exceptions(popen_exceptions, compilers) raise EnvironmentException('Unreachable code (exception to make mypy happy)') @@ -1049,7 +1042,6 @@ def detect_vala_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp from .vala import ValaCompiler exelist = env.lookup_binary_entry(MachineChoice.BUILD, 'vala') is_cross = env.is_cross_build(for_machine) - info = env.machines[for_machine] if exelist is None: # TODO support fallback exelist = [defaults['vala'][0]] @@ -1062,7 +1054,7 @@ def detect_vala_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp if 'Vala' in out: comp_class = ValaCompiler env.add_lang_args(comp_class.language, comp_class, for_machine) - return comp_class(exelist, version, for_machine, is_cross, info) + return comp_class(exelist, version, for_machine, is_cross, env) raise EnvironmentException('Unknown compiler: ' + join_args(exelist)) def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> RustCompiler: @@ -1071,7 +1063,6 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust popen_exceptions: T.Dict[str, Exception] = {} compilers, _ = _get_compilers(env, 'rust', for_machine) is_cross = env.is_cross_build(for_machine) - info = env.machines[for_machine] cc = detect_c_compiler(env, for_machine) is_link_exe = isinstance(cc.linker, linkers.VisualStudioLikeLinkerMixin) @@ -1185,7 +1176,7 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust env.add_lang_args(cls.language, cls, for_machine) return cls( - compiler, version, for_machine, is_cross, info, + compiler, version, for_machine, is_cross, env, linker=linker, full_version=full_version) _handle_exceptions(popen_exceptions, compilers) @@ -1193,7 +1184,6 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler: from . import c, d - info = env.machines[for_machine] # Detect the target architecture, required for proper architecture handling on Windows. # MSVC compiler is required for correct platform detection. @@ -1208,6 +1198,7 @@ def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compile popen_exceptions = {} is_cross = env.is_cross_build(for_machine) + info = env.machines[for_machine] compilers, ccache = _get_compilers(env, 'd', for_machine) cls: T.Type[d.DCompiler] for exelist in compilers: @@ -1264,14 +1255,14 @@ def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compile windows_proof_rm(objfile) return cls( - exelist, version, for_machine, info, arch, + exelist, version, for_machine, env, arch, full_version=full_version, linker=linker, is_cross=is_cross, version_output=out) elif 'gdc' in out: cls = d.GnuDCompiler linker = guess_nix_linker(env, exelist, cls, version, for_machine) return cls( - exelist, version, for_machine, info, arch, + exelist, version, for_machine, env, arch, is_cross=is_cross, full_version=full_version, linker=linker) elif 'The D Language Foundation' in out or 'Digital Mars' in out: cls = d.DmdDCompiler @@ -1301,7 +1292,7 @@ def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compile windows_proof_rm(objfile) return cls( - exelist, version, for_machine, info, arch, + exelist, version, for_machine, env, arch, full_version=full_version, linker=linker) raise EnvironmentException('Unknown compiler: ' + join_args(exelist)) @@ -1312,7 +1303,6 @@ def detect_swift_compiler(env: 'Environment', for_machine: MachineChoice) -> Com from .swift import SwiftCompiler exelist = env.lookup_binary_entry(for_machine, 'swift') is_cross = env.is_cross_build(for_machine) - info = env.machines[for_machine] if exelist is None: # TODO support fallback exelist = [defaults['swift'][0]] @@ -1330,7 +1320,7 @@ def detect_swift_compiler(env: 'Environment', for_machine: MachineChoice) -> Com exelist, cls, version, for_machine, extra_args=[f.name, '-o', '/dev/null']) return cls( - exelist, version, for_machine, is_cross, info, linker=linker) + exelist, version, for_machine, is_cross, env, linker=linker) raise EnvironmentException('Unknown compiler: ' + join_args(exelist)) @@ -1344,10 +1334,6 @@ def detect_nasm_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp # We need a C compiler to properly detect the machine info and linker cc = detect_c_compiler(env, for_machine) - if not is_cross: - info = detect_machine_info({'c': cc}) - else: - info = env.machines[for_machine] popen_exceptions: T.Dict[str, Exception] = {} for comp in compilers: @@ -1366,20 +1352,20 @@ def detect_nasm_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp if 'NASM' in output: comp_class = NasmCompiler env.add_lang_args(comp_class.language, comp_class, for_machine) - return comp_class([], comp, version, for_machine, info, cc.linker, is_cross=is_cross) + return comp_class([], comp, version, for_machine, env, cc.linker, is_cross=is_cross) elif 'yasm' in output: comp_class = YasmCompiler env.add_lang_args(comp_class.language, comp_class, for_machine) - return comp_class([], comp, version, for_machine, info, cc.linker, is_cross=is_cross) + return comp_class([], comp, version, for_machine, env, cc.linker, is_cross=is_cross) elif 'Metrowerks' in output or 'Freescale' in output: if 'ARM' in output: comp_class_mwasmarm = MetrowerksAsmCompilerARM env.add_lang_args(comp_class_mwasmarm.language, comp_class_mwasmarm, for_machine) - return comp_class_mwasmarm([], comp, version, for_machine, info, cc.linker, is_cross=is_cross) + return comp_class_mwasmarm([], comp, version, for_machine, env, cc.linker, is_cross=is_cross) else: comp_class_mwasmeppc = MetrowerksAsmCompilerEmbeddedPowerPC env.add_lang_args(comp_class_mwasmeppc.language, comp_class_mwasmeppc, for_machine) - return comp_class_mwasmeppc([], comp, version, for_machine, info, cc.linker, is_cross=is_cross) + return comp_class_mwasmeppc([], comp, version, for_machine, env, cc.linker, is_cross=is_cross) _handle_exceptions(popen_exceptions, compilers) raise EnvironmentException('Unreachable code (exception to make mypy happy)') @@ -1419,7 +1405,7 @@ def detect_masm_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp output = Popen_safe(comp + [arg])[2] version = search_version(output) env.add_lang_args(comp_class.language, comp_class, for_machine) - return comp_class([], comp, version, for_machine, info, cc.linker, is_cross=is_cross) + return comp_class([], comp, version, for_machine, env, cc.linker, is_cross=is_cross) except OSError as e: popen_exceptions[' '.join(comp + [arg])] = e _handle_exceptions(popen_exceptions, [comp]) @@ -1430,7 +1416,6 @@ def detect_linearasm_compiler(env: Environment, for_machine: MachineChoice) -> C comp = ['cl6x'] comp_class: T.Type[ASMCompiler] = TILinearAsmCompiler arg = '-h' - info = env.machines[for_machine] cc = detect_c_compiler(env, for_machine) is_cross = env.is_cross_build(for_machine) @@ -1439,7 +1424,7 @@ def detect_linearasm_compiler(env: Environment, for_machine: MachineChoice) -> C output = Popen_safe(comp + [arg])[2] version = search_version(output) env.add_lang_args(comp_class.language, comp_class, for_machine) - return comp_class([], comp, version, for_machine, info, cc.linker, is_cross=is_cross) + return comp_class([], comp, version, for_machine, env, cc.linker, is_cross=is_cross) except OSError as e: popen_exceptions[' '.join(comp + [arg])] = e _handle_exceptions(popen_exceptions, [comp]) diff --git a/mesonbuild/compilers/fortran.py b/mesonbuild/compilers/fortran.py index 6f4f3d2c1..447094ce9 100644 --- a/mesonbuild/compilers/fortran.py +++ b/mesonbuild/compilers/fortran.py @@ -29,7 +29,6 @@ from mesonbuild.mesonlib import ( if T.TYPE_CHECKING: from ..options import MutableKeyedOptionDictType from ..dependencies import Dependency - from ..envconfig import MachineInfo from ..environment import Environment from ..linkers.linkers import DynamicLinker from ..mesonlib import MachineChoice @@ -41,10 +40,9 @@ class FortranCompiler(CLikeCompiler, Compiler): language = 'fortran' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): - Compiler.__init__(self, [], exelist, version, for_machine, info, + Compiler.__init__(self, [], exelist, version, for_machine, env, is_cross=is_cross, full_version=full_version, linker=linker) CLikeCompiler.__init__(self) @@ -260,12 +258,12 @@ class FortranCompiler(CLikeCompiler, Compiler): class GnuFortranCompiler(GnuCompiler, FortranCompiler): def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', + env: Environment, defines: T.Optional[T.Dict[str, str]] = None, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) GnuCompiler.__init__(self, defines) default_warn_args = ['-Wall'] @@ -328,12 +326,12 @@ class GnuFortranCompiler(GnuCompiler, FortranCompiler): class ElbrusFortranCompiler(ElbrusCompiler, FortranCompiler): def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', + env: Environment, defines: T.Optional[T.Dict[str, str]] = None, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) ElbrusCompiler.__init__(self) def get_options(self) -> 'MutableKeyedOptionDictType': @@ -351,11 +349,10 @@ class G95FortranCompiler(FortranCompiler): id = 'g95' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) default_warn_args = ['-Wall'] self.warn_args = {'0': [], @@ -397,11 +394,10 @@ class IntelFortranCompiler(IntelGnuLikeCompiler, FortranCompiler): id = 'intel' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) # FIXME: Add support for OS X and Windows in detect_fortran_compiler so # we are sent the type of compiler @@ -457,11 +453,11 @@ class IntelClFortranCompiler(IntelVisualStudioLikeCompiler, FortranCompiler): always_args = ['/nologo'] def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', target: str, + is_cross: bool, env: Environment, target: str, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) IntelVisualStudioLikeCompiler.__init__(self, target) self.file_suffixes = ('f90', 'f', 'for', 'ftn', 'fpp', ) @@ -503,11 +499,10 @@ class PathScaleFortranCompiler(FortranCompiler): id = 'pathscale' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) default_warn_args = ['-fullwarn'] self.warn_args = {'0': [], @@ -523,11 +518,10 @@ class PathScaleFortranCompiler(FortranCompiler): class PGIFortranCompiler(PGICompiler, FortranCompiler): def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) PGICompiler.__init__(self) @@ -549,11 +543,10 @@ class NvidiaHPC_FortranCompiler(PGICompiler, FortranCompiler): id = 'nvidia_hpc' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) PGICompiler.__init__(self) @@ -570,11 +563,10 @@ class ClassicFlangFortranCompiler(ClangCompiler, FortranCompiler): id = 'flang' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) ClangCompiler.__init__(self, {}) default_warn_args = ['-Minform=inform'] @@ -606,10 +598,10 @@ class LlvmFlangFortranCompiler(ClangCompiler, FortranCompiler): id = 'llvm-flang' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) ClangCompiler.__init__(self, {}) default_warn_args = ['-Wall'] @@ -660,11 +652,10 @@ class Open64FortranCompiler(FortranCompiler): id = 'open64' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) default_warn_args = ['-fullwarn'] self.warn_args = {'0': [], @@ -682,11 +673,10 @@ class NAGFortranCompiler(FortranCompiler): id = 'nagfor' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool, - info: 'MachineInfo', - linker: T.Optional['DynamicLinker'] = None, + env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): FortranCompiler.__init__(self, exelist, version, for_machine, - is_cross, info, linker=linker, + is_cross, env, linker=linker, full_version=full_version) # Warnings are on by default; -w disables (by category): self.warn_args = { diff --git a/mesonbuild/compilers/java.py b/mesonbuild/compilers/java.py index 47d2ac9cd..7db9af86a 100644 --- a/mesonbuild/compilers/java.py +++ b/mesonbuild/compilers/java.py @@ -15,7 +15,6 @@ from .compilers import Compiler from .mixins.islinker import BasicLinkerIsCompilerMixin if T.TYPE_CHECKING: - from ..envconfig import MachineInfo from ..environment import Environment from ..mesonlib import MachineChoice @@ -38,8 +37,8 @@ class JavaCompiler(BasicLinkerIsCompilerMixin, Compiler): } def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - info: 'MachineInfo', full_version: T.Optional[str] = None): - super().__init__([], exelist, version, for_machine, info, full_version=full_version) + env: Environment, full_version: T.Optional[str] = None): + super().__init__([], exelist, version, for_machine, env, full_version=full_version) self.javarunner = 'java' def get_warn_args(self, level: str) -> T.List[str]: diff --git a/mesonbuild/compilers/mixins/apple.py b/mesonbuild/compilers/mixins/apple.py index ca655384d..a66c682a9 100644 --- a/mesonbuild/compilers/mixins/apple.py +++ b/mesonbuild/compilers/mixins/apple.py @@ -11,6 +11,7 @@ from ...mesonlib import MesonException if T.TYPE_CHECKING: from ..._typing import ImmutableListProtocol from ...environment import Environment + from ...envconfig import MachineInfo from ..compilers import Compiler else: # This is a bit clever, for mypy we pretend that these mixins descend from @@ -26,6 +27,10 @@ class AppleCompilerMixin(Compiler): __BASE_OMP_FLAGS: ImmutableListProtocol[str] = ['-Xpreprocessor', '-fopenmp'] + if T.TYPE_CHECKING: + # Older versions of mypy can't figure this out + info: MachineInfo + def openmp_flags(self, env: Environment) -> T.List[str]: """Flags required to compile with OpenMP on Apple. diff --git a/mesonbuild/compilers/objc.py b/mesonbuild/compilers/objc.py index d013417fc..8cbe2933d 100644 --- a/mesonbuild/compilers/objc.py +++ b/mesonbuild/compilers/objc.py @@ -15,7 +15,6 @@ from .mixins.clike import CLikeCompiler from .mixins.gnu import GnuCompiler, GnuCStds, gnu_common_warning_args, gnu_objc_warning_args if T.TYPE_CHECKING: - from ..envconfig import MachineInfo from ..environment import Environment from ..linkers.linkers import DynamicLinker from ..mesonlib import MachineChoice @@ -28,10 +27,10 @@ class ObjCCompiler(CLikeCompiler, Compiler): language = 'objc' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): - Compiler.__init__(self, ccache, exelist, version, for_machine, info, + Compiler.__init__(self, ccache, exelist, version, for_machine, env, is_cross=is_cross, full_version=full_version, linker=linker) CLikeCompiler.__init__(self) @@ -60,12 +59,12 @@ class ObjCCompiler(CLikeCompiler, Compiler): class GnuObjCCompiler(GnuCStds, GnuCompiler, ObjCCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, defines: T.Optional[T.Dict[str, str]] = None, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): ObjCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) GnuCompiler.__init__(self, defines) default_warn_args = ['-Wall', '-Winvalid-pch'] self.warn_args = {'0': [], @@ -90,12 +89,12 @@ class GnuObjCCompiler(GnuCStds, GnuCompiler, ObjCCompiler): class ClangObjCCompiler(ClangCStds, ClangCompiler, ObjCCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, defines: T.Optional[T.Dict[str, str]] = None, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): ObjCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) ClangCompiler.__init__(self, defines) default_warn_args = ['-Wall', '-Winvalid-pch'] self.warn_args = {'0': [], diff --git a/mesonbuild/compilers/objcpp.py b/mesonbuild/compilers/objcpp.py index 441428b2f..d205dd1fc 100644 --- a/mesonbuild/compilers/objcpp.py +++ b/mesonbuild/compilers/objcpp.py @@ -15,7 +15,6 @@ from .mixins.clang import ClangCompiler, ClangCPPStds from .mixins.clike import CLikeCompiler if T.TYPE_CHECKING: - from ..envconfig import MachineInfo from ..environment import Environment from ..linkers.linkers import DynamicLinker from ..mesonlib import MachineChoice @@ -28,10 +27,10 @@ class ObjCPPCompiler(CLikeCompiler, Compiler): language = 'objcpp' def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): - Compiler.__init__(self, ccache, exelist, version, for_machine, info, + Compiler.__init__(self, ccache, exelist, version, for_machine, env, is_cross=is_cross, full_version=full_version, linker=linker) CLikeCompiler.__init__(self) @@ -65,12 +64,12 @@ class ObjCPPCompiler(CLikeCompiler, Compiler): class GnuObjCPPCompiler(GnuCPPStds, GnuCompiler, ObjCPPCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, defines: T.Optional[T.Dict[str, str]] = None, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): ObjCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) GnuCompiler.__init__(self, defines) default_warn_args = ['-Wall', '-Winvalid-pch'] self.warn_args = {'0': [], @@ -96,12 +95,12 @@ class GnuObjCPPCompiler(GnuCPPStds, GnuCompiler, ObjCPPCompiler): class ClangObjCPPCompiler(ClangCPPStds, ClangCompiler, ObjCPPCompiler): def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, defines: T.Optional[T.Dict[str, str]] = None, linker: T.Optional['DynamicLinker'] = None, full_version: T.Optional[str] = None): ObjCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, - info, linker=linker, full_version=full_version) + env, linker=linker, full_version=full_version) ClangCompiler.__init__(self, defines) default_warn_args = ['-Wall', '-Winvalid-pch'] self.warn_args = {'0': [], diff --git a/mesonbuild/compilers/rust.py b/mesonbuild/compilers/rust.py index 8d5a0b5dc..55c58b56a 100644 --- a/mesonbuild/compilers/rust.py +++ b/mesonbuild/compilers/rust.py @@ -18,7 +18,6 @@ from .compilers import Compiler, CompileCheckMode, clike_debug_args, is_library if T.TYPE_CHECKING: from ..options import MutableKeyedOptionDictType - from ..envconfig import MachineInfo from ..environment import Environment # noqa: F401 from ..linkers.linkers import DynamicLinker from ..mesonlib import MachineChoice @@ -99,10 +98,10 @@ class RustCompiler(Compiler): } def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', + is_cross: bool, env: Environment, full_version: T.Optional[str] = None, linker: T.Optional['DynamicLinker'] = None): - super().__init__([], exelist, version, for_machine, info, + super().__init__([], exelist, version, for_machine, env, is_cross=is_cross, full_version=full_version, linker=linker) self.rustup_run_and_args: T.Optional[T.Tuple[T.List[str], T.List[str]]] = get_rustup_run_and_args(exelist) @@ -463,7 +462,8 @@ class RustCompiler(Compiler): return None return RustdocTestCompiler(exelist, self.version, self.for_machine, - self.is_cross, self.info, full_version=self.full_version, + self.is_cross, self.environment, + full_version=self.full_version, linker=self.linker, rustc=self) def enable_env_set_args(self) -> T.Optional[T.List[str]]: @@ -494,11 +494,10 @@ class RustdocTestCompiler(RustCompiler): id = 'rustdoc --test' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', - full_version: T.Optional[str], + is_cross: bool, env: Environment, full_version: T.Optional[str], linker: T.Optional['DynamicLinker'], rustc: RustCompiler): super().__init__(exelist, version, for_machine, - is_cross, info, full_version, linker) + is_cross, env, full_version, linker) self.rustc = rustc @functools.lru_cache(maxsize=None) diff --git a/mesonbuild/compilers/swift.py b/mesonbuild/compilers/swift.py index 4ad3affb5..80c104bdb 100644 --- a/mesonbuild/compilers/swift.py +++ b/mesonbuild/compilers/swift.py @@ -16,7 +16,6 @@ if T.TYPE_CHECKING: from .. import build from ..options import MutableKeyedOptionDictType from ..dependencies import Dependency - from ..envconfig import MachineInfo from ..environment import Environment from ..linkers.linkers import DynamicLinker from ..mesonlib import MachineChoice @@ -38,9 +37,9 @@ class SwiftCompiler(Compiler): id = 'llvm' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo', full_version: T.Optional[str] = None, + is_cross: bool, env: Environment, full_version: T.Optional[str] = None, linker: T.Optional['DynamicLinker'] = None): - super().__init__([], exelist, version, for_machine, info, + super().__init__([], exelist, version, for_machine, env, is_cross=is_cross, full_version=full_version, linker=linker) self.version = version diff --git a/mesonbuild/compilers/vala.py b/mesonbuild/compilers/vala.py index a3a196093..da05f88d2 100644 --- a/mesonbuild/compilers/vala.py +++ b/mesonbuild/compilers/vala.py @@ -14,7 +14,6 @@ from .compilers import CompileCheckMode, Compiler if T.TYPE_CHECKING: from ..arglist import CompilerArgs - from ..envconfig import MachineInfo from ..environment import Environment from ..mesonlib import MachineChoice from ..dependencies import Dependency @@ -26,8 +25,8 @@ class ValaCompiler(Compiler): id = 'valac' def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, - is_cross: bool, info: 'MachineInfo'): - super().__init__([], exelist, version, for_machine, info, is_cross=is_cross) + is_cross: bool, environment: Environment): + super().__init__([], exelist, version, for_machine, environment, is_cross=is_cross) self.version = version self.base_options = {OptionKey('b_colorout')} self.force_link = False diff --git a/unittests/internaltests.py b/unittests/internaltests.py index 8bc9c00c5..b5dad878b 100644 --- a/unittests/internaltests.py +++ b/unittests/internaltests.py @@ -109,7 +109,7 @@ class InternalTests(unittest.TestCase): stat.S_IRGRP | stat.S_IXGRP) def test_compiler_args_class_none_flush(self): - cc = ClangCCompiler([], [], 'fake', MachineChoice.HOST, False, mock.Mock()) + cc = ClangCCompiler([], [], 'fake', MachineChoice.HOST, False, get_fake_env()) a = cc.compiler_args(['-I.']) #first we are checking if the tree construction deduplicates the correct -I argument a += ['-I..'] @@ -126,14 +126,14 @@ class InternalTests(unittest.TestCase): self.assertEqual(a, ['-I.', '-I./tests2/', '-I./tests/', '-I..']) def test_compiler_args_class_d(self): - d = DmdDCompiler([], 'fake', MachineChoice.HOST, 'info', 'arch') + d = DmdDCompiler([], 'fake', MachineChoice.HOST, get_fake_env(), 'arch') # check include order is kept when deduplicating a = d.compiler_args(['-Ifirst', '-Isecond', '-Ithird']) a += ['-Ifirst'] self.assertEqual(a, ['-Ifirst', '-Isecond', '-Ithird']) def test_compiler_args_class_clike(self): - cc = ClangCCompiler([], [], 'fake', MachineChoice.HOST, False, mock.Mock()) + cc = ClangCCompiler([], [], 'fake', MachineChoice.HOST, False, get_fake_env()) # Test that empty initialization works a = cc.compiler_args() self.assertEqual(a, []) @@ -216,7 +216,7 @@ class InternalTests(unittest.TestCase): def test_compiler_args_class_visualstudio(self): linker = linkers.MSVCDynamicLinker(MachineChoice.HOST, []) # Version just needs to be > 19.0.0 - cc = VisualStudioCPPCompiler([], [], '20.00', MachineChoice.HOST, False, mock.Mock(), 'x64', linker=linker) + cc = VisualStudioCPPCompiler([], [], '20.00', MachineChoice.HOST, False, get_fake_env(), 'x64', linker=linker) a = cc.compiler_args(cc.get_always_args()) self.assertEqual(a.to_native(copy=True), ['/nologo', '/showIncludes', '/utf-8', '/Zc:__cplusplus']) @@ -237,7 +237,7 @@ class InternalTests(unittest.TestCase): def test_compiler_args_class_gnuld(self): ## Test --start/end-group linker = linkers.GnuBFDDynamicLinker([], MachineChoice.HOST, '-Wl,', []) - gcc = GnuCCompiler([], [], 'fake', False, MachineChoice.HOST, mock.Mock(), linker=linker) + gcc = GnuCCompiler([], [], 'fake', MachineChoice.HOST, False, get_fake_env(), linker=linker) ## Ensure that the fake compiler is never called by overriding the relevant function gcc.get_default_include_dirs = lambda: ['/usr/include', '/usr/share/include', '/usr/local/include'] ## Test that 'direct' append and extend works @@ -265,7 +265,7 @@ class InternalTests(unittest.TestCase): def test_compiler_args_remove_system(self): ## Test --start/end-group linker = linkers.GnuBFDDynamicLinker([], MachineChoice.HOST, '-Wl,', []) - gcc = GnuCCompiler([], [], 'fake', False, MachineChoice.HOST, mock.Mock(), linker=linker) + gcc = GnuCCompiler([], [], 'fake', MachineChoice.HOST, False, get_fake_env(), linker=linker) ## Ensure that the fake compiler is never called by overriding the relevant function gcc.get_default_include_dirs = lambda: ['/usr/include', '/usr/share/include', '/usr/local/include'] ## Test that 'direct' append and extend works @@ -1636,7 +1636,7 @@ class InternalTests(unittest.TestCase): ('aarch64_be', 'aarch64'), ] - cc = ClangCCompiler([], [], 'fake', MachineChoice.HOST, False, mock.Mock()) + cc = ClangCCompiler([], [], 'fake', MachineChoice.HOST, False, get_fake_env()) with mock.patch('mesonbuild.envconfig.any_compiler_has_define', mock.Mock(return_value=False)): for test, expected in cases: @@ -1685,7 +1685,7 @@ class InternalTests(unittest.TestCase): ('aarch64_be', 'aarch64'), ] - cc = ClangCCompiler([], [], 'fake', MachineChoice.HOST, False, mock.Mock()) + cc = ClangCCompiler([], [], 'fake', MachineChoice.HOST, False, get_fake_env()) with mock.patch('mesonbuild.envconfig.any_compiler_has_define', mock.Mock(return_value=False)): for test, expected in cases: |