开源软件构建与测试

_service:tar_scm:meson.spec Changed

_service Changed

_service:tar_scm:meson-0.61.5.tar.gz/.lgtm.yml Deleted

_service:tar_scm:meson-0.61.5.tar.gz/data/syntax-highlighting/emacs Deleted

_service:tar_scm:meson-0.61.5.tar.gz/data/syntax-highlighting/emacs/meson.el Deleted

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/RPM-module.md Deleted

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/cmake/client.py Deleted

@@ -1,373 +0,0 @@
-# Copyright 2019 The Meson development team
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# This class contains the basic functionality needed to run any interpreter
-# or an interpreter-based tool.
-
-from .common import CMakeException, CMakeConfiguration, CMakeBuildFile
-from .. import mlog
-from contextlib import contextmanager
-from subprocess import Popen, PIPE, TimeoutExpired
-from pathlib import Path
-import typing as T
-import json
-
-if T.TYPE_CHECKING:
-    from ..environment import Environment
-    from .executor import CMakeExecutor
-
-CMAKE_SERVER_BEGIN_STR = '== "CMake Server" =='
-CMAKE_SERVER_END_STR = '== "CMake Server" =='
-
-CMAKE_MESSAGE_TYPES = {
-    'error': 'cookie', 'errorMessage',
-    'hello': 'supportedProtocolVersions',
-    'message': 'cookie', 'message',
-    'progress': 'cookie',
-    'reply': 'cookie', 'inReplyTo',
-    'signal': 'cookie', 'name',
-}  # type: T.Dictstr, T.Liststr
-
-CMAKE_REPLY_TYPES = {
-    'handshake': ,
-    'configure': ,
-    'compute': ,
-    'cmakeInputs': 'buildFiles', 'cmakeRootDirectory', 'sourceDirectory',
-    'codemodel': 'configurations'
-}  # type: T.Dictstr, T.Liststr
-
-# Base CMake server message classes
-
-class MessageBase:
-    def __init__(self, msg_type: str, cookie: str) -> None:
-        self.type = msg_type
-        self.cookie = cookie
-
-    def to_dict(self) -> T.Dictstr, T.Unionstr, T.Liststr, T.Dictstr, int:
-        return {'type': self.type, 'cookie': self.cookie}
-
-    def log(self) -> None:
-        mlog.warning('CMake server message of type', mlog.bold(type(self).__name__), 'has no log function')
-
-class RequestBase(MessageBase):
-    cookie_counter = 0
-
-    def __init__(self, msg_type: str) -> None:
-        super().__init__(msg_type, self.gen_cookie())
-
-    @staticmethod
-    def gen_cookie() -> str:
-        RequestBase.cookie_counter += 1
-        return f'meson_{RequestBase.cookie_counter}'
-
-class ReplyBase(MessageBase):
-    def __init__(self, cookie: str, in_reply_to: str) -> None:
-        super().__init__('reply', cookie)
-        self.in_reply_to = in_reply_to
-
-class SignalBase(MessageBase):
-    def __init__(self, cookie: str, signal_name: str) -> None:
-        super().__init__('signal', cookie)
-        self.signal_name = signal_name
-
-    def log(self) -> None:
-        mlog.log(mlog.bold('CMake signal:'), mlog.yellow(self.signal_name))
-
-# Special Message classes
-
-class Error(MessageBase):
-    def __init__(self, cookie: str, message: str) -> None:
-        super().__init__('error', cookie)
-        self.message = message
-
-    def log(self) -> None:
-        mlog.error(mlog.bold('CMake server error:'), mlog.red(self.message))
-
-class Message(MessageBase):
-    def __init__(self, cookie: str, message: str) -> None:
-        super().__init__('message', cookie)
-        self.message = message
-
-    def log(self) -> None:
-        #mlog.log(mlog.bold('CMake:'), self.message)
-        pass
-
-class Progress(MessageBase):
-    def __init__(self, cookie: str) -> None:
-        super().__init__('progress', cookie)
-
-    def log(self) -> None:
-        pass
-
-class MessageHello(MessageBase):
-    def __init__(self, supported_protocol_versions: T.ListT.Dictstr, int) -> None:
-        super().__init__('hello', '')
-        self.supported_protocol_versions = supported_protocol_versions
-
-    def supports(self, major: int, minor: T.Optionalint = None) -> bool:
-        for i in self.supported_protocol_versions:
-            assert 'major' in i
-            assert 'minor' in i
-            if major == i'major':
-                if minor is None or minor == i'minor':
-                    return True
-        return False
-
-# Request classes
-
-class RequestHandShake(RequestBase):
-    def __init__(self, src_dir: Path, build_dir: Path, generator: str, vers_major: int, vers_minor: T.Optionalint = None) -> None:
-        super().__init__('handshake')
-        self.src_dir = src_dir
-        self.build_dir = build_dir
-        self.generator = generator
-        self.vers_major = vers_major
-        self.vers_minor = vers_minor
-
-    def to_dict(self) -> T.Dictstr, T.Unionstr, T.Liststr, T.Dictstr, int:
-        vers = {'major': self.vers_major}
-        if self.vers_minor is not None:
-            vers'minor' = self.vers_minor
-
-        # Old CMake versions (3.7) want '/' even on Windows
-        self.src_dir   = self.src_dir.resolve()
-        self.build_dir = self.build_dir.resolve()
-
-        return {
-            **super().to_dict(),
-            'sourceDirectory': self.src_dir.as_posix(),
-            'buildDirectory': self.build_dir.as_posix(),
-            'generator': self.generator,
-            'protocolVersion': vers
-        }
-
-class RequestConfigure(RequestBase):
-    def __init__(self, args: T.OptionalT.Liststr = None):
-        super().__init__('configure')
-        self.args = args
-
-    def to_dict(self) -> T.Dictstr, T.Unionstr, T.Liststr, T.Dictstr, int:
-        res = super().to_dict()
-        if self.args:
-            res'cacheArguments' = self.args
-        return res
-
-class RequestCompute(RequestBase):
-    def __init__(self) -> None:
-        super().__init__('compute')
-
-class RequestCMakeInputs(RequestBase):
-    def __init__(self) -> None:
-        super().__init__('cmakeInputs')
-
-class RequestCodeModel(RequestBase):
-    def __init__(self) -> None:
-        super().__init__('codemodel')
-
-# Reply classes
-
-class ReplyHandShake(ReplyBase):
-    def __init__(self, cookie: str) -> None:
-        super().__init__(cookie, 'handshake')
-
-class ReplyConfigure(ReplyBase):
-    def __init__(self, cookie: str) -> None:
-        super().__init__(cookie, 'configure')
-
-class ReplyCompute(ReplyBase):
-    def __init__(self, cookie: str) -> None:
-        super().__init__(cookie, 'compute')
-
-class ReplyCMakeInputs(ReplyBase):
-    def __init__(self, cookie: str, cmake_root: Path, src_dir: Path, build_files: T.ListCMakeBuildFile) -> None:
-        super().__init__(cookie, 'cmakeInputs')
-        self.cmake_root = cmake_root
-        self.src_dir = src_dir
-        self.build_files = build_files
-
-    def log(self) -> None:
-        mlog.log('CMake root: ', mlog.bold(self.cmake_root.as_posix()))
-        mlog.log('Source dir: ', mlog.bold(self.src_dir.as_posix()))
-        mlog.log('Build files:', mlog.bold(str(len(self.build_files))))
-        with mlog.nested():
-            for i in self.build_files:
-                mlog.log(str(i))
-
-class ReplyCodeModel(ReplyBase):
-    def __init__(self, data: T.Dictstr, T.Any) -> None:
-        super().__init__(data'cookie', 'codemodel')
-        self.configs = 
-        for i in data'configurations':
-            self.configs += CMakeConfiguration(i)
-
-    def log(self) -> None:
-        mlog.log('CMake code mode:')
-        for idx, i in enumerate(self.configs):
-            mlog.log(f'Configuration {idx}:')
-            with mlog.nested():
-                i.log()
-
-# Main client class
-
-class CMakeClient:
-    def __init__(self, env: 'Environment') -> None:
-        self.env = env
-        self.proc = None  # type: T.OptionalPopen
-        self.type_map = {
-            'error': lambda data: Error(data'cookie', data'errorMessage'),
-            'hello': lambda data: MessageHello(data'supportedProtocolVersions'),
-            'message': lambda data: Message(data'cookie', data'message'),
-            'progress': lambda data: Progress(data'cookie'),
-            'reply': self.resolve_type_reply,
-            'signal': lambda data: SignalBase(data'cookie', data'name')
-        }  # type: T.Dictstr, T.CallableT.Dictstr, T.Any, MessageBase
-
-        self.reply_map = {
-            'handshake': lambda data: ReplyHandShake(data'cookie'),
-            'configure': lambda data: ReplyConfigure(data'cookie'),
-            'compute': lambda data: ReplyCompute(data'cookie'),
-            'cmakeInputs': self.resolve_reply_cmakeInputs,
-            'codemodel': lambda data: ReplyCodeModel(data),
-        }  # type: T.Dictstr, T.CallableT.Dictstr, T.Any, ReplyBase
-
-    def readMessageRaw(self) -> T.Dictstr, T.Any:
-        assert self.proc is not None
-        rawData = 
-        begin = False
-        while self.proc.poll() is None:
-            line = self.proc.stdout.readline()
-            if not line:
-                break
-            line = line.decode('utf-8')
-            line = line.strip()
-
-            if begin and line == CMAKE_SERVER_END_STR:
-                break # End of the message
-            elif begin:
-                rawData += line
-            elif line == CMAKE_SERVER_BEGIN_STR:
-                begin = True # Begin of the message
-
-        if rawData:
-            res = json.loads('\n'.join(rawData))
-            assert isinstance(res, dict)
-            for i in res.keys():
-                assert isinstance(i, str)
-            return res
-        raise CMakeException('Failed to read data from the CMake server')
-
-    def readMessage(self) -> MessageBase:
-        raw_data = self.readMessageRaw()
-        if 'type' not in raw_data:
-            raise CMakeException('The "type" attribute is missing from the message')
-        msg_type = raw_data'type'
-        func = self.type_map.get(msg_type, None)
-        if not func:
-            raise CMakeException(f'Recieved unknown message type "{msg_type}"')
-        for i in CMAKE_MESSAGE_TYPESmsg_type:
-            if i not in raw_data:
-                raise CMakeException(f'Key "{i}" is missing from CMake server message type {msg_type}')
-        return func(raw_data)
-
-    def writeMessage(self, msg: MessageBase) -> None:
-        raw_data = '\n{}\n{}\n{}\n'.format(CMAKE_SERVER_BEGIN_STR, json.dumps(msg.to_dict(), indent=2), CMAKE_SERVER_END_STR)
-        self.proc.stdin.write(raw_data.encode('ascii'))
-        self.proc.stdin.flush()
-
-    def query(self, request: RequestBase) -> MessageBase:
-        self.writeMessage(request)
-        while True:
-            reply = self.readMessage()
-            if reply.cookie == request.cookie and reply.type in 'reply', 'error':
-                return reply
-
-            reply.log()
-
-    def query_checked(self, request: RequestBase, message: str) -> MessageBase:
-        reply = self.query(request)
-        h = mlog.green('SUCCEEDED') if reply.type == 'reply' else mlog.red('FAILED')
-        mlog.log(message + ':', h)
-        if reply.type != 'reply':
-            reply.log()
-            raise CMakeException('CMake server query failed')
-        return reply
-
-    def do_handshake(self, src_dir: Path, build_dir: Path, generator: str, vers_major: int, vers_minor: T.Optionalint = None) -> None:
-        # CMake prints the hello message on startup
-        msg = self.readMessage()
-        if not isinstance(msg, MessageHello):
-            raise CMakeException('Recieved an unexpected message from the CMake server')
-
-        request = RequestHandShake(src_dir, build_dir, generator, vers_major, vers_minor)
-        self.query_checked(request, 'CMake server handshake')
-
-    def resolve_type_reply(self, data: T.Dictstr, T.Any) -> ReplyBase:
-        reply_type = data'inReplyTo'
-        func = self.reply_map.get(reply_type, None)
-        if not func:
-            raise CMakeException(f'Recieved unknown reply type "{reply_type}"')
-        for i in 'cookie' + CMAKE_REPLY_TYPESreply_type:
-            if i not in data:
-                raise CMakeException(f'Key "{i}" is missing from CMake server message type {type}')
-        return func(data)
-
-    def resolve_reply_cmakeInputs(self, data: T.Dictstr, T.Any) -> ReplyCMakeInputs:
-        files = 
-        for i in data'buildFiles':
-            for j in i'sources':
-                files += CMakeBuildFile(Path(j), i'isCMake', i'isTemporary')
-        return ReplyCMakeInputs(data'cookie', Path(data'cmakeRootDirectory'), Path(data'sourceDirectory'), files)
-
-    @contextmanager
-    def connect(self, cmake_exe: 'CMakeExecutor') -> T.GeneratorNone, None, None:
-        self.startup(cmake_exe)
-        try:
-            yield
-        finally:
-            self.shutdown()
-
-    def startup(self, cmake_exe: 'CMakeExecutor') -> None:
-        if self.proc is not None:
-            raise CMakeException('The CMake server was already started')
-        assert cmake_exe.found()
-
-        mlog.debug('Starting CMake server with CMake', mlog.bold(' '.join(cmake_exe.get_command())), 'version', mlog.cyan(cmake_exe.version()))
-        self.proc = Popen(cmake_exe.get_command() + '-E', 'server', '--experimental', '--debug', stdin=PIPE, stdout=PIPE)
-
-    def shutdown(self) -> None:
-        if self.proc is None:
-            return
-
-        mlog.debug('Shutting down the CMake server')
-
-        # Close the pipes to exit
-        self.proc.stdin.close()
-        self.proc.stdout.close()
-
-        # Wait for CMake to finish
-        try:
-            self.proc.wait(timeout=2)
-        except TimeoutExpired:
-            # Terminate CMake if there is a timeout
-            # terminate() may throw a platform specific exception if the process has already
-            # terminated. This may be the case if there is a race condition (CMake exited after
-            # the timeout but before the terminate() call). Additionally, this behavior can
-            # also be triggered on cygwin if CMake crashes.
-            # See https://github.com/mesonbuild/meson/pull/4969#issuecomment-499413233
-            try:
-                self.proc.terminate()
-            except Exception:
-                pass
-
-        self.proc = None

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/c2000.py Deleted

@@ -1,131 +0,0 @@
-# Copyright 2012-2019 The Meson development team
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Representations specific to the Texas Instruments C2000 compiler family."""
-
-import os
-import typing as T
-
-from ...mesonlib import EnvironmentException
-
-if T.TYPE_CHECKING:
-    from ...environment import Environment
-    from ...compilers.compilers import Compiler
-else:
-    # This is a bit clever, for mypy we pretend that these mixins descend from
-    # Compiler, so we get all of the methods and attributes defined for us, but
-    # for runtime we make them descend from object (which all classes normally
-    # do). This gives up DRYer type checking, with no runtime impact
-    Compiler = object
-
-c2000_buildtype_args = {
-    'plain': ,
-    'debug': ,
-    'debugoptimized': ,
-    'release': ,
-    'minsize': ,
-    'custom': ,
-}  # type: T.Dictstr, T.Liststr
-
-c2000_optimization_args = {
-    '0': '-O0',
-    'g': '-Ooff',
-    '1': '-O1',
-    '2': '-O2',
-    '3': '-O3',
-    's': '-04'
-}  # type: T.Dictstr, T.Liststr
-
-c2000_debug_args = {
-    False: ,
-    True: '-g'
-}  # type: T.Dictbool, T.Liststr
-
-
-class C2000Compiler(Compiler):
-
-    def __init__(self) -> None:
-        if not self.is_cross:
-            raise EnvironmentException('c2000 supports only cross-compilation.')
-        self.id = 'c2000'
-
-        self.can_compile_suffixes.add('asm')    # Assembly
-        self.can_compile_suffixes.add('cla')    # Control Law Accelerator (CLA)
-
-        default_warn_args =   # type: T.Liststr
-        self.warn_args = {'0': ,
-                          '1': default_warn_args,
-                          '2': default_warn_args + ,
-                          '3': default_warn_args + }  # type: T.Dictstr, T.Liststr
-
-    def get_pic_args(self) -> T.Liststr:
-        # PIC support is not enabled by default for c2000,
-        # if users want to use it, they need to add the required arguments explicitly
-        return 
-
-    def get_buildtype_args(self, buildtype: str) -> T.Liststr:
-        return c2000_buildtype_argsbuildtype
-
-    def get_pch_suffix(self) -> str:
-        return 'pch'
-
-    def get_pch_use_args(self, pch_dir: str, header: str) -> T.Liststr:
-        return 
-
-    def thread_flags(self, env: 'Environment') -> T.Liststr:
-        return 
-
-    def get_coverage_args(self) -> T.Liststr:
-        return 
-
-    def get_no_stdinc_args(self) -> T.Liststr:
-        return 
-
-    def get_no_stdlib_link_args(self) -> T.Liststr:
-        return 
-
-    def get_optimization_args(self, optimization_level: str) -> T.Liststr:
-        return c2000_optimization_argsoptimization_level
-
-    def get_debug_args(self, is_debug: bool) -> T.Liststr:
-        return c2000_debug_argsis_debug
-
-    @classmethod
-    def unix_args_to_native(cls, args: T.Liststr) -> T.Liststr:
-        result = 
-        for i in args:
-            if i.startswith('-D'):
-                i = '--define=' + i2:
-            if i.startswith('-I'):
-                i = '--include_path=' + i2:
-            if i.startswith('-Wl,-rpath='):
-                continue
-            elif i == '--print-search-dirs':
-                continue
-            elif i.startswith('-L'):
-                continue
-            result.append(i)
-        return result
-
-    def compute_parameters_with_absolute_paths(self, parameter_list: T.Liststr, build_dir: str) -> T.Liststr:
-        for idx, i in enumerate(parameter_list):
-            if i:14 == '--include_path':
-                parameter_listidx = i:14 + os.path.normpath(os.path.join(build_dir, i14:))
-            if i:2 == '-I':
-                parameter_listidx = i:2 + os.path.normpath(os.path.join(build_dir, i2:))
-
-        return parameter_list
-
-    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.Liststr:
-        return '--preproc_with_compile', f'--preproc_dependency={outfile}'

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mesonlib Deleted

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mesonlib/__init__.py Deleted

@@ -1,31 +0,0 @@
-# SPDX-license-identifier: Apache-2.0
-# Copyright 2012-2021 The Meson development team
-# Copyright © 2021 Intel Corporation
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Helper functions and classes."""
-
-import os
-
-from .universal import *
-from .vsenv import setup_vsenv
-
-# Here we import either the posix implementations, the windows implementations,
-# or a generic no-op implementation
-if os.name == 'posix':
-    from .posix import *
-elif os.name == 'nt':
-    from .win32 import *
-else:
-    from .platform import *

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mesonlib/platform.py Deleted

@@ -1,37 +0,0 @@
-# SPDX-license-identifier: Apache-2.0
-# Copyright 2012-2021 The Meson development team
-# Copyright © 2021 Intel Corporation
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""base classes providing no-op functionality.."""
-
-import os
-import typing as T
-
-from .. import mlog
-
-__all__ = 'BuildDirLock'
-
-# This needs to be inherited by the specific implementations to make type
-# checking happy
-class BuildDirLock:
-
-    def __init__(self, builddir: str) -> None:
-        self.lockfilename = os.path.join(builddir, 'meson-private/meson.lock')
-
-    def __enter__(self) -> None:
-        mlog.debug('Calling the no-op version of BuildDirLock')
-
-    def __exit__(self, *args: T.Any) -> None:
-        pass

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mesonlib/posix.py Deleted

@@ -1,39 +0,0 @@
-# SPDX-license-identifier: Apache-2.0
-# Copyright 2012-2021 The Meson development team
-# Copyright © 2021 Intel Corporation
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Posix specific implementations of mesonlib functionality."""
-
-import fcntl
-import typing as T
-
-from .universal import MesonException
-from .platform import BuildDirLock as BuildDirLockBase
-
-__all__ = 'BuildDirLock'
-
-class BuildDirLock(BuildDirLockBase):
-
-    def __enter__(self) -> None:
-        self.lockfile = open(self.lockfilename, 'w', encoding='utf-8')
-        try:
-            fcntl.flock(self.lockfile, fcntl.LOCK_EX | fcntl.LOCK_NB)
-        except (BlockingIOError, PermissionError):
-            self.lockfile.close()
-            raise MesonException('Some other Meson process is already using this build directory. Exiting.')
-
-    def __exit__(self, *args: T.Any) -> None:
-        fcntl.flock(self.lockfile, fcntl.LOCK_UN)
-        self.lockfile.close()

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mesonlib/universal.py Deleted

@@ -1,2218 +0,0 @@
-# Copyright 2012-2020 The Meson development team
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""A library of random helper functionality."""
-from pathlib import Path
-import argparse
-import enum
-import sys
-import stat
-import time
-import abc
-import platform, subprocess, operator, os, shlex, shutil, re
-import collections
-from functools import lru_cache, wraps, total_ordering
-from itertools import tee, filterfalse
-from tempfile import TemporaryDirectory
-import typing as T
-import uuid
-import textwrap
-import copy
-
-from mesonbuild import mlog
-
-if T.TYPE_CHECKING:
- from .._typing import ImmutableListProtocol
- from ..build import ConfigurationData
- from ..coredata import KeyedOptionDictType, UserOption
- from ..compilers.compilers import Compiler
-
-FileOrString = T.Union'File', str
-
-_T = T.TypeVar('_T')
-_U = T.TypeVar('_U')
-
-__all__ = 
- 'GIT',
- 'python_command',
- 'project_meson_versions',
- 'HoldableObject',
- 'SecondLevelHolder',
- 'File',
- 'FileMode',
- 'GitException',
- 'LibType',
- 'MachineChoice',
- 'MesonException',
- 'MesonBugException',
- 'EnvironmentException',
- 'FileOrString',
- 'GitException',
- 'OptionKey',
- 'dump_conf_header',
- 'OptionOverrideProxy',
- 'OptionType',
- 'OrderedSet',
- 'PerMachine',
- 'PerMachineDefaultable',
- 'PerThreeMachine',
- 'PerThreeMachineDefaultable',
- 'ProgressBar',
- 'RealPathAction',
- 'TemporaryDirectoryWinProof',
- 'Version',
- 'check_direntry_issues',
- 'classify_unity_sources',
- 'current_vs_supports_modules',
- 'darwin_get_object_archs',
- 'default_libdir',
- 'default_libexecdir',
- 'default_prefix',
- 'detect_subprojects',
- 'detect_vcs',
- 'do_conf_file',
- 'do_conf_str',
- 'do_replacement',
- 'exe_exists',
- 'expand_arguments',
- 'extract_as_list',
- 'generate_list',
- 'get_compiler_for_source',
- 'get_filenames_templates_dict',
- 'get_library_dirs',
- 'get_variable_regex',
- 'get_wine_shortpath',
- 'git',
- 'has_path_sep',
- 'is_aix',
- 'is_android',
- 'is_ascii_string',
- 'is_cygwin',
- 'is_debianlike',
- 'is_dragonflybsd',
- 'is_freebsd',
- 'is_haiku',
- 'is_hurd',
- 'is_irix',
- 'is_linux',
- 'is_netbsd',
- 'is_openbsd',
- 'is_osx',
- 'is_qnx',
- 'is_sunos',
- 'is_windows',
- 'is_wsl',
- 'iter_regexin_iter',
- 'join_args',
- 'listify',
- 'partition',
- 'path_is_in_root',
- 'Popen_safe',
- 'quiet_git',
- 'quote_arg',
- 'relative_to_if_possible',
- 'relpath',
- 'replace_if_different',
- 'run_once',
- 'get_meson_command',
- 'set_meson_command',
- 'split_args',
- 'stringlistify',
- 'substitute_values',
- 'substring_is_in_list',
- 'typeslistify',
- 'verbose_git',
- 'version_compare',
- 'version_compare_condition_with_min',
- 'version_compare_many',
- 'search_version',
- 'windows_proof_rm',
- 'windows_proof_rmtree',
-
-
-
-# TODO: this is such a hack, this really should be either in coredata or in the
-# interpreter
-# {subproject: project_meson_version}
-project_meson_versions = collections.defaultdict(str) # type: T.DefaultDictstr, str
-
-
-from glob import glob
-
-if os.path.basename(sys.executable) == 'meson.exe':
- # In Windows and using the MSI installed executable.
- python_command = sys.executable, 'runpython'
-else:
- python_command = sys.executable
-_meson_command: T.Optional'ImmutableListProtocolstr' = None
-
-class MesonException(Exception):
- '''Exceptions thrown by Meson'''
-
- def __init__(self, *args: object, file: T.Optionalstr = None,
- lineno: T.Optionalint = None, colno: T.Optionalint = None):
- super().__init__(*args)
- self.file = file
- self.lineno = lineno
- self.colno = colno
-
-
-class MesonBugException(MesonException):
- '''Exceptions thrown when there is a clear Meson bug that should be reported'''
-
- def __init__(self, msg: str, file: T.Optionalstr = None,
- lineno: T.Optionalint = None, colno: T.Optionalint = None):
- super().__init__(msg + '\n\n This is a Meson bug and should be reported!',
- file=file, lineno=lineno, colno=colno)
-
-class EnvironmentException(MesonException):
- '''Exceptions thrown while processing and creating the build environment'''
-
-class GitException(MesonException):
- def __init__(self, msg: str, output: T.Optionalstr = None):
- super().__init__(msg)
- self.output = output.strip() if output else ''
-
-GIT = shutil.which('git')
-def git(cmd: T.Liststr, workingdir: str, check: bool = False, **kwargs: T.Any) -> T.Tuplesubprocess.Popen, str, str:
- cmd = GIT + cmd
- p, o, e = Popen_safe(cmd, cwd=workingdir, **kwargs)
- if check and p.returncode != 0:
- raise GitException('Git command failed: ' + str(cmd), e)
- return p, o, e
-
-def quiet_git(cmd: T.Liststr, workingdir: str, check: bool = False) -> T.Tuplebool, str:
- if not GIT:
- m = 'Git program not found.'
- if check:
- raise GitException(m)
- return False, m
- p, o, e = git(cmd, workingdir, check)
- if p.returncode != 0:
- return False, e
- return True, o
-
-def verbose_git(cmd: T.Liststr, workingdir: str, check: bool = False) -> bool:
- if not GIT:
- m = 'Git program not found.'
- if check:
- raise GitException(m)
- return False
- p, _, _ = git(cmd, workingdir, check, stdout=None, stderr=None)
- return p.returncode == 0
-
-def set_meson_command(mainfile: str) -> None:
- global python_command
- global _meson_command
- # On UNIX-like systems `meson` is a Python script
- # On Windows `meson` and `meson.exe` are wrapper exes
- if not mainfile.endswith('.py'):
- _meson_command = mainfile
- elif os.path.isabs(mainfile) and mainfile.endswith('mesonmain.py'):
- # Can't actually run meson with an absolute path to mesonmain.py, it must be run as -m mesonbuild.mesonmain
- _meson_command = python_command + '-m', 'mesonbuild.mesonmain'
- else:
- # Either run uninstalled, or full path to meson-script.py
- _meson_command = python_command + mainfile
- # We print this value for unit tests.
- if 'MESON_COMMAND_TESTS' in os.environ:
- mlog.log(f'meson_command is {_meson_command!r}')
-
-
-def get_meson_command() -> T.Optional'ImmutableListProtocolstr':
- return _meson_command
-
-
-def is_ascii_string(astring: T.Unionstr, bytes) -> bool:
- try:
- if isinstance(astring, str):
- astring.encode('ascii')
- elif isinstance(astring, bytes):
- astring.decode('ascii')
- except UnicodeDecodeError:
- return False
- return True
-
-
-def check_direntry_issues(direntry_array: T.UnionT.ListT.Unionstr, bytes, str, bytes) -> None:
- import locale
- # Warn if the locale is not UTF-8. This can cause various unfixable issues
- # such as os.stat not being able to decode filenames with unicode in them.
- # There is no way to reset both the preferred encoding and the filesystem
- # encoding, so we can just warn about it.
- e = locale.getpreferredencoding()
- if e.upper() != 'UTF-8' and not is_windows():
- if not isinstance(direntry_array, list):
- direntry_array = direntry_array
- for de in direntry_array:
- if is_ascii_string(de):
- continue
- mlog.warning(textwrap.dedent(f'''
- You are using {e!r} which is not a Unicode-compatible
- locale but you are trying to access a file system entry called {de!r} which is
- not pure ASCII. This may cause problems.
- '''), file=sys.stderr)
-
-class HoldableObject(metaclass=abc.ABCMeta):
- ''' Dummy base class for all objects that can be
- held by an interpreter.baseobjects.ObjectHolder '''
-
-class SecondLevelHolder(HoldableObject, metaclass=abc.ABCMeta):
- ''' A second level object holder. The primary purpose
- of such objects is to hold multiple objects with one
- default option. '''
-
- @abc.abstractmethod
- def get_default_object(self) -> HoldableObject: ...
-
-class FileMode:
- # The first triad is for owner permissions, the second for group permissions,
- # and the third for others (everyone else).
- # For the 1st character:
- # 'r' means can read
- # '-' means not allowed
- # For the 2nd character:
- # 'w' means can write
- # '-' means not allowed
- # For the 3rd character:
- # 'x' means can execute
- # 's' means can execute and setuid/setgid is set (owner/group triads only)
- # 'S' means cannot execute and setuid/setgid is set (owner/group triads only)
- # 't' means can execute and sticky bit is set ("others" triads only)
- # 'T' means cannot execute and sticky bit is set ("others" triads only)
- # '-' means none of these are allowed
- #
- # The meanings of 'rwx' perms is not obvious for directories; see:
- # https://www.hackinglinuxexposed.com/articles/20030424.html
- #
- # For information on this notation such as setuid/setgid/sticky bits, see:
- # https://en.wikipedia.org/wiki/File_system_permissions#Symbolic_notation
- symbolic_perms_regex = re.compile('r-w-xsS-' # Owner perms
- 'r-w-xsS-' # Group perms
- 'r-w-xtT-') # Others perms
-
- def __init__(self, perms: T.Optionalstr = None, owner: T.Unionstr, int, None = None,
- group: T.Unionstr, int, None = None):
- self.perms_s = perms
- self.perms = self.perms_s_to_bits(perms)
- self.owner = owner
- self.group = group
-
- def __repr__(self) -> str:
- ret = '<FileMode: {!r} owner={} group={}'
- return ret.format(self.perms_s, self.owner, self.group)
-
- @classmethod
- def perms_s_to_bits(cls, perms_s: T.Optionalstr) -> int:
- '''
- Does the opposite of stat.filemode(), converts strings of the form
- 'rwxr-xr-x' to st_mode enums which can be passed to os.chmod()
- '''
- if perms_s is None:
- # No perms specified, we will not touch the permissions
- return -1
- eg = 'rwxr-xr-x'
- if not isinstance(perms_s, str):
- raise MesonException(f'Install perms must be a string. For example, {eg!r}')
- if len(perms_s) != 9 or not cls.symbolic_perms_regex.match(perms_s):
- raise MesonException(f'File perms {perms_s!r} must be exactly 9 chars. For example, {eg!r}')
- perms = 0
- # Owner perms
- if perms_s0 == 'r':
- perms |= stat.S_IRUSR
- if perms_s1 == 'w':
- perms |= stat.S_IWUSR
- if perms_s2 == 'x':
- perms |= stat.S_IXUSR
- elif perms_s2 == 'S':
- perms |= stat.S_ISUID
- elif perms_s2 == 's':
- perms |= stat.S_IXUSR
- perms |= stat.S_ISUID
- # Group perms
- if perms_s3 == 'r':
- perms |= stat.S_IRGRP
- if perms_s4 == 'w':
- perms |= stat.S_IWGRP
- if perms_s5 == 'x':
- perms |= stat.S_IXGRP
- elif perms_s5 == 'S':
- perms |= stat.S_ISGID
- elif perms_s5 == 's':
- perms |= stat.S_IXGRP
- perms |= stat.S_ISGID
- # Others perms
- if perms_s6 == 'r':
- perms |= stat.S_IROTH
- if perms_s7 == 'w':
- perms |= stat.S_IWOTH
- if perms_s8 == 'x':
- perms |= stat.S_IXOTH
- elif perms_s8 == 'T':
- perms |= stat.S_ISVTX
- elif perms_s8 == 't':
- perms |= stat.S_IXOTH
- perms |= stat.S_ISVTX
- return perms
-
-dot_C_dot_H_warning = """You are using .C or .H files in your project. This is deprecated.
- Currently, Meson treats this as C++ code, but they
- used to be treated as C code.
- Note that the situation is a bit more complex if you are using the
- Visual Studio compiler, as it treats .C files as C code, unless you add
- the /TP compiler flag, but this is unreliable.
- See https://github.com/mesonbuild/meson/pull/8747 for the discussions."""
-class File(HoldableObject):
- def __init__(self, is_built: bool, subdir: str, fname: str):
- if fname.endswith(".C") or fname.endswith(".H"):
- mlog.warning(dot_C_dot_H_warning, once=True)
- self.is_built = is_built
- self.subdir = subdir
- self.fname = fname
- self.hash = hash((is_built, subdir, fname))
-
- def __str__(self) -> str:
- return self.relative_name()
-
- def __repr__(self) -> str:
- ret = '<File: {0}'
- if not self.is_built:
- ret += ' (not built)'
- ret += '>'
- return ret.format(self.relative_name())
-
- @staticmethod
- @lru_cache(maxsize=None)
- def from_source_file(source_root: str, subdir: str, fname: str) -> 'File':
- if not os.path.isfile(os.path.join(source_root, subdir, fname)):
- raise MesonException(f'File {fname} does not exist.')
- return File(False, subdir, fname)
-
- @staticmethod
- def from_built_file(subdir: str, fname: str) -> 'File':
- return File(True, subdir, fname)
-
- @staticmethod
- def from_absolute_file(fname: str) -> 'File':
- return File(False, '', fname)
-
- @lru_cache(maxsize=None)
- def rel_to_builddir(self, build_to_src: str) -> str:
- if self.is_built:
- return self.relative_name()
- else:
- return os.path.join(build_to_src, self.subdir, self.fname)
-
- @lru_cache(maxsize=None)
- def absolute_path(self, srcdir: str, builddir: str) -> str:
- absdir = srcdir
- if self.is_built:
- absdir = builddir
- return os.path.join(absdir, self.relative_name())
-
- @property
- def suffix(self) -> str:
- return os.path.splitext(self.fname)11:.lower()
-
- def endswith(self, ending: T.Unionstr, T.Tuplestr, ...) -> bool:
- return self.fname.endswith(ending)
-
- def split(self, s: str, maxsplit: int = -1) -> T.Liststr:
- return self.fname.split(s, maxsplit=maxsplit)
-
- def rsplit(self, s: str, maxsplit: int = -1) -> T.Liststr:
- return self.fname.rsplit(s, maxsplit=maxsplit)
-
- def __eq__(self, other: object) -> bool:
- if not isinstance(other, File):
- return NotImplemented
- if self.hash != other.hash:
- return False
- return (self.fname, self.subdir, self.is_built) == (other.fname, other.subdir, other.is_built)
-
- def __hash__(self) -> int:
- return self.hash
-
- @lru_cache(maxsize=None)
- def relative_name(self) -> str:
- return os.path.join(self.subdir, self.fname)
-
-
-def get_compiler_for_source(compilers: T.Iterable'Compiler', src: 'FileOrString') -> 'Compiler':
- """Given a set of compilers and a source, find the compiler for that source type."""
- for comp in compilers:
- if comp.can_compile(src):
- return comp
- raise MesonException(f'No specified compiler can handle file {src!s}')
-
-
-def classify_unity_sources(compilers: T.Iterable'Compiler', sources: T.Sequence'FileOrString') -> T.Dict'Compiler', T.List'FileOrString':
- compsrclist: T.Dict'Compiler', T.List'FileOrString' = {}
- for src in sources:
- comp = get_compiler_for_source(compilers, src)
- if comp not in compsrclist:
- compsrclistcomp = src
- else:
- compsrclistcomp.append(src)
- return compsrclist
-
-
-class MachineChoice(enum.IntEnum):
-
- """Enum class representing one of the two abstract machine names used in
- most places: the build, and host, machines.
- """
-
- BUILD = 0
- HOST = 1
-
- def get_lower_case_name(self) -> str:
- return PerMachine('build', 'host')self
-
- def get_prefix(self) -> str:
- return PerMachine('build.', '')self
-
-
-class PerMachine(T.Generic_T):
- def __init__(self, build: _T, host: _T) -> None:
- self.build = build
- self.host = host
-
- def __getitem__(self, machine: MachineChoice) -> _T:
- return {
- MachineChoice.BUILD: self.build,
- MachineChoice.HOST: self.host,
- }machine
-
- def __setitem__(self, machine: MachineChoice, val: _T) -> None:
- setattr(self, machine.get_lower_case_name(), val)
-
- def miss_defaulting(self) -> "PerMachineDefaultableT.Optional_T":
- """Unset definition duplicated from their previous to None
-
- This is the inverse of ''default_missing''. By removing defaulted
- machines, we can elaborate the original and then redefault them and thus
- avoid repeating the elaboration explicitly.
- """
- unfreeze = PerMachineDefaultable() # type: PerMachineDefaultableT.Optional_T
- unfreeze.build = self.build
- unfreeze.host = self.host
- if unfreeze.host == unfreeze.build:
- unfreeze.host = None
- return unfreeze
-
- def __repr__(self) -> str:
- return f'PerMachine({self.build!r}, {self.host!r})'
-
-
-class PerThreeMachine(PerMachine_T):
- """Like `PerMachine` but includes `target` too.
-
- It turns out just one thing do we need track the target machine. There's no
- need to computer the `target` field so we don't bother overriding the
- `__getitem__`/`__setitem__` methods.
- """
- def __init__(self, build: _T, host: _T, target: _T) -> None:
- super().__init__(build, host)
- self.target = target
-
- def miss_defaulting(self) -> "PerThreeMachineDefaultableT.Optional_T":
- """Unset definition duplicated from their previous to None
-
- This is the inverse of ''default_missing''. By removing defaulted
- machines, we can elaborate the original and then redefault them and thus
- avoid repeating the elaboration explicitly.
- """
- unfreeze = PerThreeMachineDefaultable() # type: PerThreeMachineDefaultableT.Optional_T
- unfreeze.build = self.build
- unfreeze.host = self.host
- unfreeze.target = self.target
- if unfreeze.target == unfreeze.host:
- unfreeze.target = None
- if unfreeze.host == unfreeze.build:
- unfreeze.host = None
- return unfreeze
-
- def matches_build_machine(self, machine: MachineChoice) -> bool:
- return self.build == selfmachine
-
- def __repr__(self) -> str:
- return f'PerThreeMachine({self.build!r}, {self.host!r}, {self.target!r})'
-
-
-class PerMachineDefaultable(PerMachineT.Optional_T):
- """Extends `PerMachine` with the ability to default from `None`s.
- """
- def __init__(self, build: T.Optional_T = None, host: T.Optional_T = None) -> None:
- super().__init__(build, host)
-
- def default_missing(self) -> "PerMachine_T":
- """Default host to build
-
- This allows just specifying nothing in the native case, and just host in the
- cross non-compiler case.
- """
- freeze = PerMachine(self.build, self.host)
- if freeze.host is None:
- freeze.host = freeze.build
- return freeze
-
- def __repr__(self) -> str:
- return f'PerMachineDefaultable({self.build!r}, {self.host!r})'
-
- @classmethod
- def default(cls, is_cross: bool, build: _T, host: _T) -> PerMachine_T:
- """Easy way to get a defaulted value
-
- This allows simplifying the case where you can control whether host and
- build are separate or not with a boolean. If the is_cross value is set
- to true then the optional host value will be used, otherwise the host
- will be set to the build value.
- """
- m = cls(build)
- if is_cross:
- m.host = host
- return m.default_missing()
-
-
-class PerThreeMachineDefaultable(PerMachineDefaultable, PerThreeMachineT.Optional_T):
- """Extends `PerThreeMachine` with the ability to default from `None`s.
- """
- def __init__(self) -> None:
- PerThreeMachine.__init__(self, None, None, None)
-
- def default_missing(self) -> "PerThreeMachineT.Optional_T":
- """Default host to build and target to host.
-
- This allows just specifying nothing in the native case, just host in the
- cross non-compiler case, and just target in the native-built
- cross-compiler case.
- """
- freeze = PerThreeMachine(self.build, self.host, self.target)
- if freeze.host is None:
- freeze.host = freeze.build
- if freeze.target is None:
- freeze.target = freeze.host
- return freeze
-
- def __repr__(self) -> str:
- return f'PerThreeMachineDefaultable({self.build!r}, {self.host!r}, {self.target!r})'
-
-
-def is_sunos() -> bool:
- return platform.system().lower() == 'sunos'
-
-
-def is_osx() -> bool:
- return platform.system().lower() == 'darwin'
-
-
-def is_linux() -> bool:
- return platform.system().lower() == 'linux'
-
-
-def is_android() -> bool:
- return platform.system().lower() == 'android'
-
-
-def is_haiku() -> bool:
- return platform.system().lower() == 'haiku'
-
-
-def is_openbsd() -> bool:
- return platform.system().lower() == 'openbsd'
-
-
-def is_windows() -> bool:
- platname = platform.system().lower()
- return platname == 'windows'
-
-def is_wsl() -> bool:
- return is_linux() and 'microsoft' in platform.release().lower()
-
-def is_cygwin() -> bool:
- return sys.platform == 'cygwin'
-
-
-def is_debianlike() -> bool:
- return os.path.isfile('/etc/debian_version')
-
-
-def is_dragonflybsd() -> bool:
- return platform.system().lower() == 'dragonfly'
-
-
-def is_netbsd() -> bool:
- return platform.system().lower() == 'netbsd'
-
-
-def is_freebsd() -> bool:
- return platform.system().lower() == 'freebsd'
-
-def is_irix() -> bool:
- return platform.system().startswith('irix')
-
-def is_hurd() -> bool:
- return platform.system().lower() == 'gnu'
-
-def is_qnx() -> bool:
- return platform.system().lower() == 'qnx'
-
-def is_aix() -> bool:
- return platform.system().lower() == 'aix'
-
-def exe_exists(arglist: T.Liststr) -> bool:
- try:
- if subprocess.run(arglist, timeout=10).returncode == 0:
- return True
- except (FileNotFoundError, subprocess.TimeoutExpired):
- pass
- return False
-
-
-@lru_cache(maxsize=None)
-def darwin_get_object_archs(objpath: str) -> 'ImmutableListProtocolstr':
- '''
- For a specific object (executable, static library, dylib, etc), run `lipo`
- to fetch the list of archs supported by it. Supports both thin objects and
- 'fat' objects.
- '''
- _, stdo, stderr = Popen_safe('lipo', '-info', objpath)
- if not stdo:
- mlog.debug(f'lipo {objpath}: {stderr}')
- return None
- stdo = stdo.rsplit(': ', 1)1
- # Convert from lipo-style archs to meson-style CPUs
- stdo = stdo.replace('i386', 'x86')
- stdo = stdo.replace('arm64', 'aarch64')
- stdo = stdo.replace('ppc7400', 'ppc')
- stdo = stdo.replace('ppc970', 'ppc')
- # Add generic name for armv7 and armv7s
- if 'armv7' in stdo:
- stdo += ' arm'
- return stdo.split()
-
-
-def detect_vcs(source_dir: T.Unionstr, Path) -> T.OptionalT.Dictstr, str:
- vcs_systems = 
- dict(name = 'git', cmd = 'git', repo_dir = '.git', get_rev = 'git describe --dirty=+', rev_regex = '(.*)', dep = '.git/logs/HEAD'),
- dict(name = 'mercurial', cmd = 'hg', repo_dir = '.hg', get_rev = 'hg id -i', rev_regex = '(.*)', dep = '.hg/dirstate'),
- dict(name = 'subversion', cmd = 'svn', repo_dir = '.svn', get_rev = 'svn info', rev_regex = 'Revision: (.*)', dep = '.svn/wc.db'),
- dict(name = 'bazaar', cmd = 'bzr', repo_dir = '.bzr', get_rev = 'bzr revno', rev_regex = '(.*)', dep = '.bzr'),
- 
- if isinstance(source_dir, str):
- source_dir = Path(source_dir)
-
- parent_paths_and_self = collections.deque(source_dir.parents)
- # Prepend the source directory to the front so we can check it;
- # source_dir.parents doesn't include source_dir
- parent_paths_and_self.appendleft(source_dir)
- for curdir in parent_paths_and_self:
- for vcs in vcs_systems:
- if Path.is_dir(curdir.joinpath(vcs'repo_dir')) and shutil.which(vcs'cmd'):
- vcs'wc_dir' = str(curdir)
- return vcs
- return None
-
-def current_vs_supports_modules() -> bool:
- vsver = os.environ.get('VSCMD_VER', '')
- nums = vsver.split('.', 2)
- major = int(nums0)
- if major >= 17:
- return True
- if major == 16 and int(nums1) >= 10:
- return True
- return vsver.startswith('16.9.0') and '-pre.' in vsver
-
-# a helper class which implements the same version ordering as RPM
-class Version:
- def __init__(self, s: str) -> None:
- self._s = s
-
- # split into numeric, alphabetic and non-alphanumeric sequences
- sequences1 = re.finditer(r'(\d+|a-zA-Z+|^a-zA-Z\d+)', s)
-
- # non-alphanumeric separators are discarded
- sequences2 = m for m in sequences1 if not re.match(r'^a-zA-Z\d+', m.group(1))
-
- # numeric sequences are converted from strings to ints
- sequences3 = int(m.group(1)) if m.group(1).isdigit() else m.group(1) for m in sequences2
-
- self._v = sequences3
-
- def __str__(self) -> str:
- return '{} (V={})'.format(self._s, str(self._v))
-
- def __repr__(self) -> str:
- return f'<Version: {self._s}>'
-
- def __lt__(self, other: object) -> bool:
- if isinstance(other, Version):
- return self.__cmp(other, operator.lt)
- return NotImplemented
-
- def __gt__(self, other: object) -> bool:
- if isinstance(other, Version):
- return self.__cmp(other, operator.gt)
- return NotImplemented
-
- def __le__(self, other: object) -> bool:
- if isinstance(other, Version):
- return self.__cmp(other, operator.le)
- return NotImplemented
-
- def __ge__(self, other: object) -> bool:
- if isinstance(other, Version):
- return self.__cmp(other, operator.ge)
- return NotImplemented
-
- def __eq__(self, other: object) -> bool:
- if isinstance(other, Version):
- return self._v == other._v
- return NotImplemented
-
- def __ne__(self, other: object) -> bool:
- if isinstance(other, Version):
- return self._v != other._v
- return NotImplemented
-
- def __cmp(self, other: 'Version', comparator: T.CallableT.Any, T.Any, bool) -> bool:
- # compare each sequence in order
- for ours, theirs in zip(self._v, other._v):
- # sort a non-digit sequence before a digit sequence
- ours_is_int = isinstance(ours, int)
- theirs_is_int = isinstance(theirs, int)
- if ours_is_int != theirs_is_int:
- return comparator(ours_is_int, theirs_is_int)
-
- if ours != theirs:
- return comparator(ours, theirs)
-
- # if equal length, all components have matched, so equal
- # otherwise, the version with a suffix remaining is greater
- return comparator(len(self._v), len(other._v))
-
-
-def _version_extract_cmpop(vstr2: str) -> T.TupleT.CallableT.Any, T.Any, bool, str:
- if vstr2.startswith('>='):
- cmpop = operator.ge
- vstr2 = vstr22:
- elif vstr2.startswith('<='):
- cmpop = operator.le
- vstr2 = vstr22:
- elif vstr2.startswith('!='):
- cmpop = operator.ne
- vstr2 = vstr22:
- elif vstr2.startswith('=='):
- cmpop = operator.eq
- vstr2 = vstr22:
- elif vstr2.startswith('='):
- cmpop = operator.eq
- vstr2 = vstr21:
- elif vstr2.startswith('>'):
- cmpop = operator.gt
- vstr2 = vstr21:
- elif vstr2.startswith('<'):
- cmpop = operator.lt
- vstr2 = vstr21:
- else:
- cmpop = operator.eq
-
- return (cmpop, vstr2)
-
-
-def version_compare(vstr1: str, vstr2: str) -> bool:
- (cmpop, vstr2) = _version_extract_cmpop(vstr2)
- return cmpop(Version(vstr1), Version(vstr2))
-
-
-def version_compare_many(vstr1: str, conditions: T.Unionstr, T.Iterablestr) -> T.Tuplebool, T.Liststr, T.Liststr:
- if isinstance(conditions, str):
- conditions = conditions
- found = 
- not_found = 
- for req in conditions:
- if not version_compare(vstr1, req):
- not_found.append(req)
- else:
- found.append(req)
- return not_found == , not_found, found
-
-
-# determine if the minimum version satisfying the condition |condition| exceeds
-# the minimum version for a feature |minimum|
-def version_compare_condition_with_min(condition: str, minimum: str) -> bool:
- if condition.startswith('>='):
- cmpop = operator.le
- condition = condition2:
- elif condition.startswith('<='):
- return False
- elif condition.startswith('!='):
- return False
- elif condition.startswith('=='):
- cmpop = operator.le
- condition = condition2:
- elif condition.startswith('='):
- cmpop = operator.le
- condition = condition1:
- elif condition.startswith('>'):
- cmpop = operator.lt
- condition = condition1:
- elif condition.startswith('<'):
- return False
- else:
- cmpop = operator.le
-
- # Declaring a project(meson_version: '>=0.46') and then using features in
- # 0.46.0 is valid, because (knowing the meson versioning scheme) '0.46.0' is
- # the lowest version which satisfies the constraint '>=0.46'.
- #
- # But this will fail here, because the minimum version required by the
- # version constraint ('0.46') is strictly less (in our version comparison)
- # than the minimum version needed for the feature ('0.46.0').
- #
- # Map versions in the constraint of the form '0.46' to '0.46.0', to embed
- # this knowledge of the meson versioning scheme.
- condition = condition.strip()
- if re.match(r'^\d+.\d+$', condition):
- condition += '.0'
-
- return T.cast(bool, cmpop(Version(minimum), Version(condition)))
-
-def search_version(text: str) -> str:
- # Usually of the type 4.1.4 but compiler output may contain
- # stuff like this:
- # (Sourcery CodeBench Lite 2014.05-29) 4.8.3 20140320 (prerelease)
- # Limiting major version number to two digits seems to work
- # thus far. When we get to GCC 100, this will break, but
- # if we are still relevant when that happens, it can be
- # considered an achievement in itself.
- #
- # This regex is reaching magic levels. If it ever needs
- # to be updated, do not complexify but convert to something
- # saner instead.
- # We'll demystify it a bit with a verbose definition.
- version_regex = re.compile(r"""
- (?<! # Zero-width negative lookbehind assertion
- (
- \d # One digit
- | \. # Or one period
- ) # One occurrence
- )
- # Following pattern must not follow a digit or period
- (
- \d{1,2} # One or two digits
- (
- \.\d+ # Period and one or more digits
- )+ # One or more occurrences
- (
- -a-zA-Z0-9+ # Hyphen and one or more alphanumeric
- )? # Zero or one occurrence
- ) # One occurrence
- """, re.VERBOSE)
- match = version_regex.search(text)
- if match:
- return match.group(0)
-
- # try a simpler regex that has like "blah 2020.01.100 foo" or "blah 2020.01 foo"
- version_regex = re.compile(r"(\d{1,4}\.\d{1,4}\.?\d{0,4})")
- match = version_regex.search(text)
- if match:
- return match.group(0)
-
- return 'unknown version'
-
-
-def default_libdir() -> str:
- if is_debianlike():
- try:
- pc = subprocess.Popen('dpkg-architecture', '-qDEB_HOST_MULTIARCH',
- stdout=subprocess.PIPE,
- stderr=subprocess.DEVNULL)
- (stdo, _) = pc.communicate()
- if pc.returncode == 0:
- archpath = stdo.decode().strip()
- return 'lib/' + archpath
- except Exception:
- pass
- if is_freebsd() or is_irix():
- return 'lib'
- if os.path.isdir('/usr/lib64') and not os.path.islink('/usr/lib64'):
- return 'lib64'
- return 'lib'
-
-
-def default_libexecdir() -> str:
- # There is no way to auto-detect this, so it must be set at build time
- return 'libexec'
-
-
-def default_prefix() -> str:
- return 'c:/' if is_windows() else '/usr/local'
-
-
-def get_library_dirs() -> T.Liststr:
- if is_windows():
- return 'C:/mingw/lib' # TODO: get programmatically
- if is_osx():
- return '/usr/lib' # TODO: get programmatically
- # The following is probably Debian/Ubuntu specific.
- # /usr/local/lib is first because it contains stuff
- # installed by the sysadmin and is probably more up-to-date
- # than /usr/lib. If you feel that this search order is
- # problematic, please raise the issue on the mailing list.
- unixdirs = '/usr/local/lib', '/usr/lib', '/lib'
-
- if is_freebsd():
- return unixdirs
- # FIXME: this needs to be further genericized for aarch64 etc.
- machine = platform.machine()
- if machine in ('i386', 'i486', 'i586', 'i686'):
- plat = 'i386'
- elif machine.startswith('arm'):
- plat = 'arm'
- else:
- plat = ''
-
- # Solaris puts 32-bit libraries in the main /lib & /usr/lib directories
- # and 64-bit libraries in platform specific subdirectories.
- if is_sunos():
- if machine == 'i86pc':
- plat = 'amd64'
- elif machine.startswith('sun4'):
- plat = 'sparcv9'
-
- usr_platdir = Path('/usr/lib/') / plat
- if usr_platdir.is_dir():
- unixdirs += str(x) for x in (usr_platdir).iterdir() if x.is_dir()
- if os.path.exists('/usr/lib64'):
- unixdirs.append('/usr/lib64')
-
- lib_platdir = Path('/lib/') / plat
- if lib_platdir.is_dir():
- unixdirs += str(x) for x in (lib_platdir).iterdir() if x.is_dir()
- if os.path.exists('/lib64'):
- unixdirs.append('/lib64')
-
- return unixdirs
-
-
-def has_path_sep(name: str, sep: str = '/\\') -> bool:
- 'Checks if any of the specified @sep path separators are in @name'
- for each in sep:
- if each in name:
- return True
- return False
-
-
-if is_windows():
- # shlex.split is not suitable for splitting command line on Window (https://bugs.python.org/issue1724822);
- # shlex.quote is similarly problematic. Below are "proper" implementations of these functions according to
- # https://docs.microsoft.com/en-us/cpp/c-language/parsing-c-command-line-arguments and
- # https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
-
- _whitespace = ' \t\n\r'
- _find_unsafe_char = re.compile(fr'{_whitespace}"').search
-
- def quote_arg(arg: str) -> str:
- if arg and not _find_unsafe_char(arg):
- return arg
-
- result = '"'
- num_backslashes = 0
- for c in arg:
- if c == '\\':
- num_backslashes += 1
- else:
- if c == '"':
- # Escape all backslashes and the following double quotation mark
- num_backslashes = num_backslashes * 2 + 1
-
- result += num_backslashes * '\\' + c
- num_backslashes = 0
-
- # Escape all backslashes, but let the terminating double quotation
- # mark we add below be interpreted as a metacharacter
- result += (num_backslashes * 2) * '\\' + '"'
- return result
-
- def split_args(cmd: str) -> T.Liststr:
- result = 
- arg = ''
- num_backslashes = 0
- num_quotes = 0
- in_quotes = False
- for c in cmd:
- if c == '\\':
- num_backslashes += 1
- else:
- if c == '"' and not num_backslashes % 2:
- # unescaped quote, eat it
- arg += (num_backslashes // 2) * '\\'
- num_quotes += 1
- in_quotes = not in_quotes
- elif c in _whitespace and not in_quotes:
- if arg or num_quotes:
- # reached the end of the argument
- result.append(arg)
- arg = ''
- num_quotes = 0
- else:
- if c == '"':
- # escaped quote
- num_backslashes = (num_backslashes - 1) // 2
-
- arg += num_backslashes * '\\' + c
-
- num_backslashes = 0
-
- if arg or num_quotes:
- result.append(arg)
-
- return result
-else:
- def quote_arg(arg: str) -> str:
- return shlex.quote(arg)
-
- def split_args(cmd: str) -> T.Liststr:
- return shlex.split(cmd)
-
-
-def join_args(args: T.Iterablestr) -> str:
- return ' '.join(quote_arg(x) for x in args)
-
-
-def do_replacement(regex: T.Patternstr, line: str, variable_format: str,
- confdata: T.UnionT.Dictstr, T.Tuplestr, T.Optionalstr, 'ConfigurationData') -> T.Tuplestr, T.Setstr:
- missing_variables = set() # type: T.Setstr
- if variable_format == 'cmake':
- start_tag = '${'
- backslash_tag = '\\${'
- else:
- assert variable_format in 'meson', 'cmake@'
- start_tag = '@'
- backslash_tag = '\\@'
-
- def variable_replace(match: T.Matchstr) -> str:
- # Pairs of escape characters before '@' or '\@'
- if match.group(0).endswith('\\'):
- num_escapes = match.end(0) - match.start(0)
- return '\\' * (num_escapes // 2)
- # Single escape character and '@'
- elif match.group(0) == backslash_tag:
- return start_tag
- # Template variable to be replaced
- else:
- varname = match.group(1)
- var_str = ''
- if varname in confdata:
- var, _ = confdata.get(varname)
- if isinstance(var, str):
- var_str = var
- elif isinstance(var, int):
- var_str = str(var)
- else:
- msg = f'Tried to replace variable {varname!r} value with ' \
- f'something other than a string or int: {var!r}'
- raise MesonException(msg)
- else:
- missing_variables.add(varname)
- return var_str
- return re.sub(regex, variable_replace, line), missing_variables
-
-def do_define(regex: T.Patternstr, line: str, confdata: 'ConfigurationData', variable_format: str) -> str:
- def get_cmake_define(line: str, confdata: 'ConfigurationData') -> str:
- arr = line.split()
- define_value = 
- for token in arr2::
- try:
- (v, desc) = confdata.get(token)
- define_value += str(v)
- except KeyError:
- define_value += token
- return ' '.join(define_value)
-
- arr = line.split()
- if variable_format == 'meson' and len(arr) != 2:
- raise MesonException('#mesondefine does not contain exactly two tokens: %s' % line.strip())
-
- varname = arr1
- try:
- (v, desc) = confdata.get(varname)
- except KeyError:
- return '/* #undef %s */\n' % varname
- if isinstance(v, bool):
- if v:
- return '#define %s\n' % varname
- else:
- return '#undef %s\n' % varname
- elif isinstance(v, int):
- return '#define %s %d\n' % (varname, v)
- elif isinstance(v, str):
- if variable_format == 'meson':
- result = v
- else:
- result = get_cmake_define(line, confdata)
- result = f'#define {varname} {result}\n'
- (result, missing_variable) = do_replacement(regex, result, variable_format, confdata)
- return result
- else:
- raise MesonException('#mesondefine argument "%s" is of unknown type.' % varname)
-
-def get_variable_regex(variable_format: str = 'meson') -> T.Patternstr:
- # Only allow (a-z, A-Z, 0-9, _, -) as valid characters for a define
- # Also allow escaping '@' with '\@'
- if variable_format in 'meson', 'cmake@':
- regex = re.compile(r'(?:\\\\)+(?=\\?@)|\\@|@(-a-zA-Z0-9_+)@')
- elif variable_format == 'cmake':
- regex = re.compile(r'(?:\\\\)+(?=\\?\$)|\\\${|\${(-a-zA-Z0-9_+)}')
- else:
- raise MesonException(f'Format "{variable_format}" not handled')
- return regex
-
-def do_conf_str(src: str, data: list, confdata: 'ConfigurationData', variable_format: str,
- encoding: str = 'utf-8') -> T.TupleT.Liststr, T.Setstr, bool:
- def line_is_valid(line: str, variable_format: str) -> bool:
- if variable_format == 'meson':
- if '#cmakedefine' in line:
- return False
- else: # cmake format
- if '#mesondefine' in line:
- return False
- return True
-
- regex = get_variable_regex(variable_format)
-
- search_token = '#mesondefine'
- if variable_format != 'meson':
- search_token = '#cmakedefine'
-
- result = 
- missing_variables = set()
- # Detect when the configuration data is empty and no tokens were found
- # during substitution so we can warn the user to use the `copy:` kwarg.
- confdata_useless = not confdata.keys()
- for line in data:
- if line.startswith(search_token):
- confdata_useless = False
- line = do_define(regex, line, confdata, variable_format)
- else:
- if not line_is_valid(line, variable_format):
- raise MesonException(f'Format error in {src}: saw "{line.strip()}" when format set to "{variable_format}"')
- line, missing = do_replacement(regex, line, variable_format, confdata)
- missing_variables.update(missing)
- if missing:
- confdata_useless = False
- result.append(line)
-
- return result, missing_variables, confdata_useless
-
-def do_conf_file(src: str, dst: str, confdata: 'ConfigurationData', variable_format: str,
- encoding: str = 'utf-8') -> T.TupleT.Setstr, bool:
- try:
- with open(src, encoding=encoding, newline='') as f:
- data = f.readlines()
- except Exception as e:
- raise MesonException(f'Could not read input file {src}: {e!s}')
-
- (result, missing_variables, confdata_useless) = do_conf_str(src, data, confdata, variable_format, encoding)
- dst_tmp = dst + '~'
- try:
- with open(dst_tmp, 'w', encoding=encoding, newline='') as f:
- f.writelines(result)
- except Exception as e:
- raise MesonException(f'Could not write output file {dst}: {e!s}')
- shutil.copymode(src, dst_tmp)
- replace_if_different(dst, dst_tmp)
- return missing_variables, confdata_useless
-
-CONF_C_PRELUDE = '''/*
- * Autogenerated by the Meson build system.
- * Do not edit, your changes will be lost.
- */
-
-#pragma once
-
-'''
-
-CONF_NASM_PRELUDE = '''; Autogenerated by the Meson build system.
-; Do not edit, your changes will be lost.
-
-'''
-
-def dump_conf_header(ofilename: str, cdata: 'ConfigurationData', output_format: str) -> None:
- if output_format == 'c':
- prelude = CONF_C_PRELUDE
- prefix = '#'
- elif output_format == 'nasm':
- prelude = CONF_NASM_PRELUDE
- prefix = '%'
- else:
- raise MesonBugException(f'Undefined output_format: "{output_format}"')
-
- ofilename_tmp = ofilename + '~'
- with open(ofilename_tmp, 'w', encoding='utf-8') as ofile:
- ofile.write(prelude)
- for k in sorted(cdata.keys()):
- (v, desc) = cdata.get(k)
- if desc:
- if output_format == 'c':
- ofile.write('/* %s */\n' % desc)
- elif output_format == 'nasm':
- for line in desc.split('\n'):
- ofile.write('; %s\n' % line)
- if isinstance(v, bool):
- if v:
- ofile.write(f'{prefix}define {k}\n\n')
- else:
- ofile.write(f'{prefix}undef {k}\n\n')
- elif isinstance(v, (int, str)):
- ofile.write(f'{prefix}define {k} {v}\n\n')
- else:
- raise MesonException('Unknown data type in configuration file entry: ' + k)
- replace_if_different(ofilename, ofilename_tmp)
-
-
-def replace_if_different(dst: str, dst_tmp: str) -> None:
- # If contents are identical, don't touch the file to prevent
- # unnecessary rebuilds.
- different = True
- try:
- with open(dst, 'rb') as f1, open(dst_tmp, 'rb') as f2:
- if f1.read() == f2.read():
- different = False
- except FileNotFoundError:
- pass
- if different:
- os.replace(dst_tmp, dst)
- else:
- os.unlink(dst_tmp)
-
-
-def listify(item: T.Any, flatten: bool = True) -> T.ListT.Any:
- '''
- Returns a list with all args embedded in a list if they are not a list.
- This function preserves order.
- @flatten: Convert lists of lists to a flat list
- '''
- if not isinstance(item, list):
- return item
- result = # type: T.ListT.Any
- for i in item:
- if flatten and isinstance(i, list):
- result += listify(i, flatten=True)
- else:
- result.append(i)
- return result
-
-
-def extract_as_list(dict_object: T.Dict_T, _U, key: _T, pop: bool = False) -> T.List_U:
- '''
- Extracts all values from given dict_object and listifies them.
- '''
- fetch: T.Callable_T, _U = dict_object.get
- if pop:
- fetch = dict_object.pop
- # If there's only one key, we don't return a list with one element
- return listify(fetch(key) or , flatten=True)
-
-
-def typeslistify(item: 'T.Union_T, T.Sequence_T',
- types: 'T.UnionT.Type_T, T.TupleT.Type_T') -> T.List_T:
- '''
- Ensure that type(@item) is one of @types or a
- list of items all of which are of type @types
- '''
- if isinstance(item, types):
- item = T.cast(T.List_T, item)
- if not isinstance(item, list):
- raise MesonException('Item must be a list or one of {!r}, not {!r}'.format(types, type(item)))
- for i in item:
- if i is not None and not isinstance(i, types):
- raise MesonException('List item must be one of {!r}, not {!r}'.format(types, type(i)))
- return item
-
-
-def stringlistify(item: T.UnionT.Any, T.SequenceT.Any) -> T.Liststr:
- return typeslistify(item, str)
-
-
-def expand_arguments(args: T.Iterablestr) -> T.OptionalT.Liststr:
- expended_args = # type: T.Liststr
- for arg in args:
- if not arg.startswith('@'):
- expended_args.append(arg)
- continue
-
- args_file = arg1:
- try:
- with open(args_file, encoding='utf-8') as f:
- extended_args = f.read().split()
- expended_args += extended_args
- except Exception as e:
- mlog.error('Expanding command line arguments:', args_file, 'not found')
- mlog.exception(e)
- return None
- return expended_args
-
-
-def partition(pred: T.Callable_T, object, iterable: T.Iterable_T) -> T.TupleT.Iterator_T, T.Iterator_T:
- """Use a predicate to partition entries into false entries and true
- entries.
-
- >>> x, y = partition(is_odd, range(10))
- >>> (list(x), list(y))
- (0, 2, 4, 6, 8, 1, 3, 5, 7, 9)
- """
- t1, t2 = tee(iterable)
- return filterfalse(pred, t1), filter(pred, t2)
-
-
-def Popen_safe(args: T.Liststr, write: T.Optionalstr = None,
- stdout: T.UnionT.TextIO, T.BinaryIO, int = subprocess.PIPE,
- stderr: T.UnionT.TextIO, T.BinaryIO, int = subprocess.PIPE,
- **kwargs: T.Any) -> T.Tuple'subprocess.Popenstr', str, str:
- import locale
- encoding = locale.getpreferredencoding()
- # Redirect stdin to DEVNULL otherwise the command run by us here might mess
- # up the console and ANSI colors will stop working on Windows.
- if 'stdin' not in kwargs:
- kwargs'stdin' = subprocess.DEVNULL
- if not sys.stdout.encoding or encoding.upper() != 'UTF-8':
- p, o, e = Popen_safe_legacy(args, write=write, stdout=stdout, stderr=stderr, **kwargs)
- else:
- p = subprocess.Popen(args, universal_newlines=True, close_fds=False,
- stdout=stdout, stderr=stderr, **kwargs)
- o, e = p.communicate(write)
- # Sometimes the command that we run will call another command which will be
- # without the above stdin workaround, so set the console mode again just in
- # case.
- mlog.setup_console()
- return p, o, e
-
-
-def Popen_safe_legacy(args: T.Liststr, write: T.Optionalstr = None,
- stdout: T.UnionT.TextIO, T.BinaryIO, int = subprocess.PIPE,
- stderr: T.UnionT.TextIO, T.BinaryIO, int = subprocess.PIPE,
- **kwargs: T.Any) -> T.Tuple'subprocess.Popenstr', str, str:
- p = subprocess.Popen(args, universal_newlines=False, close_fds=False,
- stdout=stdout, stderr=stderr, **kwargs)
- input_ = None # type: T.Optionalbytes
- if write is not None:
- input_ = write.encode('utf-8')
- o, e = p.communicate(input_)
- if o is not None:
- if sys.stdout.encoding:
- o = o.decode(encoding=sys.stdout.encoding, errors='replace').replace('\r\n', '\n')
- else:
- o = o.decode(errors='replace').replace('\r\n', '\n')
- if e is not None:
- if sys.stderr is not None and sys.stderr.encoding:
- e = e.decode(encoding=sys.stderr.encoding, errors='replace').replace('\r\n', '\n')
- else:
- e = e.decode(errors='replace').replace('\r\n', '\n')
- return p, o, e
-
-
-def iter_regexin_iter(regexiter: T.Iterablestr, initer: T.Iterablestr) -> T.Optionalstr:
- '''
- Takes each regular expression in @regexiter and tries to search for it in
- every item in @initer. If there is a match, returns that match.
- Else returns False.
- '''
- for regex in regexiter:
- for ii in initer:
- if not isinstance(ii, str):
- continue
- match = re.search(regex, ii)
- if match:
- return match.group()
- return None
-
-
-def _substitute_values_check_errors(command: T.Liststr, values: T.Dictstr, T.Unionstr, T.Liststr) -> None:
- # Error checking
- inregex = '@INPUT(0-9+)?@', '@PLAINNAME@', '@BASENAME@' # type: T.Liststr
- outregex = '@OUTPUT(0-9+)?@', '@OUTDIR@' # type: T.Liststr
- if '@INPUT@' not in values:
- # Error out if any input-derived templates are present in the command
- match = iter_regexin_iter(inregex, command)
- if match:
- raise MesonException(f'Command cannot have {match!r}, since no input files were specified')
- else:
- if len(values'@INPUT@') > 1:
- # Error out if @PLAINNAME@ or @BASENAME@ is present in the command
- match = iter_regexin_iter(inregex1:, command)
- if match:
- raise MesonException(f'Command cannot have {match!r} when there is '
- 'more than one input file')
- # Error out if an invalid @INPUTnn@ template was specified
- for each in command:
- if not isinstance(each, str):
- continue
- match2 = re.search(inregex0, each)
- if match2 and match2.group() not in values:
- m = 'Command cannot have {!r} since there are only {!r} inputs'
- raise MesonException(m.format(match2.group(), len(values'@INPUT@')))
- if '@OUTPUT@' not in values:
- # Error out if any output-derived templates are present in the command
- match = iter_regexin_iter(outregex, command)
- if match:
- raise MesonException(f'Command cannot have {match!r} since there are no outputs')
- else:
- # Error out if an invalid @OUTPUTnn@ template was specified
- for each in command:
- if not isinstance(each, str):
- continue
- match2 = re.search(outregex0, each)
- if match2 and match2.group() not in values:
- m = 'Command cannot have {!r} since there are only {!r} outputs'
- raise MesonException(m.format(match2.group(), len(values'@OUTPUT@')))
-
-
-def substitute_values(command: T.Liststr, values: T.Dictstr, T.Unionstr, T.Liststr) -> T.Liststr:
- '''
- Substitute the template strings in the @values dict into the list of
- strings @command and return a new list. For a full list of the templates,
- see get_filenames_templates_dict()
-
- If multiple inputs/outputs are given in the @values dictionary, we
- substitute @INPUT@ and @OUTPUT@ only if they are the entire string, not
- just a part of it, and in that case we substitute *all* of them.
-
- The typing of this function is difficult, as only @OUTPUT@ and @INPUT@ can
- be lists, everything else is a string. However, TypeDict cannot represent
- this, as you can have optional keys, but not extra keys. We end up just
- having to us asserts to convince type checkers that this is okay.
-
- https://github.com/python/mypy/issues/4617
- '''
-
- def replace(m: T.Matchstr) -> str:
- v = valuesm.group(0)
- assert isinstance(v, str), 'for mypy'
- return v
-
- # Error checking
- _substitute_values_check_errors(command, values)
-
- # Substitution
- outcmd = # type: T.Liststr
- rx_keys = re.escape(key) for key in values if key not in ('@INPUT@', '@OUTPUT@')
- value_rx = re.compile('|'.join(rx_keys)) if rx_keys else None
- for vv in command:
- more: T.Optionalstr = None
- if not isinstance(vv, str):
- outcmd.append(vv)
- elif '@INPUT@' in vv:
- inputs = values'@INPUT@'
- if vv == '@INPUT@':
- outcmd += inputs
- elif len(inputs) == 1:
- outcmd.append(vv.replace('@INPUT@', inputs0))
- else:
- raise MesonException("Command has '@INPUT@' as part of a "
- "string and more than one input file")
- elif '@OUTPUT@' in vv:
- outputs = values'@OUTPUT@'
- if vv == '@OUTPUT@':
- outcmd += outputs
- elif len(outputs) == 1:
- outcmd.append(vv.replace('@OUTPUT@', outputs0))
- else:
- raise MesonException("Command has '@OUTPUT@' as part of a "
- "string and more than one output file")
-
- # Append values that are exactly a template string.
- # This is faster than a string replace.
- elif vv in values:
- o = valuesvv
- assert isinstance(o, str), 'for mypy'
- more = o
- # Substitute everything else with replacement
- elif value_rx:
- more = value_rx.sub(replace, vv)
- else:
- more = vv
-
- if more is not None:
- outcmd.append(more)
-
- return outcmd
-
-
-def get_filenames_templates_dict(inputs: T.Liststr, outputs: T.Liststr) -> T.Dictstr, T.Unionstr, T.Liststr:
- '''
- Create a dictionary with template strings as keys and values as values for
- the following templates:
-
- @INPUT@ - the full path to one or more input files, from @inputs
- @OUTPUT@ - the full path to one or more output files, from @outputs
- @OUTDIR@ - the full path to the directory containing the output files
-
- If there is only one input file, the following keys are also created:
-
- @PLAINNAME@ - the filename of the input file
- @BASENAME@ - the filename of the input file with the extension removed
-
- If there is more than one input file, the following keys are also created:
-
- @INPUT0@, @INPUT1@, ... one for each input file
-
- If there is more than one output file, the following keys are also created:
-
- @OUTPUT0@, @OUTPUT1@, ... one for each output file
- '''
- values = {} # type: T.Dictstr, T.Unionstr, T.Liststr
- # Gather values derived from the input
- if inputs:
- # We want to substitute all the inputs.
- values'@INPUT@' = inputs
- for (ii, vv) in enumerate(inputs):
- # Write out @INPUT0@, @INPUT1@, ...
- valuesf'@INPUT{ii}@' = vv
- if len(inputs) == 1:
- # Just one value, substitute @PLAINNAME@ and @BASENAME@
- values'@PLAINNAME@' = plain = os.path.basename(inputs0)
- values'@BASENAME@' = os.path.splitext(plain)0
- if outputs:
- # Gather values derived from the outputs, similar to above.
- values'@OUTPUT@' = outputs
- for (ii, vv) in enumerate(outputs):
- valuesf'@OUTPUT{ii}@' = vv
- # Outdir should be the same for all outputs
- values'@OUTDIR@' = os.path.dirname(outputs0)
- # Many external programs fail on empty arguments.
- if values'@OUTDIR@' == '':
- values'@OUTDIR@' = '.'
- return values
-
-
-def _make_tree_writable(topdir: str) -> None:
- # Ensure all files and directories under topdir are writable
- # (and readable) by owner.
- for d, _, files in os.walk(topdir):
- os.chmod(d, os.stat(d).st_mode | stat.S_IWRITE | stat.S_IREAD)
- for fname in files:
- fpath = os.path.join(d, fname)
- if os.path.isfile(fpath):
- os.chmod(fpath, os.stat(fpath).st_mode | stat.S_IWRITE | stat.S_IREAD)
-
-
-def windows_proof_rmtree(f: str) -> None:
- # On Windows if anyone is holding a file open you can't
- # delete it. As an example an anti virus scanner might
- # be scanning files you are trying to delete. The only
- # way to fix this is to try again and again.
- delays = 0.1, 0.1, 0.2, 0.2, 0.2, 0.5, 0.5, 1, 1, 1, 1, 2
- writable = False
- for d in delays:
- try:
- # Start by making the tree writable.
- if not writable:
- _make_tree_writable(f)
- writable = True
- except PermissionError:
- time.sleep(d)
- continue
- try:
- shutil.rmtree(f)
- return
- except FileNotFoundError:
- return
- except OSError:
- time.sleep(d)
- # Try one last time and throw if it fails.
- shutil.rmtree(f)
-
-
-def windows_proof_rm(fpath: str) -> None:
- """Like windows_proof_rmtree, but for a single file."""
- if os.path.isfile(fpath):
- os.chmod(fpath, os.stat(fpath).st_mode | stat.S_IWRITE | stat.S_IREAD)
- delays = 0.1, 0.1, 0.2, 0.2, 0.2, 0.5, 0.5, 1, 1, 1, 1, 2
- for d in delays:
- try:
- os.unlink(fpath)
- return
- except FileNotFoundError:
- return
- except OSError:
- time.sleep(d)
- os.unlink(fpath)
-
-
-class TemporaryDirectoryWinProof(TemporaryDirectory):
- """
- Like TemporaryDirectory, but cleans things up using
- windows_proof_rmtree()
- """
-
- def __exit__(self, exc: T.Any, value: T.Any, tb: T.Any) -> None:
- try:
- super().__exit__(exc, value, tb)
- except OSError:
- windows_proof_rmtree(self.name)
-
- def cleanup(self) -> None:
- try:
- super().cleanup()
- except OSError:
- windows_proof_rmtree(self.name)
-
-
-def detect_subprojects(spdir_name: str, current_dir: str = '',
- result: T.OptionalT.Dictstr, T.Liststr = None) -> T.Dictstr, T.Liststr:
- if result is None:
- result = {}
- spdir = os.path.join(current_dir, spdir_name)
- if not os.path.exists(spdir):
- return result
- for trial in glob(os.path.join(spdir, '*')):
- basename = os.path.basename(trial)
- if trial == 'packagecache':
- continue
- append_this = True
- if os.path.isdir(trial):
- detect_subprojects(spdir_name, trial, result)
- elif trial.endswith('.wrap') and os.path.isfile(trial):
- basename = os.path.splitext(basename)0
- else:
- append_this = False
- if append_this:
- if basename in result:
- resultbasename.append(trial)
- else:
- resultbasename = trial
- return result
-
-
-def substring_is_in_list(substr: str, strlist: T.Liststr) -> bool:
- for s in strlist:
- if substr in s:
- return True
- return False
-
-
-class OrderedSet(T.MutableSet_T):
- """A set that preserves the order in which items are added, by first
- insertion.
- """
- def __init__(self, iterable: T.OptionalT.Iterable_T = None):
- # typing.OrderedDict is new in 3.7.2, so we can't use that, but we can
- # use MutableMapping, which is fine in this case.
- self.__container = collections.OrderedDict() # type: T.MutableMapping_T, None
- if iterable:
- self.update(iterable)
-
- def __contains__(self, value: object) -> bool:
- return value in self.__container
-
- def __iter__(self) -> T.Iterator_T:
- return iter(self.__container.keys())
-
- def __len__(self) -> int:
- return len(self.__container)
-
- def __repr__(self) -> str:
- # Don't print 'OrderedSet("")' for an empty set.
- if self.__container:
- return 'OrderedSet("{}")'.format(
- '", "'.join(repr(e) for e in self.__container.keys()))
- return 'OrderedSet()'
-
- def __reversed__(self) -> T.Iterator_T:
- return reversed(self.__container.keys())
-
- def add(self, value: _T) -> None:
- self.__containervalue = None
-
- def discard(self, value: _T) -> None:
- if value in self.__container:
- del self.__containervalue
-
- def move_to_end(self, value: _T, last: bool = True) -> None:
- # Mypy does not know about move_to_end, because it is not part of MutableMapping
- self.__container.move_to_end(value, last) # type: ignore
-
- def pop(self, last: bool = True) -> _T:
- # Mypy does not know about the last argument, because it is not part of MutableMapping
- item, _ = self.__container.popitem(last) # type: ignore
- return item
-
- def update(self, iterable: T.Iterable_T) -> None:
- for item in iterable:
- self.__containeritem = None
-
- def difference(self, set_: T.UnionT.Set_T, 'OrderedSet_T') -> 'OrderedSet_T':
- return type(self)(e for e in self if e not in set_)
-
- def difference_update(self, iterable: T.Iterable_T) -> None:
- for item in iterable:
- self.discard(item)
-
-def relpath(path: str, start: str) -> str:
- # On Windows a relative path can't be evaluated for paths on two different
- # drives (i.e. c:\foo and f:\bar). The only thing left to do is to use the
- # original absolute path.
- try:
- return os.path.relpath(path, start)
- except (TypeError, ValueError):
- return path
-
-def path_is_in_root(path: Path, root: Path, resolve: bool = False) -> bool:
- # Check whether a path is within the root directory root
- try:
- if resolve:
- path.resolve().relative_to(root.resolve())
- else:
- path.relative_to(root)
- except ValueError:
- return False
- return True
-
-def relative_to_if_possible(path: Path, root: Path, resolve: bool = False) -> Path:
- try:
- if resolve:
- return path.resolve().relative_to(root.resolve())
- else:
- return path.relative_to(root)
- except ValueError:
- return path
-
-class LibType(enum.IntEnum):
-
- """Enumeration for library types."""
-
- SHARED = 0
- STATIC = 1
- PREFER_SHARED = 2
- PREFER_STATIC = 3
-
-
-class ProgressBarFallback: # lgtm py/iter-returns-non-self
- '''
- Fallback progress bar implementation when tqdm is not found
-
- Since this class is not an actual iterator, but only provides a minimal
- fallback, it is safe to ignore the 'Iterator does not return self from
- __iter__ method' warning.
- '''
- def __init__(self, iterable: T.OptionalT.Iterablestr = None, total: T.Optionalint = None,
- bar_type: T.Optionalstr = None, desc: T.Optionalstr = None):
- if iterable is not None:
- self.iterable = iter(iterable)
- return
- self.total = total
- self.done = 0
- self.printed_dots = 0
- if self.total and bar_type == 'download':
- print('Download size:', self.total)
- if desc:
- print(f'{desc}: ', end='')
-
- # Pretend to be an iterator when called as one and don't print any
- # progress
- def __iter__(self) -> T.Iteratorstr:
- return self.iterable
-
- def __next__(self) -> str:
- return next(self.iterable)
-
- def print_dot(self) -> None:
- print('.', end='')
- sys.stdout.flush()
- self.printed_dots += 1
-
- def update(self, progress: int) -> None:
- self.done += progress
- if not self.total:
- # Just print one dot per call if we don't have a total length
- self.print_dot()
- return
- ratio = int(self.done / self.total * 10)
- while self.printed_dots < ratio:
- self.print_dot()
-
- def close(self) -> None:
- print('')
-
-try:
- from tqdm import tqdm
-except ImportError:
- # ideally we would use a typing.Protocol here, but it's part of typing_extensions until 3.8
- ProgressBar = ProgressBarFallback # type: T.UnionT.TypeProgressBarFallback, T.TypeProgressBarTqdm
-else:
- class ProgressBarTqdm(tqdm):
- def __init__(self, *args: T.Any, bar_type: T.Optionalstr = None, **kwargs: T.Any) -> None:
- if bar_type == 'download':
- kwargs.update({'unit': 'bytes', 'leave': True})
- else:
- kwargs.update({'leave': False})
- kwargs'ncols' = 100
- super().__init__(*args, **kwargs)
-
- ProgressBar = ProgressBarTqdm
-
-
-class RealPathAction(argparse.Action):
- def __init__(self, option_strings: T.Liststr, dest: str, default: str = '.', **kwargs: T.Any):
- default = os.path.abspath(os.path.realpath(default))
- super().__init__(option_strings, dest, nargs=None, default=default, **kwargs)
-
- def __call__(self, parser: argparse.ArgumentParser, namespace: argparse.Namespace,
- values: T.Unionstr, T.SequenceT.Any, None, option_string: str = None) -> None:
- assert isinstance(values, str)
- setattr(namespace, self.dest, os.path.abspath(os.path.realpath(values)))
-
-
-def get_wine_shortpath(winecmd: T.Liststr, wine_paths: T.Sequencestr) -> str:
- """Get A short version of @wine_paths to avoid reaching WINEPATH number
- of char limit.
- """
-
- wine_paths = list(OrderedSet(wine_paths))
-
- getShortPathScript = '%s.bat' % str(uuid.uuid4()).lower():5
- with open(getShortPathScript, mode='w', encoding='utf-8') as f:
- f.write("@ECHO OFF\nfor %%x in (%*) do (\n echo|set /p=;%~sx\n)\n")
- f.flush()
- try:
- with open(os.devnull, 'w', encoding='utf-8') as stderr:
- wine_path = subprocess.check_output(
- winecmd +
- 'cmd', '/C', getShortPathScript + wine_paths,
- stderr=stderr).decode('utf-8')
- except subprocess.CalledProcessError as e:
- print("Could not get short paths: %s" % e)
- wine_path = ';'.join(wine_paths)
- finally:
- os.remove(getShortPathScript)
- if len(wine_path) > 2048:
- raise MesonException(
- 'WINEPATH size {} > 2048'
- ' this will cause random failure.'.format(
- len(wine_path)))
-
- return wine_path.strip(';')
-
-
-def run_once(func: T.Callable..., _T) -> T.Callable..., _T:
- ret = # type: T.List_T
-
- @wraps(func)
- def wrapper(*args: T.Any, **kwargs: T.Any) -> _T:
- if ret:
- return ret0
-
- val = func(*args, **kwargs)
- ret.append(val)
- return val
-
- return wrapper
-
-
-def generate_list(func: T.Callable..., T.Generator_T, None, None) -> T.Callable..., T.List_T:
- @wraps(func)
- def wrapper(*args: T.Any, **kwargs: T.Any) -> T.List_T:
- return list(func(*args, **kwargs))
-
- return wrapper
-
-
-class OptionOverrideProxy(collections.abc.MutableMapping):
-
- '''Mimic an option list but transparently override selected option
- values.
- '''
-
- # TODO: the typing here could be made more explicit using a TypeDict from
- # python 3.8 or typing_extensions
-
- def __init__(self, overrides: T.Dict'OptionKey', T.Any, *options: 'KeyedOptionDictType'):
- self.overrides = overrides.copy()
- self.options: T.Dict'OptionKey', UserOption = {}
- for o in options:
- self.options.update(o)
-
- def __getitem__(self, key: 'OptionKey') -> T.Union'UserOption':
- if key in self.options:
- opt = self.optionskey
- if key in self.overrides:
- opt = copy.copy(opt)
- opt.set_value(self.overrideskey)
- return opt
- raise KeyError('Option not found', key)
-
- def __setitem__(self, key: 'OptionKey', value: T.Union'UserOption') -> None:
- self.overrideskey = value.value
-
- def __delitem__(self, key: 'OptionKey') -> None:
- del self.overrideskey
-
- def __iter__(self) -> T.Iterator'OptionKey':
- return iter(self.options)
-
- def __len__(self) -> int:
- return len(self.options)
-
- def copy(self) -> 'OptionOverrideProxy':
- return OptionOverrideProxy(self.overrides.copy(), self.options.copy())
-
-
-class OptionType(enum.IntEnum):
-
- """Enum used to specify what kind of argument a thing is."""
-
- BUILTIN = 0
- BACKEND = 1
- BASE = 2
- COMPILER = 3
- PROJECT = 4
-
-# This is copied from coredata. There is no way to share this, because this
-# is used in the OptionKey constructor, and the coredata lists are
-# OptionKeys...
-_BUILTIN_NAMES = {
- 'prefix',
- 'bindir',
- 'datadir',
- 'includedir',
- 'infodir',
- 'libdir',
- 'libexecdir',
- 'localedir',
- 'localstatedir',
- 'mandir',
- 'sbindir',
- 'sharedstatedir',
- 'sysconfdir',
- 'auto_features',
- 'backend',
- 'buildtype',
- 'debug',
- 'default_library',
- 'errorlogs',
- 'install_umask',
- 'layout',
- 'optimization',
- 'stdsplit',
- 'strip',
- 'unity',
- 'unity_size',
- 'warning_level',
- 'werror',
- 'wrap_mode',
- 'force_fallback_for',
- 'pkg_config_path',
- 'cmake_prefix_path',
-}
-
-
-def _classify_argument(key: 'OptionKey') -> OptionType:
- """Classify arguments into groups so we know which dict to assign them to."""
-
- if key.name.startswith('b_'):
- return OptionType.BASE
- elif key.lang is not None:
- return OptionType.COMPILER
- elif key.name in _BUILTIN_NAMES or key.module:
- return OptionType.BUILTIN
- elif key.name.startswith('backend_'):
- assert key.machine is MachineChoice.HOST, str(key)
- return OptionType.BACKEND
- else:
- assert key.machine is MachineChoice.HOST, str(key)
- return OptionType.PROJECT
-
-
-@total_ordering
-class OptionKey:
-
- """Represents an option key in the various option dictionaries.
-
- This provides a flexible, powerful way to map option names from their
- external form (things like subproject:build.option) to something that
- internally easier to reason about and produce.
- """
-
- __slots__ = 'name', 'subproject', 'machine', 'lang', '_hash', 'type', 'module'
-
- name: str
- subproject: str
- machine: MachineChoice
- lang: T.Optionalstr
- _hash: int
- type: OptionType
- module: T.Optionalstr
-
- def __init__(self, name: str, subproject: str = '',
- machine: MachineChoice = MachineChoice.HOST,
- lang: T.Optionalstr = None,
- module: T.Optionalstr = None,
- _type: T.OptionalOptionType = None):
- # the _type option to the constructor is kinda private. We want to be
- # able tos ave the state and avoid the lookup function when
- # pickling/unpickling, but we need to be able to calculate it when
- # constructing a new OptionKey
- object.__setattr__(self, 'name', name)
- object.__setattr__(self, 'subproject', subproject)
- object.__setattr__(self, 'machine', machine)
- object.__setattr__(self, 'lang', lang)
- object.__setattr__(self, 'module', module)
- object.__setattr__(self, '_hash', hash((name, subproject, machine, lang, module)))
- if _type is None:
- _type = _classify_argument(self)
- object.__setattr__(self, 'type', _type)
-
- def __setattr__(self, key: str, value: T.Any) -> None:
- raise AttributeError('OptionKey instances do not support mutation.')
-
- def __getstate__(self) -> T.Dictstr, T.Any:
- return {
- 'name': self.name,
- 'subproject': self.subproject,
- 'machine': self.machine,
- 'lang': self.lang,
- '_type': self.type,
- 'module': self.module,
- }
-
- def __setstate__(self, state: T.Dictstr, T.Any) -> None:
- """De-serialize the state of a pickle.
-
- This is very clever. __init__ is not a constructor, it's an
- initializer, therefore it's safe to call more than once. We create a
- state in the custom __getstate__ method, which is valid to pass
- splatted to the initializer.
- """
- # Mypy doesn't like this, because it's so clever.
- self.__init__(**state) # type: ignore
-
- def __hash__(self) -> int:
- return self._hash
-
- def _to_tuple(self) -> T.Tuplestr, OptionType, str, str, MachineChoice, str:
- return (self.subproject, self.type, self.lang or '', self.module or '', self.machine, self.name)
-
- def __eq__(self, other: object) -> bool:
- if isinstance(other, OptionKey):
- return self._to_tuple() == other._to_tuple()
- return NotImplemented
-
- def __lt__(self, other: object) -> bool:
- if isinstance(other, OptionKey):
- return self._to_tuple() < other._to_tuple()
- return NotImplemented
-
- def __str__(self) -> str:
- out = self.name
- if self.lang:
- out = f'{self.lang}_{out}'
- if self.machine is MachineChoice.BUILD:
- out = f'build.{out}'
- if self.module:
- out = f'{self.module}.{out}'
- if self.subproject:
- out = f'{self.subproject}:{out}'
- return out
-
- def __repr__(self) -> str:
- return f'OptionKey({self.name!r}, {self.subproject!r}, {self.machine!r}, {self.lang!r}, {self.module!r}, {self.type!r})'
-
- @classmethod
- def from_string(cls, raw: str) -> 'OptionKey':
- """Parse the raw command line format into a three part tuple.
-
- This takes strings like `mysubproject:build.myoption` and Creates an
- OptionKey out of them.
- """
- try:
- subproject, raw2 = raw.split(':')
- except ValueError:
- subproject, raw2 = '', raw
-
- module = None
- for_machine = MachineChoice.HOST
- try:
- prefix, raw3 = raw2.split('.')
- if prefix == 'build':
- for_machine = MachineChoice.BUILD
- else:
- module = prefix
- except ValueError:
- raw3 = raw2
-
- from ..compilers import all_languages
- if any(raw3.startswith(f'{l}_') for l in all_languages):
- lang, opt = raw3.split('_', 1)
- else:
- lang, opt = None, raw3
- assert ':' not in opt
- assert '.' not in opt
-
- return cls(opt, subproject, for_machine, lang, module)
-
- def evolve(self, name: T.Optionalstr = None, subproject: T.Optionalstr = None,
- machine: T.OptionalMachineChoice = None, lang: T.Optionalstr = '',
- module: T.Optionalstr = '') -> 'OptionKey':
- """Create a new copy of this key, but with alterted members.
-
- For example:
- >>> a = OptionKey('foo', '', MachineChoice.Host)
- >>> b = OptionKey('foo', 'bar', MachineChoice.Host)
- >>> b == a.evolve(subproject='bar')
- True
- """
- # We have to be a little clever with lang here, because lang is valid
- # as None, for non-compiler options
- return OptionKey(
- name if name is not None else self.name,
- subproject if subproject is not None else self.subproject,
- machine if machine is not None else self.machine,
- lang if lang != '' else self.lang,
- module if module != '' else self.module
- )
-
- def as_root(self) -> 'OptionKey':
- """Convenience method for key.evolve(subproject='')."""
- return self.evolve(subproject='')
-
- def as_build(self) -> 'OptionKey':
- """Convenience method for key.evolve(machine=MachinceChoice.BUILD)."""
- return self.evolve(machine=MachineChoice.BUILD)
-
- def as_host(self) -> 'OptionKey':
- """Convenience method for key.evolve(machine=MachinceChoice.HOST)."""
- return self.evolve(machine=MachineChoice.HOST)
-
- def is_backend(self) -> bool:
- """Convenience method to check if this is a backend option."""
- return self.type is OptionType.BACKEND
-
- def is_builtin(self) -> bool:
- """Convenience method to check if this is a builtin option."""
- return self.type is OptionType.BUILTIN
-
- def is_compiler(self) -> bool:
- """Convenience method to check if this is a builtin option."""
- return self.type is OptionType.COMPILER
-
- def is_project(self) -> bool:
- """Convenience method to check if this is a project option."""
- return self.type is OptionType.PROJECT
-
- def is_base(self) -> bool:
- """Convenience method to check if this is a base option."""
- return self.type is OptionType.BASE

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mesonlib/vsenv.py Deleted

@@ -1,112 +0,0 @@
-import os
-import subprocess
-import json
-import pathlib
-import platform
-import shutil
-import tempfile
-
-from .. import mlog
-from .universal import MesonException, is_windows
-
-
-bat_template = '''@ECHO OFF
-
-call "{}"
-
-ECHO {}
-SET
-'''
-
-# If on Windows and VS is installed but not set up in the environment,
-# set it to be runnable. In this way Meson can be directly invoked
-# from any shell, VS Code etc.
-def _setup_vsenv(force: bool) -> bool:
-    if not is_windows():
-        return False
-    if os.environ.get('OSTYPE') == 'cygwin':
-        return False
-    if 'MESON_FORCE_VSENV_FOR_UNITTEST' not in os.environ:
-        if 'Visual Studio' in os.environ'PATH':
-            return False
-        # VSINSTALL is set when running setvars from a Visual Studio installation
-        # Tested with Visual Studio 2012 and 2017
-        if 'VSINSTALLDIR' in os.environ:
-            return False
-        # Check explicitly for cl when on Windows
-        if shutil.which('cl.exe'):
-            return False
-    if not force:
-        if shutil.which('cc'):
-            return False
-        if shutil.which('gcc'):
-            return False
-        if shutil.which('clang'):
-            return False
-        if shutil.which('clang-cl'):
-            return False
-
-    root = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles")
-    bat_locator_bin = pathlib.Path(root, 'Microsoft Visual Studio/Installer/vswhere.exe')
-    if not bat_locator_bin.exists():
-        raise MesonException(f'Could not find {bat_locator_bin}')
-    bat_json = subprocess.check_output(
-        
-            str(bat_locator_bin),
-            '-latest',
-            '-prerelease',
-            '-requiresAny',
-            '-requires', 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
-            '-requires', 'Microsoft.VisualStudio.Workload.WDExpress',
-            '-products', '*',
-            '-utf8',
-            '-format',
-            'json'
-        
-    )
-    bat_info = json.loads(bat_json)
-    if not bat_info:
-        # VS installer instelled but not VS itself maybe?
-        raise MesonException(f'Could not parse vswhere.exe output')
-    bat_root = pathlib.Path(bat_info0'installationPath')
-    if platform.machine() == 'ARM64':
-        bat_path = bat_root / 'VC/Auxiliary/Build/vcvarsx86_arm64.bat'
-    else:
-        bat_path = bat_root / 'VC/Auxiliary/Build/vcvars64.bat'
-        # if VS is not found try VS Express
-        if not bat_path.exists():
-            bat_path = bat_root / 'VC/Auxiliary/Build/vcvarsx86_amd64.bat'
-    if not bat_path.exists():
-        raise MesonException(f'Could not find {bat_path}')
-
-    mlog.log('Activating VS', bat_info0'catalog''productDisplayVersion')
-    bat_separator = '---SPLIT---'
-    bat_contents = bat_template.format(bat_path, bat_separator)
-    bat_file = tempfile.NamedTemporaryFile('w', suffix='.bat', encoding='utf-8', delete=False)
-    bat_file.write(bat_contents)
-    bat_file.flush()
-    bat_file.close()
-    bat_output = subprocess.check_output(bat_file.name, universal_newlines=True)
-    os.unlink(bat_file.name)
-    bat_lines = bat_output.split('\n')
-    bat_separator_seen = False
-    for bat_line in bat_lines:
-        if bat_line == bat_separator:
-            bat_separator_seen = True
-            continue
-        if not bat_separator_seen:
-            continue
-        if not bat_line:
-            continue
-        k, v = bat_line.split('=', 1)
-        os.environk = v
-    return True
-
-def setup_vsenv(force: bool = False) -> bool:
-    try:
-        return _setup_vsenv(force)
-    except MesonException as e:
-        if force:
-            raise
-        mlog.warning('Failed to activate VS environment:', str(e))
-        return False

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mesonlib/win32.py Deleted

@@ -1,39 +0,0 @@
-# SPDX-license-identifier: Apache-2.0
-# Copyright 2012-2021 The Meson development team
-# Copyright © 2021 Intel Corporation
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Windows specific implementations of mesonlib functionality."""
-
-import msvcrt
-import typing as T
-
-from .universal import MesonException
-from .platform import BuildDirLock as BuildDirLockBase
-
-__all__ = 'BuildDirLock'
-
-class BuildDirLock(BuildDirLockBase):
-
-    def __enter__(self) -> None:
-        self.lockfile = open(self.lockfilename, 'w', encoding='utf-8')
-        try:
-            msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_NBLCK, 1)
-        except (BlockingIOError, PermissionError):
-            self.lockfile.close()
-            raise MesonException('Some other Meson process is already using this build directory. Exiting.')
-
-    def __exit__(self, *args: T.Any) -> None:
-        msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_UNLCK, 1)
-        self.lockfile.close()

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/rpm.py Deleted

@@ -1,186 +0,0 @@
-# Copyright 2015 The Meson development team
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-'''This module provides helper functions for RPM related
-functionality such as generating template RPM spec file.'''
-
-from .. import build
-from .. import compilers
-import datetime
-from .. import mlog
-from . import GirTarget, TypelibTarget
-from . import ExtensionModule
-from ..interpreterbase import noKwargs
-
-import os
-
-class RPMModule(ExtensionModule):
- def __init__(self, interpreter):
- super().__init__(interpreter)
- self.methods.update({
- 'generate_spec_template': self.generate_spec_template,
- })
-
- @noKwargs
- def generate_spec_template(self, state, args, kwargs):
- required_compilers = self.__get_required_compilers(state)
- proj = state.project_name.replace(' ', '_').replace('\t', '_')
- so_installed = False
- devel_subpkg = False
- files = set()
- files_devel = set()
- to_delete = set()
- for target in state.targets.values():
- if isinstance(target, build.Executable) and target.need_install:
- files.add('%%{_bindir}/%s' % target.get_filename())
- elif isinstance(target, build.SharedLibrary) and target.need_install:
- files.add('%%{_libdir}/%s' % target.get_filename())
- for alias in target.get_aliases():
- if alias.endswith('.so'):
- files_devel.add('%%{_libdir}/%s' % alias)
- else:
- files.add('%%{_libdir}/%s' % alias)
- so_installed = True
- elif isinstance(target, build.StaticLibrary) and target.need_install:
- to_delete.add('%%{buildroot}%%{_libdir}/%s' % target.get_filename())
- mlog.warning('removing', mlog.bold(target.get_filename()),
- 'from package because packaging static libs not recommended')
- elif isinstance(target, GirTarget) and target.should_install():
- files_devel.add('%%{_datadir}/gir-1.0/%s' % target.get_filename()0)
- elif isinstance(target, TypelibTarget) and target.should_install():
- files.add('%%{_libdir}/girepository-1.0/%s' % target.get_filename()0)
- for header in state.headers:
- if header.get_install_subdir():
- files_devel.add('%%{_includedir}/%s/' % header.get_install_subdir())
- else:
- for hdr_src in header.get_sources():
- files_devel.add('%%{_includedir}/%s' % hdr_src)
- for man in state.man:
- for man_file in man.get_sources():
- if man.locale:
- files.add('%%{_mandir}/%s/man%u/%s.*' % (man.locale, int(man_file.split('.')-1), man_file))
- else:
- files.add('%%{_mandir}/man%u/%s.*' % (int(man_file.split('.')-1), man_file))
- if files_devel:
- devel_subpkg = True
-
- filename = os.path.join(state.environment.get_build_dir(),
- '%s.spec' % proj)
- with open(filename, 'w+', encoding='utf-8') as fn:
- fn.write('Name: %s\n' % proj)
- fn.write('Version: # FIXME\n')
- fn.write('Release: 1%{?dist}\n')
- fn.write('Summary: # FIXME\n')
- fn.write('License: # FIXME\n')
- fn.write('\n')
- fn.write('Source0: %{name}-%{version}.tar.xz # FIXME\n')
- fn.write('\n')
- fn.write('BuildRequires: meson\n')
- for compiler in required_compilers:
- fn.write('BuildRequires: %s\n' % compiler)
- for dep in state.environment.coredata.deps.host:
- fn.write('BuildRequires: pkgconfig(%s)\n' % dep0)
-# ext_libs and ext_progs have been removed from coredata so the following code
-# no longer works. It is kept as a reminder of the idea should anyone wish
-# to re-implement it.
-#
-# for lib in state.environment.coredata.ext_libs.values():
-# name = lib.get_name()
-# fn.write('BuildRequires: {} # FIXME\n'.format(name))
-# mlog.warning('replace', mlog.bold(name), 'with the real package.',
-# 'You can use following command to find package which '
-# 'contains this lib:',
-# mlog.bold("dnf provides '*/lib{}.so'".format(name)))
-# for prog in state.environment.coredata.ext_progs.values():
-# if not prog.found():
-# fn.write('BuildRequires: %%{_bindir}/%s # FIXME\n' %
-# prog.get_name())
-# else:
-# fn.write('BuildRequires: {}\n'.format(prog.get_path()))
- fn.write('\n')
- fn.write('%description\n')
- fn.write('\n')
- if devel_subpkg:
- fn.write('%package devel\n')
- fn.write('Summary: Development files for %{name}\n')
- fn.write('Requires: %{name}%{?_isa} = %{?epoch:%{epoch}:}{version}-%{release}\n')
- fn.write('\n')
- fn.write('%description devel\n')
- fn.write('Development files for %{name}.\n')
- fn.write('\n')
- fn.write('%prep\n')
- fn.write('%autosetup\n')
- fn.write('\n')
- fn.write('%build\n')
- fn.write('%meson\n')
- fn.write('%meson_build\n')
- fn.write('\n')
- fn.write('%install\n')
- fn.write('%meson_install\n')
- if to_delete:
- fn.write('rm -vf %s\n' % ' '.join(to_delete))
- fn.write('\n')
- fn.write('%check\n')
- fn.write('%meson_test\n')
- fn.write('\n')
- fn.write('%files\n')
- for f in files:
- fn.write('%s\n' % f)
- fn.write('\n')
- if devel_subpkg:
- fn.write('%files devel\n')
- for f in files_devel:
- fn.write('%s\n' % f)
- fn.write('\n')
- if so_installed:
- fn.write('%post -p /sbin/ldconfig\n')
- fn.write('%postun -p /sbin/ldconfig\n')
- fn.write('\n')
- fn.write('%changelog\n')
- fn.write('* %s meson <meson@example.com> - \n' %
- datetime.date.today().strftime('%a %b %d %Y'))
- fn.write('- \n')
- fn.write('\n')
- mlog.log('RPM spec template written to %s.spec.\n' % proj)
-
- def __get_required_compilers(self, state):
- required_compilers = set()
- for compiler in state.environment.coredata.compilers.host.values():
- # Elbrus has one 'lcc' package for every compiler
- if isinstance(compiler, compilers.GnuCCompiler):
- required_compilers.add('gcc')
- elif isinstance(compiler, compilers.GnuCPPCompiler):
- required_compilers.add('gcc-c++')
- elif isinstance(compiler, compilers.ElbrusCCompiler):
- required_compilers.add('lcc')
- elif isinstance(compiler, compilers.ElbrusCPPCompiler):
- required_compilers.add('lcc')
- elif isinstance(compiler, compilers.ElbrusFortranCompiler):
- required_compilers.add('lcc')
- elif isinstance(compiler, compilers.ValaCompiler):
- required_compilers.add('vala')
- elif isinstance(compiler, compilers.GnuFortranCompiler):
- required_compilers.add('gcc-gfortran')
- elif isinstance(compiler, compilers.GnuObjCCompiler):
- required_compilers.add('gcc-objc')
- elif compiler == compilers.GnuObjCPPCompiler:
- required_compilers.add('gcc-objc++')
- else:
- mlog.log('RPM spec file not created, generation not allowed for:',
- mlog.bold(compiler.get_id()))
- return required_compilers
-
-
-def initialize(*args, **kwargs):
- return RPMModule(*args, **kwargs)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/unstable_cuda.py Deleted

@@ -1,352 +0,0 @@
-# Copyright 2017 The Meson development team
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import typing as T
-import re
-
-from ..mesonlib import version_compare
-from ..compilers import CudaCompiler, Compiler
-
-from . import NewExtensionModule
-
-from ..interpreterbase import (
- flatten, permittedKwargs, noKwargs,
- InvalidArguments, FeatureNew
-)
-
-if T.TYPE_CHECKING:
- from . import ModuleState
-
-class CudaModule(NewExtensionModule):
-
- @FeatureNew('CUDA module', '0.50.0')
- def __init__(self, *args, **kwargs):
- super().__init__()
- self.methods.update({
- "min_driver_version": self.min_driver_version,
- "nvcc_arch_flags": self.nvcc_arch_flags,
- "nvcc_arch_readable": self.nvcc_arch_readable,
- })
-
- @noKwargs
- def min_driver_version(self, state: 'ModuleState',
- args: T.Tuplestr,
- kwargs: T.Dictstr, T.Any) -> str:
- argerror = InvalidArguments('min_driver_version must have exactly one positional argument: ' +
- 'a CUDA Toolkit version string. Beware that, since CUDA 11.0, ' +
- 'the CUDA Toolkit\'s components (including NVCC) are versioned ' +
- 'independently from each other (and the CUDA Toolkit as a whole).')
-
- if len(args) != 1 or not isinstance(args0, str):
- raise argerror
-
- cuda_version = args0
- driver_version_table = 
- {'cuda_version': '>=11.5.0', 'windows': '496.04', 'linux': '495.29.05'},
- {'cuda_version': '>=11.4.1', 'windows': '471.41', 'linux': '470.57.02'},
- {'cuda_version': '>=11.4.0', 'windows': '471.11', 'linux': '470.42.01'},
- {'cuda_version': '>=11.3.0', 'windows': '465.89', 'linux': '465.19.01'},
- {'cuda_version': '>=11.2.2', 'windows': '461.33', 'linux': '460.32.03'},
- {'cuda_version': '>=11.2.1', 'windows': '461.09', 'linux': '460.32.03'},
- {'cuda_version': '>=11.2.0', 'windows': '460.82', 'linux': '460.27.03'},
- {'cuda_version': '>=11.1.1', 'windows': '456.81', 'linux': '455.32'},
- {'cuda_version': '>=11.1.0', 'windows': '456.38', 'linux': '455.23'},
- {'cuda_version': '>=11.0.3', 'windows': '451.82', 'linux': '450.51.06'},
- {'cuda_version': '>=11.0.2', 'windows': '451.48', 'linux': '450.51.05'},
- {'cuda_version': '>=11.0.1', 'windows': '451.22', 'linux': '450.36.06'},
- {'cuda_version': '>=10.2.89', 'windows': '441.22', 'linux': '440.33'},
- {'cuda_version': '>=10.1.105', 'windows': '418.96', 'linux': '418.39'},
- {'cuda_version': '>=10.0.130', 'windows': '411.31', 'linux': '410.48'},
- {'cuda_version': '>=9.2.148', 'windows': '398.26', 'linux': '396.37'},
- {'cuda_version': '>=9.2.88', 'windows': '397.44', 'linux': '396.26'},
- {'cuda_version': '>=9.1.85', 'windows': '391.29', 'linux': '390.46'},
- {'cuda_version': '>=9.0.76', 'windows': '385.54', 'linux': '384.81'},
- {'cuda_version': '>=8.0.61', 'windows': '376.51', 'linux': '375.26'},
- {'cuda_version': '>=8.0.44', 'windows': '369.30', 'linux': '367.48'},
- {'cuda_version': '>=7.5.16', 'windows': '353.66', 'linux': '352.31'},
- {'cuda_version': '>=7.0.28', 'windows': '347.62', 'linux': '346.46'},
- 
-
- driver_version = 'unknown'
- for d in driver_version_table:
- if version_compare(cuda_version, d'cuda_version'):
- driver_version = d.get(state.host_machine.system, d'linux')
- break
-
- return driver_version
-
- @permittedKwargs('detected')
- def nvcc_arch_flags(self, state: 'ModuleState',
- args: T.TupleT.UnionCompiler, CudaCompiler, str,
- kwargs: T.Dictstr, T.Any) -> T.Liststr:
- nvcc_arch_args = self._validate_nvcc_arch_args(args, kwargs)
- ret = self._nvcc_arch_flags(*nvcc_arch_args)0
- return ret
-
- @permittedKwargs('detected')
- def nvcc_arch_readable(self, state: 'ModuleState',
- args: T.TupleT.UnionCompiler, CudaCompiler, str,
- kwargs: T.Dictstr, T.Any) -> T.Liststr:
- nvcc_arch_args = self._validate_nvcc_arch_args(args, kwargs)
- ret = self._nvcc_arch_flags(*nvcc_arch_args)1
- return ret
-
- @staticmethod
- def _break_arch_string(s):
- s = re.sub(' \t\r\n,;+', ';', s)
- s = s.strip(';').split(';')
- return s
-
- @staticmethod
- def _detected_cc_from_compiler(c):
- if isinstance(c, CudaCompiler):
- return c.detected_cc
- return ''
-
- @staticmethod
- def _version_from_compiler(c):
- if isinstance(c, CudaCompiler):
- return c.version
- if isinstance(c, str):
- return c
- return 'unknown'
-
- def _validate_nvcc_arch_args(self, args, kwargs):
- argerror = InvalidArguments('The first argument must be an NVCC compiler object, or its version string!')
-
- if len(args) < 1:
- raise argerror
- else:
- compiler = args0
- cuda_version = self._version_from_compiler(compiler)
- if cuda_version == 'unknown':
- raise argerror
-
- arch_list = if len(args) <= 1 else flatten(args1:)
- arch_list = self._break_arch_string(a) for a in arch_list
- arch_list = flatten(arch_list)
- if len(arch_list) > 1 and not set(arch_list).isdisjoint({'All', 'Common', 'Auto'}):
- raise InvalidArguments('''The special architectures 'All', 'Common' and 'Auto' must appear alone, as a positional argument!''')
- arch_list = arch_list0 if len(arch_list) == 1 else arch_list
-
- detected = kwargs.get('detected', self._detected_cc_from_compiler(compiler))
- detected = flatten(detected)
- detected = self._break_arch_string(a) for a in detected
- detected = flatten(detected)
- if not set(detected).isdisjoint({'All', 'Common', 'Auto'}):
- raise InvalidArguments('''The special architectures 'All', 'Common' and 'Auto' must appear alone, as a positional argument!''')
-
- return cuda_version, arch_list, detected
-
- def _filter_cuda_arch_list(self, cuda_arch_list, lo=None, hi=None, saturate=None):
- """
- Filter CUDA arch list (no codenames) for >= low and < hi architecture
- bounds, and deduplicate.
- If saturate is provided, architectures >= hi are replaced with saturate.
- """
-
- filtered_cuda_arch_list = 
- for arch in cuda_arch_list:
- if arch:
- if lo and version_compare(arch, '<' + lo):
- continue
- if hi and version_compare(arch, '>=' + hi):
- if not saturate:
- continue
- arch = saturate
- if arch not in filtered_cuda_arch_list:
- filtered_cuda_arch_list.append(arch)
- return filtered_cuda_arch_list
-
- def _nvcc_arch_flags(self, cuda_version, cuda_arch_list='Auto', detected=''):
- """
- Using the CUDA Toolkit version and the target architectures, compute
- the NVCC architecture flags.
- """
-
- # Replicates much of the logic of
- # https://github.com/Kitware/CMake/blob/master/Modules/FindCUDA/select_compute_arch.cmake
- # except that a bug with cuda_arch_list="All" is worked around by
- # tracking both lower and upper limits on GPU architectures.
-
- cuda_known_gpu_architectures = 'Fermi', 'Kepler', 'Maxwell' # noqa: E221
- cuda_common_gpu_architectures = '3.0', '3.5', '5.0' # noqa: E221
- cuda_hi_limit_gpu_architecture = None # noqa: E221
- cuda_lo_limit_gpu_architecture = '2.0' # noqa: E221
- cuda_all_gpu_architectures = '3.0', '3.2', '3.5', '5.0' # noqa: E221
-
- if version_compare(cuda_version, '<7.0'):
- cuda_hi_limit_gpu_architecture = '5.2'
-
- if version_compare(cuda_version, '>=7.0'):
- cuda_known_gpu_architectures += 'Kepler+Tegra', 'Kepler+Tesla', 'Maxwell+Tegra' # noqa: E221
- cuda_common_gpu_architectures += '5.2' # noqa: E221
-
- if version_compare(cuda_version, '<8.0'):
- cuda_common_gpu_architectures += '5.2+PTX' # noqa: E221
- cuda_hi_limit_gpu_architecture = '6.0' # noqa: E221
-
- if version_compare(cuda_version, '>=8.0'):
- cuda_known_gpu_architectures += 'Pascal', 'Pascal+Tegra' # noqa: E221
- cuda_common_gpu_architectures += '6.0', '6.1' # noqa: E221
- cuda_all_gpu_architectures += '6.0', '6.1', '6.2' # noqa: E221
-
- if version_compare(cuda_version, '<9.0'):
- cuda_common_gpu_architectures += '6.1+PTX' # noqa: E221
- cuda_hi_limit_gpu_architecture = '7.0' # noqa: E221
-
- if version_compare(cuda_version, '>=9.0'):
- cuda_known_gpu_architectures += 'Volta', 'Xavier' # noqa: E221
- cuda_common_gpu_architectures += '7.0' # noqa: E221
- cuda_all_gpu_architectures += '7.0', '7.2' # noqa: E221
- # https://docs.nvidia.com/cuda/archive/9.0/cuda-toolkit-release-notes/index.html#unsupported-features
- cuda_lo_limit_gpu_architecture = '3.0' # noqa: E221
-
- if version_compare(cuda_version, '<10.0'):
- cuda_common_gpu_architectures += '7.2+PTX' # noqa: E221
- cuda_hi_limit_gpu_architecture = '8.0' # noqa: E221
-
- if version_compare(cuda_version, '>=10.0'):
- cuda_known_gpu_architectures += 'Turing' # noqa: E221
- cuda_common_gpu_architectures += '7.5' # noqa: E221
- cuda_all_gpu_architectures += '7.5' # noqa: E221
-
- if version_compare(cuda_version, '<11.0'):
- cuda_common_gpu_architectures += '7.5+PTX' # noqa: E221
- cuda_hi_limit_gpu_architecture = '8.0' # noqa: E221
-
- if version_compare(cuda_version, '>=11.0'):
- cuda_known_gpu_architectures += 'Ampere' # noqa: E221
- cuda_common_gpu_architectures += '8.0' # noqa: E221
- cuda_all_gpu_architectures += '8.0' # noqa: E221
- # https://docs.nvidia.com/cuda/archive/11.0/cuda-toolkit-release-notes/index.html#deprecated-features
- cuda_lo_limit_gpu_architecture = '3.5' # noqa: E221
-
- if version_compare(cuda_version, '<11.1'):
- cuda_common_gpu_architectures += '8.0+PTX' # noqa: E221
- cuda_hi_limit_gpu_architecture = '8.6' # noqa: E221
-
- if version_compare(cuda_version, '>=11.1'):
- cuda_common_gpu_architectures += '8.6', '8.6+PTX' # noqa: E221
- cuda_all_gpu_architectures += '8.6' # noqa: E221
-
- if version_compare(cuda_version, '<12.0'):
- cuda_hi_limit_gpu_architecture = '9.0' # noqa: E221
-
- if not cuda_arch_list:
- cuda_arch_list = 'Auto'
-
- if cuda_arch_list == 'All': # noqa: E271
- cuda_arch_list = cuda_known_gpu_architectures
- elif cuda_arch_list == 'Common': # noqa: E271
- cuda_arch_list = cuda_common_gpu_architectures
- elif cuda_arch_list == 'Auto': # noqa: E271
- if detected:
- if isinstance(detected, list):
- cuda_arch_list = detected
- else:
- cuda_arch_list = self._break_arch_string(detected)
- cuda_arch_list = self._filter_cuda_arch_list(cuda_arch_list,
- cuda_lo_limit_gpu_architecture,
- cuda_hi_limit_gpu_architecture,
- cuda_common_gpu_architectures-1)
- else:
- cuda_arch_list = cuda_common_gpu_architectures
- elif isinstance(cuda_arch_list, str):
- cuda_arch_list = self._break_arch_string(cuda_arch_list)
-
- cuda_arch_list = sorted(x for x in set(cuda_arch_list) if x)
-
- cuda_arch_bin = 
- cuda_arch_ptx = 
- for arch_name in cuda_arch_list:
- arch_bin = 
- arch_ptx = 
- add_ptx = arch_name.endswith('+PTX')
- if add_ptx:
- arch_name = arch_name:-len('+PTX')
-
- if re.fullmatch('0-9+\\.0-9(\$0-9+\\.0-9\$)?', arch_name):
- arch_bin, arch_ptx = arch_name, arch_name
- else:
- arch_bin, arch_ptx = {
- 'Fermi': ('2.0', '2.1(2.0)', ),
- 'Kepler+Tegra': ('3.2', ),
- 'Kepler+Tesla': ('3.7', ),
- 'Kepler': ('3.0', '3.5', '3.5'),
- 'Maxwell+Tegra': ('5.3', ),
- 'Maxwell': ('5.0', '5.2', '5.2'),
- 'Pascal': ('6.0', '6.1', '6.1'),
- 'Pascal+Tegra': ('6.2', ),
- 'Volta': ('7.0', '7.0'),
- 'Xavier': ('7.2', ),
- 'Turing': ('7.5', '7.5'),
- 'Ampere': ('8.0', '8.0'),
- }.get(arch_name, (None, None))
-
- if arch_bin is None:
- raise InvalidArguments(f'Unknown CUDA Architecture Name {arch_name}!')
-
- cuda_arch_bin += arch_bin
-
- if add_ptx:
- if not arch_ptx:
- arch_ptx = arch_bin
- cuda_arch_ptx += arch_ptx
-
- cuda_arch_bin = sorted(list(set(cuda_arch_bin)))
- cuda_arch_ptx = sorted(list(set(cuda_arch_ptx)))
-
- nvcc_flags = 
- nvcc_archs_readable = 
-
- for arch in cuda_arch_bin:
- arch, codev = re.fullmatch(
- '(0-9+\\.0-9)(?:\$(0-9+\\.0-9)\$)?', arch).groups()
-
- if version_compare(arch, '<' + cuda_lo_limit_gpu_architecture):
- continue
- if version_compare(arch, '>=' + cuda_hi_limit_gpu_architecture):
- continue
-
- if codev:
- arch = arch.replace('.', '')
- codev = codev.replace('.', '')
- nvcc_flags += '-gencode', 'arch=compute_' + codev + ',code=sm_' + arch
- nvcc_archs_readable += 'sm_' + arch
- else:
- arch = arch.replace('.', '')
- nvcc_flags += '-gencode', 'arch=compute_' + arch + ',code=sm_' + arch
- nvcc_archs_readable += 'sm_' + arch
-
- for arch in cuda_arch_ptx:
- arch, codev = re.fullmatch(
- '(0-9+\\.0-9)(?:\$(0-9+\\.0-9)\$)?', arch).groups()
-
- if codev:
- arch = codev
-
- if version_compare(arch, '<' + cuda_lo_limit_gpu_architecture):
- continue
- if version_compare(arch, '>=' + cuda_hi_limit_gpu_architecture):
- continue
-
- arch = arch.replace('.', '')
- nvcc_flags += '-gencode', 'arch=compute_' + arch + ',code=compute_' + arch
- nvcc_archs_readable += 'compute_' + arch
-
- return nvcc_flags, nvcc_archs_readable
-
-def initialize(*args, **kwargs):
- return CudaModule(*args, **kwargs)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/unstable_external_project.py Deleted

@@ -1,297 +0,0 @@
-# Copyright 2020 The Meson development team
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from pathlib import Path
-import os
-import shlex
-import subprocess
-import typing as T
-
-from . import ExtensionModule, ModuleReturnValue, NewExtensionModule
-from .. import mlog, build
-from ..compilers.compilers import CFLAGS_MAPPING
-from ..envconfig import ENV_VAR_PROG_MAP
-from ..dependencies import InternalDependency, PkgConfigDependency
-from ..interpreterbase import FeatureNew
-from ..interpreter.type_checking import ENV_KW
-from ..interpreterbase.decorators import ContainerTypeInfo, KwargInfo, typed_kwargs, typed_pos_args
-from ..mesonlib import (EnvironmentException, MesonException, Popen_safe, MachineChoice,
-                        get_variable_regex, do_replacement, join_args, OptionKey)
-
-if T.TYPE_CHECKING:
-    from typing_extensions import TypedDict
-
-    from . import ModuleState
-    from ..interpreter import Interpreter
-    from ..interpreterbase import TYPE_var
-
-    class Dependency(TypedDict):
-
-        subdir: str
-
-    class AddProject(TypedDict):
-
-        configure_options: T.Liststr
-        cross_configure_options: T.Liststr
-        verbose: bool
-        env: build.EnvironmentVariables
-
-
-class ExternalProject(NewExtensionModule):
-    def __init__(self,
-                 state: 'ModuleState',
-                 configure_command: str,
-                 configure_options: T.Liststr,
-                 cross_configure_options: T.Liststr,
-                 env: build.EnvironmentVariables,
-                 verbose: bool):
-        super().__init__()
-        self.methods.update({'dependency': self.dependency_method,
-                             })
-
-        self.subdir = Path(state.subdir)
-        self.project_version = state.project_version
-        self.subproject = state.subproject
-        self.env = state.environment
-        self.build_machine = state.build_machine
-        self.host_machine = state.host_machine
-        self.configure_command = configure_command
-        self.configure_options = configure_options
-        self.cross_configure_options = cross_configure_options
-        self.verbose = verbose
-        self.user_env = env
-
-        self.src_dir = Path(self.env.get_source_dir(), self.subdir)
-        self.build_dir = Path(self.env.get_build_dir(), self.subdir, 'build')
-        self.install_dir = Path(self.env.get_build_dir(), self.subdir, 'dist')
-        _p = self.env.coredata.get_option(OptionKey('prefix'))
-        assert isinstance(_p, str), 'for mypy'
-        self.prefix = Path(_p)
-        _l = self.env.coredata.get_option(OptionKey('libdir'))
-        assert isinstance(_l, str), 'for mypy'
-        self.libdir = Path(_l)
-        _i = self.env.coredata.get_option(OptionKey('includedir'))
-        assert isinstance(_i, str), 'for mypy'
-        self.includedir = Path(_i)
-        self.name = self.src_dir.name
-
-        # On Windows if the prefix is "c:/foo" and DESTDIR is "c:/bar", `make`
-        # will install files into "c:/bar/c:/foo" which is an invalid path.
-        # Work around that issue by removing the drive from prefix.
-        if self.prefix.drive:
-            self.prefix = self.prefix.relative_to(self.prefix.drive)
-
-        # self.prefix is an absolute path, so we cannot append it to another path.
-        self.rel_prefix = self.prefix.relative_to(self.prefix.root)
-
-        self._configure(state)
-
-        self.targets = self._create_targets()
-
-    def _configure(self, state: 'ModuleState') -> None:
-        if self.configure_command == 'waf':
-            FeatureNew('Waf external project', '0.60.0', location=state.current_node).use(self.subproject)
-            waf = state.find_program('waf')
-            configure_cmd = waf.get_command()
-            configure_cmd += 'configure', '-o', str(self.build_dir)
-            workdir = self.src_dir
-            self.make = waf.get_command() + 'build'
-        else:
-            # Assume it's the name of a script in source dir, like 'configure',
-            # 'autogen.sh', etc).
-            configure_path = Path(self.src_dir, self.configure_command)
-            configure_prog = state.find_program(configure_path.as_posix())
-            configure_cmd = configure_prog.get_command()
-            workdir = self.build_dir
-            self.make = state.find_program('make').get_command()
-
-        d = ('PREFIX', '--prefix=@PREFIX@', self.prefix.as_posix()),
-             ('LIBDIR', '--libdir=@PREFIX@/@LIBDIR@', self.libdir.as_posix()),
-             ('INCLUDEDIR', None, self.includedir.as_posix()),
-             
-        self._validate_configure_options(d, state)
-
-        configure_cmd += self._format_options(self.configure_options, d)
-
-        if self.env.is_cross_build():
-            host = '{}-{}-{}'.format(self.host_machine.cpu_family,
-                                     self.build_machine.system,
-                                     self.host_machine.system)
-            d = ('HOST', None, host)
-            configure_cmd += self._format_options(self.cross_configure_options, d)
-
-        # Set common env variables like CFLAGS, CC, etc.
-        link_exelist: T.Liststr = 
-        link_args: T.Liststr = 
-        self.run_env = os.environ.copy()
-        for lang, compiler in self.env.coredata.compilersMachineChoice.HOST.items():
-            if any(lang not in i for i in (ENV_VAR_PROG_MAP, CFLAGS_MAPPING)):
-                continue
-            cargs = self.env.coredata.get_external_args(MachineChoice.HOST, lang)
-            assert isinstance(cargs, list), 'for mypy'
-            self.run_envENV_VAR_PROG_MAPlang = self._quote_and_join(compiler.get_exelist())
-            self.run_envCFLAGS_MAPPINGlang = self._quote_and_join(cargs)
-            if not link_exelist:
-                link_exelist = compiler.get_linker_exelist()
-                _l = self.env.coredata.get_external_link_args(MachineChoice.HOST, lang)
-                assert isinstance(_l, list), 'for mypy'
-                link_args = _l
-        if link_exelist:
-            # FIXME: Do not pass linker because Meson uses CC as linker wrapper,
-            # but autotools often expects the real linker (e.h. GNU ld).
-            # self.run_env'LD' = self._quote_and_join(link_exelist)
-            pass
-        self.run_env'LDFLAGS' = self._quote_and_join(link_args)
-
-        self.run_env = self.user_env.get_env(self.run_env)
-
-        PkgConfigDependency.setup_env(self.run_env, self.env, MachineChoice.HOST,
-                                      Path(self.env.get_build_dir(), 'meson-uninstalled').as_posix())
-
-        self.build_dir.mkdir(parents=True, exist_ok=True)
-        self._run('configure', configure_cmd, workdir)
-
-    def _quote_and_join(self, array: T.Liststr) -> str:
-        return ' '.join(shlex.quote(i) for i in array)
-
-    def _validate_configure_options(self, variables: T.ListT.Tuplestr, str, str, state: 'ModuleState') -> None:
-        # Ensure the user at least try to pass basic info to the build system,
-        # like the prefix, libdir, etc.
-        for key, default, val in variables:
-            if default is None:
-                continue
-            key_format = f'@{key}@'
-            for option in self.configure_options:
-                if key_format in option:
-                    break
-            else:
-                FeatureNew('Default configure_option', '0.57.0', location=state.current_node).use(self.subproject)
-                self.configure_options.append(default)
-
-    def _format_options(self, options: T.Liststr, variables: T.ListT.Tuplestr, str, str) -> T.Liststr:
-        out: T.Liststr = 
-        missing = set()
-        regex = get_variable_regex('meson')
-        confdata: T.Dictstr, T.Tuplestr, T.Optionalstr = {k: (v, None) for k, _, v in variables}
-        for o in options:
-            arg, missing_vars = do_replacement(regex, o, 'meson', confdata)
-            missing.update(missing_vars)
-            out.append(arg)
-        if missing:
-            var_list = ", ".join(map(repr, sorted(missing)))
-            raise EnvironmentException(
-                f"Variables {var_list} in configure options are missing.")
-        return out
-
-    def _run(self, step: str, command: T.Liststr, workdir: Path) -> None:
-        mlog.log(f'External project {self.name}:', mlog.bold(step))
-        m = 'Running command ' + str(command) + ' in directory ' + str(workdir) + '\n'
-        log_filename = Path(mlog.log_dir, f'{self.name}-{step}.log')
-        output = None
-        if not self.verbose:
-            output = open(log_filename, 'w', encoding='utf-8')
-            output.write(m + '\n')
-            output.flush()
-        else:
-            mlog.log(m)
-        p, *_ = Popen_safe(command, cwd=str(workdir), env=self.run_env,
-                           stderr=subprocess.STDOUT,
-                           stdout=output)
-        if p.returncode != 0:
-            m = f'{step} step returned error code {p.returncode}.'
-            if not self.verbose:
-                m += '\nSee logs: ' + str(log_filename)
-            raise MesonException(m)
-
-    def _create_targets(self) -> T.List'TYPE_var':
-        cmd = self.env.get_build_command()
-        cmd += '--internal', 'externalproject',
-                '--name', self.name,
-                '--srcdir', self.src_dir.as_posix(),
-                '--builddir', self.build_dir.as_posix(),
-                '--installdir', self.install_dir.as_posix(),
-                '--logdir', mlog.log_dir,
-                '--make', join_args(self.make),
-                
-        if self.verbose:
-            cmd.append('--verbose')
-
-        target_kwargs = {'output': f'{self.name}.stamp',
-                         'depfile': f'{self.name}.d',
-                         'command': cmd + '@OUTPUT@', '@DEPFILE@',
-                         'console': True,
-                         }
-        self.target = build.CustomTarget(self.name,
-                                         self.subdir.as_posix(),
-                                         self.subproject,
-                                         target_kwargs)
-
-        idir = build.InstallDir(self.subdir.as_posix(),
-                                Path('dist', self.rel_prefix).as_posix(),
-                                install_dir='.',
-                                install_mode=None,
-                                exclude=None,
-                                strip_directory=True,
-                                from_source_dir=False,
-                                subproject=self.subproject)
-
-        return self.target, idir
-
-    @typed_pos_args('external_project.dependency', str)
-    @typed_kwargs('external_project.dependency', KwargInfo('subdir', str, default=''))
-    def dependency_method(self, state: 'ModuleState', args: T.Tuplestr, kwargs: 'Dependency') -> InternalDependency:
-        libname = args0
-
-        abs_includedir = Path(self.install_dir, self.rel_prefix, self.includedir)
-        if kwargs'subdir':
-            abs_includedir = Path(abs_includedir, kwargs'subdir')
-        abs_libdir = Path(self.install_dir, self.rel_prefix, self.libdir)
-
-        version = self.project_version
-        compile_args = f'-I{abs_includedir}'
-        link_args = f'-L{abs_libdir}', f'-l{libname}'
-        sources = self.target
-        dep = InternalDependency(version, , compile_args, link_args, ,
-                                 , sources, , {})
-        return dep
-
-
-class ExternalProjectModule(ExtensionModule):
-    @FeatureNew('External build system Module', '0.56.0')
-    def __init__(self, interpreter: 'Interpreter'):
-        super().__init__(interpreter)
-        self.methods.update({'add_project': self.add_project,
-                             })
-
-    @typed_pos_args('external_project_mod.add_project', str)
-    @typed_kwargs(
-        'external_project.add_project',
-        KwargInfo('configure_options', ContainerTypeInfo(list, str), default=, listify=True),
-        KwargInfo('cross_configure_options', ContainerTypeInfo(list, str), default='--host=@HOST@', listify=True),
-        KwargInfo('verbose', bool, default=False),
-        ENV_KW,
-    )
-    def add_project(self, state: 'ModuleState', args: T.Tuplestr, kwargs: 'AddProject') -> ModuleReturnValue:
-        configure_command = args0
-        project = ExternalProject(state,
-                                  configure_command,
-                                  kwargs'configure_options',
-                                  kwargs'cross_configure_options',
-                                  kwargs'env',
-                                  kwargs'verbose')
-        return ModuleReturnValue(project, project.targets)
-
-
-def initialize(interp: 'Interpreter') -> ExternalProjectModule:
-    return ExternalProjectModule(interp)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/unstable_icestorm.py Deleted

@@ -1,89 +0,0 @@
-# Copyright 2017 The Meson development team
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .. import mesonlib
-from ..interpreterbase import flatten
-from ..interpreterbase import FeatureNew
-
-from . import ExtensionModule
-
-class IceStormModule(ExtensionModule):
-
-    @FeatureNew('FPGA/Icestorm Module', '0.45.0')
-    def __init__(self, interpreter):
-        super().__init__(interpreter)
-        self.yosys_bin = None
-        self.methods.update({
-            'project': self.project,
-        })
-
-    def detect_binaries(self, state):
-        self.yosys_bin = state.find_program('yosys')
-        self.arachne_bin = state.find_program('arachne-pnr')
-        self.icepack_bin = state.find_program('icepack')
-        self.iceprog_bin = state.find_program('iceprog')
-        self.icetime_bin = state.find_program('icetime')
-
-    def project(self, state, args, kwargs):
-        if not self.yosys_bin:
-            self.detect_binaries(state)
-        if not args:
-            raise mesonlib.MesonException('Project requires at least one argument, which is the project name.')
-        proj_name = args0
-        arg_sources = args1:
-        if not isinstance(proj_name, str):
-            raise mesonlib.MesonException('Argument must be a string.')
-        kwarg_sources = kwargs.get('sources', )
-        if not isinstance(kwarg_sources, list):
-            kwarg_sources = kwarg_sources
-        all_sources = self.interpreter.source_strings_to_files(flatten(arg_sources + kwarg_sources))
-        if 'constraint_file' not in kwargs:
-            raise mesonlib.MesonException('Constraint file not specified.')
-
-        constraint_file = self.interpreter.source_strings_to_files(kwargs'constraint_file')
-        if len(constraint_file) != 1:
-            raise mesonlib.MesonException('Constraint file must contain one and only one entry.')
-        blif_name = proj_name + '_blif'
-        blif_fname = proj_name + '.blif'
-        asc_name = proj_name + '_asc'
-        asc_fname = proj_name + '.asc'
-        bin_name = proj_name + '_bin'
-        bin_fname = proj_name + '.bin'
-        time_name = proj_name + '-time'
-        upload_name = proj_name + '-upload'
-
-        blif_target = self.interpreter.func_custom_target(None, blif_name, {
-            'input': all_sources,
-            'output': blif_fname,
-            'command': self.yosys_bin, '-q', '-p', 'synth_ice40 -blif @OUTPUT@', '@INPUT@'})
-
-        asc_target = self.interpreter.func_custom_target(None, asc_name, {
-            'input': blif_target,
-            'output': asc_fname,
-            'command': self.arachne_bin, '-q', '-d', '1k', '-p', constraint_file, '@INPUT@', '-o', '@OUTPUT@'})
-
-        bin_target = self.interpreter.func_custom_target(None, bin_name, {
-            'input': asc_target,
-            'output': bin_fname,
-            'command': self.icepack_bin, '@INPUT@', '@OUTPUT@',
-            'build_by_default': True})
-
-        self.interpreter.func_run_target(None, upload_name, {
-            'command': self.iceprog_bin, bin_target})
-
-        self.interpreter.func_run_target(None, time_name, {
-            'command': self.icetime_bin, bin_target})
-
-def initialize(*args, **kwargs):
-    return IceStormModule(*args, **kwargs)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/unstable_rust.py Deleted

@@ -1,235 +0,0 @@
-# Copyright © 2020 Intel Corporation
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import typing as T
-
-from . import ExtensionModule, ModuleReturnValue
-from .. import mlog
-from ..build import BothLibraries, BuildTarget, CustomTargetIndex, Executable, ExtractedObjects, GeneratedList, IncludeDirs, CustomTarget
-from ..dependencies import Dependency, ExternalLibrary
-from ..interpreter.interpreter import TEST_KWARGS
-from ..interpreterbase import ContainerTypeInfo, InterpreterException, KwargInfo, FeatureNew, typed_kwargs, typed_pos_args, noPosargs
-from ..mesonlib import File
-
-if T.TYPE_CHECKING:
-    from . import ModuleState
-    from ..interpreter import Interpreter
-    from ..interpreter import kwargs as _kwargs
-    from ..interpreter.interpreter import SourceInputs, SourceOutputs
-    from ..programs import ExternalProgram
-
-    from typing_extensions import TypedDict
-
-    class FuncTest(_kwargs.BaseTest):
-
-        dependencies: T.ListT.UnionDependency, ExternalLibrary
-        is_parallel: bool
-
-    class FuncBindgen(TypedDict):
-
-        args: T.Liststr
-        c_args: T.Liststr
-        include_directories: T.ListIncludeDirs
-        input: T.ListSourceInputs
-        output: str
-
-
-class RustModule(ExtensionModule):
-
-    """A module that holds helper functions for rust."""
-
-    @FeatureNew('rust module', '0.57.0')
-    def __init__(self, interpreter: 'Interpreter') -> None:
-        super().__init__(interpreter)
-        self._bindgen_bin: T.Optional'ExternalProgram' = None
-        self.methods.update({
-            'test': self.test,
-            'bindgen': self.bindgen,
-        })
-
-    @typed_pos_args('rust.test', str, BuildTarget)
-    @typed_kwargs(
-        'rust.test',
-        *TEST_KWARGS,
-        KwargInfo('is_parallel', bool, default=False),
-        KwargInfo(
-            'dependencies',
-            ContainerTypeInfo(list, (Dependency, ExternalLibrary)),
-            listify=True,
-            default=),
-    )
-    def test(self, state: 'ModuleState', args: T.Tuplestr, BuildTarget, kwargs: 'FuncTest') -> ModuleReturnValue:
-        """Generate a rust test target from a given rust target.
-
-        Rust puts it's unitests inside it's main source files, unlike most
-        languages that put them in external files. This means that normally
-        you have to define two separate targets with basically the same
-        arguments to get tests:
-
-        ```meson
-        rust_lib_sources = ...
-        rust_lib = static_library(
-            'rust_lib',
-            rust_lib_sources,
-        )
-
-        rust_lib_test = executable(
-            'rust_lib_test',
-            rust_lib_sources,
-            rust_args : '--test',
-        )
-
-        test(
-            'rust_lib_test',
-            rust_lib_test,
-            protocol : 'rust',
-        )
-        ```
-
-        This is all fine, but not very DRY. This method makes it much easier
-        to define rust tests:
-
-        ```meson
-        rust = import('unstable-rust')
-
-        rust_lib = static_library(
-            'rust_lib',
-            sources,
-        )
-
-        rust.test('rust_lib_test', rust_lib)
-        ```
-        """
-        name = args0
-        base_target: BuildTarget = args1
-        if not base_target.uses_rust():
-            raise InterpreterException('Second positional argument to rustmod.test() must be a rust based target')
-        extra_args = kwargs'args'
-
-        # Delete any arguments we don't want passed
-        if '--test' in extra_args:
-            mlog.warning('Do not add --test to rustmod.test arguments')
-            extra_args.remove('--test')
-        if '--format' in extra_args:
-            mlog.warning('Do not add --format to rustmod.test arguments')
-            i = extra_args.index('--format')
-            # Also delete the argument to --format
-            del extra_argsi + 1
-            del extra_argsi
-        for i, a in enumerate(extra_args):
-            if isinstance(a, str) and a.startswith('--format='):
-                del extra_argsi
-                break
-
-        dependencies = d for d in kwargs'dependencies'
-
-        # We need to cast here, as currently these don't have protocol in them, but test itself does.
-        tkwargs = T.cast('_kwargs.FuncTest', kwargs.copy())
-
-        tkwargs'args' = extra_args + '--test', '--format', 'pretty'
-        tkwargs'protocol' = 'rust'
-
-        new_target_kwargs = base_target.kwargs.copy()
-        # Don't mutate the shallow copied list, instead replace it with a new
-        # one
-        new_target_kwargs'rust_args' = new_target_kwargs.get('rust_args', ) + '--test'
-        new_target_kwargs'install' = False
-        new_target_kwargs'dependencies' = new_target_kwargs.get('dependencies', ) + dependencies
-
-        new_target = Executable(
-            name, base_target.subdir, state.subproject,
-            base_target.for_machine, base_target.sources,
-            base_target.objects, base_target.environment,
-            new_target_kwargs
-        )
-
-        test = self.interpreter.make_test(
-            self.interpreter.current_node, (name, new_target), tkwargs)
-
-        return ModuleReturnValue(None, new_target, test)
-
-    @noPosargs
-    @typed_kwargs(
-        'rust.bindgen',
-        KwargInfo('c_args', ContainerTypeInfo(list, str), default=, listify=True),
-        KwargInfo('args', ContainerTypeInfo(list, str), default=, listify=True),
-        KwargInfo('include_directories', ContainerTypeInfo(list, IncludeDirs), default=, listify=True),
-        KwargInfo(
-            'input',
-            ContainerTypeInfo(list, (File, GeneratedList, BuildTarget, BothLibraries, ExtractedObjects, CustomTargetIndex, CustomTarget, str), allow_empty=False),
-            default=,
-            listify=True,
-            required=True,
-        ),
-        KwargInfo('output', str, required=True),
-    )
-    def bindgen(self, state: 'ModuleState', args: T.List, kwargs: 'FuncBindgen') -> ModuleReturnValue:
-        """Wrapper around bindgen to simplify it's use.
-
-        The main thing this simplifies is the use of `include_directory`
-        objects, instead of having to pass a plethora of `-I` arguments.
-        """
-        header, *_deps = self.interpreter.source_strings_to_files(kwargs'input')
-
-        # Split File and Target dependencies to add pass to CustomTarget
-        depends: T.List'SourceOutputs' = 
-        depend_files: T.ListFile = 
-        for d in _deps:
-            if isinstance(d, File):
-                depend_files.append(d)
-            else:
-                depends.append(d)
-
-        inc_strs: T.Liststr = 
-        for i in kwargs'include_directories':
-            # bindgen always uses clang, so it's safe to hardcode -I here
-            inc_strs.extend(f'-I{x}' for x in i.to_string_list(
-                state.environment.get_source_dir(), state.environment.get_build_dir()))
-
-        if self._bindgen_bin is None:
-            self._bindgen_bin = state.find_program('bindgen')
-
-        name: str
-        if isinstance(header, File):
-            name = header.fname
-        elif isinstance(header, (BuildTarget, BothLibraries, ExtractedObjects)):
-            raise InterpreterException('bindgen source file must be a C header, not an object or build target')
-        else:
-            name = header.get_outputs()0
-
-        target = CustomTarget(
-            f'rustmod-bindgen-{name}'.replace('/', '_'),
-            state.subdir,
-            state.subproject,
-            {
-                'input': header,
-                'output': kwargs'output',
-                'command': self._bindgen_bin.get_command() + 
-                    '@INPUT@', '--output',
-                    os.path.join(state.environment.build_dir, '@OUTPUT@') +
-                    kwargs'args' + '--' + kwargs'c_args' + inc_strs +
-                    '-MD', '-MQ', '@INPUT@', '-MF', '@DEPFILE@',
-                'depfile': '@PLAINNAME@.d',
-                'depends': depends,
-                'depend_files': depend_files,
-            },
-            backend=state.backend,
-        )
-
-        return ModuleReturnValue(target, target)
-
-
-def initialize(interp: 'Interpreter') -> RustModule:
-    return RustModule(interp)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/unstable_simd.py Deleted

@@ -1,88 +0,0 @@
-# Copyright 2017 The Meson development team
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .. import mesonlib, compilers, mlog
-
-from . import ExtensionModule
-
-from ..interpreterbase import FeatureNew
-
-class SimdModule(ExtensionModule):
-
-    @FeatureNew('SIMD module', '0.42.0')
-    def __init__(self, interpreter):
-        super().__init__(interpreter)
-        # FIXME add Altivec and AVX512.
-        self.isets = ('mmx',
-                      'sse',
-                      'sse2',
-                      'sse3',
-                      'ssse3',
-                      'sse41',
-                      'sse42',
-                      'avx',
-                      'avx2',
-                      'neon',
-                      )
-        self.methods.update({
-            'check': self.check,
-        })
-
-    def check(self, state, args, kwargs):
-        result = 
-        if len(args) != 1:
-            raise mesonlib.MesonException('Check requires one argument, a name prefix for checks.')
-        prefix = args0
-        if not isinstance(prefix, str):
-            raise mesonlib.MesonException('Argument must be a string.')
-        if 'compiler' not in kwargs:
-            raise mesonlib.MesonException('Must specify compiler keyword')
-        if 'sources' in kwargs:
-            raise mesonlib.MesonException('SIMD module does not support the "sources" keyword')
-        basic_kwargs = {}
-        for key, value in kwargs.items():
-            if key not in self.isets and key != 'compiler':
-                basic_kwargskey = value
-        compiler = kwargs'compiler'
-        if not isinstance(compiler, compilers.compilers.Compiler):
-            raise mesonlib.MesonException('Compiler argument must be a compiler object.')
-        cdata = self.interpreter.func_configuration_data(None, , {})
-        conf = cdata.conf_data
-        for iset in self.isets:
-            if iset not in kwargs:
-                continue
-            iset_fname = kwargsiset # Might also be an array or Files. static_library will validate.
-            args = compiler.get_instruction_set_args(iset)
-            if args is None:
-                mlog.log('Compiler supports %s:' % iset, mlog.red('NO'))
-                continue
-            if args:
-                if not compiler.has_multi_arguments(args, state.environment)0:
-                    mlog.log('Compiler supports %s:' % iset, mlog.red('NO'))
-                    continue
-            mlog.log('Compiler supports %s:' % iset, mlog.green('YES'))
-            conf.values'HAVE_' + iset.upper() = ('1', 'Compiler supports %s.' % iset)
-            libname = prefix + '_' + iset
-            lib_kwargs = {'sources': iset_fname,
-                          }
-            lib_kwargs.update(basic_kwargs)
-            langarg_key = compiler.get_language() + '_args'
-            old_lang_args = mesonlib.extract_as_list(lib_kwargs, langarg_key)
-            all_lang_args = old_lang_args + args
-            lib_kwargslangarg_key = all_lang_args
-            result.append(self.interpreter.func_static_lib(None, libname, lib_kwargs))
-        return result, cdata
-
-def initialize(*args, **kwargs):
-    return SimdModule(*args, **kwargs)

_service:tar_scm:meson-0.61.5.tar.gz/test cases/cmake/11 cmake_module_path/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/100 no lang Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/100 no lang/main.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/100 no lang/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/101 no glib-compile-resources Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/101 no glib-compile-resources/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/102 number in combo Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/102 number in combo/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/103 bool in combo Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/103 bool in combo/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/104 compiler no lang Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/104 compiler no lang/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/105 no fallback Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/105 no fallback/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/105 no fallback/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/105 no fallback/subprojects/foob Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/106 feature require Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/106 feature require/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/106 feature require/meson_options.txt Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/107 feature require.bis Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/107 feature require.bis/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/108 no build get_external_property Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/108 no build get_external_property/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/109 enter subdir twice Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/109 enter subdir twice/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/109 enter subdir twice/sub Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/109 enter subdir twice/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/111 invalid fstring Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/111 invalid fstring/109 invalid fstring Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/111 invalid fstring/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/111 invalid fstring/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/112 compiler argument checking Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/112 compiler argument checking/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/113 empty fallback Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/113 empty fallback/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/113 empty fallback/subprojects/foo Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/113 empty fallback/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/114 cmake executable dependency Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/114 cmake executable dependency/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/114 cmake executable dependency/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/114 cmake executable dependency/subprojects/cmlib Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/114 cmake executable dependency/subprojects/cmlib/main.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/114 cmake executable dependency/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/115 allow_fallback with fallback Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/115 allow_fallback with fallback/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/116 nonsensical bindgen Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/116 nonsensical bindgen/src Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/116 nonsensical bindgen/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/117 run_target in test Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/117 run_target in test/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/117 run_target in test/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/118 run_target in add_install_script Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/118 run_target in add_install_script/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/118 run_target in add_install_script/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/119 pathsep in install_symlink Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/119 pathsep in install_symlink/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/38 libdir must be inside prefix Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/38 libdir must be inside prefix/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/38 libdir must be inside prefix/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/39 prefix absolute Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/39 prefix absolute/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/39 prefix absolute/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/40 kwarg assign Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/40 kwarg assign/prog.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/40 kwarg assign/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/41 custom target plainname many inputs Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/41 custom target plainname many inputs/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/41 custom target plainname many inputs/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/42 custom target outputs not matching install_dirs Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/42 custom target outputs not matching install_dirs/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/43 project name colon Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/43 project name colon/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/44 abs subdir Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/44 abs subdir/bob Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/44 abs subdir/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/44 abs subdir/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/45 abspath to srcdir Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/45 abspath to srcdir/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/45 abspath to srcdir/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/46 pkgconfig variables reserved Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/46 pkgconfig variables reserved/simple.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/46 pkgconfig variables reserved/simple.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/46 pkgconfig variables reserved/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/47 pkgconfig variables zero length Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/47 pkgconfig variables zero length/simple.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/47 pkgconfig variables zero length/simple.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/47 pkgconfig variables zero length/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/48 pkgconfig variables zero length value Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/48 pkgconfig variables zero length value/simple.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/48 pkgconfig variables zero length value/simple.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/48 pkgconfig variables zero length value/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/49 pkgconfig variables not key value Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/49 pkgconfig variables not key value/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/50 executable comparison Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/50 executable comparison/prog.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/50 executable comparison/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/51 inconsistent comparison Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/51 inconsistent comparison/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/51 inconsistent comparison/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/52 slashname Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/52 slashname/sub Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/52 slashname/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/53 reserved meson prefix Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/53 reserved meson prefix/meson-foo Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/53 reserved meson prefix/meson-foo/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/53 reserved meson prefix/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/54 wrong shared crate type Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/54 wrong shared crate type/foo.rs Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/54 wrong shared crate type/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/54 wrong shared crate type/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/55 wrong static crate type Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/55 wrong static crate type/foo.rs Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/55 wrong static crate type/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/55 wrong static crate type/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/56 or on new line Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/56 or on new line/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/56 or on new line/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/57 link with executable Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/57 link with executable/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/58 assign custom target index Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/58 assign custom target index/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/59 getoption prefix Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/59 getoption prefix/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/59 getoption prefix/subprojects/abc Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/59 getoption prefix/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/60 bad option argument Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/60 bad option argument/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/61 subproj filegrab Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/61 subproj filegrab/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/61 subproj filegrab/prog.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/61 subproj filegrab/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/61 subproj filegrab/subprojects/a Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/61 subproj filegrab/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/62 grab subproj Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/62 grab subproj/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/62 grab subproj/subprojects/foo Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/62 grab subproj/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/63 grab sibling Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/63 grab sibling/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/63 grab sibling/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/63 grab sibling/subprojects/a Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/63 grab sibling/subprojects/b Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/63 grab sibling/subprojects/b/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/63 grab sibling/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/64 string as link target Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/64 string as link target/prog.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/64 string as link target/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/65 dependency not-found and required Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/65 dependency not-found and required/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/66 subproj different versions Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/66 subproj different versions/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/66 subproj different versions/subprojects/a Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/66 subproj different versions/subprojects/b Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/66 subproj different versions/subprojects/c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/66 subproj different versions/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/67 wrong boost module Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/67 wrong boost module/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/68 install_data rename bad size Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/68 install_data rename bad size/file1.txt Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/68 install_data rename bad size/file2.txt Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/68 install_data rename bad size/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/68 install_data rename bad size/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/69 skip only subdir Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/69 skip only subdir/subdir Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/69 skip only subdir/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/70 dual override Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/70 dual override/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/70 dual override/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/71 override used Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/71 override used/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/71 override used/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/72 run_command unclean exit Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/72 run_command unclean exit/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/72 run_command unclean exit/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/73 int literal leading zero Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/73 int literal leading zero/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/74 configuration immutable Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/74 configuration immutable/input Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/74 configuration immutable/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/75 link with shared module on osx Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/75 link with shared module on osx/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/76 non ascii in ascii encoded configure file Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/76 non ascii in ascii encoded configure file/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/76 non ascii in ascii encoded configure file/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/77 subproj dependency not-found and required Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/77 subproj dependency not-found and required/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/78 unfound run Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/78 unfound run/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/79 framework dependency with version Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/79 framework dependency with version/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/80 override exe config Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/80 override exe config/foo.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/80 override exe config/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/81 gl dependency with version Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/81 gl dependency with version/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/82 threads dependency with version Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/82 threads dependency with version/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/83 gtest dependency with version Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/83 gtest dependency with version/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/83 gtest dependency with version/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/84 dub libray Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/84 dub libray/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/85 dub executable Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/85 dub executable/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/86 dub compiler Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/86 dub compiler/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/87 subproj not-found dep Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/87 subproj not-found dep/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/87 subproj not-found dep/subprojects/somesubproj Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/87 subproj not-found dep/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/88 invalid configure file Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/88 invalid configure file/input Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/88 invalid configure file/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/89 kwarg dupe Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/89 kwarg dupe/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/90 missing pch file Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/90 missing pch file/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/91 pch source different folder Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/91 pch source different folder/include Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/91 pch source different folder/include/pch.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/91 pch source different folder/src Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/91 pch source different folder/src/pch.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/91 pch source different folder/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/92 unknown config tool Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/92 unknown config tool/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/93 custom target install data Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/93 custom target install data/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/94 add dict non string key Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/94 add dict non string key/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/95 add dict duplicate keys Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/95 add dict duplicate keys/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/96 no host get_external_property Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/96 no host get_external_property/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/97 no native compiler Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/97 no native compiler/main.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/97 no native compiler/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/98 subdir parse error Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/98 subdir parse error/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/98 subdir parse error/subdir Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/98 subdir parse error/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/99 invalid option file Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/99 invalid option file/test.json Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk/lib Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk/lib/com_mesonbuild_JdkTest.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk/lib/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk/src Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk/src/com Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk/src/com/mesonbuild Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk/src/com/mesonbuild/JdkTest.java Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk/src/com/mesonbuild/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/java/9 jdk/src/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/100 custom target name Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/100 custom target name/file.txt.in Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/100 custom target name/subdir Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/101 relative find program Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/101 relative find program/subdir Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/102 rlib linkage Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/103 python without pkgconfig Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/103 python without pkgconfig/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/39 python extmodule Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/39 python extmodule/ext Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/39 python extmodule/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/40 external, internal library rpath Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/40 external, internal library rpath/built library Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/40 external, internal library rpath/external library Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/41 featurenew subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/41 featurenew subprojects/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/41 featurenew subprojects/subprojects/bar Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/41 featurenew subprojects/subprojects/baz Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/41 featurenew subprojects/subprojects/foo Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/42 rpath order Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/42 rpath order/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/42 rpath order/subprojects/sub1 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/42 rpath order/subprojects/sub1/lib.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/42 rpath order/subprojects/sub2 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/42 rpath order/subprojects/sub2/lib.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/43 dep order Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/43 dep order/lib1.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/43 dep order/lib2.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/44 promote wrap Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/44 promote wrap/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/44 promote wrap/subprojects/s1 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/44 promote wrap/subprojects/s1/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/44 promote wrap/subprojects/s1/subprojects/ambiguous Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/44 promote wrap/subprojects/s2 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/44 promote wrap/subprojects/s2/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/45 vscpp17 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/46 native dep pkgconfig var Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/46 native dep pkgconfig var/cross_pkgconfig Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/46 native dep pkgconfig var/native_pkgconfig Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/47 native file binary Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/48 reconfigure Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/48 reconfigure/main.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/48 reconfigure/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/48 reconfigure/subprojects/sub1 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/49 testsetup default Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/50 pkgconfig csharp library Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/51 noncross options Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/52 ldflagdedup Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/53 pkgconfig static link order Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/53 pkgconfig static link order/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/54 clang-format Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/54 clang-format/dummydir.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/54 clang-format/dummydir.h/dummy.dat Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/55 introspect buildoptions Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/55 introspect buildoptions/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/55 introspect buildoptions/subprojects/projectBad Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/55 introspect buildoptions/subprojects/projectBad/meson_options.txt Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/56 dedup compiler libs Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/56 dedup compiler libs/app Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/56 dedup compiler libs/liba Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/56 dedup compiler libs/libb Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/57 introspection Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/57 introspection/sharedlib Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/57 introspection/staticlib Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/58 pkg_config_path option Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/58 pkg_config_path option/build_extra_path Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/58 pkg_config_path option/host_extra_path Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/59 introspect buildoptions Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/59 introspect buildoptions/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/59 introspect buildoptions/subprojects/evilFile.txt Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/59 introspect buildoptions/subprojects/projectA Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/59 introspect buildoptions/subprojects/projectBad Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/60 native file override Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/61 identity cross Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/62 pkgconfig relative paths Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/62 pkgconfig relative paths/pkgconfig Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/63 cmake_prefix_path Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/63 cmake_prefix_path/prefix Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/63 cmake_prefix_path/prefix/lib Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/63 cmake_prefix_path/prefix/lib/cmake Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/63 cmake_prefix_path/prefix/lib/cmake/mesontest Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/64 cmake parser Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/64 cmake parser/meson.build Deleted

@@ -1,19 +0,0 @@
-project('61 cmake parser')
-
-dep = dependency('mesontest')
-
-# Test a bunch of variations of the set() command
-assert(dep.get_variable(cmake : 'VAR_WITHOUT_SPACES') == 'NoSpaces', 'set() without spaces incorrect')
-assert(dep.get_variable(cmake : 'VAR_WITH_SPACES') == 'With Spaces', 'set() with spaces incorrect')
-
-assert(dep.get_variable(cmake : 'VAR_WITHOUT_SPACES_PS') == 'NoSpaces', 'set(PARENT_SCOPE) without spaces incorrect')
-assert(dep.get_variable(cmake : 'VAR_WITH_SPACES_PS') == 'With Spaces', 'set(PARENT_SCOPE) with spaces incorrect')
-
-assert(dep.get_variable(cmake : 'VAR_THAT_IS_UNSET', default_value : 'sentinal') == 'sentinal', 'set() to unset is incorrect')
-assert(dep.get_variable(cmake : 'CACHED_STRING_NS') == 'foo', 'set(CACHED) without spaces is incorrect')
-assert(dep.get_variable(cmake : 'CACHED_STRING_WS') == 'foo bar', 'set(CACHED STRING) with spaces is incorrect')
-assert(dep.get_variable(cmake : 'CACHED_STRING_ARRAY_NS') == 'foo', 'bar', 'set(CACHED STRING) without spaces is incorrect')
-assert(dep.get_variable(cmake : 'CACHED_STRING_ARRAY_WS') == 'foo', 'foo bar', 'bar', 'set(CACHED STRING) with spaces is incorrect')
-
-# We don't support this, so it should be unset.
-assert(dep.get_variable(cmake : 'ENV{var}', default_value : 'sentinal') == 'sentinal', 'set(ENV) should be ignored')
\ No newline at end of file

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/64 cmake parser/prefix Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/64 cmake parser/prefix/lib Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/64 cmake parser/prefix/lib/cmake Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/64 cmake parser/prefix/lib/cmake/mesontest Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/65 alias target Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/65 alias target/main.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/65 alias target/subdir Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/66 static archive stripping Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/66 static archive stripping/app Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/66 static archive stripping/lib Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/67 static link Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/67 static link/lib Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/68 test env value Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/69 clang-tidy Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/69 clang-tidy/dummydir.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/70 cross Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/71 cross test passed Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/71 cross test passed/src Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/72 summary Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/72 summary/meson.build Deleted

@@ -1,23 +0,0 @@
-project('My Project', version : '1.0')
-
-subproject('sub')
-subproject('sub2', required : false)
-
-summary({'Some boolean': false,
-         'Another boolean': true,
-         'Some string': 'Hello World',
-         'A list': 'string', 1, true,
-         'empty list': ,
-         'enabled_opt': get_option('enabled_opt'),
-        }, section: 'Configuration')
-summary({'missing prog': find_program('xyzzy', required: false),
-         'existing prog': import('python').find_installation(),
-         'missing dep': dependency('', required: false),
-         'external dep': dependency('zlib', required: false),
-         'internal dep': declare_dependency(),
-        }, section: 'Stuff')
-summary('A number', 1, section: 'Configuration')
-summary('yes', true, bool_yn : true, section: 'Configuration')
-summary('no', false, bool_yn : true, section: 'Configuration')
-summary('coma list', 'a', 'b', 'c', list_sep: ', ', section: 'Configuration')
-summary('long coma list', 'alpha', 'alphacolor', 'apetag', 'audiofx', 'audioparsers', 'auparse', 'autodetect', 'avi', list_sep: ', ', section: 'Plugins')

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/72 summary/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/72 summary/subprojects/sub Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/72 summary/subprojects/sub2 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/72 summary/subprojects/sub2/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/72 summary/subprojects/sub2/subprojects/subsub Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/73 wrap file url Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/73 wrap file url/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/74 dep files Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/74 dep files/foo.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/75 pkgconfig prefixes Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/75 pkgconfig prefixes/client Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/75 pkgconfig prefixes/val1 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/75 pkgconfig prefixes/val2 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/76 subdir libdir Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/76 subdir libdir/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/76 subdir libdir/subprojects/flub Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/77 as link whole Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/78 nostdlib Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/78 nostdlib/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/78 nostdlib/subprojects/mylibc Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/79 user options for subproject Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/79 user options for subproject/75 user options for subproject Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/80 global-rpath Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/80 global-rpath/yonder Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/81 wrap-git Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/81 wrap-git/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/81 wrap-git/subprojects/packagefiles Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/81 wrap-git/subprojects/packagefiles/wrap_git_builddef Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/81 wrap-git/subprojects/wrap_git_upstream Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/82 meson version compare Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/82 meson version compare/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/82 meson version compare/subprojects/foo Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/83 cross only introspect Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/84 change option choices Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/85 nested subproject regenerate depends Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/85 nested subproject regenerate depends/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/85 nested subproject regenerate depends/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/85 nested subproject regenerate depends/subprojects/sub1 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/85 nested subproject regenerate depends/subprojects/sub2 Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/86 cpp modules Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/86 cpp modules/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/87 prelinking Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/88 run native test Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/89 multiple envvars Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/90 pkgconfig build rpath order Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/90 pkgconfig build rpath order/sub Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/91 devenv Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/91 devenv/meson.build Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/91 devenv/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/91 devenv/subprojects/sub Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/91 devenv/test-devenv.py Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/92 install skip subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/92 install skip subprojects/foo Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/92 install skip subprojects/foo.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/92 install skip subprojects/foo.dat Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/92 install skip subprojects/foo.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/92 install skip subprojects/foo/foofile Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/92 install skip subprojects/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/92 install skip subprojects/subprojects/bar Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/92 install skip subprojects/subprojects/bar/bar Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/92 install skip subprojects/subprojects/bar/bar.dat Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/93 new subproject in configured project Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/93 new subproject in configured project/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/93 new subproject in configured project/subprojects/sub Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/94 clangformat Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/94 clangformat/not-included Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/94 clangformat/not-included/badformat.cpp Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/94 clangformat/src Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/95 custominc Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/95 custominc/easytogrepfor Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/96 implicit force fallback Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/96 implicit force fallback/subprojects Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/96 implicit force fallback/subprojects/something Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/97 compiler.links file arg Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/98 link full name Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/98 link full name/libtestprovider Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/98 link full name/proguser Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/bar-custom.txt Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/bar-devel.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/bar-notag.txt Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/custom_files Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/foo.in Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/foo1-devel.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/lib.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/main.c Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/meson.build Deleted

@@ -1,82 +0,0 @@
-project('install tag', 'c')
-
-subdir('subdir')
-
-# Those files should not be tagged
-configure_file(input: 'foo.in', output: 'foo-notag.h',
-  configuration: {'foo': 'bar'},
-  install_dir: get_option('datadir'),
-  install: true,
-)
-install_data('bar-notag.txt',
-  install_dir: get_option('datadir')
-)
-custom_target('ct1',
-  output: 'out1-notag.txt', 'out2-notag.txt',
-  command: 'script.py', '@OUTPUT@',
-  install_dir: get_option('datadir'),
-  install: true,
-)
-
-# Those files should be tagged as devel
-install_headers('foo1-devel.h')
-install_data('bar-devel.h',
-  install_dir: get_option('includedir'),
-)
-configure_file(input: 'foo.in', output: 'foo2-devel.h',
-  configuration: {'foo': 'bar'},
-  install_dir: get_option('includedir'),
-  install: true,
-)
-static_library('static', 'lib.c',
-  install: true,
-)
-
-# Those files should have 'runtime' tag
-executable('app', 'main.c',
-  install: true,
-)
-shared_library('shared', 'lib.c',
-  install: true,
-)
-both_libraries('both', 'lib.c',
-  install: true,
-)
-
-# Those files should have custom tag
-install_data('bar-custom.txt',
-  install_dir: get_option('datadir'),
-  install_tag: 'custom')
-configure_file(input: 'foo.in', output: 'foo-custom.h',
-  configuration: {'foo': 'bar'},
-  install_dir: get_option('datadir'),
-  install_tag: 'custom',
-  install: true,
-)
-both_libraries('bothcustom', 'lib.c',
-  install_tag: 'custom',
-  install: true,
-)
-custom_target('ct2',
-  output: 'out1-custom.txt', 'out2-custom.txt',
-  command: 'script.py', '@OUTPUT@',
-  install_dir: get_option('datadir'),
-  install_tag: 'custom',
-  install: true,
-)
-install_subdir('custom_files',
-  install_dir: get_option('datadir'),
-  install_tag: 'custom',
-)
-
-# First is custom, 2nd is devel, 3rd has no tag
-custom_target('ct3',
-  output: 'out3-custom.txt', 'out-devel.h', 'out3-notag.txt',
-  command: 'script.py', '@OUTPUT@',
-  install_dir: get_option('datadir'), get_option('includedir'), get_option('datadir'),
-  install_tag: 'custom', 'devel', false,
-  install: true,
-)
-
-meson.add_install_script('script.py', install_tag: 'custom')
-meson.add_install_script('script.py')

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/script.py Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/subdir Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/subdir/bar2-devel.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/subdir/foo2.in Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/99 install all targets/subdir/foo3-devel.h Deleted

_service:tar_scm:meson-0.61.5.tar.gz/test cases/windows/19 vs install static lib with generated obj deps Deleted

_service:tar_scm:meson-0.61.5.tar.gz/tools/gen_data.py Deleted

@@ -1,140 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2020 Daniel Mensinger
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-# http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import sys
-import hashlib
-import textwrap
-import re
-from pathlib import Path
-from datetime import datetime
-import typing as T
-
-class DataFile:
- file_counter = 0
-
- def __init__(self, path: Path, root: Path):
- self.path = path
- self.id = self.path.relative_to(root)
- self.data_str = f'file_{DataFile.file_counter}_data_' + re.sub('^a-zA-Z0-9', '_', self.path.name)
- DataFile.file_counter += 1
-
- b = self.path.read_bytes()
- self.data = b.decode()
- self.sha256sum = hashlib.sha256(b).hexdigest()
-
- def __repr__(self) -> str:
- return f'<{type(self).__name__}: {self.sha256sum} {self.id}>'
-
-def main() -> int:
- root_dir = Path(__file__).resolve().parents1
- mesonbuild_dir = root_dir / 'mesonbuild'
- out_file = mesonbuild_dir / 'mesondata.py'
-
- data_dirs = sorted(mesonbuild_dir.glob('**/data'))
-
- data_files: T.ListDataFile = 
-
- for d in data_dirs:
- for p in sorted(d.iterdir()):
- data_files += DataFile(p, mesonbuild_dir)
-
- print(f'Found {len(data_files)} data files')
-
- # Generate the data script
- data = ''
-
- data += textwrap.dedent(f'''\
- # Copyright {datetime.today().year} The Meson development team
-
- # Licensed under the Apache License, Version 2.0 (the "License");
- # you may not use this file except in compliance with the License.
- # You may obtain a copy of the License at
-
- # http://www.apache.org/licenses/LICENSE-2.0
-
- # Unless required by applicable law or agreed to in writing, software
- # distributed under the License is distributed on an "AS IS" BASIS,
- # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- # See the License for the specific language governing permissions and
- # limitations under the License.
-
-
- ####
- #### WARNING: This is an automatically generated file! Do not edit!
- #### Generated by {Path(__file__).resolve().relative_to(root_dir)}
- ####
-
-
- # TODO: Remember to remove this also from tools/gen_data.py
- from pathlib import Path
- import typing as T
-
- if T.TYPE_CHECKING:
- from .environment import Environment
-
- ######################
- # BEGIN Data section #
- ######################
-
- ''')
-
- for i in data_files:
- data += f"{i.data_str} = '''\\\n{i.data}'''\n\n"
-
- data += textwrap.dedent(f'''
- ####################
- # END Data section #
- ####################
-
- class DataFile:
- def __init__(self, path: Path, sha256sum: str, data: str) -> None:
- self.path = path
- self.sha256sum = sha256sum
- self.data = data
-
- def write_once(self, path: Path) -> None:
- if not path.exists():
- path.write_text(self.data, encoding='utf-8')
-
- def write_to_private(self, env: 'Environment') -> Path:
- out_file = Path(env.scratch_dir) / 'data' / self.path.name
- out_file.parent.mkdir(exist_ok=True)
- self.write_once(out_file)
- return out_file
-
-
- mesondata = {{
- ''')
-
- for i in data_files:
- data += textwrap.indent(textwrap.dedent(f"""\
- '{i.id}': DataFile(
- Path('{i.id}'),
- '{i.sha256sum}',
- {i.data_str},
- ),
- """), ' ')
-
- data += textwrap.dedent('''\
- }
- ''')
-
- print(f'Updating {out_file}')
- out_file.write_text(data, encoding='utf-8')
- return 0
-
-if __name__ == '__main__':
- sys.exit(main())

_service:tar_scm:meson-0.61.5.tar.gz/.flake8 -> _service:tar_scm:meson-1.0.1.tar.gz/.flake8 Changed

_service:tar_scm:meson-1.0.1.tar.gz/.github/codeql Added

_service:tar_scm:meson-1.0.1.tar.gz/.github/codeql/codeql-config.yml Added

_service:tar_scm:meson-1.0.1.tar.gz/.github/codeql/lgtm.qls Added

_service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/codeql-analysis.yml Added

_service:tar_scm:meson-0.61.5.tar.gz/.github/workflows/cygwin.yml -> _service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/cygwin.yml Changed

@@ -1,7 +1,7 @@
 name: cygwin
 
 concurrency:
- group: cygwin-${{ github.head_ref }}
+ group: cygwin-${{ github.head_ref || github.ref }}
 cancel-in-progress: true
 
 on:
@@ -18,6 +18,9 @@
 - ".github/workflows/cygwin.yml"
 - "run*tests.py"
 
+permissions:
+ contents: read
+
 jobs:
 test:
 runs-on: windows-latest
@@ -43,7 +46,7 @@
 
 - run: git config --global core.autocrlf input
 
- - uses: actions/checkout@v2
+ - uses: actions/checkout@v3
 
 - uses: cygwin/cygwin-install-action@master
 with:
@@ -71,6 +74,12 @@
 vala
 zlib-devel
 
+ - name: work around gcovr bug https://github.com/gcovr/gcovr/pull/576
+ run: |
+ export PATH=/usr/bin:/usr/local/bin:$(cygpath ${SYSTEMROOT})/system32
+ python3 -m pip --disable-pip-version-check install 'jinja2<3.1.0'
+ shell: C:\cygwin\bin\bash.exe --noprofile --norc -o igncr -eo pipefail '{0}'
+
 - name: Run pip
 run: |
 export PATH=/usr/bin:/usr/local/bin:$(cygpath ${SYSTEMROOT})/system32
@@ -87,7 +96,7 @@
 SKIP_STATIC_BOOST: 1
 shell: C:\cygwin\bin\bash.exe --noprofile --norc -o igncr -eo pipefail '{0}'
 
- - uses: actions/upload-artifact@v2
+ - uses: actions/upload-artifact@v3
 with:
 name: ${{ matrix.NAME }}
 path: meson-test-run.*

_service:tar_scm:meson-0.61.5.tar.gz/.github/workflows/file_format.yml -> _service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/file_format.yml Changed

_service:tar_scm:meson-0.61.5.tar.gz/.github/workflows/images.yml -> _service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/images.yml Changed

_service:tar_scm:meson-0.61.5.tar.gz/.github/workflows/lint.yml -> _service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/lint.yml Changed

@@ -1,7 +1,7 @@
 name: Lint
 
 concurrency:
-  group: lint-${{ github.head_ref }}
+  group: lint-${{ github.head_ref || github.ref }}
   cancel-in-progress: true
 
 on:
@@ -14,24 +14,37 @@
     - "**.py"
     - ".github/workflows/lint.yml"
 
+permissions:
+  contents: read
+
 jobs:
 
   pylint:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-python@v2
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
       with:
         python-version: '3.x'
     - run: python -m pip install pylint
     - run: pylint mesonbuild
 
+  flake8:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+      - run: python -m pip install flake8
+      - run: flake8 mesonbuild/
+
   mypy:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-python@v2
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
       with:
         python-version: '3.x'
-    - run: python -m pip install mypy
+    - run: python -m pip install mypy types-PyYAML
     - run: python run_mypy.py

_service:tar_scm:meson-0.61.5.tar.gz/.github/workflows/macos.yml -> _service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/macos.yml Changed

@@ -1,7 +1,7 @@
 name: macos
 
 concurrency:
-  group: macos-${{ github.head_ref }}
+  group: macos-${{ github.head_ref || github.ref }}
   cancel-in-progress: true
 
 on:
@@ -20,12 +20,15 @@
       - ".github/workflows/macos.yml"
       - "run_unittests.py"
 
+permissions:
+  contents: read
+
 jobs:
   unittests-appleclang:
     runs-on: macos-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-python@v2
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
       with:
         python-version: '3.x'
     - run: |
@@ -63,10 +66,18 @@
       MESON_CI_JOBNAME: ${{ matrix.NAME }}
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
+    # Avoid picking up an older version of LLVM that does not work.
+    - run: brew update
+    # github actions overwrites brew's python. Force it to reassert itself, by running in a separate step.
+    - name: unbreak python in github actions
+      run: |
+        find /usr/local/bin -lname '*/Library/Frameworks/Python.framework/*' -delete
+        sudo rm -rf /Library/Frameworks/Python.framework/
+        brew install --force python3 && brew unlink python3 && brew unlink python3 && brew link --overwrite python3
     # use python3 from homebrew because it is a valid framework, unlike the actions one:
     # https://github.com/actions/setup-python/issues/58
-    - run: brew install pkg-config ninja llvm qt@5 boost ldc hdf5 openmpi lapack scalapack sdl2 python3 boost-python3
+    - run: brew install pkg-config ninja llvm qt@5 boost ldc hdf5 openmpi lapack scalapack sdl2 boost-python3 gtk-doc
     - run: |
         python3 -m pip install --upgrade setuptools
         python3 -m pip install --upgrade pip
@@ -81,6 +92,7 @@
         export SDKROOT="$(xcodebuild -version -sdk macosx Path)"
         export PATH="$HOME/tools:/usr/local/opt/qt@5/bin:$PATH:$(brew --prefix llvm)/bin"
         export PKG_CONFIG_PATH="/usr/local/opt/qt@5/lib/pkgconfig:$PKG_CONFIG_PATH"
+        export XML_CATALOG_FILES="/usr/local/etc/xml/catalog"
         ./tools/run_with_cov.py ./run_project_tests.py --backend=ninja
     - name: Upload coverage report
       run: ./ci/upload_cov.sh "appleclang project tests; unity=${{ matrix.unity }}"
@@ -88,23 +100,26 @@
   Qt4macos:
     runs-on: macos-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-python@v2
+    - uses: actions/checkout@v3
+    - uses: actions/setup-python@v4
       with:
         python-version: '3.x'
     - run: python -m pip install -e .
     - run: brew install pkg-config ninja gcc
     - run: brew tap cartr/qt4
     - run: brew install qt@4
+    - run: brew link qt@4
+      # qt4 tap seems to be broken
+    - run: ln -sfn /usr/local/Cellar/qt@4/4.8.7_6.reinstall /usr/local/Cellar/qt@4/4.8.7_6
     - run: meson setup "test cases/frameworks/4 qt" build -Drequired=qt4
     - run: meson compile -C build
-    - uses: actions/upload-artifact@v1
+    - uses: actions/upload-artifact@v3
       if: failure()
       with:
         name: Qt4_Mac_build
         path: build/meson-logs/meson-log.txt
     - run: meson test -C build -v
-    - uses: actions/upload-artifact@v1
+    - uses: actions/upload-artifact@v3
       if: failure()
       with:
         name: Qt4_Mac_test

_service:tar_scm:meson-0.61.5.tar.gz/.github/workflows/msys2.yml -> _service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/msys2.yml Changed

@@ -1,7 +1,7 @@
 name: msys2
 
 concurrency:
-  group: msys2-${{ github.head_ref }}
+  group: msys2-${{ github.head_ref || github.ref }}
   cancel-in-progress: true
 
 on:
@@ -20,6 +20,9 @@
       - ".github/workflows/msys2.yml"
       - "run_unittests.py"
 
+permissions:
+  contents: read
+
 jobs:
   test:
     runs-on: windows-2019
@@ -48,13 +51,16 @@
             TOOLCHAIN: clang
     env:
       MESON_CI_JOBNAME: msys2-${{ matrix.NAME }}
+      # XXX: For some reason enabling jit debugging "fixes" random python crashes
+      # see https://github.com/msys2/MINGW-packages/issues/11864
+      MSYS: "winjitdebug"
 
     defaults:
       run:
         shell: msys2 {0}
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - uses: msys2/setup-msys2@v2
         with:
@@ -65,6 +71,8 @@
             git
             mercurial
             lcov
+            wget
+            unzip
             mingw-w64-${{ matrix.MSYS2_ARCH }}-cmake
             mingw-w64-${{ matrix.MSYS2_ARCH }}-glib2
             mingw-w64-${{ matrix.MSYS2_ARCH }}-libxml2
@@ -81,9 +89,26 @@
         run: |
           python3 -m pip --disable-pip-version-check install gcovr jsonschema pefile pytest pytest-subtests pytest-xdist coverage codecov
 
+      - name: Install pypy3 on x86_64
+        run: |
+          mkdir pypy3local
+          pushd pypy3local
+          wget -nv https://downloads.python.org/pypy/pypy3.8-v7.3.9-win64.zip
+          unzip pypy3.8-v7.3.9-win64.zip
+          mv pypy3.8-v7.3.9-win64/* ./
+          popd
+        if: ${{ matrix.MSYS2_ARCH == 'x86_64' }}
+
       - name: Run Tests
         run: |
-          export BOOST_ROOT=
+          if  "${{ matrix.MSYS2_ARCH }}" == "x86_64" ; then
+            # There apparently is no clean way to add to the PATH in the 
+            # previous step?
+            # See for instance https://github.com/msys2/setup-msys2/issues/171
+            export PATH=$PATH:$PWD/pypy3local
+            # Make sure it is on the PATH
+            pypy3 -c "import sys; print(sys.version)"
+          fi
           export PATHEXT="$PATHEXT;.py"
 
           if  '${{ matrix.COMPILER }}' == 'clang' ; then
@@ -99,7 +124,7 @@
 
           MSYSTEM= python3 ./tools/run_with_cov.py run_tests.py --backend=ninja
 
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v3
         with:
           name: ${{ matrix.NAME }}
           path: meson-test-run.*

_service:tar_scm:meson-0.61.5.tar.gz/.github/workflows/nonative.yml -> _service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/nonative.yml Changed

_service:tar_scm:meson-0.61.5.tar.gz/.github/workflows/os_comp.yml -> _service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/os_comp.yml Changed

@@ -1,7 +1,7 @@
 name: linux
 
 concurrency:
-  group: linux-${{ github.head_ref }}
+  group: linux-${{ github.head_ref || github.ref }}
   cancel-in-progress: true
 
 on:
@@ -26,6 +26,9 @@
       - ".github/workflows/os_comp.yml"
       - "run_unittests.py"
 
+permissions:
+  contents: read
+
 jobs:
   arch:
     name: ${{ matrix.cfg.name }}
@@ -44,7 +47,7 @@
       MESON_CI_JOBNAME: linux-${{ matrix.cfg.id }}-gcc
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Run tests
       # All environment variables are stored inside the docker image in /ci/env_vars.sh
       # They are defined in the `env` section in each image.json. CI_ARGS should be set
@@ -53,6 +56,21 @@
     - name: Upload coverage report
       run: ./ci/upload_cov.sh "OS Comp ${{ matrix.cfg.name }}"
 
+  pypy:
+    name: 'Arch / PyPy'
+    runs-on: ubuntu-latest
+    container: mesonbuild/arch:latest
+    env:
+      MESON_CI_JOBNAME_UPDATE: linux-arch-gcc-pypy
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Run tests
+      run: |
+        source /ci/env_vars.sh
+        export MESON_CI_JOBNAME=$MESON_CI_JOBNAME_UPDATE
+        pypy3 run_tests.py
+
   ubuntu-rolling:
     name: 'Ubuntu Rolling'
     runs-on: ubuntu-latest
@@ -100,7 +118,7 @@
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Run tests
         shell: bash

_service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/stable_builddir.yml Added

@@ -0,0 +1,35 @@
+name: stable build directories
+
+on:
+  push:
+    branches:
+      - '0-9+.0-9+'
+
+permissions:
+  contents: read
+
+jobs:
+  regression:
+    runs-on: ubuntu-latest
+    env:
+      TESTDIR: "manual tests/13 builddir upgrade"
+    steps:
+      - uses: actions/checkout@v3
+      - name: install ninja
+        run: sudo apt-get -y install build-essential ninja-build
+      - name: Fetch tags and unshallow
+        run: git fetch --unshallow --tags
+      - name: Checkout latest release on this branch
+        run: |
+          cp -r "$TESTDIR" "$TESTDIR"-temp
+          git checkout "$(git describe --abbrev=0)"
+      - name: Configure with most recent tag
+        run: ./meson.py setup "$TESTDIR"-temp builddir
+      - name: Return to testing commit
+        run: git checkout $GITHUB_SHA
+      - name: check that everything still works
+        run: |
+          ./meson.py compile -C builddir
+          ninja -C builddir test
+          DESTDIR=pkg ninja -C builddir install
+          ./meson.py introspect builddir --all

_service:tar_scm:meson-0.61.5.tar.gz/.github/workflows/unusedargs_missingreturn.yml -> _service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/unusedargs_missingreturn.yml Changed

_service:tar_scm:meson-0.61.5.tar.gz/.github/workflows/website.yml -> _service:tar_scm:meson-1.0.1.tar.gz/.github/workflows/website.yml Changed

_service:tar_scm:meson-0.61.5.tar.gz/.mailmap -> _service:tar_scm:meson-1.0.1.tar.gz/.mailmap Changed

_service:tar_scm:meson-0.61.5.tar.gz/.pylintrc -> _service:tar_scm:meson-1.0.1.tar.gz/.pylintrc Changed

@@ -1,32 +1,80 @@
 MASTER
 jobs=0
+load-plugins=
+    pylint.extensions.bad_builtin,
+    pylint.extensions.set_membership,
 
 REPORTS
 score=no
 
 MESSAGES CONTROL
-disable=all
-enable=
-    abstract-class-instantiated,
-    assert-on-tuple,
-    bad-indentation,
-    bare-except,
-    compare-to-zero,
-    consider-iterating-dictionary,
-    consider-using-enumerate,
-    dangerous-default-value,
-    deprecated-lambda,
-    function-redefined,
-    len-as-condition,
-    literal-comparison,
-    missing-kwoa,
-    mixed-indentation,
-    no-value-for-parameter,
-    redundant-keyword-arg,
-    reimported,
-    singleton-comparison,
-    superfluous-parens,
-    too-many-function-args,
-    unexpected-keyword-arg,
-    unneeded-not,
-    unreachable
+disable=
+    abstract-method,
+    arguments-differ,
+    arguments-renamed,
+    attribute-defined-outside-init,
+    broad-except,
+    cell-var-from-loop,
+    consider-using-f-string,
+    consider-using-with,
+    cyclic-import,
+    deprecated-decorator,
+    duplicate-code,
+    duplicate-value,
+    exec-used,
+    fixme,
+    import-error,
+    import-outside-toplevel,
+    inconsistent-mro,
+    inconsistent-return-statements,
+    invalid-name,
+    invalid-unary-operand-type,
+    line-too-long,
+    method-cache-max-size-none,
+    missing-class-docstring,
+    missing-function-docstring,
+    missing-module-docstring,
+    multiple-imports,
+    multiple-statements,
+    no-else-break,
+    no-else-continue,
+    no-else-raise,
+    no-else-return,
+    no-member,
+    no-name-in-module,
+    no-self-argument,
+    non-parent-init-called,
+    not-an-iterable,
+    not-callable,
+    pointless-string-statement,
+    protected-access,
+    raise-missing-from,
+    redeclared-assigned-name,
+    redefined-argument-from-local,
+    redefined-builtin,
+    redefined-outer-name,
+    subprocess-run-check,
+    super-init-not-called,
+    too-few-public-methods,
+    too-many-ancestors,
+    too-many-arguments,
+    too-many-boolean-expressions,
+    too-many-branches,
+    too-many-instance-attributes,
+    too-many-lines,
+    too-many-locals,
+    too-many-nested-blocks,
+    too-many-public-methods,
+    too-many-return-statements,
+    too-many-statements,
+    typevar-name-incorrect-variance,
+    undefined-loop-variable,
+    unidiomatic-typecheck,
+    unnecessary-dict-index-lookup,
+    unnecessary-lambda-assignment,
+    unsubscriptable-object,
+    unused-argument,
+    unused-variable,
+    useless-super-delegation,
+    wrong-import-order,
+    wrong-import-position,

_service:tar_scm:meson-0.61.5.tar.gz/CODEOWNERS -> _service:tar_scm:meson-1.0.1.tar.gz/CODEOWNERS Changed

_service:tar_scm:meson-0.61.5.tar.gz/MANIFEST.in -> _service:tar_scm:meson-1.0.1.tar.gz/MANIFEST.in Changed

_service:tar_scm:meson-0.61.5.tar.gz/README.md -> _service:tar_scm:meson-1.0.1.tar.gz/README.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/azure-pipelines.yml -> _service:tar_scm:meson-1.0.1.tar.gz/azure-pipelines.yml Changed

@@ -1,3 +1,17 @@
+# intel oneapi installation is based on the examples at
+# https://github.com/oneapi-src/oneapi-ci
+#
+# and are copyrighted:
+#
+# SPDX-FileCopyrightText: 2020 Intel Corporation
+# SPDX-License-Identifier: MIT
+#
+# The rest of this file contains the standard Meson project copyright:
+#
+# SPDX-License-Identifer: Apache-2.0
+# Copyright 2022 The Meson development team
+
+
 name: $(BuildID)
 
 trigger:
@@ -35,43 +49,11 @@
 variables:
   CI: 1
   SOURCE_VERSION: $(Build.SourceVersion)
+  WINDOWS_HPCKIT_URL: https://registrationcenter-download.intel.com/akdlm/IRC_NAS/18680/w_HPCKit_p_2022.2.0.173_offline.exe
+  WINDOWS_FORTRAN_COMPONENTS: intel.oneapi.win.ifort-compiler
 
 jobs:
 
-- job: vs2017
-  timeoutInMinutes: 120
-  pool:
-    vmImage: VS2017-Win2016
-
-  strategy:
-    matrix:
-        vc2017x86ninja:
-          arch: x86
-          compiler: msvc2017
-          backend: ninja
-          MESON_RSP_THRESHOLD: 0
-        vc2017x64vs:
-          arch: x64
-          compiler: msvc2017
-          backend: vs2017
-        clangclx64ninja:
-          arch: x64
-          compiler: clang-cl
-          backend: ninja
-
-  steps:
-  - task: UsePythonVersion@0
-    inputs:
-      versionSpec: '3.6'
-      addToPath: true
-      architecture: 'x64'
-  - task: PowerShell@2
-    inputs:
-      targetType: 'filePath'
-      filePath: .\ci\run.ps1
-    env:
-      MESON_CI_JOBNAME: azure-$(System.JobName)
-
 - job: vs2019
   timeoutInMinutes: 120
   pool:
@@ -83,25 +65,55 @@
           arch: x64
           compiler: msvc2019
           backend: ninja
+          ifort: true
         vc2019x64vs:
           arch: x64
           compiler: msvc2019
           backend: vs2019
+          # mysteriously, several tests fail because vs cannot find
+          # executables such as cmd.exe ???
+          ifort: false
         vc2019arm64ninjacross:
           arch: arm64
           compiler: msvc2019
           backend: ninja
           extraargs: --cross arm64cl.txt --cross-only
+          # ifort doesn't support arm64
+          ifort: false
 
   steps:
+  - task: Cache@2
+    inputs:
+      path: C:\Program Files (x86)\Intel\oneAPI
+      key: '"install" | "$(WINDOWS_HPCKIT_URL)" | "$(WINDOWS_FORTRAN_COMPONENTS)" | "compiler" | ci/intel-scripts/cache_exclude_windows.sh'
+      cacheHitVar: CACHE_RESTORED
+    condition: eq(variables.ifort, 'true')
+  - script: ci/intel-scripts/install_windows.bat $(WINDOWS_HPCKIT_URL) $(WINDOWS_FORTRAN_COMPONENTS)
+    displayName: install ifort
+    condition: and(ne(variables.CACHE_RESTORED, 'true'), eq(variables.ifort, 'true'))
+  - bash: ci/intel-scripts/cache_exclude_windows.sh
+    displayName: exclude unused files from cache
+    condition: and(ne(variables.CACHE_RESTORED, 'true'), eq(variables.ifort, 'true'))
   - task: UsePythonVersion@0
     inputs:
       versionSpec: '3.7'
       addToPath: true
       architecture: 'x64'
+  - task: BatchScript@1
+    displayName: insert ifort into environment
+    inputs:
+      filename: ci/intel-scripts/activate_windows.bat
+      arguments: vs2019
+      modifyEnvironment: True
+    condition: eq(variables.ifort, 'true')
   - task: PowerShell@2
     inputs:
       targetType: 'filePath'
       filePath: .\ci\run.ps1
     env:
       MESON_CI_JOBNAME: azure-$(System.JobName)
+  - task: PowerShell@2
+    displayName: Gathering coverage report
+    inputs:
+      targetType: 'filePath'
+      filePath: .\ci\coverage.ps1

_service:tar_scm:meson-0.61.5.tar.gz/ci/ciimage/arch/install.sh -> _service:tar_scm:meson-1.0.1.tar.gz/ci/ciimage/arch/install.sh Changed

_service:tar_scm:meson-0.61.5.tar.gz/ci/ciimage/bionic/install.sh -> _service:tar_scm:meson-1.0.1.tar.gz/ci/ciimage/bionic/install.sh Changed

@@ -10,6 +10,7 @@
 
 pkgs=(
   python3-pip libxml2-dev libxslt1-dev libyaml-dev libjson-glib-dev
+  python3.7 python3.7-dev
   wget unzip cmake doxygen
   clang
   pkg-config-arm-linux-gnueabihf
@@ -25,6 +26,8 @@
   libboost-python-dev libboost-regex-dev
   libblocksruntime-dev
   libperl-dev libscalapack-mpi-dev libncurses-dev
+  itstool
+  openjdk-11-jre
 )
 
 boost_pkgs=(atomic chrono date-time filesystem log regex serialization system test thread)
@@ -47,7 +50,29 @@
 # packages
 eatmydata apt-get -y install "${pkgs@}"
 
-install_python_packages
+# Actually select the right python version
+update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.6 1 \
+    --slave /usr/lib/x86_64-linux-gnu/pkgconfig/python3.pc python3.pc /usr/lib/x86_64-linux-gnu/pkgconfig/python-3.6.pc
+update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.7 2 \
+    --slave /usr/lib/x86_64-linux-gnu/pkgconfig/python3.pc python3.pc /usr/lib/x86_64-linux-gnu/pkgconfig/python-3.7.pc
+
+python3 -m pip install -U "${base_python_pkgs@}" "${python_pkgs@}"
+
+pushd /opt
+# Download and install PyPy3.8, and link it to /usr/bin/pypy3
+# At some point it would be more robust to download and parse
+# https://downloads.python.org/pypy/versions.json
+wget https://downloads.python.org/pypy/pypy3.8-v7.3.9-linux64.tar.bz2
+pypy_sha256="08be25ec82fc5d23b78563eda144923517daba481a90af0ace7a047c9c9a3c34"
+if  $pypy_sha256 != $(sha256sum pypy3.8-v7.3.9-linux64.tar.bz2 | cut -f1 -d" ") ; then
+  echo bad sha256 for PyPy
+  exit -1
+fi
+tar -xf pypy3.8-v7.3.9-linux64.tar.bz2
+pypy3.8-v7.3.9-linux64/bin/pypy3 -m ensurepip
+popd
+ln -s /opt/pypy3.8-v7.3.9-linux64/bin/pypy3 /usr/bin/pypy3
+
 
 # Install the ninja 0.10
 wget https://github.com/ninja-build/ninja/releases/download/v1.10.0/ninja-linux.zip

_service:tar_scm:meson-0.61.5.tar.gz/ci/ciimage/fedora/install.sh -> _service:tar_scm:meson-1.0.1.tar.gz/ci/ciimage/fedora/install.sh Changed

_service:tar_scm:meson-0.61.5.tar.gz/ci/ciimage/ubuntu-rolling/install.sh -> _service:tar_scm:meson-1.0.1.tar.gz/ci/ciimage/ubuntu-rolling/install.sh Changed

_service:tar_scm:meson-1.0.1.tar.gz/ci/coverage.ps1 Added

_service:tar_scm:meson-1.0.1.tar.gz/ci/intel-scripts Added

_service:tar_scm:meson-1.0.1.tar.gz/ci/intel-scripts/activate_windows.bat Added

_service:tar_scm:meson-1.0.1.tar.gz/ci/intel-scripts/cache_exclude_windows.sh Added

_service:tar_scm:meson-1.0.1.tar.gz/ci/intel-scripts/install_windows.bat Added

_service:tar_scm:meson-0.61.5.tar.gz/ci/run.ps1 -> _service:tar_scm:meson-1.0.1.tar.gz/ci/run.ps1 Changed

@@ -20,7 +20,7 @@
     # Rust puts its shared stdlib in a secret place, but it is needed to run tests.
     $env:Path += ";$HOME/.rustup/toolchains/stable-i686-pc-windows-msvc/bin"
     # Need 32-bit Python for tests that need the Python dependency
-    $env:Path = "C:\hostedtoolcache\windows\Python\3.6.8\x86;C:\hostedtoolcache\windows\Python\3.6.8\x86\Scripts;$env:Path"
+    $env:Path = "C:\hostedtoolcache\windows\Python\3.7.9\x86;C:\hostedtoolcache\windows\Python\3.7.9\x86\Scripts;$env:Path"
 }
 
 # Set the CI env var for the meson test framework
@@ -54,19 +54,27 @@
 Expand-Archive $env:AGENT_WORKFOLDER\ci_data.zip -DestinationPath $env:AGENT_WORKFOLDER\ci_data
 & "$env:AGENT_WORKFOLDER\ci_data\install.ps1" -Arch $env:arch -Compiler $env:compiler -Boost $true -DMD $dmd
 
+if ($env:arch -eq 'x64') {
+    DownloadFile -Source https://downloads.python.org/pypy/pypy3.8-v7.3.9-win64.zip -Destination $env:AGENT_WORKFOLDER\pypy38.zip
+    Expand-Archive $env:AGENT_WORKFOLDER\pypy38.zip -DestinationPath $env:AGENT_WORKFOLDER\pypy38
+    $ENV:Path = $ENV:Path + ";$ENV:AGENT_WORKFOLDER\pypy38\pypy3.8-v7.3.9-win64;$ENV:AGENT_WORKFOLDER\pypy38\pypy3.8-v7.3.9-win64\Scripts"
+    pypy3 -m ensurepip
+}
+
 
 echo "=== PATH BEGIN ==="
 echo ($env:Path).Replace(';',"`n")
 echo "=== PATH END ==="
 echo ""
 
-$progs = @("python","ninja","pkg-config","cl","rc","link")
+$progs = @("python","ninja","pkg-config","cl","rc","link","pypy3","ifort")
 foreach ($prog in $progs) {
   echo ""
   echo "Locating ${prog}:"
   where.exe $prog
 }
 
+
 echo ""
 echo "Ninja / MSBuld version:"
 if ($env:backend -eq 'ninja') {
@@ -90,21 +98,4 @@
 # does that by default so we need to forward it.
 cmd /c "python 2>&1 ./tools/run_with_cov.py  run_tests.py --backend $env:backend $env:extraargs"
 
-$result = $LastExitCode
-
-echo ""
-echo ""
-echo "=== Gathering coverage report ==="
-echo ""
-
-python3 -m coverage combine
-python3 -m coverage xml
-python3 -m coverage report
-
-# Currently codecov.py does not handle Azure, use this fork of a fork to get it
-# working without requiring a token
-git clone https://github.com/mensinda/codecov-python
-python3 -m pip install --ignore-installed ./codecov-python
-python3 -m codecov -f .coverage/coverage.xml -n "VS$env:compiler $env:arch $env:backend" -c $env:SOURCE_VERSION
-
-exit $result
+exit $LastExitCode

_service:tar_scm:meson-0.61.5.tar.gz/cross/arm64cl.txt -> _service:tar_scm:meson-1.0.1.tar.gz/cross/arm64cl.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/cross/msp430.txt Added

_service:tar_scm:meson-0.61.5.tar.gz/cross/none.txt -> _service:tar_scm:meson-1.0.1.tar.gz/cross/none.txt Changed

_service:tar_scm:meson-0.61.5.tar.gz/cross/wasm.txt -> _service:tar_scm:meson-1.0.1.tar.gz/cross/wasm.txt Changed

_service:tar_scm:meson-0.61.5.tar.gz/data/macros.meson -> _service:tar_scm:meson-1.0.1.tar.gz/data/macros.meson Changed

_service:tar_scm:meson-0.61.5.tar.gz/data/shell-completions/bash/meson -> _service:tar_scm:meson-1.0.1.tar.gz/data/shell-completions/bash/meson Changed

@@ -1,21 +1,27 @@
 _meson() {
   command="${COMP_WORDS1}"
-  case "$command" in
-    setup |\
-    configure |\
-    install |\
-    introspect |\
-    init |\
-    test |\
-    wrap |\
-    subprojects |\
-    help)
+  meson_subcommands=(
+      setup
+      configure
+      dist
+      install
+      introspect
+      init
+      test
+      wrap
+      subprojects
+      help
+      rewrite
+      compile
+      devenv
+      env2mfile
+  )
+
+  if  " ${meson_subcommands*} " =~ " ${command} " ; then
       _meson-$command "${COMP_WORDS@:1}"
-      ;;
-    *)
+  else
       _meson-setup "${COMP_WORDS@}"
-      ;;
-  esac
+  fi
 } &&
 complete -F _meson meson
 
@@ -192,7 +198,7 @@
     fi
 
     if  $COMP_CWORD -eq 1 ; then
-      COMPREPLY+=($(compgen -W 'setup configure test introspect' -- "$cur"))
+      COMPREPLY+=($(compgen -W "${meson_subcommands*}" -- "$cur"))
     fi
   fi
 }
@@ -242,6 +248,96 @@
   fi
 }
 
+_meson-dist() {
+  : TODO
+}
+
+_meson-install() {
+  : TODO
+}
+
+_meson-introspect() {
+  shortopts=(
+    h
+  )
+
+  longopts=(
+    targets
+    installed
+    buildsystem-files
+    buildoptions
+    tests
+    benchmarks
+    dependencies
+    projectinfo
+  )
+
+  local cur prev
+  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
+    cur="${COMP_WORDSCOMP_CWORD}"
+  fi
+
+  if  "$cur" == "--"* ; then
+    COMPREPLY+=($(compgen -P '--' -W '${longopts*}' -- "${cur:2}"))
+  elif  "$cur" == "-"* ; then
+    COMPREPLY+=($(compgen -P '--' -W '${longopts*}' -- "${cur:2}"))
+    COMPREPLY+=($(compgen -P '-' -W '${shortopts*}' -- "${cur:1}"))
+  else
+    for dir in "${COMP_WORDS@}"; do
+      if  -d "$dir" ; then
+        break
+      fi
+      dir=.
+    done
+    if  ! -d "$dir/meson-private" ; then
+      _filedir -d
+    fi
+
+    if  -z "$cur" ; then
+      COMPREPLY+=($(compgen -P '--' -W '${longopts*}'))
+      COMPREPLY+=($(compgen -P '-' -W '${shortopts*}'))
+    fi
+  fi
+}
+
+_meson-init() {
+  shortopts=(
+    h
+    C
+    n
+    e
+    e
+    d
+    l
+    b
+    f
+  )
+
+  longopts=(
+    help
+	name
+	executable
+	deps
+	language
+	builddir
+	force
+	type
+	version
+  )
+
+  if  "$cur" == "--"* ; then
+    COMPREPLY+=($(compgen -P '--' -W '${longopts*}' -- "${cur:2}"))
+  elif  "$cur" == "-"* && ${#cur} -gt 1 ; then
+    COMPREPLY+=($(compgen -P '-' -W '${shortopts*}' -- "${cur:1}"))
+  else
+    if  -z "$cur" ; then
+      COMPREPLY+=($(compgen -P '--' -W '${longopts*}'))
+      COMPREPLY+=($(compgen -P '-' -W '${shortopts*}'))
+    fi
+  fi
+
+}
+
 _meson-test() {
   shortopts=(
     q
@@ -367,50 +463,30 @@
   fi
 }
 
-_meson-introspect() {
-  shortopts=(
-    h
-  )
+_meson-wrap() {
+  : TODO
+}
 
-  longopts=(
-    targets
-    installed
-    buildsystem-files
-    buildoptions
-    tests
-    benchmarks
-    dependencies
-    projectinfo
-  )
+_meson-subprojects() {
+  : TODO
+}
 
-  local cur prev
-  if ! _get_comp_words_by_ref cur prev &>/dev/null; then
-    cur="${COMP_WORDSCOMP_CWORD}"
-  fi
+_meson-help() {
+  : # Nothing to do
+}
 
-  if  "$cur" == "--"* ; then
-    COMPREPLY+=($(compgen -P '--' -W '${longopts*}' -- "${cur:2}"))
-  elif  "$cur" == "-"* ; then
-    COMPREPLY+=($(compgen -P '--' -W '${longopts*}' -- "${cur:2}"))
-    COMPREPLY+=($(compgen -P '-' -W '${shortopts*}' -- "${cur:1}"))
-  else
-    for dir in "${COMP_WORDS@}"; do
-      if  -d "$dir" ; then
-        break
-      fi
-      dir=.
-    done
-    if  ! -d "$dir/meson-private" ; then
-      _filedir -d
-    fi
+_meson-rewrite() {
+  : TODO
+}
 
-    if  -z "$cur" ; then
-      COMPREPLY+=($(compgen -P '--' -W '${longopts*}'))
-      COMPREPLY+=($(compgen -P '-' -W '${shortopts*}'))
-    fi
-  fi
+_meson-compile() {
+  : TODO
 }
 
-_meson-wrap() {
+_meson-devenv() {
+  : TODO
+}
+
+_meson-env2mfile() {
   : TODO
 }

_service:tar_scm:meson-0.61.5.tar.gz/data/shell-completions/zsh/_meson -> _service:tar_scm:meson-1.0.1.tar.gz/data/shell-completions/zsh/_meson Changed

_service:tar_scm:meson-0.61.5.tar.gz/data/syntax-highlighting/vim/syntax/meson.vim -> _service:tar_scm:meson-1.0.1.tar.gz/data/syntax-highlighting/vim/syntax/meson.vim Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/README.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/README.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/extensions/refman_links.py -> _service:tar_scm:meson-1.0.1.tar.gz/docs/extensions/refman_links.py Changed

@@ -52,9 +52,9 @@
 with valid links to the correct URL. To reference objects / types use the
 @object syntax.
 '''
- link_regex = re.compile(r'\\#?@?( \n\t*a-zA-Z0-9_+ \n\t*\.)* \n\t*a-zA-Z0-9_+ \n\t*\\', re.MULTILINE)
+ link_regex = re.compile(r'(\\#?@?( \n\t*a-zA-Z0-9_+ \n\t*\.)* \n\t*a-zA-Z0-9_+ \n\t*\\)(.)?', re.MULTILINE)
 for m in link_regex.finditer(page.formatted_contents):
- i = m.group()
+ i = m.group(1)
 obj_id: str = i2:-2
 obj_id = re.sub(r' \n\t', '', obj_id) # Remove whitespaces
 
@@ -77,12 +77,15 @@
 text = obj_id
 if text.startswith('@'):
 text = text1:
+ elif in_code_block:
+ if m.group(3) != '(':
+ text = text + '()'
 else:
 text = text + '()'
 if not in_code_block:
 text = f'<code>{text}</code>'
 link = f'<a href="{self._dataobj_id}"><ins>{text}</ins></a>'
- page.formatted_contents = page.formatted_contents.replace(i, link)
+ page.formatted_contents = page.formatted_contents.replace(i, link, 1)
 
 def setup(self) -> None:
 super().setup()
@@ -94,7 +97,7 @@
 raw = Path(self._data_file).read_text(encoding='utf-8')
 self._data = loads(raw)
 
- # Register formater
+ # Register formatter
 for ext in self.project.extensions.values():
 ext = T.cast(Extension, ext)
 ext.formatter.formatting_page_signal.connect(self._formatting_page_cb)

_service:tar_scm:meson-0.61.5.tar.gz/docs/genrelnotes.py -> _service:tar_scm:meson-1.0.1.tar.gz/docs/genrelnotes.py Changed

@@ -16,58 +16,90 @@
 '''
   Generates release notes for new releases of Meson build system
 '''
+import argparse
 import subprocess
-import sys
-import os
-from glob import glob
+import re
+import shutil
+import datetime
+from pathlib import Path
 
 RELNOTE_TEMPLATE = '''---
 title: Release {}
 short-description: Release notes for {}
 ...
 
-# New features
+# New features{}
 
 '''
 
 
-def add_to_sitemap(from_version, to_version):
+def add_to_sitemap(sitemap, output_sitemap):
     '''
        Adds release note entry to sitemap.txt.
     '''
-    sitemapfile = '../sitemap.txt'
-    s_f = open(sitemapfile, encoding='utf-8')
-    lines = s_f.readlines()
-    s_f.close()
-    with open(sitemapfile, 'w', encoding='utf-8') as s_f:
+    sitemapfile = Path(sitemap)
+    with sitemapfile.open(encoding='utf-8') as s_f:
+        lines = s_f.readlines()
+    relnotes = None
+    to_version = None
+    output = Path(output_sitemap)
+    output.parent.mkdir(exist_ok=True, parents=True)
+    with output.open('w', encoding='utf-8') as s_f:
         for line in lines:
-            if 'Release-notes' in line and from_version in line:
-                new_line = line.replace(from_version, to_version)
-                s_f.write(new_line)
+            if relnotes is None:
+                m = re.match(r'\s*Release-notes-for-(0-9+)\.(0-9+)\.(0-9+)\.md', line)
+                if m:
+                    from_version = f'{m1}.{m2}.{m3}'
+                    if from_version == '0.64.0':
+                        to_version = '1.0.0'
+                    else:
+                        to_version = f'{m1}.{int(m2) + 1}.{m3}'
+                    new_line = line.replace(from_version, to_version)
+                    relnotes = new_line.strip()
+                    s_f.write(new_line)
             s_f.write(line)
 
-def generate(from_version, to_version):
+    if sitemapfile == output:
+        subprocess.check_call('git', 'add', output)
+
+    return relnotes, to_version
+
+def generate(relnotes, to_version, source_dir, output_dir):
     '''
        Generate notes for Meson build next release.
     '''
-    ofilename = f'Release-notes-for-{to_version}.md'
-    with open(ofilename, 'w', encoding='utf-8') as ofile:
-        ofile.write(RELNOTE_TEMPLATE.format(to_version, to_version))
-        for snippetfile in glob('snippets/*.md'):
-            snippet = open(snippetfile, encoding='utf-8').read()
+    title_suffix = ' (in development)' if output_dir else ''
+    title = f'{to_version}{title_suffix}'
+    output = Path(output_dir, relnotes) if output_dir else Path('markdown', relnotes)
+    output.parent.mkdir(exist_ok=True, parents=True)
+    with output.open('w', encoding='utf-8') as ofile:
+        ofile.write(RELNOTE_TEMPLATE.format(title, to_version, title_suffix))
+        if not output_dir:
+            date = datetime.date.today()
+            date_str = date.strftime("%d %B %Y")
+            ofile.write(f'Meson {to_version} was released on {date_str}\n')
+        for snippetfile in sorted(Path(source_dir, 'markdown/snippets').glob('*.md')):
+            snippet = snippetfile.read_text(encoding='utf-8')
             ofile.write(snippet)
             if not snippet.endswith('\n'):
                 ofile.write('\n')
             ofile.write('\n')
-            subprocess.check_call('git', 'rm', snippetfile)
-    subprocess.check_call('git', 'add', ofilename)
-    add_to_sitemap(from_version, to_version)
+
+    if not output_dir:
+        subprocess.check_call('git', 'rm', 'markdown/snippets/*.md')
+        subprocess.check_call('git', 'add', output)
 
 if __name__ == '__main__':
-    if len(sys.argv) != 3:
-        print(sys.argv0, 'from_version to_version')
-        sys.exit(1)
-    FROM_VERSION = sys.argv1
-    TO_VERSION = sys.argv2
-    os.chdir('markdown')
-    generate(FROM_VERSION, TO_VERSION)
+    parser = argparse.ArgumentParser(description='Generate meson docs')
+    parser.add_argument('--input-sitemap', default='sitemap.txt')
+    parser.add_argument('--output-sitemap', default='sitemap.txt')
+    parser.add_argument('--source-dir', default='.')
+    parser.add_argument('--output-dir')
+
+    args = parser.parse_args()
+
+    if Path(args.source_dir, 'markdown/snippets').glob('*.md'):
+        relnotes, to_version = add_to_sitemap(args.input_sitemap, args.output_sitemap)
+        generate(relnotes, to_version, args.source_dir, args.output_dir)
+    elif args.input_sitemap != args.output_sitemap:
+        shutil.copyfile(args.input_sitemap, args.output_sitemap)

_service:tar_scm:meson-0.61.5.tar.gz/docs/jsonvalidator.py -> _service:tar_scm:meson-1.0.1.tar.gz/docs/jsonvalidator.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Adding-arguments.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Adding-arguments.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Build-options.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Build-options.md Changed

@@ -76,16 +76,20 @@
 A `feature` option has three states: `enabled`, `disabled` or `auto`.
 It is intended to be passed as value for the `required` keyword
 argument of most functions. Currently supported in
-dependency,
+add_languages,
 compiler.find_library,
-find_program and
-add_languages functions.
+compiler.has_header,
+dependency,
+find_program,
+import and
+subproject
+functions.
 
 - `enabled` is the same as passing `required : true`.
 - `auto` is the same as passing `required : false`.
 - `disabled` do not look for the dependency and always return 'not-found'.
 
-When getting the value of this type of option using `get_option()`, a
+When getting the value of this type of option using get_option, a
 special @feature object is returned instead
 of the string representation of the option's value. This object can be
 passed to `required`:
@@ -149,6 +153,21 @@
 option('o5', type: 'boolean', deprecated: {'enabled': 'true', 'disabled': 'false', 'auto': 'false'})
 ```
 
+Since *0.63.0* the `deprecated` keyword argument can take the name of a new option
+that replace this option. In that case, setting a value on the deprecated option
+will set the value on both the old and new names, assuming they accept the same
+values.
+
+```meson
+# A boolean option has been replaced by a feature with another name, old true/false values
+# are accepted by the new option for backward compatibility.
+option('o6', type: 'boolean', value: 'true', deprecated: 'o7')
+option('o7', type: 'feature', value: 'enabled', deprecated: {'true': 'enabled', 'false': 'disabled'})
+
+# A project option is replaced by a module option
+option('o8', type: 'string', value: '', deprecated: 'python.platlibdir')
+```
+
 ## Using build options
 
 ```meson

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Builtin-options.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Builtin-options.md Changed

@@ -10,12 +10,10 @@
 
 ## Universal options
 
-A list of these options can be found by running `meson --help`. All
-these can be set by passing `-Doption=value` to `meson` (aka `meson
-setup`), or by setting them inside `default_options` of `project()` in
-your `meson.build`. Some options can also be set by `--option=value`,
-or `--option value`--- a list is shown by running `meson setup
---help`.
+All these can be set by passing `-Doption=value` to `meson` (aka `meson
+setup`), or by setting them inside `default_options` of project in your
+`meson.build`. Some options can also be set by `--option=value`, or `--option
+value` -- a list is shown by running `meson setup --help`.
 
 For legacy reasons `--warnlevel` is the cli argument for the
 `warning_level` option.
@@ -23,13 +21,15 @@
 They can also be edited after setup using `meson configure
 -Doption=value`.
 
-Installation options are all relative to the prefix, except:
+Installation options are usually relative to the prefix but it should
+not be relied on, since they can be absolute paths in the following cases:
 
 * When the prefix is `/usr`: `sysconfdir` defaults to `/etc`,
 `localstatedir` defaults to `/var`, and `sharedstatedir` defaults to
 `/var/lib`
 * When the prefix is `/usr/local`: `localstatedir` defaults
 to `/var/local`, and `sharedstatedir` defaults to `/var/local/lib`
+* When an absolute path outside of prefix is provided by the user/distributor.
 
 ### Directories
 
@@ -67,27 +67,28 @@
 machine. See the specifying options per
 machine(#specifying-options-per-machine) section for details.
 
-| Option | Default value | Description | Is per machine | Is per subproject |
-| ------ | ------------- | ----------- | -------------- | ----------------- |
+| Option | Default value | Description | Is per machine | Is per subproject |
+| -------------------------------------- | ------------- | ----------- | -------------- | ----------------- |
 | auto_features {enabled, disabled, auto} | auto | Override value of all 'auto' features | no | no |
 | backend {ninja, vs, vs2010, vs2012, vs2013, vs2015, vs2017, vs2019, vs2022, xcode} | ninja | Backend to use | no | no |
 | buildtype {plain, debug, debugoptimized, release, minsize, custom} | debug | Build type to use | no | no |
-| debug | true | Enable debug symbols and other information | no | no |
+| debug | true | Enable debug symbols and other information | no | no |
 | default_library {shared, static, both} | shared | Default library type | no | yes |
-| errorlogs | true | Whether to print the logs from failing tests. | no | no |
-| install_umask {preserve, 0000-0777} | 022 | Default umask to apply on permissions of installed files | no | no |
-| layout {mirror,flat} | mirror | Build directory layout | no | no |
-| optimization {0, g, 1, 2, 3, s} | 0 | Optimization level | no | no |
-| pkg_config_path {OS separated path} | '' | Additional paths for pkg-config to search before builtin paths | yes | no |
-| cmake_prefix_path | | Additional prefixes for cmake to search before builtin paths | yes | no |
-| stdsplit | true | Split stdout and stderr in test logs | no | no |
-| strip | false | Strip targets on install | no | no |
-| unity {on, off, subprojects} | off | Unity build | no | no |
-| unity_size {>=2} | 4 | Unity file block size | no | no |
-| warning_level {0, 1, 2, 3} | 1 | Set the warning level. From 0 = none to 3 = highest | no | yes |
-| werror | false | Treat warnings as errors | no | yes |
+| errorlogs | true | Whether to print the logs from failing tests. | no | no |
+| install_umask {preserve, 0000-0777} | 022 | Default umask to apply on permissions of installed files | no | no |
+| layout {mirror,flat} | mirror | Build directory layout | no | no |
+| optimization {plain, 0, g, 1, 2, 3, s} | 0 | Optimization level | no | no |
+| pkg_config_path {OS separated path} | '' | Additional paths for pkg-config to search before builtin paths | yes | no |
+| prefer_static | false | Whether to try static linking before shared linking | no | no |
+| cmake_prefix_path | | Additional prefixes for cmake to search before builtin paths | yes | no |
+| stdsplit | true | Split stdout and stderr in test logs | no | no |
+| strip | false | Strip targets on install | no | no |
+| unity {on, off, subprojects} | off | Unity build | no | no |
+| unity_size {>=2} | 4 | Unity file block size | no | no |
+| warning_level {0, 1, 2, 3, everything} | 1 | Set the warning level. From 0 = none to everything = highest | no | yes |
+| werror | false | Treat warnings as errors | no | yes |
 | wrap_mode {default, nofallback, nodownload, forcefallback, nopromote} | default | Wrap mode to use | no | no |
-| force_fallback_for | | Force fallback for those dependencies | no | no |
+| force_fallback_for | | Force fallback for those dependencies | no | no |
 
 <a name="build-type-options"></a> For setting optimization levels and
 toggling debug, you can either set the `buildtype` option, or you can
@@ -99,7 +100,7 @@
 
 | buildtype | debug | optimization |
 | --------- | ----- | ------------ |
-| plain | false | 0 |
+| plain | false | plain |
 | debug | true | 0 |
 | debugoptimized | true | 2 |
 | release | false | 3 |
@@ -111,8 +112,8 @@
 
 These are set in the same way as universal options, either by
 `-Doption=value`, or by setting them inside `default_options` of
-`project()` in your `meson.build`. However, they cannot be shown in
-the output of `meson --help` because they depend on both the current
+project in your `meson.build`. However, they cannot be shown in
+the output of `meson setup --help` because they depend on both the current
 platform and the compiler that will be selected. The only way to see
 them is to setup a builddir and then run `meson configure` on it with
 no options.
@@ -120,30 +121,32 @@
 The following options are available. Note that they may not be
 available on all platforms or with all compilers:
 
-| Option | Default value | Possible values | Description |
-|---------------|----------------|------------------------------------------------------------------|-------------------------------------------------------------------------------|
-| b_asneeded | true | true, false | Use -Wl,--as-needed when linking |
-| b_bitcode | false | true, false | Embed Apple bitcode, see below |
-| b_colorout | always | auto, always, never | Use colored output |
-| b_coverage | false | true, false | Enable coverage tracking |
-| b_lundef | true | true, false | Don't allow undefined symbols when linking |
-| b_lto | false | true, false | Use link time optimization |
-| b_lto_threads | 0 | Any integer* | Use multiple threads for lto. *(Added in 0.57.0)* |
-| b_lto_mode | default | default, thin | Select between lto modes, thin and default. *(Added in 0.57.0)* |
-| b_ndebug | false | true, false, if-release | Disable asserts |
-| b_pch | true | true, false | Use precompiled headers |
-| b_pgo | off | off, generate, use | Use profile guided optimization |
-| b_sanitize | none | see below | Code sanitizer to use |
-| b_staticpic | true | true, false | Build static libraries as position independent |
-| b_pie | false | true, false | Build position-independent executables (since 0.49.0) |
-| b_vscrt | from_buildtype | none, md, mdd, mt, mtd, from_buildtype, static_from_buildtype | VS runtime library to use (since 0.48.0) (static_from_buildtype since 0.56.0) |
+| Option | Default value | Possible values | Description |
+|---------------------|----------------------|---------------------------------------------------------------|--------------------------------------------------------------------------------|
+| b_asneeded | true | true, false | Use -Wl,--as-needed when linking |
+| b_bitcode | false | true, false | Embed Apple bitcode, see below |
+| b_colorout | always | auto, always, never | Use colored output |
+| b_coverage | false | true, false | Enable coverage tracking |
+| b_lundef | true | true, false | Don't allow undefined symbols when linking |
+| b_lto | false | true, false | Use link time optimization |
+| b_lto_threads | 0 | Any integer* | Use multiple threads for lto. *(Added in 0.57.0)* |
+| b_lto_mode | default | default, thin | Select between lto modes, thin and default. *(Added in 0.57.0)* |
+| b_thinlto_cache | false | true, false | Enable LLVM's ThinLTO cache for faster incremental builds. *(Added in 0.64.0)* |
+| b_thinlto_cache_dir | (Internal build dir) | true, false | Specify where to store ThinLTO cache objects. *(Added in 0.64.0)* |
+| b_ndebug | false | true, false, if-release | Disable asserts |
+| b_pch | true | true, false | Use precompiled headers |
+| b_pgo | off | off, generate, use | Use profile guided optimization |
+| b_sanitize | none | see below | Code sanitizer to use |
+| b_staticpic | true | true, false | Build static libraries as position independent |
+| b_pie | false | true, false | Build position-independent executables (since 0.49.0) |
+| b_vscrt | from_buildtype | none, md, mdd, mt, mtd, from_buildtype, static_from_buildtype | VS runtime library to use (since 0.48.0) (static_from_buildtype since 0.56.0) |
 
 The value of `b_sanitize` can be one of: `none`, `address`, `thread`,
-`undefined`, `memory`, `address,undefined`, but note that some
+`undefined`, `memory`, `leak`, `address,undefined`, but note that some
 compilers might not support all of them. For example Visual Studio
 only supports the address sanitizer.
 
-* < 0 means disable, == 0 means automatic selection, > 0 sets a specific number to use
+\* < 0 means disable, == 0 means automatic selection, > 0 sets a specific number to use
 
 LLVM supports `thin` lto, for more discussion see LLVM's documentation(https://clang.llvm.org/docs/ThinLTO.html)
 
@@ -218,41 +221,47 @@
 the value passed to `-s PTHREAD_POOL_SIZE` when using emcc. No other
 c/c++ compiler supports this option.
 
+Since *0.63.0* all compiler options can be set per subproject, see
+here(#specifying-options-per-subproject) for details on how the default value
+is inherited from the main project. This is useful, for example, when the main
+project requires C++11, but a subproject requires C++14. The `cpp_std` value
+from the subproject's `default_options` is now respected.
+
 ## Specifying options per machine
 
 Since *0.51.0*, some options are specified per machine rather than
 globally for all machine configurations. Prefixing the option with
-`build.` just affects the build machine configuration, while
-unprefixed just affects the host machine configuration, respectively.
+`build.` only affects the build machine configuration, while leaving it
+unprefixed only affects the host machine configuration.
 For example:
 
 - `build.pkg_config_path` controls the paths pkg-config will search
- for just `native: true` dependencies (build machine).
+ for `native: true` (build machine) dependencies.
 
 - `pkg_config_path` controls the paths pkg-config will search for
- just `native: false` dependencies (host machine).
+ `native: false` (host machine) dependencies.
 
-This is useful for cross builds. In the native builds, build = host,
-and the unprefixed option alone will suffice.
+This is useful for cross builds. In native builds, the build and host
+machines are the same, and the unprefixed option alone will suffice.
 
-Prior to *0.51.0*, these options just effected native builds when
-specified on the command line, as there was no `build.` prefix.
+Prior to *0.51.0*, these options only affected native builds when
+specified on the command line as there was no `build.` prefix.
 Similarly named fields in the `properties` section of the cross file
-would effect cross compilers, but the code paths were fairly different
+would affect cross compilers, but the code paths were fairly different,
 allowing differences in behavior to crop out.
 
 ## Specifying options per subproject
 
 Since *0.54.0* `default_library` and `werror` built-in options can be
-defined per subproject. This is useful for example when building
-shared libraries in the main project, but static link a subproject, or
-when the main project must build with no warnings but some subprojects
+defined per subproject. This is useful, for example, when building
+shared libraries in the main project and statically linking a subproject,
+or when the main project must build with no warnings but some subprojects
 cannot.
 
-Most of the time this would be used either by the parent project by
+Most of the time, this would be used either in the parent project by
 setting subproject's default_options (e.g. `subproject('foo',
-default_options: 'default_library=static')`), or by the user using the
-command line `-Dfoo:default_library=static`.
+default_options: 'default_library=static')`), or by the user through the
+command line: `-Dfoo:default_library=static`.
 
 The value is overridden in this order:
 - Value from parent project
@@ -260,24 +269,59 @@
 - Value from subproject() default_options if set
 - Value from command line if set
 
-Since 0.56.0 `warning_level` can also be defined per subproject.
+Since *0.56.0* `warning_level` can also be defined per subproject.
 
 ## Module options
 
-Some Meson modules have built-in options. They can be set by prefixing the option
-name with the module name: `-D<module>.<option>=<value>` (e.g. `-Dpython.platlibdir=/foo`).
+Some Meson modules have built-in options. They can be set by prefixing the
+option with the module's name:
+`-D<module>.<option>=<value>` (e.g. `-Dpython.platlibdir=/foo`).
+
+### Pkgconfig module
+
+| Option | Default value | Possible values | Description |
+|-------------|---------------|-----------------|------------------------------------------------------------|
+| relocatable | false | true, false | Generate the pkgconfig files as relocatable (Since 0.63.0) |
+
+*Since 0.63.0* The `pkgconfig.relocatable` option is used by the
+pkgconfig module–namely `pkg.generate()`(Pkgconfig-module.md)–and
+affects how the `prefix` (not to be confused with the
+install prefix(#directories)) in the generated pkgconfig file is set.
+When it is `true`, the `prefix` will be relative to the `install_dir`-this
+allows the pkgconfig file to be moved around and still work, as long
+as the relative path is not broken. In general, this allows for the whole
+installed package to be placed anywhere on the system and still work as a
+dependency. When it is set to `false`, the `prefix` will be the same as
+the install prefix.
+
+An error will be raised if `pkgconfig.relocatable` is `true` and the
+`install_dir` for a generated pkgconfig file points outside the
+install prefix. For example: if the install prefix is `/usr` and the
+`install_dir` for a pkgconfig file is `/var/lib/pkgconfig`.
 
 ### Python module
 
-| Option | Default value | Possible values | Description |
-| ------ | ------------- | --------------- | ----------- |
-| platlibdir | | Directory path | Directory for site-specific, platform-specific files (Since 0.60.0) |
-| purelibdir | | Directory path | Directory for site-specific, non-platform-specific files (Since 0.60.0) |
-
-*Since 0.60.0* `python.platlibdir` and `python.purelibdir` options are used by
-python module methods `python.install_sources()` and `python.get_install_dir()`.
-By default Meson tries to detect the correct installation path, but make them
-relative to the installation `prefix`, which will often result in installed python
-modules to not be found by the interpreter unless `prefix` is `/usr` on Linux,
-or for example `C:\Python39` on Windows. These options can be absolute paths
-outside of `prefix`.
+| Option | Default value | Possible values | Description |
+| ------ | ------------- | ----------------- | ----------- |
+| install_env | prefix | {auto,prefix,system,venv} | Which python environment to install to (Since 0.62.0) |
+| platlibdir | | Directory path | Directory for site-specific, platform-specific files (Since 0.60.0) |
+| purelibdir | | Directory path | Directory for site-specific, non-platform-specific files (Since 0.60.0) |
+
+*Since 0.60.0* The `python.platlibdir` and `python.purelibdir` options are used
+by the python module methods `python.install_sources()` and
+`python.get_install_dir()`; Meson tries to detect the correct installation paths
+and make them relative to the installation `prefix` by default which will often
+result in the interpreter not finding the installed python modules unless
+`prefix` is `/usr` on Linux, or, for instance, `C:\Python39` on Windows. These
+options can be absolute paths outside of `prefix`.
+
+*Since 0.62.0* The `python.install_env` option is used to detect the correct
+installation path. Setting to `system` will avoid making the paths relative to
+`prefix` and instead use the global site-packages of the selected python
+interpreter directly, even if it is a venv. Setting to `venv` will instead use
+the paths for the virtualenv the python found installation comes from (or fail
+if it is not a virtualenv). Setting to `auto` will check if the found
+installation is a virtualenv, and use `venv` or `system` as appropriate (but
+never `prefix`). This option is mutually exclusive with the `platlibdir`/`purelibdir`.
+
+For backwards compatibility purposes, the default `install_env` is `prefix`.

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/CMake-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/CMake-module.md Changed

@@ -45,7 +45,7 @@
 ```
 
 The `subproject` method is almost identical to the normal Meson
-`subproject` function. The only difference is that a CMake project
+subproject function. The only difference is that a CMake project
 instead of a Meson project is configured.
 
 The returned `sub_proj` supports the same options as a "normal"
@@ -54,7 +54,7 @@
 
 It is usually enough to just use the dependency object returned by the
 `dependency()` method in the build targets. This is almost identical
-to using `declare_dependency()` object from a normal Meson subproject.
+to using the declare_dependency object from a normal Meson subproject.
 
 It is also possible to use executables defined in the CMake project as code
 generators with the `target()` method:
@@ -117,7 +117,7 @@
 The CMake configuration options object is very similar to the
 @cfg_data object object returned
 by configuration_data. It
-is generated by the `subproject_options` function
+is generated by the `subproject_options` method.
 
 All configuration options have to be set *before* the subproject is
 configured and must be passed to the `subproject` method via the
@@ -131,7 +131,7 @@
 
 ### `subproject` object
 
-This object is returned by the `subproject` function described above
+This object is returned by the `subproject` method described above
 and supports the following methods:
 
  - `dependency(target)` returns a dependency object for any CMake target. The
@@ -139,7 +139,7 @@
    returned dependency object similar to the same kwarg in the
    dependency function.
  - `include_directories(target)` returns a Meson @inc
-   object for the specified target. Using this function is not necessary
+   object for the specified target. Using this method is not necessary
    if the dependency object is used.
  - `target(target)` returns the raw build target.
  - `target_type(target)` returns the type of the target as a string
@@ -152,8 +152,8 @@
 
 ### `cmake options` object
 
-This object is returned by the `subproject_options()` function and
-consumed by the `options` kwarg of the `subproject` function. The
+This object is returned by the `subproject_options()` method and
+consumed by the `options` kwarg of the `subproject` method. The
 following methods are supported:
 
  - `add_cmake_defines({'opt1': val1, ...})` add additional CMake commandline defines
@@ -163,7 +163,7 @@
  - `set_install(bool)` override whether targets should be installed or not
  - `append_compile_args(lang, arg1, ...)` append compile flags for a specific
    language to the targets
- - `append_link_args(arg1, ...)` append linger args to the targets
+ - `append_link_args(arg1, ...)` append linker args to the targets
  - `clear()` reset all data in the `cmake options` object
 
 The methods `set_override_option`, `set_install`,
@@ -225,8 +225,8 @@
 
 ### cmake.write_basic_package_version_file()
 
-This function is the equivalent of the corresponding CMake
-function(https://cmake.org/cmake/help/v3.11/module/CMakePackageConfigHelpers.html#generating-a-package-version-file),
+This method is the equivalent of the corresponding CMake
+function(https://cmake.org/cmake/help/latest/module/CMakePackageConfigHelpers.html#command:write_basic_package_version_file),
 it generates a `name` package version file.
 
 * `name`: the name of the package.
@@ -235,6 +235,8 @@
 `AnyNewerVersion`, `SameMajorVersion`, `SameMinorVersion` or `ExactVersion`.
 It defaults to `AnyNewerVersion`. Depending on your cmake installation some kind of
 compatibility may not be available.
+* `arch_independent`: *new in 0.62.0*, if true the generated package file
+  will skip architecture checks. Useful for header-only libraries.
 * `install_dir`: optional installation directory, it defaults to `$(libdir)/cmake/$(name)`
 
 
@@ -248,7 +250,7 @@
 
 ### cmake.configure_package_config_file()
 
-This function is the equivalent of the corresponding CMake
+This method is the equivalent of the corresponding CMake
 function(https://cmake.org/cmake/help/v3.11/module/CMakePackageConfigHelpers.html#generating-a-package-configuration-file),
 it generates a `name` package configuration file from the `input`
 template file. Just like the cmake function in this file the
@@ -260,6 +262,7 @@
 * `input`: the template file where that will be treated for variable substitutions contained in `configuration`.
 * `install_dir`: optional installation directory, it defaults to `$(libdir)/cmake/$(name)`.
 * `configuration`: a `configuration_data` object that will be used for variable substitution in the template file.
+  *Since 0.62.0* it can take a dictionary instead.
 
 
 Example:

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Code-formatting.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Code-formatting.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Commands.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Commands.md Changed

@@ -150,6 +150,35 @@
 meson init -C sourcedir
 ```
 
+### env2mfile
+
+*This command is experimental and subject to change.*
+
+*{Since 0.62.0}*
+
+{{ env2mfile_usage.inc }}
+
+Create native and cross files from the current environment, typically
+by sniffing environment variables like `CC` and `CFLAGS`.
+
+{{ env2mfile_arguments.inc }}
+
+#### Examples:
+
+Autodetect the current cross build environment:
+
+```
+meson env2mfile --cross -o current_cross.txt --cpu=arm7a --cpu-family=arm --system=linux
+```
+
+Generate a cross build using Debian system information:
+
+```
+meson env2mfile --cross --debarch=armhf -o deb_arm_cross.txt
+```
+
+
+
 ### introspect
 
 {{ introspect_usage.inc }}
@@ -211,7 +240,9 @@
 
 Configures a build directory for the Meson project.
 
-This is the default Meson command (invoked if there was no COMMAND supplied).
+*Deprecated since 0.64.0*: This is the default Meson command (invoked if there
+was no COMMAND supplied). However, supplying the command is necessary to avoid
+clashes with future added commands, so "setup" should be used explicitly.
 
 {{ setup_arguments.inc }}
 
@@ -235,6 +266,9 @@
 multiple subprojects in parallel by default, use `--num-processes=1` if it is
 not desired.
 
+Since *0.64.0* the `update` subcommand will not download new wrap files
+from WrapDB any more. Use `meson wrap update` command for that instead.
+
 {{ subprojects_arguments.inc }}
 
 ### test
@@ -292,7 +326,7 @@
 ...
 ```
 
-These variables are set in environment in addition to those set using `meson.add_devenv()`:
+These variables are set in environment in addition to those set using meson.add_devenv:
 - `MESON_DEVENV` is defined to `'1'`.
 - `MESON_PROJECT_NAME` is defined to the main project's name.
 - `PKG_CONFIG_PATH` includes the directory where Meson generates `-uninstalled.pc`
@@ -311,5 +345,23 @@
 schemas is compiled. This is automatically set when using `gnome.compile_schemas()`.
 Note that this requires GLib >= 2.64 when `gnome.compile_schemas()` is used in
 more than one directory.
+- `QEMU_LD_PREFIX` *Since 1.0.0* is set to the `sys_root` value from cross file
+ when cross compiling and that property is defined.
+
+Since *Since 0.62.0* if bash-completion scripts are being installed and the
+shell is bash, they will be automatically sourced.
+
+Since *Since 0.62.0* when GDB helper scripts (*-gdb.py, *-gdb.gdb, and *-gdb.csm)
+are installed with a library name that matches one being built, Meson adds the
+needed auto-load commands into `<builddir>/.gdbinit` file. When running gdb from
+top build directory, that file is loaded by gdb automatically. In the case of
+python scripts that needs to load other python modules, `PYTHONPATH` may need
+to be modified using `meson.add_devenv()`.
+
+Since *Since 0.63.0* when cross compiling for Windows `WINEPATH` is used instead
+of `PATH` which allows running Windows executables using wine. Note that since
+`WINEPATH` size is currently limited to 1024 characters, paths relative to the
+root of build directory are used. That means current workdir must be the root of
+build directory when running wine.
 
 {{ devenv_arguments.inc }}

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Compiler-properties.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Compiler-properties.md Changed

@@ -2,11 +2,12 @@
 
 Not all compilers and platforms are alike. Therefore Meson provides
 the tools to detect properties of the system during configure time. To
-get most of this information, you first need to extract the *compiler
-object* from the main *meson* variable.
+get most of this information, you first need to extract the *compiler
+object(Reference-manual_returned_compiler.html)* from the main
+*meson* variable.
 
 ```meson
-compiler = meson.get_compiler('c')
+compiler = #meson.get_compiler('c')
 ```
 
 Here we extract the C compiler. We could also have given the argument
@@ -27,19 +28,19 @@
 
 ## Compiler id
 
-The compiler object method `get_id` returns a
+The compiler object method compiler.get_id returns a
 lower case string describing the "family" of the compiler. Since 0.53.0
-`get_linker_id` returns a lower case string with the linker name. Since
+compiler.get_linker_id returns a lower case string with the linker name. Since
 compilers can often choose from multiple linkers depending on operating
 system, `get_linker_id` can be useful for handling or mitigating effects
 of particular linkers.
 
-The compiler object also has a method `get_argument_syntax` which
+The compiler object also has a method compiler.get_argument_syntax which
 returns a lower case string of `gcc`, `msvc`, or another undefined string
 value; identifying whether the compiler arguments use the same syntax as
 either `gcc` or `msvc`, or that its arguments are not like either. This should
 only be used to select the syntax of the arguments, such as those to test
-with `has_argument`.
+with compiler.has_argument.
 
 See reference tables(Reference-tables.md#compiler-ids) for a list of
 supported compiler ids and their argument type.
@@ -63,7 +64,7 @@
 Then we can run the test.
 
 ```meson
-result = compiler.compiles(code, name : 'basic check')
+result = #compiler.compiles(code, name : 'basic check')
 ```
 
 The variable *result* will now contain either `true` or `false`
@@ -76,7 +77,7 @@
 Sometimes it is necessary to check whether a certain code fragment not
 only compiles, but also links successfully, e.g. to check if a symbol
 is actually present in a library. This can be done using the
-'''.links()''' method on a compiler object like this:
+compiler.links method like this:
 
 ```meson
 code = '''#include<stdio.h>
@@ -87,7 +88,7 @@
 Then we can run the test.
 
 ```meson
-result = compiler.links(code, args : '-lfoo', name : 'link check')
+result = #compiler.links(code, args : '-lfoo', name : 'link check')
 ```
 
 The variable *result* will now contain either `true` or `false`
@@ -109,7 +110,7 @@
 return 0;
 }
 '''
-result = compiler.run(code, name : 'basic check')
+result = #compiler.run(code, name : 'basic check')
 ```
 
 The `result` variable encapsulates the state of the test, which can be
@@ -140,7 +141,7 @@
 describes how this feature can be used.
 
 ```meson
-if compiler.has_header('sys/fstat.h')
+if #compiler.has_header('sys/fstat.h')
 # header exists, do something
 endif
 ```
@@ -152,7 +153,7 @@
 above, the check can be done like this.
 
 ```meson
-wcharsize = compiler.sizeof('wchar_t', prefix : '#include<wchar.h>')
+wcharsize = #compiler.sizeof('wchar_t', prefix : '#include<wchar.h>')
 ```
 
 This will put the size of `wchar_t` as reported by sizeof into
@@ -173,7 +174,7 @@
 header `stdio.h`
 
 ```meson
-if compiler.has_function('open_memstream', prefix : '#include <stdio.h>')
+if #compiler.has_function('open_memstream', prefix : '#include <stdio.h>')
 # function exists, do whatever is required.
 endif
 ```
@@ -183,7 +184,7 @@
 assumed that the OS version that is compiled on matches the OS version
 that the binary will run on.
 
-Therefore when detecting function availability with `has_function`, it
+Therefore when detecting function availability with compiler.has_function, it
 is important to specify the correct header in the prefix argument.
 
 In the example above, the function `open_memstream` is detected, which
@@ -200,7 +201,7 @@
 contains a member called `some_member`.
 
 ```meson
-if compiler.has_member('struct mystruct', 'some_member', prefix : '#include<myheader.h>')
+if #compiler.has_member('struct mystruct', 'some_member', prefix : '#include<myheader.h>')
 # member exists, do whatever is required
 endif
 ```
@@ -213,7 +214,7 @@
 alignment of data types is simple.
 
 ```meson
-int_alignment = compiler.alignment('int') # Will most likely contain the value 4.
+int_alignment = #compiler.alignment('int') # Will most likely contain the value 4.
 ```
 
 ## Has argument
@@ -223,7 +224,7 @@
 argument.
 
 ```meson
-has_special_flags = compiler.has_argument('-Wspecialthing')
+has_special_flags = #compiler.has_argument('-Wspecialthing')
 ```
 
 *Note*: some compilers silently swallow command line arguments they do

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Configuration.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Configuration.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Configuring-a-build-directory.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Configuring-a-build-directory.md Changed

@@ -30,10 +30,11 @@
       default_library shared        shared, static, both                                     Default library type
       install_umask   0022          preserve, 0000-0777                                      Default umask to apply on permissions of installed files
       layout          mirror        mirror, flat                                             Build directory layout
-      optimization    3             0, g, 1, 2, 3, s                                         Optimization level
+      optimization    3             plain, 0, g, 1, 2, 3, s                                  Optimization level
+      prefer_static   false         true, false                                              Whether to try static linking before shared linking
       strip           false         true, false                                              Strip targets on install
       unity           off           on, off, subprojects                                     Unity build
-      warning_level   1             0, 1, 2, 3                                               Compiler warning level to use
+      warning_level   1             0, 1, 2, 3, everything                                   Compiler warning level to use
       werror          false         true, false                                              Treat warnings as errors
 
     Backend options:
@@ -52,7 +53,7 @@
       b_ndebug    false         true, false, if-release                                     Disable asserts
       b_pch       true          true, false                                                 Use precompiled headers
       b_pgo       off           off, generate, use                                          Use profile guided optimization
-      b_sanitize  none          none, address, thread, undefined, memory, address,undefined Code sanitizer to use
+      b_sanitize  none          none, address, thread, undefined, leak, memory, address,undefined Code sanitizer to use
       b_staticpic true          true, false                                                 Build static libraries as position independent
 
     Compiler options:

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Continuous-Integration.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Continuous-Integration.md Changed

@@ -36,8 +36,8 @@
   - if  "$TRAVIS_OS_NAME" == "linux" ; then echo FROM YOUR/REPO:eoan > Dockerfile; fi
   - if  "$TRAVIS_OS_NAME" == "linux" ; then echo ADD . /root >> Dockerfile; fi
   - if  "$TRAVIS_OS_NAME" == "linux" ; then docker build -t withgit .; fi
-  - if  "$TRAVIS_OS_NAME" == "linux" ; then docker run withgit /bin/sh -c "cd /root && TRAVIS=true CC=$CC CXX=$CXX meson builddir && meson test -C builddir"; fi
-  - if  "$TRAVIS_OS_NAME" == "osx" ; then SDKROOT=$(xcodebuild -version -sdk macosx Path) meson builddir && meson test -C builddir; fi
+  - if  "$TRAVIS_OS_NAME" == "linux" ; then docker run withgit /bin/sh -c "cd /root && TRAVIS=true CC=$CC CXX=$CXX meson setup builddir && meson test -C builddir"; fi
+  - if  "$TRAVIS_OS_NAME" == "osx" ; then SDKROOT=$(xcodebuild -version -sdk macosx Path) meson setup builddir && meson test -C builddir; fi
 ```
 
 ## CircleCi for Linux (with Docker)
@@ -192,7 +192,7 @@
   - pip install meson ninja
 
 script:
-  - meson builddir
+  - meson setup builddir
   - meson compile -C builddir
   - meson test -C builddir
 ```

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Contributing.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Contributing.md Changed

@@ -198,7 +198,7 @@
 for configuring the test. All of the following root entries in the `test.json`
 are independent of each other and can be combined as needed.
 
-Exanple `test.json`:
+Example `test.json`:
 
 ```json
 {
@@ -387,6 +387,7 @@
 
 - `line`
 - `match` (optional)
+- `count` (optional)
 
 Each item in the list is matched, in order, against the remaining
 actual stdout lines, after any previous matches. If the actual stdout
@@ -401,6 +402,10 @@
 | `literal` | Literal match (default) |
 | `re`      | regex match             |
 
+The `count` element determines how many times the line is expected, and allowed,
+to be in the output. If unspecified, it must appear "any number of times, but at
+least once".
+
 #### skip_on_env
 
 The `skip_on_env` key can be used to specify a list of environment variables. If
@@ -445,21 +450,18 @@
 ## Documentation
 
 The `docs` directory contains the full documentation that will be used
-to generate the Meson web site(http://mesonbuild.com). Every change
-in functionality must change the documentation pages. In most cases
-this means updating the reference documentation page but bigger
-changes might need changes in other documentation, too.
+to generate the Meson web site(https://mesonbuild.com). Line length
+in most cases should not exceed 70 characters (lines containing links
+or examples are usually exempt). Every change in functionality must
+change the documentation pages. In most cases this means updating the
+reference documentation page but bigger changes might need changes in
+other documentation, too.
 
 All new functionality needs to have a mention in the release
 notes. These features should be written in standalone files in the
 `docs/markdown/snippets` directory. The release manager will combine
 them into one page when doing the release.
 
-Integration tests should be disabled(#skipping-integration-tests) for
-documentation-only commits by putting `skip ci` into commit title.
-Reviewers should ask contributors to put `skip ci` into the title because
-tests are run again after merge for `master`.
-
 ## Python Coding style
 
 Meson follows the basic Python coding style. Additional rules are the

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Creating-Linux-binaries.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Creating-Linux-binaries.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Creating-OSX-packages.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Creating-OSX-packages.md Changed

@@ -79,16 +79,20 @@
 
 If you are not using any external libraries, this is all you need to
 do. You now have a full app bundle in `/tmp/myapp.app` that you can
-use. Most applications use third party frameworks and libraries,
-though, so you need to add them to the bundle so it will work on other
-peoples' machines.
+use.
+
+### External libraries 
+
+Most applications use third party frameworks and libraries.
+If it is the case for your project, you need to add them to 
+the bundle so it will work on other peoples' machines.
 
 As an example we are going to use the SDL2(https://libsdl.org/)
 framework. In order to bundle it in our app, we first specify an
 installer script to run.
 
 ```meson
-meson.add_install_script('install_script.sh')
+#meson.add_install_script('install_script.sh')
 ```
 
 The install script does two things. First it copies the whole
@@ -125,6 +129,24 @@
 After this you have a fully working, self-contained OSX app bundle
 ready for distribution.
 
+#### Qt
+
+Qt offers a deployment tool(https://doc.qt.io/qt-5/macos-deployment.html#macdeploy),
+called `macdeployqt`, that automates bundling Qt's libraries in your application folder and
+optionally create the final `.dmg` installer
+
+```console
+# cd into the folder that contains the `myapp.app` folder
+macdeployqt myapp.app -executable=myapp.app/Contents/MacOS/myapp
+```
+
+This copies the needed Qt libraries to the correct subfolders within `myapp.app`.
+The `-executable=myapp.app/Contents/MacOS/myapp` argument is
+to automatically alter the search path of the executable 
+`myapp.app/Contents/MacOS/myapp` for the Qt libraries. One can also pass the `-dmg`
+argument to create a `.dmg` installer from the updated `myapp.app` folder.
+More information is available on the tool's documentation page.
+
 ## Creating a .dmg installer
 
 A .dmg installer is similarly quite simple, at its core it is

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Creating-releases.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Creating-releases.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Cross-compilation.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Cross-compilation.md Changed

@@ -4,7 +4,34 @@
 
 # Cross compilation
 
-Meson has full support for cross compilation. Since cross compiling is
+Meson has full support for cross compilation through the use of
+a cross build definition file.  An minimal example of one such
+file `x86_64-w64-mingw32.txt` for a GCC/MinGW cross compiler
+targeting 64-bit Windows could be:
+
+```ini
+binaries
+c = 'x86_64-w64-mingw32-gcc'
+cpp = 'x86_64-w64-mingw32-g++'
+ar = 'x86_64-w64-mingw32-ar'
+strip = 'x86_64-w64-mingw32-strip'
+exe_wrapper = 'wine64'
+
+host_machine
+system = 'windows'
+cpu_family = 'x86_64'
+cpu = 'x86_64'
+endian = 'little'
+```
+
+Which is then used during the `setup` phase.
+
+```sh
+meson setup --cross-file x86_64-w64-mingw32.txt build-mingw
+meson compile -C build-mingw
+```
+
+Since cross compiling is
 more complicated than native building, let's first go over some
 nomenclature. The three most important definitions are traditionally
 called *build*, *host* and *target*. This is confusing because those
@@ -19,8 +46,8 @@
   machine-specific output.
 
 The `tl/dr` summary is the following: if you are doing regular cross
-compilation, you only care about `build_machine` and
-`host_machine`. Just ignore `target_machine` altogether and you will
+compilation, you only care about @build_machine and
+@host_machine. Just ignore @target_machine altogether and you will
 be correct 99% of the time. Only compilers and similar tools care
 about the target machine. In fact, for so-called "multi-target" tools
 the target machine need not be fixed at build-time like the others but
@@ -194,7 +221,7 @@
 purposes. The corresponding target definition would look the same but
 have `target_machine` in the header. These values are available in
 your Meson scripts. There are three predefined variables called,
-surprisingly, `build_machine`, `host_machine` and `target_machine`.
+surprisingly, @build_machine, @host_machine and @target_machine.
 Determining the operating system of your host machine is simply a
 matter of calling `host_machine.system()`.
 
@@ -235,16 +262,16 @@
 compilation status.
 
 ```meson
-meson.is_cross_build()        # returns true when cross compiling
-meson.can_run_host_binaries() # returns true if the host binaries can be run, either with a wrapper or natively
+#meson.is_cross_build        # returns true when cross compiling
+#meson.can_run_host_binaries # returns true if the host binaries can be run, either with a wrapper or natively
 ```
 
 You can run system checks on both the system compiler or the cross
 compiler. You just have to specify which one to use.
 
 ```meson
-build_compiler = meson.get_compiler('c', native : true)
-host_compiler = meson.get_compiler('c', native : false)
+build_compiler = #meson.get_compiler('c', native : true)
+host_compiler = #meson.get_compiler('c', native : false)
 
 build_int_size = build_compiler.sizeof('int')
 host_int_size  = host_compiler.sizeof('int')
@@ -344,5 +371,5 @@
 build using that cross files:
 
 ```sh
-meson builddir/ --cross-file x86-linux
+meson setup builddir/ --cross-file x86-linux
 ```

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Cuda-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Cuda-module.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/D.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/D.md Changed

@@ -35,6 +35,23 @@
 executable('myapp', 'app.d', d_debug: 3, 'DebugFeatureA')
 ```
 
+## In `declare_dependency`
+
+*Since 0.62.0*, when declaring your own dependency using `declare_dependency`,
+it is possible to add parameters for D specific features, e.g. to propagate
+conditional compilation versions:
+
+```meson
+my_dep = declare_dependency(
+    # ...
+    d_module_versions: 'LUA_53',
+    d_import_dirs: include_directories('my_lua_folder'),
+)
+```
+
+Accepted D specific parameters are `d_module_versions` and `d_import_dirs`
+(DMD `-J` switch).
+
 ## Using embedded unittests
 
 If you are using embedded unittest
@@ -78,7 +95,7 @@
     install: true,
     version: meson.project_version(),
     soversion: project_soversion,
-    d_module_versions: 'FeatureA', 'featureB'
+    d_module_versions: 'FeatureA', 'featureB', 1
 )
 
 pkgc = import('pkgconfig')
@@ -87,7 +104,7 @@
               subdirs: 'd/mylib',
               version: meson.project_version(),
               description: 'A simple example D library.',
-              d_module_versions: 'FeatureA'
+              d_module_versions: 'FeatureA', 1
 )
 install_subdir('src/mylib/', install_dir: 'include/d/mylib/')
 ```

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Dependencies.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Dependencies.md Changed

@@ -45,7 +45,7 @@
 
 Meson also allows to get variables that are defined in the
 `pkg-config` file. This can be done by using the
-`get_pkgconfig_variable` function.
+dep.get_pkgconfig_variable function.
 
 ```meson
 zdep_prefix = zdep.get_pkgconfig_variable('prefix')
@@ -90,6 +90,28 @@
 be returned, if 'default_value' was not provided then an error will be
 raised.
 
+## Dependencies that provide resource files
+
+Sometimes a dependency provides installable files which other projects then
+need to use. For example, wayland-protocols XML files.
+
+```meson
+foo_dep = dependency('foo')
+foo_datadir = foo_dep.get_variable('pkgdatadir')
+custom_target(
+ 'foo-generated.c',
+ input: foo_datadir / 'prototype.xml',
+ output: 'foo-generated.c',
+ command: generator, '@INPUT@', '@OUTPUT@'
+)
+```
+
+*Since 0.63.0* these actually work as expected, even when they come from a
+(well-formed) internal dependency. This only works when treating the files to
+be obtained as interchangeable with a system dependency -- e.g. only public
+files may be used, and leaving the directory pointed to by the dependency is
+not allowed.
+
 # Declaring your own
 
 You can declare your own dependency objects that can be used
@@ -166,7 +188,7 @@
 In these cases Meson provides convenience wrappers in the form of `system`
 dependencies. Internally these dependencies do exactly what a user would do
 in the build system DSL or with a script, likely calling
-`compiler.find_library()`, setting `link_with` and `include_directories`. By
+compiler.find_library, setting `link_with` and `include_directories`. By
 putting these in Meson upstream the barrier of using them is lowered, as
 projects using Meson don't have to re-implement the logic.
 
@@ -211,15 +233,15 @@
 kwarg (*introduced in 0.57.0*). The specified `cmake_package_version`
 will be passed directly as the second parameter to `find_package`.
 
-It is also possible to reuse existing `Find<name>.cmake` files with
-the `cmake_module_path` property. Using this property is equivalent to
-setting the `CMAKE_MODULE_PATH` variable in CMake. The path(s) given
-to `cmake_module_path` should all be relative to the project source
-directory. Absolute paths should only be used if the CMake files are
-not stored in the project itself.
+It is also possible to reuse existing `Find<name>.cmake` files with the
+`cmake_module_path` property (*since 0.50.0*). Using this property is
+equivalent to setting the `CMAKE_MODULE_PATH` variable in CMake. The
+path(s) given to `cmake_module_path` should all be relative to the
+project source directory. Absolute paths should only be used if the
+CMake files are not stored in the project itself.
 
 Additional CMake parameters can be specified with the `cmake_args`
-property.
+property (*since 0.50.0*).
 
 ## Dub
 
@@ -239,7 +261,7 @@
 variable when running Meson.
 ```
 dub build urld --compiler=dmd
-DC="dmd" meson builddir
+DC="dmd" meson setup builddir
 ```
 
 ## Config tool
@@ -322,7 +344,7 @@
 exe = executable('myprog', 'file.cc', dependencies : boost_dep)
 ```
 
-You can call `dependency` multiple times with different modules and
+You can call dependency multiple times with different modules and
 use those to link against your targets.
 
 If your boost headers or libraries are in non-standard locations you
@@ -370,7 +392,7 @@
 
 *New in 0.56.0* The `config-tool` and `system` methods.
 
-To define some of the the preprocessor symbols mentioned in the
+To define some of the preprocessor symbols mentioned in the
 curses autoconf documentation(http://git.savannah.gnu.org/gitweb/?p=autoconf-archive.git;a=blob_plain;f=m4/ax_with_curses.m4):
 
 ```meson
@@ -393,6 +415,17 @@
 endforeach
 ```
 
+## dl (libdl)
+
+*(added 0.62.0)*
+
+Provides access to the dynamic link interface (functions: dlopen,
+dlclose, dlsym and others). On systems where this is not built
+into libc (mostly glibc < 2.34), tries to find an external library
+providing them instead.
+
+`method` may be `auto`, `builtin` or `system`.
+
 ## Fortran Coarrays
 
 *(added 0.50.0)*
@@ -472,6 +505,45 @@
 
 `method` may be `auto`, `builtin` or `system`.
 
+## JDK
+
+*(added 0.58.0)*
+*(deprecated 0.62.0)*
+
+Deprecated name for JNI. `dependency('jdk')` instead of `dependency('jni')`.
+
+## JNI
+
+*(added 0.62.0)*
+
+`modules` is an optional list of strings containing any of `jvm` and `awt`.
+
+Provides access to compiling with the Java Native Interface (JNI). The lookup
+will first check if `JAVA_HOME` is set in the environment, and if not will use
+the resolved path of `javac`. Systems will usually link your preferred JDK to
+well known paths like `/usr/bin/javac` on Linux for instance. Using the path
+from `JAVA_HOME` or the resolved `javac`, this dependency will place the JDK
+installation's `include` directory and its platform-dependent subdirectory on
+the compiler's include path. If `modules` is non-empty, then the proper linker
+arguments will also be added.
+
+```meson
+dep = dependency('jni', version: '>= 1.8.0', modules: 'jvm')
+```
+
+**Note**: Due to usage of a resolved path, upgrading the JDK may cause the
+various paths to not be found. In that case, please reconfigure the build
+directory. One workaround is to explicitly set `JAVA_HOME` instead of relying on
+the fallback `javac` resolved path behavior.
+
+**Note**: Include paths might be broken on platforms other than `linux`,
+`windows`, `darwin`, and `sunos`. Please submit a PR or open an issue in this
+case.
+
+**Note**: Use of the `modules` argument on a JDK `<= 1.8` may be broken if your
+system is anything other than `x86_64`. Please submit a PR or open an issue in
+this case.
+
 ## libgcrypt
 
 *(added 0.49.0)*
@@ -498,7 +570,7 @@
 
 ### Modules, a.k.a. Components
 
-Meson wraps LLVM's concept of components in it's own modules concept.
+Meson wraps LLVM's concept of components in its own modules concept.
 When you need specific components you add them as modules as Meson
 will do the right thing:
 
@@ -575,6 +647,12 @@
 
 The `language` keyword may used.
 
+## OpenSSL
+
+*(added 0.62.0)*
+
+`method` may be `auto`, `pkg-config`, `system` or `cmake`.
+
 ## pcap
 
 *(added 0.42.0)*
@@ -653,11 +731,17 @@
 
 *(added 0.51.0)*
 
-Shaderc currently does not ship with any means of detection.
-Nevertheless, Meson can try to detect it using `pkg-config`, but will
-default to looking for the appropriate library manually. If the
-`static` keyword argument is `true`, `shaderc_combined` is preferred.
-Otherwise, `shaderc_shared` is preferred. Note that it is not possible
+Meson will first attempt to find shaderc using `pkg-config`. Upstream
+currently ships three different `pkg-config` files and by default will
+check them in this order: `shaderc`, `shaderc_combined`, and
+`shaderc_static`. If the `static` keyword argument is `true`, then
+Meson instead checks in this order: `shaderc_combined`, `shaderc_static`,
+and `shaderc`.
+
+If no `pkg-config` file is found, then Meson will try to detect the
+library manually. In this case, it will try to link against either
+`-lshaderc_shared` or `-lshaderc_combined`, preferring the latter
+if the static keyword argument is true. Note that it is not possible
 to obtain the shaderc version using this method.
 
 `method` may be `auto`, `pkg-config` or `system`.
@@ -672,7 +756,7 @@
 ## Valgrind
 
 Meson will find valgrind using `pkg-config`, but only uses the
-compilation flags and avoids trying to link with it's non-PIC static
+compilation flags and avoids trying to link with its non-PIC static
 libs.
 
 ## Vulkan

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Design-rationale.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Design-rationale.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/External-Project-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/External-Project-module.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/FAQ.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/FAQ.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Fs-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Fs-module.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Generating-sources.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Generating-sources.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Getting-meson.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Getting-meson.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Getting-meson_ptbr.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Getting-meson_ptbr.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Gnome-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Gnome-module.md Changed

@@ -103,10 +103,14 @@
 * `header`: *(Added 0.43.0)* name of main c header to include for the library, e.g. `glib.h`
 * `include_directories`: extra include paths to look for gir files
 * `install`: if true, install the generated files
+* `install_gir`: (*Added 0.61.0*) overrides `install`, whether to install the
+ generated gir
 * `install_dir_gir`: (*Added 0.35.0*) which directory to install the
- gir file into; can be false to disable installation
+ gir file into; (*Deprecated since 0.61.0*) can be false to disable installation
+* `install_typelib`: (*Added 0.61.0*) overrides `install`, whether to install the
+ generated typelib
 * `install_dir_typelib`: (*Added 0.35.0*) which directory to install
- the typelib file into; can be false to disable installation
+ the typelib file into; (*Deprecated since 0.61.0*) can be false to disable installation
 * `link_with`: list of libraries to link with
 * `symbol_prefix`: the symbol prefix for the gir object, e.g. `gtk`,
 (*Since 0.43.0*) an ordered list of multiple prefixes is allowed
@@ -411,3 +415,5 @@
 `<prefix>/<datadir>/icons/hicolor`.
 - `update_desktop_database`: *Since 0.59.0* If set to `true`, update cache of
 MIME types handled by desktop files in `<prefix>/<datadir>/applications`.
+- `update_mime_database`: *Since 0.64.0* If set to `true`, update cache of
+ MIME types in `<prefix>/<datadir>/mime`.

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/GuiTutorial.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/GuiTutorial.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/IDE-integration.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/IDE-integration.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/IndepthTutorial.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/IndepthTutorial.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Installing.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Installing.md Changed

@@ -96,7 +96,7 @@
 Telling Meson to run this script at install time is a one-liner.
 
 ```meson
-meson.add_install_script('myscript.sh')
+#meson.add_install_script('myscript.sh')
 ```
 
 The argument is the name of the script file relative to the current
@@ -149,25 +149,31 @@
 Meson sets predefined tags on some files. More tags are likely to be added over
 time, please help extending the list of well known categories.
 - `devel`:
-  * `static_library()`,
-  * `install_headers()`,
+  * static_library,
+  * install_headers,
   * `pkgconfig.generate()`,
   * `gnome.generate_gir()` - `.gir` file,
+  * `gnome.generate_vapi()` - `.vapi` file (*Since 0.64.0*),
   * Files installed into `libdir` and with `.a` or `.pc` extension,
-  * File installed into `includedir`.
+  * File installed into `includedir`,
+  * Generated header files installed with `gnome.compile_resources()`,
+    `gnome.genmarshal()`, `gnome.mkenums()`, `gnome.mkenums_simple()`
+    and `gnome.gdbus_codegen()` (*Since 0.64.0*).
 - `runtime`:
-  * `executable()`,
-  * `shared_library()`,
-  * `shared_module()`,
-  * `jar()`,
-  * Files installed into `bindir`.
+  * executable,
+  * shared_library,
+  * shared_module,
+  * jar,
+  * `gnome.compile_resources()` - `.gresource` file (*Since 0.64.0*),
+  * Files installed into `bindir`,
   * Files installed into `libdir` and with `.so` or `.dll` extension.
 - `python-runtime`:
   * `python.install_sources()`.
 - `man`:
-  * `install_man()`.
+  * install_man.
 - `doc`:
   * `gnome.gtkdoc()`,
+  * `gnome.yelp()`,
   * `hotdoc.generate_doc()`.
 - `i18n`:
   * `i18n.gettext()`,
@@ -175,10 +181,20 @@
   * Files installed into `localedir`.
 - `typelib`:
   * `gnome.generate_gir()` - `.typelib` file.
+- `bin`:
+  * Scripts and executables bundled with a library meant to be used by end
+    users.
+- `bin-devel`:
+  * Scripts and executables bundled with a library meant to be used by
+    developers (i.e. build tools).
+- `tests`:
+  * Files installed into `installed-tests` subdir (*Since 0.64.0*).
+- `systemtap`:
+  * Files installed into `systemtap` subdir (*Since 0.64.0*).
 
 Custom installation tag can be set using the `install_tag` keyword argument
-on various functions such as `custom_target()`, `configure_file()`,
-`install_subdir()` and `install_data()`. See their respective documentation
+on various functions such as custom_target, configure_file,
+install_subdir and install_data. See their respective documentation
 in the reference manual for details. It is recommended to use one of the
 predefined tags above when possible.

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Java-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Java-module.md Changed

@@ -1,11 +1,14 @@
 # Java Module
 
-*Added 0.60.0*
+*(added in 0.60.0)*
 
 ## Functions
 
 ### `generate_native_header()`
 
+*(deprecated in 0.62.0, use `generate_native_headers()`)*
+*(removed in 1.0.0)*
+
 This function will generate a header file for use in Java native module
 development by reading the supplied Java file for `native` method declarations.
 
@@ -13,3 +16,90 @@
 
 - `package`: The package(https://en.wikipedia.org/wiki/Java_package) of the
 file. If left empty, Meson will assume that there is no package.
+
+### `generate_native_headers()`
+
+*(added in 0.62.0)*
+*(deprecated in 1.0.0, use `native_headers()`)*
+
+This function will generate native header files for use in Java native module
+development by reading the supplied Java files for `native` method declarations.
+
+Keyword arguments:
+
+- `classes`: The list of class names relative to the `package`, if it exists,
+which contain `native` method declarations. Use `.` separated class names.
+
+- `package`: The package(https://en.wikipedia.org/wiki/Java_package) of the
+file. If left empty, Meson will assume that there is no package.
+
+Example:
+
+```java
+// Outer.java
+
+package com.mesonbuild;
+
+public class Outer {
+    private static native void outer();
+
+    public static class Inner {
+        private static native void inner();
+    }
+}
+```
+
+With the above file, an invocation would look like the following:
+
+```meson
+java = import('java')
+
+native_headers = java.generate_native_headers(
+    'Outer.java',
+    package: 'com.mesonbuild',
+    classes: 'Outer', 'Outer.Inner'
+)
+```
+
+### `native_headers()`
+
+*(added in 1.0.0)*
+
+This function will generate native header files for use in Java native module
+development by reading the supplied Java files for `native` method declarations.
+
+Keyword arguments:
+
+- `classes`: The list of class names relative to the `package`, if it exists,
+which contain `native` method declarations. Use `.` separated class names.
+
+- `package`: The package(https://en.wikipedia.org/wiki/Java_package) of the
+file. If left empty, Meson will assume that there is no package.
+
+Example:
+
+```java
+// Outer.java
+
+package com.mesonbuild;
+
+public class Outer {
+    private static native void outer();
+
+    public static class Inner {
+        private static native void inner();
+    }
+}
+```
+
+With the above file, an invocation would look like the following:
+
+```meson
+java = import('java')
+
+native_headers = java.generate_native_headers(
+    'Outer.java',
+    package: 'com.mesonbuild',
+    classes: 'Outer', 'Outer.Inner'
+)
+```

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Localisation.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Localisation.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Native-environments.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Native-environments.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Pkgconfig-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Pkgconfig-module.md Changed

@@ -45,8 +45,7 @@
   would be `foobar-1`
 - `requires` list of strings, pkgconfig-dependencies or libraries that
    `pkgconfig.generate()` was used on to put in the `Requires` field
-- `requires_private` same as `requires` but for `Requires.private` field
-  field
+- `requires_private` the same as `requires` but for the `Requires.private` field
 - `url` a string with a url for the library
 - `variables` a list of strings with custom variables to add to the
   generated file. The strings must be in the form `name=value` and may
@@ -58,7 +57,8 @@
   Spaces in values are escaped with `\`, this is required in the case the value is
   a path that and is used in `cflags` or `libs` arguments. *Since 0.59.0* if
   escaping is not desired (e.g. space separate list of values) `unescaped_variables`
-  keyword argument should be used instead.
+  keyword argument should be used instead. *Since 0.62.0* builtin directory variables
+  that are referenced are automatically created by default.
 - `uninstalled_variables` used instead of the `variables` keyword argument, when
   generating the uninstalled pkg-config file. Since *0.54.0*
   Spaces in values are escaped with `\`, this is required in the case the value is
@@ -125,3 +125,9 @@
 - Once a pkg-config file is generated for a library using `pkg.generate(mylib)`,
   any subsequent call to `pkg.generate()` where mylib appears, will generate a
   `Requires:` or `Requires.private` instead of a `Libs:` or `Libs.private:`.
+
+### Relocatable pkg-config files
+
+By default, the files generated by `pkg.generate` contain a hardcoded prefix path.
+In order to make them relocatable, a `pkgconfig.relocatable` builtin option is provided.
+See Pkgconfig module options(Builtin-options.md#pkgconfig-module).

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Python-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Python-module.md Changed

@@ -53,6 +53,12 @@
   *Since 0.49.0*
 - `modules`: a list of module names that this python installation must have.
   *Since 0.51.0*
+- `pure`: On some platforms, architecture independent files are
+  expected to be placed in a separate directory. However, if the
+  python sources should be installed alongside an extension module
+  built with this module, this keyword argument can be used to
+  override the default behavior of `.install_sources()`.
+  *since 0.64.0*
 
 **Returns**: a python installation`python_installation` object
 
@@ -93,9 +99,15 @@
   it will be appended to that location. This keyword argument is
   mutually exclusive with `install_dir`
 
-`extension_module` does not add any dependencies to the library so
-user may need to add `dependencies : py_installation.dependency()`,
-see dependency.
+Additionally, the following diverge from shared_module's default behavior:
+
+- `gnu_symbol_visibility`: if unset, it will default to `'hidden'` on versions
+  of Python that support this (the python headers define `PyMODINIT_FUNC` has
+  default visibility).
+
+*since 0.63.0* `extension_module` automatically adds a dependency to the library
+if one is not explicitly provided. To support older versions, the user may need to
+add `dependencies : py_installation.dependency()`, see dependency.
 
 **Returns**: a @build_tgt object
 
@@ -105,6 +117,8 @@
 python_dependency py_installation.dependency(...)
 ```
 
+*since 0.53.0*
+
 This method accepts no positional arguments, and the same keyword
 arguments as the standard dependency function. It also supports the
 following keyword argument:
@@ -135,7 +149,8 @@
   expected to be placed in a separate directory. However, if the
   python sources should be installed alongside an extension module
   built with this module, this keyword argument can be used to
-  override that behaviour. Defaults to `true`
+  override that behaviour. Defaults to the value specified in
+  `find_installation()`, or else `true`
 
 - `subdir`: See documentation for the argument of the same name to
   `extension_module()`

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Qt6-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Qt6-module.md Changed

@@ -2,7 +2,178 @@
 
 *New in Meson 0.57.0*
 
-The Qt5 module provides tools to automatically deal with the various
+The Qt6 module provides tools to automatically deal with the various
 tools and steps required for Qt.
 
-{{ _include_qt_base.md }}
+## compile_resources
+
+*New in 0.59.0*
+
+Compiles Qt's resources collection files (.qrc) into c++ files for compilation.
+
+It takes no positional arguments, and the following keyword arguments:
+ - `name` (string | empty): if provided a single .cpp file will be generated,
+ and the output of all qrc files will be combined in this file, otherwise
+ each qrc file be written to it's own cpp file.
+ - `sources` (File | string | custom_target | custom_target index | generator_output):
+ A list of sources to be transpiled. Required, must have at least one source 
+ *New in 0.60.0*: support for custom_target, custom_target_index, and generator_output.
+ - `extra_args` string: Extra arguments to pass directly to `qt-rcc`
+ - `method` string: The method to use to detect qt, see dependency
+
+## compile_ui
+
+*New in 0.59.0*
+
+Compiles Qt's ui files (.ui) into header files.
+
+It takes no positional arguments, and the following keyword arguments:
+ - `sources` (File | string | custom_target | custom_target index | generator_output):
+ A list of sources to be transpiled. Required, must have at least one source 
+ *New in 0.60.0*: support for custom_target, custom_target_index, and generator_output.
+ - `extra_args` string: Extra arguments to pass directly to `qt-uic`
+ - `method` string: The method to use to detect qt, see dependency
+
+## compile_moc
+
+*New in 0.59.0*
+
+Compiles Qt's moc files (.moc) into header and/or source files. At least one of
+the keyword arguments `headers` and `sources` must be provided.
+
+It takes no positional arguments, and the following keyword arguments:
+ - `sources` (File | string | custom_target | custom_target index | generator_output):
+ A list of sources to be transpiled into .moc files for manual inclusion. 
+ *New in 0.60.0*: support for custom_target, custom_target_index, and generator_output.
+ - `headers` (File | string | custom_target | custom_target index | generator_output):
+ A list of headers to be transpiled into .cpp files 
+ *New in 0.60.0*: support for custom_target, custom_target_index, and generator_output.
+ - `extra_args` string: Extra arguments to pass directly to `qt-moc`
+ - `method` string: The method to use to detect qt, see dependency
+ - `dependencies`: dependency objects whose include directories are used by moc.
+ - `include_directories` (string | IncludeDirectory): A list of `include_directory()`
+ objects used when transpiling the .moc files
+
+## preprocess
+
+Consider using `compile_resources`, `compile_ui`, and `compile_moc` instead.
+
+Takes sources for moc, uic, and rcc, and converts them into c++ files for
+compilation.
+
+Has the following signature: `qt.preprocess(name: str | None, *sources: str)`
+
+If the `name` parameter is passed then all of the rcc files will be written to
+a single output file
+
+*Deprecated in 0.59.0*: Files given in the variadic `sources` arguments as well
+as the `sources` keyword argument, were passed unmodified through the preprocessor
+programs. Don't do this - just add the output of `preprocess()` to another sources
+list:
+```meson
+sources = files('a.cpp', 'main.cpp', 'bar.c')
+sources += qt.preprocess(qresources : 'resources')
+```
+
+This method takes the following keyword arguments:
+ - `qresources` (string | File): Passed to the RCC compiler
+ - `ui_files`: (string | File | CustomTarget): Passed the `uic` compiler
+ - `moc_sources`: (string | File | CustomTarget): Passed the `moc` compiler.
+ These are converted into .moc files meant to be `#include`ed
+ - `moc_headers`: (string | File | CustomTarget): Passied the `moc` compiler.
+ These will be converted into .cpp files
+ - `include_directories` (IncludeDirectories | string), the directories to add
+ to header search path for `moc`
+ - `moc_extra_arguments` string: any additional arguments to `moc`.
+ - `uic_extra_arguments` string: any additional arguments to `uic`.
+ - `rcc_extra_arguments` string: any additional arguments to `rcc`.
+ - `dependencies` Dependency: dependency objects needed by moc.
+ - *Deprecated in 0.59.0.*: `sources`: a list of extra sources, which are added
+ to the output unchanged.
+
+It returns an array of targets and sources to pass to a compilation target.
+
+## compile_translations
+
+This method generates the necessary targets to build translation files with
+lrelease, it takes no positional arguments, and the following keyword arguments:
+
+ - `ts_files` (File | string | custom_target | custom_target index | generator_output):
+ the list of input translation files produced by Qt's lupdate tool. 
+ *New in 0.60.0*: support for custom_target, custom_target_index, and generator_output.
+ - `install` bool: when true, this target is installed during the install step (optional).
+ - `install_dir` string: directory to install to (optional).
+ - `build_by_default` bool: when set to true, to have this target be built by
+ default, that is, when invoking `meson compile`; the default value is false
+ (optional).
+ - `qresource` string: rcc source file to extract ts_files from; cannot be used
+ with ts_files kwarg.
+ - `rcc_extra_arguments` string: any additional arguments to `rcc` (optional),
+ when used with `qresource.
+
+Returns either: a list of custom targets for the compiled
+translations, or, if using a `qresource` file, a single custom target
+containing the processed source file, which should be passed to a main
+build target.
+
+## has_tools
+
+This method returns `true` if all tools used by this module are found,
+`false` otherwise.
+
+It should be used to compile optional Qt code:
+```meson
+qt6 = import('qt6')
+if qt6.has_tools(required: get_option('qt_feature'))
+ moc_files = qt6.preprocess(...)
+ ...
+endif
+```
+
+This method takes the following keyword arguments:
+- `required` bool | FeatureOption: by default, `required` is set to `false`. If `required` is set to
+ `true` or an enabled `feature`(Build-options.md#features) and some tools are
+ missing Meson will abort.
+- `method` string: The method to use to detect qt, see dependency
+
+## Dependencies
+
+See Qt dependencies(Dependencies.md#qt4-qt5)
+
+The 'modules' argument is used to include Qt modules in the project.
+See the Qt documentation for the list of
+modules(https://doc.qt.io/qt-6/qtmodules.html).
+
+The 'private_headers' argument allows usage of Qt's modules private
+headers.
+
+## Example
+A simple example would look like this:
+
+```meson
+qt6 = import('qt6')
+qt6_dep = dependency('qt6', modules: 'Core', 'Gui')
+inc = include_directories('includes')
+moc_files = qt6.compile_moc(headers : 'myclass.h',
+ extra_arguments: '-DMAKES_MY_MOC_HEADER_COMPILE',
+ include_directories: inc,
+ dependencies: qt6_dep)
+translations = qt6.compile_translations(ts_files : 'myTranslation_fr.ts', build_by_default : true)
+executable('myprog', 'main.cpp', 'myclass.cpp', moc_files,
+ include_directories: inc,
+ dependencies : qt6_dep)
+```
+
+Sometimes, translations are embedded inside the binary using qresource
+files. In this case the ts files do not need to be explicitly listed,
+but will be inferred from the built qm files listed in the qresource
+file. For example:
+
+```meson
+qt6 = import('qt6')
+qt6_dep = dependency('qt6', modules: 'Core', 'Gui')
+lang_cpp = qt6.compile_translations(qresource: 'lang.qrc')
+executable('myprog', 'main.cpp', lang_cpp,
+ dependencies: qt6_dep)
+```
+

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Quick-guide.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Quick-guide.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Reference-tables.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Reference-tables.md Changed

@@ -9,7 +9,6 @@
 | ----- | --------------- | --------------- |
 | arm | ARM compiler | |
 | armclang | ARMCLANG compiler | |
-| c2000 | Texas Instruments C2000 compiler | |
 | ccomp | The CompCert formally-verified C compiler | |
 | ccrx | Renesas RX Family C/C++ compiler | |
 | clang | The Clang compiler | gcc |
@@ -21,6 +20,8 @@
 | gcc | The GNU Compiler Collection | gcc |
 | intel | Intel compiler (Linux and Mac) | gcc |
 | intel-cl | Intel compiler (Windows) | msvc |
+| intel-llvm | Intel oneAPI LLVM-based compiler | |
+| intel-llvm-cl | Intel oneAPI LLVM-based compiler (Windows) | msvc |
 | lcc | Elbrus C/C++/Fortran Compiler | |
 | llvm | LLVM-based compiler (Swift, D) | |
 | mono | Xamarin C# compiler | |
@@ -32,9 +33,15 @@
 | pgi | Portland PGI C/C++/Fortran compilers | |
 | rustc | Rust compiler | |
 | sun | Sun Fortran compiler | |
+| c2000 | Texas Instruments C/C++ Compiler (C2000) | |
+| ti | Texas Instruments C/C++ Compiler | |
 | valac | Vala compiler | |
 | xc16 | Microchip XC16 C compiler | |
 | cython | The Cython compiler | |
+| nasm | The NASM compiler (Since 0.64.0) | |
+| yasm | The YASM compiler (Since 0.64.0) | |
+| ml | Microsoft Macro Assembler for x86 and x86_64 (Since 0.64.0) | msvc |
+| armasm | Microsoft Macro Assembler for ARM and AARCH64 (Since 0.64.0) | |
 
 ## Linker ids
 
@@ -45,6 +52,7 @@
 | ld.bfd | The GNU linker |
 | ld.gold | The GNU gold linker |
 | ld.lld | The LLVM linker, with the GNU interface |
+| ld.mold | The fast MOLD linker |
 | ld.solaris | Solaris and illumos |
 | ld.wasm | emscripten's wasm-ld linker |
 | ld64 | Apple ld64 |
@@ -55,6 +63,7 @@
 | rlink | The Renesas linker, used with CCrx only |
 | xc16-ar | The Microchip linker, used with XC16 only |
 | ar2000 | The Texas Instruments linker, used with C2000 only |
+| ti-ar | The Texas Instruments linker |
 | armlink | The ARM linker (arm and armclang compilers) |
 | pgi | Portland/Nvidia PGI |
 | nvlink | Nvidia Linker used with cuda |
@@ -97,6 +106,7 @@
 | microblaze | MicroBlaze processor |
 | mips | 32 bit MIPS processor |
 | mips64 | 64 bit MIPS processor |
+| msp430 | 16 bit MSP430 processor |
 | parisc | HP PA-RISC processor |
 | pic24 | 16 bit Microchip PIC24 |
 | ppc | 32 bit PPC processors |
@@ -163,6 +173,8 @@
 | Rust | rust_args | rust_link_args |
 | Vala | vala_args | vala_link_args |
 | Cython | cython_args | cython_link_args |
+| NASM | nasm_args | N/A |
+| MASM | masm_args | N/A |
 
 All these `<lang>_*` options are specified per machine. See in
 specifying options per
@@ -240,7 +252,10 @@
 | optimize |
 | packed |
 | pure |
+| retain⁴ |
 | returns_nonnull |
+| section⁵ |
+| sentinel⁵ |
 | unused |
 | used |
 | visibility* |
@@ -251,7 +266,7 @@
 | warning |
 | warn_unused_result |
 | weak |
-| weakreaf |
+| weakref |
 
 \* *Changed in 0.52.0* the "visibility" target no longer includes
 "protected", which is not present in Apple's clang.
@@ -261,6 +276,10 @@
 
 ³ *New in 0.55.0*
 
+⁴ *New in 0.62.0*
+
+⁵ *New in 0.63.0*
+
 ### MSVC __declspec
 
 These values are supported using the MSVC style `__declspec` annotation,
@@ -304,6 +323,7 @@
 | Rust | RUSTC | RUSTC_LD | Before 0.54 RUST_LD* |
 | Vala | VALAC | | Use CC_LD. Vala transpiles to C |
 | C# | CSC | CSC | The linker is the compiler |
+| nasm | NASM | | Uses the C linker |
 
 *The old environment variales are still supported, but are deprecated
 and will be removed in a future version of Meson.*

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Release-notes-for-0.51.0.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.51.0.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Release-notes-for-0.52.0.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.52.0.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Release-notes-for-0.54.0.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.54.0.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Release-notes-for-0.55.0.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.55.0.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Release-notes-for-0.56.0.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.56.0.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Release-notes-for-0.57.0.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.57.0.md Changed

@@ -128,7 +128,7 @@
 only specify compiler/linker arguments or other dependencies that satisfy
 the same requirements.
 
-## `unstable_external_project` improvements
+## `unstable-external_project` improvements
 
 - Default arguments are added to `add_project()` in case some tags are not found
   in `configure_options`: `'--prefix=@PREFIX@'`, `'--libdir=@PREFIX@/@LIBDIR@'`,
@@ -187,7 +187,7 @@
 ```sh
 git clone https://github.com/myproject
 cd myproject/subprojects/mysubproject
-meson builddir
+meson setup builddir
 meson dist -C builddir
 ```
 
@@ -337,7 +337,7 @@
 Both the gnu linker and lld support using threads for speeding up LTO, meson
 now provides a knob for this: `-Db_lto_threads`. Currently this is only
 supported for clang and gcc. Any positive integer is supported, `0` means
-`auto`. If the compiler or linker implements it's on `auto` we use that,
+`auto`. If the compiler or linker implements its own `auto` we use that,
 otherwise the number of threads on the machine is used.
 
 ## `summary()` now uses left alignment for both keys and values

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Release-notes-for-0.58.0.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.58.0.md Changed

@@ -150,7 +150,7 @@
 
 The file `.clang-format-ignore` contains a list of patterns matching the files
 that will be excluded. Files matching the include list (see above) that match
-one of the ignore pattern will not be reformatted. Unlike include patters, ignore
+one of the ignore pattern will not be reformatted. Unlike include patterns, ignore
 patterns does not support `**` and a single `*` match any characters including
 path separators. Empty lines and lines starting with `#` are ignored.
 
@@ -279,7 +279,7 @@
 pkg-config file generator. The output filename must have a known library extension
 such as `.a`, `.so`, etc.
 
-## JDK System Dependency
+## JNI System Dependency
 
 When building projects such as those interacting with the JNI, you need access
 to a few header files located in a Java installation. This system dependency
@@ -289,7 +289,7 @@
 symlinks are resolved.
 
 ```meson
-jdk = dependency('jdk', version : '>=1.8')
+jni_dep = dependency('jni', version : '>=1.8')
 ```
 
 Currently this system dependency only works on `linux`, `win32`, and `darwin`.

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Release-notes-for-0.59.0.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.59.0.md Changed

_service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.62.0.md Added

@@ -0,0 +1,409 @@
+---
+title: Release 0.62.0
+short-description: Release notes for 0.62.0
+...
+
+# New features
+
+## Bash completion scripts sourced in `meson devenv`
+
+If bash-completion scripts are being installed and the shell is bash, they will
+be automatically sourced.
+
+## Setup GDB auto-load for `meson devenv`
+
+When GDB helper scripts (*-gdb.py, *-gdb.gdb, and *-gdb.csm) are installed with
+a library name that matches one being built, Meson adds the needed auto-load
+commands into `<builddir>/.gdbinit` file. When running gdb from top build
+directory, that file is loaded by gdb automatically.
+
+## Print modified environment variables with `meson devenv --dump`
+
+With `--dump` option, all envorinment variables that have been modified are
+printed instead of starting an interactive shell. It can be used by shell
+scripts that wish to setup their environment themself.
+
+## New `method` and `separator` kwargs on `environment()` and `meson.add_devenv()`
+
+It simplifies this common pattern:
+```meson
+env = environment()
+env.prepend('FOO', 'a', 'b', separator: ',')
+meson.add_devenv(env)
+```
+
+becomes one line:
+```meson
+meson.add_devenv({'FOO': 'a', 'b'}, method: 'prepend', separator: ',')
+```
+
+or two lines:
+```meson
+env = environment({'FOO': 'a', 'b'}, method: 'prepend', separator: ',')
+meson.add_devenv(env)
+```
+
+## New custom dependency for libdl
+
+```
+dependency('dl')
+```
+
+will now check for the functionality of libdl.so, but first check if it is
+provided in the libc (for example in libc on OpenBSD or in musl libc on linux).
+
+## pkgconfig.generate will now include variables for builtin directories when referenced
+
+When using the `variables:` family of kwargs to `pkgconfig.generate` to refer
+to installed paths, traditionally only `prefix`, `includedir`, and `libdir`
+were available by default, and generating a correct (relocatable) pkg-config
+file required manually constructing variables for e.g. `datadir`.
+
+Meson now checks each variable to see if it begins with a reference to a
+standard directory, and if so, adds it to the list of directories for which a
+builtin variable is created.
+
+For example, before it was necessary to do this:
+```meson
+pkgconfig.generate(
+ name: 'bash-completion',
+ description: 'programmable completion for the bash shell',
+ dataonly: true,
+ variables: {
+ 'prefix': get_option('prefix'),
+ 'datadir': join_paths('${prefix}', get_option('datadir')),
+ 'sysconfdir': join_paths('${prefix}', get_option('sysconfdir')),
+
+ 'compatdir': '${sysconfdir}/bash_completion.d',
+ 'completionsdir': '${datadir}/bash-completion/completions',
+ 'helpersdir': '${datadir}/bash-completion/helpers',
+ },
+ install_dir: join_paths(get_option('datadir'), 'pkgconfig'),
+)
+```
+
+Now the first three variables are not needed.
+
+## New keyword argument `verbose` for tests and benchmarks
+
+The new keyword argument `verbose` can be used to mark tests and benchmarks
+that must always be logged verbosely on the console. This is particularly
+useful for long-running tests, or when a single Meson test() is wrapping
+an external test harness.
+
+## CMake support for versions <3.17.0 is deprecated
+
+Support for CMake versions below 3.17.0 is now deprecated for *both* CMake
+dependencies and subprojects.
+
+## Removal of the RPM module
+
+Due to lack of interest, lack of maintainership, and lack of a clear purpose,
+the RPM module has been removed.
+
+Users interested in one-shot tools to generate an RPM spec file template for
+distro packaging, are encouraged develop an external tool that reads the
+introspection data.
+
+For more details, see https://github.com/mesonbuild/meson/issues/9764
+
+## CMake server API support is removed
+
+Support for the
+deprecated (since CMake 3.15)(https://cmake.org/cmake/help/latest/release/3.15.html#deprecated-and-removed-features)
+and now
+removed (since CMake 3.20)(https://cmake.org/cmake/help/latest/release/3.20.html#deprecated-and-removed-features)
+CMake server API is dropped from Meson.
+
+The new CMake minimum version for CMake subprojects is now CMake 3.14.
+
+## Rust proc-macro crates
+
+Rust has these handy things called proc-macro crates, which are a bit like a
+compiler plugin. We can now support them, simply build a shared_library with
+the `rust_crate_type` set to `proc-macro`.
+
+```meson
+proc = shared_library(
+ 'proc',
+ 'proc.rs',
+ rust_crate_type : 'proc-macro',
+ install : false,
+)
+
+user = executable('user, 'user.rs', link_with : proc)
+```
+
+## found programs now have a version method
+
+The return value of find_program can now check the exact version of the
+found program, independent of the minimum version requirement. This can be used
+e.g. to perform different actions depending on the exact version detected.
+
+## Minimum required Python version updated to 3.7
+
+Meson now requires at least Python version 3.7 to run as Python 3.6 reached EOL
+on December 2021. In practice this should only affect people developing on
+Ubuntu Bionic, who will need to manually install python3.8 from the official
+repositories.
+
+
+## Added support for XML translations using itstool
+
+XML files can now be translated easier by using `itstool` via
+`i18n.itstool_join()`. This ensures the XML is translated correctly
+based on the defined ITS rules for the specific XML layout.
+
+## JNI System Dependency Modules
+
+The JNI system dependency now supports a `modules` keyword argument which is a
+list containing any of the following: `jvm`, `awt`.
+
+```meson
+jni_dep = dependency('jni', version: '>= 1.8.0', modules: 'jvm', 'awt')
+```
+
+This will add appropriate linker arguments to your target.
+
+## New unstable wayland module
+
+This module can search for protocol xml files from the wayland-protocols
+package, and generate .c and .h files using wayland-scanner.
+
+## Experimental command to convert environments to cross files
+
+Meson has a new command `env2mfile` that can be used to convert
+"environment variable based" cross and native compilation environments
+to Meson machine files. This is especially convenient for e.g. distro
+packagers so they can easily generate unambiguous configuration files
+for package building.
+
+As an example here's how you would generate a cross file that takes
+its settings from the `CC`, `CXX`, `CFLAGS` etc environment variables.
+
+ meson env2mfile --cross --system=baremetal --cpu=armv7 --cpu-family=arm -o armcross.txt
+
+The command also has support for generating Debian build files using
+system introspection:
+
+ meson env2mfile --cross --debarch armhf -o debarmhf_cross.txt
+
+Note how you don't need to specify any system details, the command
+gets them transparently via `dpkg-architecture`.
+
+Creating a native file is done in the same way:
+
+ meson env2mfile --native -o current_system.txt
+
+This system will detect if the `_FOR_BUILD` environment variables are
+enabled and then uses them as needed.
+
+With this you should be able to convert any envvar-based cross build
+setup to cross and native files and then use those. This means, among
+other things, that you can then run your compilations from any shell,
+not just the special one that has all the environment variables set.
+
+As this functionality is still a bit in flux, the specific behaviour
+and command line arguments to use are subject to change. Because of
+this the main documentation has not yet been updated.
+
+Please try this for your use cases and report to us if it is working.
+Patches to make the autodetection work on other distros and platforms
+are also welcome.
+
+## Added optional '--allow-dirty' flag for the 'dist' command
+
+An optional `--allow-dirty` flag has been added to the `dist` command.
+
+Previously, if uncommitted changes were present, Meson would warn about
+this but continue with the dist process. It now errors out instead. The
+error can be suppressed by using the `--allow-dirty` option.
+
+## ldconfig is no longer run on install
+
+Due to various issues of fragility and concern that it doesn't predictably do
+the right thing, meson no longer runs ldconfig during `meson install`, and
+users who need it run should run it themselves, instead.
+
+## Added support for Texas Instruments MSP430 and ARM compilers
+
+Meson now supports the TI MSP430(https://www.ti.com/tool/MSP-CGT) and
+ARM(https://www.ti.com/tool/ARM-CGT) toolchains. The compiler and linker are
+identified as `ti` and `ti-ar`, respectively. To maintain backwards
+compatibility with existing build definitions, the C2000
+toolchain(https://www.ti.com/tool/C2000-CGT) is still identified as `c2000` and
+`ar2000`.
+
+## cmake.configure_package_config_file can now take a dict
+
+The `configuration` kwarg of the `configure_package_config_file()` function
+from the `cmake` module can now take a dict object, just like the regular
+`configure_file()` function.
+
+## Deprecated `java.generate_native_header()` in favor of the new `java.generate_native_headers()`
+
+`java.generate_native_header()` was only useful for the most basic of
+situations. It didn't take into account that in order to generate native
+headers, you had to have all the referenced Java files. It also didn't take
+into account inner classes. Do not use this function from `0.62.0` onward.
+
+`java.generate_native_headers()` has been added as a replacement which should account for the previous function's shortcomings.
+
+```java
+// Outer.java
+
+package com.mesonbuild;
+
+public class Outer {
+ private static native void outer();
+
+ public static class Inner {
+ private static native void inner();
+ }
+}
+```
+
+With the above file, an invocation would look like the following:
+
+```meson
+java = import('java')
+
+native_headers = java.generate_native_headers(
+ 'Outer.java',
+ package: 'com.mesonbuild',
+ classes: 'Outer', 'Outer.Inner'
+)
+```
+
+## New option to choose python installation environment
+
+It is now possible to specify `-Dpython.install_env` and choose how python modules are installed.
+
+- `venv`: assume that a virtualenv is active and install to that
+- `system`: install to the global site-packages of the selected interpreter
+ (the one that the venv module calls --system-site-packages)
+- `prefix`: preserve existing behavior
+- `auto`: autodetect whether to use venv or system
+
+## JDK System Dependency Renamed from `jdk` to `jni`
+
+The JDK system dependency is useful for creating native Java modules using the
+JNI. Since the purpose is to find the JNI, it has been decided that a better
+name is in fact "jni". Use of `dependency('jdk')` should be replaced with
+`dependency('jni')`.
+
+## i18n.merge_file no longer arbitrarily leaves your project half-built
+
+The i18n module partially accounts for builds with NLS disabled, by disabling
+gettext compiled translation catalogs if it cannot build them. Due to
+implementation details, this also disabled important data files created via
+merge_file, leading to important desktop files etc. not being installed.
+
+This overreaction has been fixed. It is no longer possible to have NLS-disabled
+builds which break the project by not installing important files which have
+nothing to do with NLS (other than including some).
+
+If you were depending on not having the Gettext tools installed and
+successfully mis-building your project, you may need to make your project
+actually work with NLS disabled, for example by providing some version of your
+files which is still installed even when merge_file cannot be run.
+
+## All directory options now support paths outside of prefix
+
+Previously, Meson only allowed most directory options to be relative to prefix.
+This restriction has been now lifted, bringing us in line with Autotools and
+CMake. It is also useful for platforms like Nix, which install projects into
+multiple independent prefixes.
+
+As a consequence, `get_option` might return absolute paths for any
+directory option, if a directory outside of prefix is passed. This
+is technically a backwards incompatible change but its effect
+should be minimal, thanks to widespread use of `join_paths`/
+`/` operator and pkg-config generator module.
+
+## `meson install --strip`
+
+It is now possible to strip targets using `meson install --strip` even if
+`-Dstrip=true` option was not set during configuration. This allows doing
+stripped and not stripped installations without reconfiguring the build.
+
+## Support for ARM Ltd. Clang toolchain
+
+Support for the `armltdclang` compiler has been added. This differs from the
+existing `armclang` toolchain in that it is a fork of Clang by ARM Ltd. and
+supports native compilation. The Keil `armclang` toolchain only supports
+cross-compilation to embedded devices.
+
+## structured_sources()
+
+A new function, `structured_sources()` has been added. This function allows
+languages like Rust which depend on the filesystem layout at compile time to mix
+generated and static sources.
+
+```meson
+executable(
+ 'main',
+ structured_sources(
+ 'main.rs,
+ {'mod' : generated_mod_rs},
+ )
+)
+```
+
+Meson will then at build time copy the files into the build directory (if
+necessary), so that the desired file structure is laid out, and compile that. In
+this case:
+
+```
+root/
+ main.rs
+ mod/
+ mod.rs
+```
+
+## New custom dependency for OpenSSL
+
+Detecting an OpenSSL installation in a cross-platform manner can be
+complicated. Officially, pkg-config is supported by upstream. Unofficially,
+cmake includes a FindOpenSSL using a different name and which requires
+specifying modules.
+
+Meson will now allow the pkg-config name to work in all cases using the following lookup order:
+- prefer pkg-config if at all possible
+- attempt to probe the system for the standard library naming, and retrieve the version from the headers
+- if all else fails, check if cmake can find it
+
+## D features in `declare_dependency`
+
+`declare_dependency`accepts parameters for D specific features.
+Accepted new parameters are `d_module_versions` and `d_import_dirs`.
+
+This can be useful to propagate conditional compilation versions. E.g.:
+
+```meson
+my_lua_dep = declare_dependency(
+ # ...
+ d_module_versions: 'LUA_53',
+ d_import_dirs: include_directories('my_lua_folder'),
+)
+```
+
+## arch_independent kwarg in cmake.write_basic_package_version_file
+
+The `write_basic_package_version_file()` function from the `cmake` module
+now supports an `arch_independent` kwarg, so that architecture checks in
+the generated Package Version file are skipped, reproducing the behaviour of
+CMake's ARCH_INDEPENDENT(https://cmake.org/cmake/help/latest/module/CMakePackageConfigHelpers.html#command:write_basic_package_version_file)
+option.
+
+## `dataonly` Pkgconfig Default Install Path
+
+The default install path for `dataonly` pkgconfig files has changed from
+`${libdir}/pkgconfig` to `${datadir}/pkgconfig`.
+
+## JAR default install dir
+
+The previous default for `jar()` was `libdir`. With this release, it has been
+changed to `datadir/java`. Please open an issue if this is not a sane default
+for your system.
+

_service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.63.0.md Added

@@ -0,0 +1,269 @@
+---
+title: Release 0.63.0
+short-description: Release notes for 0.63.0
+...
+
+# New features
+
+## `add_project_dependencies()` function
+
+Dependencies can now be added to all build products using
+`add_project_dependencies()`.  This can be useful in several
+cases:
+
+* with special dependencies such as `dependency('threads')`
+* with system libraries such as `find_library('m')`
+* with the `include_directories` keyword argument of
+`declare_dependency()`, to add both source and build
+directories to the include search path
+
+## Coverage targets now respect tool config files
+
+gcovr >= 4.2 supports `gcovr.cfg` in the project source root to configure how
+coverage is generated. If Meson detects that gcovr will load this file, it no
+longer excludes the `subprojects/` directory from coverage. It's a good default
+for Meson to guess that projects want to ignore it, but not all projects prefer
+that and it is assumed that if a gcovr.cfg exists then it will manually
+include/exclude desired paths.
+
+lcov supports `.lcovrc`, but only as a systemwide or user setting. This is
+non-ideal for projects, so Meson will now detect one in the project source root
+and, if present, manually tell lcov to use it.
+
+## D compiler checks
+
+Some compiler checks are implemented for D:
+ - `run`
+ - `sizeof`
+ - `has_header` (to check if a module is present)
+ - `alignment`
+
+Example:
+
+```meson
+ptr_size = meson.get_compiler('d').sizeof('void*')
+```
+
+## Deprecate an option and replace it with a new one
+
+The `deprecated` keyword argument can now take the name of a new option
+that replace this option. In that case, setting a value on the deprecated option
+will set the value on both the old and new names, assuming they accept the same
+values.
+
+```meson
+# A boolean option has been replaced by a feature with another name, old true/false values
+# are accepted by the new option for backward compatibility.
+option('o1', type: 'boolean', value: 'true', deprecated: 'o2')
+option('o2', type: 'feature', value: 'enabled', deprecated: {'true': 'enabled', 'false': 'disabled'})
+
+# A project option is replaced by a module option
+option('o3', type: 'string', value: '', deprecated: 'python.platlibdir')
+```
+
+## Running Windows executables with Wine in `meson devenv`
+
+When cross compiling for Windows, `meson devenv` now sets `WINEPATH` pointing to
+all directories containing needed DLLs and executables.
+
+## Diff files for wraps
+
+Wrap files can now define `diff_files`, a list of local patch files in `diff`
+format. Meson will apply the diff files after extracting or cloning the project,
+and after applying the overlay archive (`patch_*`). For this feature, the
+`patch` or `git` command-line tool must be available.
+
+## Added preserve_path arg to install_headers
+
+The install_headers function now has an optional argument `preserve_path`
+that allows installing multi-directory headerfile structures that live
+alongside sourcecode with a single command.
+
+For example, the headerfile structure
+
+```meson
+headers = 
+  'one.h',
+  'two.h',
+  'alpha/one.h',
+  'alpha/two.h',
+  'alpha/three.h'
+  'beta/one.h'
+
+```
+
+can now be passed to `install_headers(headers, subdir: 'mylib', preserve_path: true)`
+and the resulting directory tree will look like
+
+```
+{prefix}
+└── include
+    └── mylib
+        ├── alpha
+        │   ├── one.h
+        │   ├── two.h
+        │   └── three.h
+        ├── beta
+        │   └── one.h
+        ├── one.h
+        └── two.h
+```
+
+## JAR Resources
+
+The ability to add resources to a JAR has been added. Use the `java_resources`
+keyword argument. It takes a `sturctured_src` object.
+
+```meson
+jar(
+  meson.project_name(),
+  sources,
+  main_class: 'com.mesonbuild.Resources',
+  java_resources: structured_sources(
+    files('resources/resource1.txt'),
+    {
+      'subdir': files('resources/subdir/resource2.txt'),
+    }
+  )
+)
+```
+
+To access these resources in your Java application:
+
+```java
+try (InputStreamReader reader = new InputStreamReader(
+        Resources.class.getResourceAsStream("/resource1.txt"),
+        StandardCharsets.UTF_8)) {
+    // ...
+}
+
+try (InputStreamReader reader = new InputStreamReader(
+        Resources.class.getResourceAsStream("/subdir/resource2.txt"),
+        StandardCharsets.UTF_8)) {
+    // ...
+}
+```
+
+## Support for mold linker added
+
+The high performance linker mold can be selected via `CC_LD` or `CXX_LD` for
+Clang and GCC >= 12.0.1.
+
+## MSVC now sets the __cplusplus #define accurately
+
+MSVC will always return `199711L` for `__cplusplus`, even when a newer c++
+standard is explicitly requested, unless you pass a specific option to the
+compiler for MSVC 2017 15.7 and newer. Older versions are unaffected by this.
+
+Microsoft's stated rationale is that "a lot of existing code appears to depend
+on the value of this macro matching 199711L", therefore for compatibility with
+such (MSVC-only) code they will require opting in to the standards-conformant
+value.
+
+Meson now always sets the option if it is available, as it is unlikely that
+users want the default behavior, and *impossible* to use the default behavior
+in cross-platform code (which frequently breaks as soon as the first person
+tries to compile using MSVC).
+
+## Added `debug` function
+
+In addition to the `message()`, `warning()` and `error()` functions there is now the
+`debug()` function to log messages that only end up in the `meson-log.txt` logfile
+and are not printed to stdout at configure time.
+
+## Compiler options can be set per subproject
+
+All compiler options can now be set per subproject. See
+here(Build-options.md#specifying-options-per-subproject) for details on how
+the default value is inherited from main project.
+
+This is useful for example when the main project requires C++11 but a subproject
+requires C++14. The `cpp_std` value from subproject's `default_options` is now
+respected.
+
+## Per-subproject languages
+
+Subprojects does not inherit languages added by main project or other subprojects
+any more. This could break subprojects that wants to compile e.g. `.c` files but
+did not add `c` language, either in `project()` or `add_languages()`, and were
+relying on the main project to do it for them.
+
+## Installed pkgconfig files can now be relocatable
+
+The pkgconfig module now has a module option `pkgconfig.relocatable`.
+When set to `true`, the pkgconfig files generated will have their
+`prefix` variable set to be relative to their `install_dir`.
+
+For example to enable it from the command line run:
+
+```sh
+meson setup builddir -Dpkgconfig.relocatable=true …
+```
+
+It will only work if the `install_dir` for the generated pkgconfig
+files are located inside the install prefix of the package. Not doing
+so will cause an error.
+
+This should be useful on Windows or any other platform where
+relocatable packages are desired.
+
+## New prefer_static built-in option
+
+Users can now set a boolean, `prefer_static`, that controls whether or not
+static linking should be tried before shared linking. This option acts as
+strictly a preference. If the preferred linking method is not successful,
+then Meson will fallback and try the other linking method. Specifically
+setting the `static` kwarg in the meson.build will take precedence over
+the value of `prefer_static` for that specific `dependency` or
+`find_library` call.
+
+## Python extension modules now depend on the python library by default
+
+Python extension modules are usually expected to link to the python library
+and/or its headers in order to build correctly (via the default `embed: false`,
+which may not actually link to the library itself). This means that every
+single use of `.extension_module()` needed to include the `dependencies:
+py_installation.dependency()` kwarg explicitly.
+
+In the interest of doing the right thing out of the box, this is now the
+default for extension modules that don't already include a dependency on
+python. This is not expected to break anything, because it should always be
+needed. Nevertheless, `py_installation.dependency().partial_dependency()` will
+be detected as already included while providing no compile/link args.
+
+## Python extension modules now build with hidden visibility
+
+Python extension modules are usually expected to only export a single symbol,
+decorated with the `PyMODINIT_FUNC` macro and providing the module entry point.
+On versions of python >= 3.9, the python headers contain GNU symbol visibility
+attributes to mark the init function with default visibility; it is then safe
+to set the shared_module inherited kwarg `gnu_symbol_visibility: 'hidden'`.
+
+In the interest of doing the right thing out of the box, this is now the
+default for extension modules for found installations that are new enough to
+have this set, which is not expected to break anything, but remains possible to
+set explicitly (in which case that will take precedence).
+
+## Added support for multiline fstrings
+
+Added support for multiline f-strings which use the same syntax as f-strings
+for string substitution.
+
+```meson
+x = 'hello'
+y = 'world'
+
+msg = f'''Sending a message...
+"@x@ @y@"
+'''
+```
+
+which produces:
+
+```
+Sending a message....
+
+"hello world"
+
+```
+

_service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-0.64.0.md Added

@@ -0,0 +1,185 @@
+---
+title: Release 0.64.0
+short-description: Release notes for 0.64.0
+...
+
+# New features
+
+## Add `optimization` `plain` option
+
+The `optimization` built-in option now accepts `plain` value,
+which will not set any optimization flags. This is now the default
+value of the flag for `buildtype=plain`, which is useful for distros,
+that set the optimization and hardening flags by other means.
+
+If you are using the value of `get_option('optimization')` in your
+Meson scripts, make sure you are not making assumptions about it,
+such as that the value can be passed to a compiler in `-O` flag.
+
+## New languages: `nasm` and `masm`
+
+When the `nasm` language is added to the project, `.asm` files are
+automatically compiled with NASM. This is only supported for x86 and x86_64 CPU
+family. `yasm` is used as fallback if `nasm` command is not found.
+
+When the `masm` language is added to the project, `.masm` files are
+automatically compiled with Microsoft's Macro Assembler. This is only supported
+for x86, x86_64, ARM and AARCH64 CPU families.
+
+Note that GNU Assembly files usually have `.s` or `.S` extension and were already
+built using C compiler such as GCC or CLANG.
+
+```meson
+project('test', 'nasm')
+
+exe = executable('hello', 'hello.asm')
+test('hello', exe)
+```
+
+## Pager and colors for `meson configure` output
+
+The output of `meson configure`, printing all options, is now more readable by
+automatically using a pager (`less` by default) and colors. The pager used can
+be controlled by setting `PAGER` environment variable, or `--no-pager` command
+line option.
+
+## various `install_*` functions no longer handle the sticky bit
+
+It is not possible to portably grant the sticky bit to a file, and where
+possible, it doesn't do anything. It is not expected that any users are using
+this functionality.
+
+Variously:
+- on Linux, it has no meaningful effect
+- on Solaris, attempting to set the permission bit is silently ignored by the OS
+- on FreeBSD, attempting to set the permission bit is an error
+
+Attempting to set this permission bit in the `install_mode:` kwarg to any
+function other than install_emptydir will now result in a warning, and the
+permission bit being ignored.
+
+## `fs.copyfile` to replace `configure_file(copy : true)`
+
+A new method has been added to the `fs` module, `copyfile`. This method replaces
+`configure_file(copy : true)`, but only copies files. Unlike `configure_file()`
+it runs at build time, and the output name is optional defaulting to the
+filename without paths of the input if unset:
+
+```meson
+fs.copyfile('src/file.txt')
+```
+Will create a file in the current build directory called `file.txt`
+
+
+```meson
+fs.copyfile('file.txt', 'outfile.txt')
+```
+Will create a copy renamed to `outfile.txt`
+
+## Added `update_mime_database` to `gnome.post_install()`
+
+Applications that install a `.xml` file containing a `mime-type` need to update
+the cache upon installation. Most applications do that using a custom script,
+but it can now be done by Meson directly.
+
+## Added preserve_path arg to install_data
+
+The install_data function now has an optional argument `preserve_path`
+that allows installing multi-directory data file structures that live
+alongside source code with a single command.
+
+This is also available in the specialized `py_installation.install_sources`
+method.
+
+## BSD support for the `jni` dependency
+
+This system dependency now supports all BSD systems that Meson currently
+supports, including FreeBSD, NetBSD, OpenBSD, and DragonflyBSD.
+
+## Credentials from `~/.netrc` for `https` URLs
+
+When a subproject is downloaded using an `https://` URL, credentials from
+`~/.netrc` are now used. This avoids hardcoding login and password in plain
+text in the URL itself.
+
+## Basic support for oneAPI compilers on Linux and Windows
+
+To use on Linux:
+
+```
+source /opt/intel/oneapi/setvars.sh
+CC=icx CXX=icpx FC=ifx meson setup builddir
+```
+
+## New method to preprocess source files
+
+Compiler object has a new `preprocess()` method. It is supported by all C/C++
+compilers. It preprocess sources without compiling them.
+
+The preprocessor will receive the same arguments (include directories, defines,
+etc) as with normal compilation. That includes for example args added with
+`add_project_arguments()`, or on the command line with `-Dc_args=-DFOO`.
+
+```meson
+cc = meson.get_compiler('c')
+pp_files = cc.preprocess('foo.c', 'bar.c', output: '@PLAINNAME@')
+exe = executable('app', pp_files)
+```
+
+## python.find_installation() now accepts pure argument
+
+The default value of `pure:` for `py.install_sources()` and
+`py.get_install_dir()` can now be changed by explicitly passing a `pure:` kwarg
+to `find_installation()`.
+
+This can be used to ensure that multiple `install_sources()` invocations do not
+forget to specify the kwarg each time.
+
+## Generates rust-project.json when there are Rust targets
+
+This is a format similar to compile_commands.json, but specifically used by the
+official rust LSP, rust-analyzer. It is generated automatically if there are
+Rust targets, and is placed in the build directory.
+
+## `summary()` accepts disablers
+
+Disabler options can be passed to `summary()` as the value to be printed.
+
+## Option to allow meson test to fail fast after the first failing testcase
+
+`meson test --maxfail=1` will now cause all pending or in-progress tests to be
+canceled or interrupted after 1 test is marked as failing. This can be used for
+example to quit a CI run and avoid burning additional time as soon as it is
+known that the overall return status will be failing.
+
+## Incremental ThinLTO with `b_thinlto_cache`
+
+Incremental ThinLTO(https://clang.llvm.org/docs/ThinLTO.html#incremental) can now be enabled by passing
+`-Db_thinlto_cache=true` during setup. The use of caching speeds up incremental builds significantly while retaining all
+the runtime performance benefits of ThinLTO.
+
+The cache location defaults to a Meson-managed directory inside the build folder, but can be customized with
+`b_thinlto_cache_dir`.
+
+## Update all wraps from WrapDB with `meson wrap update` command
+
+The command `meson wrap update`, with no extra argument, will now update all wraps
+that comes from WrapDB to the latest version. The extra `--force` argument will
+also replace wraps that do not come from WrapDB if one is available.
+
+The command `meson subprojects update` will not download new wrap files from
+WrapDB any more.
+
+## Added `include_core_only` arg to wayland.scan_xml.
+
+The `scan_xml` function from the wayland module now has an optional bool
+argument `include_core_only`, so that headers generated by wayland-scanner now
+only include `wayland-client-core.h` instead of `wayland-client.h`.
+
+## Automatic fallback using WrapDB
+
+A new command has been added: `meson wrap update-db`. It downloads the list of
+wraps available in WrapDB(https://wrapdb.mesonbuild.com) and stores it locally in
+`subprojects/wrapdb.json`. When that file exists and a dependency is not found
+on the system but is available in WrapDB, Meson will automatically download it.
+

_service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Release-notes-for-1.0.0.md Added

@@ -0,0 +1,85 @@
+---
+title: Release 1.0.0
+short-description: Release notes for 1.0.0
+...
+
+# New features
+
+Meson 1.0.0 was released on 23 December 2022
+## Compiler check functions `prefix` kwargs accepts arrays
+
+The `prefix` kwarg that most compiler check functions support
+now accepts an array in addition to a string. The elements of the
+array will be concatenated separated by a newline.
+
+This makes it more readable to write checks that need multiple headers
+to be included:
+
+```meson
+cc.check_header('GL/wglew.h', prefix : '#include <windows.h>', '#include <GL/glew.h>')
+```
+
+instead of
+
+```meson
+cc.check_header('GL/wglew.h', prefix : '#include <windows.h>\n#include <GL/glew.h>')
+```
+
+## Flags removed from cpp/objcpp warning level 1
+
+`-Wnon-virtual-dtor` is no longer implied by `meson setup -Dwarning_level=1`.
+
+## Developer environment improvements
+
+When cross compiling, the developer environment now sets all environment
+variables for the HOST machine. It now also sets `QEMU_LD_PREFIX` to the
+`sys_root` value from cross file if property is defined. That means that cross
+compiled executables can often be run transparently on the build machine, for
+example when cross compiling for aarch64 linux from x86_64 linux.
+
+A new argument `--workdir` has been added, by default it is set to build
+directory. For example, `meson devenv -C builddir --workdir .` can be used to
+remain in the current dir (often source dir) instead.
+
+`--dump` now prints shell commands like `FOO="/prepend/path:$FOO:/append/path"`,
+using the literal `$FOO` instead of current value of `FOO` from environment.
+This makes easier to evaluate those expressions in a different environment.
+
+## Deprecate `java.generate_native_headers`, rename to `java.native_headers`
+
+The functions operate in the exact same way. The new name matches more with
+Meson function name styling.
+
+## rust.bindgen accepts a dependency argument
+
+The `bindgen` method of the `rust` module now accepts a dependencies argument.
+Any include paths in these dependencies will be passed to the underlying call to
+`clang`, and the call to `bindgen` will correctly depend on any generatd sources.
+
+## String arguments to the rust.bindgen include_directories argument
+
+Most other cases of include_directories accept strings as well as
+`IncludeDirectory` objects, so lets do that here too for consistency.
+
+## The Rust module is stable
+
+Mesa is using the rust module in production, so it's time to mark it as stable.
+
+## `in` operator for strings
+
+`in` and `not in` operators now works on strings, in addition to arrays and
+dictionaries.
+
+```
+fs = import('fs')
+if 'something' in fs.read('somefile')
+ # True
+endif
+```
+
+## `warning-level=everything` option
+
+The new `everything` value for the built-in `warning_level` enables roughly all applicable compiler warnings.
+For clang and MSVC, this simply enables `-Weverything` or `/Wall`, respectively.
+For GCC, meson enables warnings approximately equivalent to `-Weverything` from clang.
+

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Rust-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Rust-module.md Changed

@@ -3,14 +3,13 @@
 authors:
     - name: Dylan Baker
       email: dylan@pnwbakers.com
-      years: 2020, 2021
+      years: 2020, 2021, 2022
 ...
 
-# Unstable Rust module
+# Rust module
 
 *(new in 0.57.0)*
-
-**Note** Unstable modules make no backwards compatible API guarantees.
+*(Stable since 1.0.0)*
 
 The rust module provides helper to integrate rust code into Meson. The
 goal is to make using rust in Meson more pleasant, while still
@@ -34,7 +33,7 @@
 Additional, test only dependencies may be passed via the dependencies
 argument.
 
-### bindgen(*, input: string | BuildTarget | string | BuildTarget, output: string, include_directories: include_directories, c_args: string, args: string)
+### bindgen(*, input: string | BuildTarget | (string | BuildTarget), output: string, include_directories: (include_directories | string), c_args: string, args: string, dependencies: Dependency)
 
 This function wraps bindgen to simplify creating rust bindings around C
 libraries. This has two advantages over hand-rolling ones own with a
@@ -49,10 +48,11 @@
 - input — A list of Files, Strings, or CustomTargets. The first element is
   the header bindgen will parse, additional elements are dependencies.
 - output — the name of the output rust file
-- include_directories — A list of `include_directories` objects, these are
-  passed to clang as `-I` arguments
+- include_directories — A list of `include_directories` or `string` objects,
+  these are passed to clang as `-I` arguments *(string since 1.0.0)*
 - c_args — A list of string arguments to pass to clang untouched
 - args — A list of string arguments to pass to `bindgen` untouched.
+- dependencies — A list of `Dependency` objects to pass to the underlying clang call (*since 1.0.0*)
 
 ```meson
 rust = import('unstable-rust')
@@ -60,8 +60,8 @@
 inc = include_directories('..'¸ '../../foo')
 
 generated = rust.bindgen(
-    'myheader.h',
-    'generated.rs',
+    input : 'myheader.h',
+    output : 'generated.rs',
     include_directories : inc, include_directories('foo'),
     args : '--no-rustfmt-bindings',
     c_args : '-DFOO=1',
@@ -77,7 +77,7 @@
 h2 = custom_target(...)
 
 r1 = rust.bindgen(
-  h1, h2,  # h1 includes h2,
-  'out.rs',
+  input : h1, h2,  # h1 includes h2,
+  output : 'out.rs',
 )
 ```

_service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Rust.md Added

@@ -0,0 +1,67 @@
+---
+title: Rust
+short-description: Working with Rust in Meson
+...
+
+# Using Rust with Meson
+
+## Mixing Rust and non-Rust sources
+
+Meson currently does not support creating a single target with Rust and non Rust
+sources mixed together, therefore one must compile multiple libraries and link
+them.
+
+```meson
+rust_lib = static_library(
+    'rust_lib',
+    sources : 'lib.rs',
+    ...
+)
+
+c_lib = static_library(
+    'c_lib',
+    sources : 'lib.c',
+    link_with : rust_lib,
+)
+```
+This is an implementation detail of Meson, and is subject to change in the future.
+
+## Mixing Generated and Static sources
+
+*Note* This feature was added in 0.62
+
+You can use a @structured_src for this. Structured sources are a dictionary
+mapping a string of the directory, to a source or list of sources.
+When using a structured source all inputs *must* be listed, as Meson may copy
+the sources from the source tree to the build tree.
+
+Structured inputs are generally not needed when not using generated sources.
+
+As an implementation detail, Meson will attempt to determine if it needs to copy
+files at configure time and will skip copying if it can. Copying is done at
+build time (when necessary), to avoid reconfiguring when sources change.
+
+```meson
+executable(
+    'rust_exe',
+    #structured_sources(
+        'main.rs',
+        {
+            'foo' : 'bar.rs', 'foo/lib.rs', generated_rs,
+            'foo/bar' : ...,
+            'other' : ...,
+        }
+    )
+)
+```
+
+## Use with rust-analyzer
+
+*Since 0.64.0.*
+
+Meson will generate a `rust-project.json` file in the root of the build
+directory if there are any rust targets in the project. Most IDEs will need to
+be configured to use the file as it's not in the source root (Meson does not
+write files into the source directory). See the upstream
+docs(https://rust-analyzer.github.io/manual.html#non-cargo-based-projects) for
+more information on how to configure that.

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Shipping-prebuilt-binaries-as-wraps.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Shipping-prebuilt-binaries-as-wraps.md Changed

@@ -34,3 +34,11 @@
 compiler flags) might not be compatible. If you do this, then you are
 responsible for verifying that your libraries are compatible, Meson
 will not check things for you.
+
+## Note for Linux libraries
+
+A precompiled linux shared library (.so) requires a soname field to be properly installed. If the soname field is missing, binaries referencing the library will require a hard link to the location of the library at install time (`/path/to/your/project/subprojects/precompiledlibrary/lib.so` instead of `$INSTALL_PREFIX/lib/lib.so`) after installation.
+
+You should change the compilation options for the precompiled library to avoid this issue. If recompiling is not an option, you can use the patchelf(https://github.com/NixOS/patchelf) tool with the command `patchelf --set-soname libfoo.so libfoo.so` to edit the precompiled library after the fact.
+
+Meson generally guarantees any library it compiles has a soname. One notable exception is libraries built with the shared_module function.

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Subprojects.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Subprojects.md Changed

@@ -84,12 +84,13 @@
 ### Build options in subproject
 
 All Meson features of the subproject, such as project options keep
-working and can be set in the master project. There are a few
-limitations, the most important being that global compiler arguments
-must be set in the main project before calling subproject. Subprojects
-must not set global arguments because there is no way to do that
-reliably over multiple subprojects. To check whether you are running
-as a subproject, use the `is_subproject` function.
+working and can be set in the master
+project(Builtin-options.md#specifying-options-per-subproject). There
+are a few limitations, the most important being that global compiler
+arguments must be set in the main project before calling subproject.
+Subprojects must not set global arguments because there is no way to
+do that reliably over multiple subprojects. To check whether you are
+running as a subproject, use meson.is_subproject.
 
 ## Using a subproject
 
@@ -153,7 +154,7 @@
 this use case.
 
 ```meson
-dep = dependency('foo', fallback : subproject_name, variable_name)
+dep = dependency('foo', fallback : 'subproject_name', 'variable_name')
 ```
 
 The `fallback` keyword argument takes two items, the name of the
@@ -175,9 +176,23 @@
   install : true)
 ```
 
-With this setup when libsimple is provided by the system, we use it.
-When that is not the case we use the embedded version (the one from
-subprojects).
+You may change default options of the
+subproject(Builtin-options.md#specifying-options-per-subproject) by
+adding a keyword argument to the invocation. For example, to change the
+default library type:
+
+```
+libsimple_dep = dependency(
+  'libsimple',
+  fallback : 'libsimple', 'libsimple_dep',
+  default_options: 'default_library=static'
+)
+```
+
+With this setup, when libsimple is provided by the system we use it and
+completely ignore subproject options (i.e. we link to a shared system
+library). When that is not the case, we use the embedded version (the
+one from subprojects).
 
 Note that `libsimple_dep` can point to an external or an internal
 dependency but you don't have to worry about their differences. Meson

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Syntax.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Syntax.md Changed

@@ -176,7 +176,9 @@
 
 These are raw strings that do not support the escape sequences listed
 above.  These strings can also be combined with the string formatting
-functionality described below.
+functionality via `.format()` described below.
+
+Note that multiline f-string support was added in version 0.63.
 
 ### String index
 
@@ -209,7 +211,8 @@
 *(Added 0.58)*
 
 Format strings can be used as a non-positional alternative to the
-string formatting functionality described above.
+string formatting functionality described above. Note that multiline f-string
+support was added in version 0.63.
 
 ```meson
 n = 10
@@ -527,6 +530,54 @@
 
 Attempting to do this causes Meson to immediately exit with an error.
 
+### Argument flattening
+
+Argument flattening is a Meson feature that aims to simplify using
+methods and functions. For functions where this feature is active,
+Meson takes the list of arguments and flattens all nested lists into
+one big list.
+
+For instance the following function calls to executable are
+identical in Meson:
+
+```meson
+# A normal example:
+executable('exe1', 'foo.c', 'bar.c', 'foobar.c')
+
+# A more contrived example that also works but certainly
+# isn't good Meson code:
+l1 = 'bar.c'
+executable('exe1', 'foo.c', l1, 'foobar.c')
+
+# How meson will treat all the previous calls internally:
+executable('exe1', 'foo.c', 'bar.c', 'foobar.c')
+```
+
+Because of an internal implementation detail, the following syntax
+is currently also supported, even though the first argument of
+executable is a single @str and not a @list:
+
+```meson
+# WARNING: This example is only valid because of an internal
+#          implementation detail and not because it is intended
+#
+#          PLEASE DO NOT DO SOMETHING LIKE THIS!
+#
+executable('exe1', 'foo.c', 'bar.c', 'foobar.c')
+```
+
+This code is currently accepted because argument flattening *currently*
+happens before the parameters are evaluated. "Support" for
+such constructs will likely be removed in future Meson releases!
+
+Argument flattening is supported by *most* but not *all* Meson
+functions and methods. As a general rule, it can be assumed that a
+function or method supports argument flattening if the exact list
+structure is irrelevant to a function.
+
+Whether a function supports argument flattening is documented in the
+Reference Manual(Reference-manual.md).
+
 ## Method calls
 
 Objects can have methods, which are called with the dot operator. The
@@ -717,6 +768,8 @@
 array_literal: "" expression_list ""
 assignment_statement: expression asssignment_operator expression
 assignment_operator: "=" | "*=" | "/=" | "%=" | "+=" | "-="
+binary_literal: "0b" BINARY_NUMBER
+BINARY_NUMBER: /01+/
 boolean_literal: "true" | "false"
 build_definition: (NEWLINE | statement)*
 condition: expression

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Tutorial.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Tutorial.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Unit-tests.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Unit-tests.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Users.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Users.md Changed

@@ -13,16 +13,21 @@
 topic(https://github.com/topics/meson).
 
  - 2048.cpp(https://github.com/plibither8/2048.cpp), a fully featured terminal version of the game "2048" written in C++
+ - aawordsearch(https://github.com/theimpossibleastronaut/aawordsearch), generate wordsearch puzzles using random words in different languages
+ - Adwaita Manager(https://github.com/AdwCustomizerTeam/AdwCustomizer), change the look of Adwaita, with ease
  - Aravis(https://github.com/AravisProject/aravis), a glib/gobject based library for video acquisition using Genicam cameras
  - Akira(https://github.com/akiraux/Akira), a native Linux app for UI and UX design built in Vala and Gtk
  - AQEMU(https://github.com/tobimensch/aqemu), a Qt GUI for QEMU virtual machines, since version 0.9.3
  - Arduino sample project(https://github.com/jpakkane/mesonarduino)
+ - Audacious(https://github.com/audacious-media-player), a lightweight and versatile audio player
  - bolt(https://gitlab.freedesktop.org/bolt/bolt), userspace daemon to enable security levels for Thunderbolt™ 3 on Linux
+ - Bubblewrap(https://github.com/containers/bubblewrap), unprivileged sandboxing tool
  - Budgie Desktop(https://github.com/budgie-desktop/budgie-desktop), a desktop environment built on GNOME technologies
  - Bzip2(https://gitlab.com/federicomenaquintero/bzip2), the bzip2 compressor/decompressor
  - Cage(https://github.com/Hjdskes/cage), a Wayland kiosk
  - canfigger(https://github.com/andy5995/canfigger), simple configuration file parser library
  - casync(https://github.com/systemd/casync), Content-Addressable Data Synchronization Tool
+ - cglm(https://github.com/recp/cglm), a highly optimized graphics math library for C
  - cinnamon-desktop(https://github.com/linuxmint/cinnamon-desktop), the cinnamon desktop library
  - Cozy(https://github.com/geigi/cozy), a modern audio book player for Linux and macOS using GTK+ 3
  - dav1d(https://code.videolan.org/videolan/dav1d), an AV1 decoder
@@ -63,6 +68,7 @@
  - HelenOS(http://helenos.org), a portable microkernel-based multiserver operating system
  - HexChat(https://github.com/hexchat/hexchat), a cross-platform IRC client in C
  - IGT(https://gitlab.freedesktop.org/drm/igt-gpu-tools), Linux kernel graphics driver test suite
+ - i3(https://i3wm.org), improved tiling window manager
  - inih(https://github.com/benhoyt/inih) (INI Not Invented Here), a small and simple .INI file parser written in C
  - Irssi(https://github.com/irssi/irssi), a terminal chat client in C
  - iSH(https://github.com/tbodt/ish), Linux shell for iOS
@@ -89,21 +95,27 @@
  - libratbag(https://github.com/libratbag/libratbag), provides a DBus daemon to configure input devices, mainly gaming mice.
  - libspng(https://github.com/randy408/libspng), a C library for reading and writing Portable Network Graphics (PNG)
 format files
+ - libSRTP(https://github.com/cisco/libsrtp) (from Cisco Systems), a library for SRTP (Secure Realtime Transport Protocol)
  - libui(https://github.com/andlabs/libui), a simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports
  - Libva(https://github.com/intel/libva), an implementation for the VA (VIdeo Acceleration) API
+ - libvips(https://github.com/libvips/libvips), a fast image processing library with low memory needs
  - Libvirt(https://libvirt.org), a toolkit to manage virtualization platforms
  - Libzim(https://github.com/openzim/libzim), the reference implementation for the ZIM file format
+ - LXC(https://github.com/lxc/lxc), Linux container runtime
  - Marker(https://github.com/fabiocolacio/Marker), a GTK-3 markdown editor
- - Mesa(https://gitlab.freedesktop.org/mesa/mesa/), an open source graphics driver project
+ - Mesa(https://mesa3d.org/), an open source graphics driver project
+ - Miniz(https://github.com/richgel999/miniz), a zlib replacement library
  - MiracleCast(https://github.com/albfan/miraclecast), connect external monitors to your system via Wifi-Display specification aka Miracast
  - mpv(https://github.com/mpv-player/mpv), a free, open source, and cross-platform media player
  - mrsh(https://github.com/emersion/mrsh), a minimal POSIX shell
  - Nautilus(https://gitlab.gnome.org/GNOME/nautilus), the GNOME file manager
  - Nemo(https://github.com/linuxmint/nemo), the file manager for the Cinnamon desktop environment
+ - nvme-cli(https://github.com/linux-nvme/nvme-cli), NVMe management command line interface
  - OcherBook(https://github.com/ccoffing/OcherBook), an open source book reader for Kobo devices
  - oomd(https://github.com/facebookincubator/oomd), a userspace Out-Of-Memory (OOM) killer for Linux systems
  - OpenH264(https://github.com/cisco/openh264), open source H.264 codec
  - OpenHMD(https://github.com/OpenHMD/OpenHMD), a free and open source API and drivers for immersive technology, such as head mounted displays with built in head tracking
+ - OpenRC(https://github.com/OpenRC/openrc), an init system for Unix-like operating systems
  - OpenTitan(https://github.com/lowRISC/opentitan), an open source silicon Root of Trust (RoT) project.
  - Orc(https://gitlab.freedesktop.org/gstreamer/orc), the Optimized Inner Loop Runtime Compiler
  - OTS(https://github.com/khaledhosny/ots), the OpenType Sanitizer, parses and serializes OpenType files (OTF, TTF) and WOFF and WOFF2 font files, validating and sanitizing them as it goes. Used by Chromium and Firefox
@@ -116,19 +128,24 @@
  - PicoLibc(https://github.com/keith-packard/picolibc), a standard C library for small embedded systems with limited RAM
  - PipeWire(https://github.com/PipeWire/pipewire), a framework for video and audio for containerized applications
  - Paper Rock Scissors(https://github.com/michaelbrockus/paper_rock_scissors), a game with weapons themed at home paper rock scissors style.
+ - Pistache(https://github.com/pistacheio/pistache), a high performance REST toolkit written in C++
  - Pithos(https://github.com/pithos/pithos), a Pandora Radio client
  - Pitivi(https://github.com/pitivi/pitivi/), a nonlinear video editor
+ - Planner(https://github.com/alainm23/planner), task manager with Todoist support designed for GNU/Linux
  - Playerctl(https://github.com/acrisci/playerctl), mpris command-line controller and library for spotify, vlc, audacious, bmp, cmus, and others
  - Polari(https://gitlab.gnome.org/GNOME/polari), an IRC client
+ - PostgreSQL(https://www.postgresql.org/), an advanced open source relational database
  - qboot(https://github.com/bonzini/qboot), a minimal x86 firmware for booting Linux kernels
  - radare2(https://github.com/radare/radare2), unix-like reverse engineering framework and commandline tools (not the default)
  - rmw(https://remove-to-waste.info), safe-remove utility for the command line
  - Rizin(https://rizin.re), Free and Open Source Reverse Engineering Framework
  - QEMU(https://qemu.org), a processor emulator and virtualizer
  - RxDock(https://gitlab.com/rxdock/rxdock), a protein-ligand docking software designed for high throughput virtual screening (fork of rDock)
+ - SciPy(https://scipy.org/), an open-source software for mathematics, science, and engineering
  - scrcpy(https://github.com/Genymobile/scrcpy), a cross platform application that provides display and control of Android devices connected on USB or over TCP/IP
  - Sequeler(https://github.com/Alecaddd/sequeler), a friendly SQL client for Linux, built with Vala and Gtk
  - Siril(https://gitlab.com/free-astro/siril), an image processing software for amateur astronomy
+ - Spot(https://github.com/xou816/spot), Rust based Spotify client for the GNOME desktop
  - SSHFS(https://github.com/libfuse/sshfs), allows you to mount a remote filesystem using SFTP
  - sway(https://github.com/swaywm/sway), i3-compatible Wayland compositor
  - Sysprof(https://git.gnome.org/browse/sysprof), a profiling tool
@@ -142,16 +159,16 @@
  - Vala Language Server(https://github.com/benwaffle/vala-language-server), code intelligence engine for the Vala and Genie programming languages
  - Valum(https://github.com/valum-framework/valum), a micro web framework written in Vala
  - Venom(https://github.com/naxuroqa/Venom), a modern Tox client for the GNU/Linux desktop
+ - vkQuake(https://github.com/Novum/vkQuake), a port of id Software's Quake using Vulkan instead of OpenGL for rendering
  - VMAF(https://github.com/Netflix/vmaf) (by Netflix), a perceptual video quality assessment based on multi-method fusion
  - Wayland(https://github.com/wayland-project/wayland) and Weston(https://github.com/wayland-project/weston), a next generation display server
  - wlroots(https://github.com/swaywm/wlroots), a modular Wayland compositor library
- - wxFormBuilder(https://github.com/wxFormBuilder/wxFormBuilder), RAD tool for wxWidgets GUI design
  - xi-gtk(https://github.com/eyelash/xi-gtk), a GTK+ front-end for the Xi editor
  - Xorg(https://gitlab.freedesktop.org/xorg/xserver), the X.org display server (not the default yet)
  - X Test Suite(https://gitlab.freedesktop.org/xorg/test/xts), The X.org test suite
  - zathura(https://github.com/pwmt/zathura), a highly customizable and functional document viewer based on the
 girara user interface library and several document libraries
- - Zrythm(https://git.zrythm.org/cgit/zrythm), a cross-platform digital audio workstation using GTK+ 3
+ - Zrythm(https://git.sr.ht/~alextee/zrythm), a cross-platform digital audio workstation written in C using GTK4
  - ZStandard(https://github.com/facebook/zstd/commit/4dca56ed832c6a88108a2484a8f8ff63d8d76d91), a compression algorithm developed at Facebook (not used by default)
 
 Note that a more up-to-date list of GNOME projects that use Meson can

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Using-multiple-build-directories.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Using-multiple-build-directories.md Changed

@@ -6,12 +6,14 @@
 tradition where you build your projects in-source. Building out of
 source gives two major advantages.
 
-First of all this makes for very simple `.gitignore` files. In
+First of all this makes for very simple VCS "ignore" files. In
 classical build systems you may need to have tens of lines of
 definitions, most of which contain wildcards. When doing out of source
 builds all of this busywork goes away. A common ignore file for a
 Meson project only contains a few lines that are the build directory
-and IDE project files.
+and IDE project files. (Note that since Meson 0.57.0, build directories
+are automatically ignored for git and mercurial by generating an ignore
+file inside the build directory.)
 
 Secondly this makes it very easy to clean your projects: just delete
 the build subdirectory and you are done. There is no need to guess
@@ -39,7 +41,7 @@
 Meson, so setting it up is simple.
 
     mkdir builddir
-    meson builddir
+    meson setup builddir
 
 Another common setup is to build with debug and optimizations to, for
 example, run performance tests. Setting this up is just as simple.
@@ -51,7 +53,7 @@
 compile with Clang, too. So let's do that.
 
     mkdir buildclang
-    CC=clang CXX=clang++ meson buildclang
+    CC=clang CXX=clang++ meson setup buildclang
 
 You can add cross builds, too. As an example, let's set up a Linux ->
 Windows cross compilation build using MinGW.
@@ -84,7 +86,7 @@
 
     rm -rf buildscan
     mkdir buildscan
-    scan-build meson buildscan
+    scan-build meson setup buildscan
     cd buildscan
     scan-build ninja

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Using-wraptool.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Using-wraptool.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Vs-External.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Vs-External.md Changed

_service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Wayland-module.md Added

@@ -0,0 +1,76 @@
+# Unstable Wayland Module
+
+This module is available since version 0.62.0.
+
+This module provides helper functions to find wayland protocol
+xmls and to generate .c and .h files using wayland-scanner
+
+**Note**: this module is unstable. It is only provided as a technology
+preview. Its API may change in arbitrary ways between releases or it
+might be removed from Meson altogether.
+
+## Quick Usage
+
+```meson
+project('hello-wayland', 'c')
+
+wl_dep = dependency('wayland-client')
+wl_mod = import('unstable-wayland')
+
+xml = wl_mod.find_protocol('xdg-shell')
+xdg_shell = wl_mod.scan_xml(xml)
+
+executable('hw', 'main.c', xdg_shell, dependencies : wl_dep)
+```
+
+## Methods
+
+### find_protocol
+```meson
+xml = wl_mod.find_protocol(
+ 'xdg-decoration',
+ state : 'unstable',
+ version : 1,
+)
+```
+This function requires one positional argument: the protocol base name.
+
+It takes the following keyword arguments:
+- `state` Optional arg that specifies the current state of the protocol.
+ Either `'stable'`, `'staging'`, or `'unstable'`. The default is `'stable'`.
+- `version` The backwards incompatible version number as integer.
+ Required for staging and unstable, but not allowed for stable.
+
+**Returns**: a @file that can be passed to scan_xml(#scan_xml)
+
+### scan_xml
+```meson
+generated = wl_mod.scan_xml(
+ 'my-protocol.xml',
+ client : true,
+ server : true,
+ public : false,
+ include_core_only : true,
+)
+```
+This function accepts one or more arguments of either string or file type.
+
+It takes the following keyword arguments:
+- `public` Optional arg that specifies the scope of the generated code.
+ The default is false.
+- `client` Optional arg that specifies if client side header file is
+ generated. The default is true.
+- `server` Optional arg that specifies if server side header file is
+ generated. The default is false.
+- `include_core_only` Optional arg that specifies that generated headers only include
+ `wayland-<client|server>-core.h` instead of `wayland-<client|server>.h`. 
+ The default is true. Since *0.64.0*
+
+**Returns**: a list of @custom_tgt in the order source, client side header,
+server side header. Generated header files have the name
+`<name>-<client|server>-protocol.h`.
+
+## Links
+- Official Wayland Documentation(https://wayland.freedesktop.org/docs/html/)
+- Wayland GitLab(https://gitlab.freedesktop.org/wayland)
+- Wayland Book(https://wayland-book.com/)

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Windows-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Windows-module.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Wrap-dependency-system-manual.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Wrap-dependency-system-manual.md Changed

@@ -67,6 +67,7 @@
 wrap-git
 url = https://github.com/libfoobar/libfoobar.git
 revision = head
+depth = 1
 ```
 
 ## Accepted configuration properties for wraps
@@ -84,6 +85,8 @@
 - `patch_directory` - *Since 0.55.0* Overlay directory, alternative to `patch_filename` in the case
   files are local instead of a downloaded archive. The directory must be placed in
   `subprojects/packagefiles`.
+- `diff_files` - *Since 0.63.0* Comma-separated list of local diff files (see
+  Diff files(#diff-files) below).
 
 ### Specific to wrap-file
 - `source_url` - download url to retrieve the wrap-file source archive
@@ -113,7 +116,8 @@
   (for git) `head` to track upstream's default branch. Required.
 
 ### Specific to wrap-git
-- `depth` - shallowly clone the repository to X number of commits. Note
+- `depth` - shallowly clone the repository to X number of commits. This saves bandwidth and disk
+  space, and should typically always be specified unless commit history is needed. Note
   that git always allow shallowly cloning branches, but in order to
   clone commit ids shallowly, the server must support
   `uploadpack.allowReachableSHA1InWant=true`.  *(since 0.52.0)*
@@ -147,6 +151,37 @@
 Meson build definitions. Since *0.55.0* Meson build patches are
 supported for any wrap modes, including wrap-git.
 
+## Diff files
+
+*Since: 0.63.0*
+
+You can also provide local patch files in `diff` format. For historic reasons,
+they are referred to as "diff files", since the "patch" name is already used for
+overlay archives.
+
+The diff files are described by the `diff_files` property (a comma-separated
+list), and must be available locally in the `subprojects/packagefiles`
+directory.
+
+Meson will apply the diff files after extracting or cloning the project, and
+after applying the overlay archive (`patch_*`). For this feature, the `patch` or
+`git` command-line tool must be available.
+
+The diff files will be applied with `-p1`, i.e. treating the first path
+component as a prefix to be stripped. This is the default for diffs produced by
+Git.
+
+```ini
+wrap-file
+directory = libfoobar-1.0
+
+source_url = https://example.com/foobar-1.0.tar.gz
+source_filename = foobar-1.0.tar.gz
+source_hash = 5ebeea0dfb75d090ea0e7ff84799b2a7a1550db3fe61eb5f6f61c2e971e57663
+
+diff_files = libfoobar-1.0/0001.patch, libfoobar-1.0/0002.patch
+```
+
 ## `provide` section
 
 *Since *0.55.0*
@@ -216,6 +251,7 @@
 wrap-git
 url=https://gitlab.gnome.org/GNOME/glib.git
 revision=glib-2-62
+depth=1
 
 provide
 dependency_names = glib-2.0, gobject-2.0, gio-2.0
@@ -228,6 +264,7 @@
 wrap-git
 url=https://gitlab.gnome.org/GNOME/glib.git
 revision=glib-2-62
+depth=1
 
 provide
 glib-2.0=glib_dep

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/Yaml-RefMan.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/Yaml-RefMan.md Changed

@@ -13,7 +13,15 @@
 Markdown generator for mesonbuild.com).
 
 The generator that reads these YAML files is located in `docs/refman`, with the
-main executable being `docs/genrefman.py`.
+main executable being `docs/genrefman.py`.  By default `genrefman.py` will load
+the yaml manual using a strict subset of yaml at the cost of loading slowly.
+You may optionally disable all these safety checks using the `fastyaml` loader,
+which will significantly speed things up at the cost of being less correct.
+
+The following python packages are required for the `genrefman` script:
+
+- chevron
+- strictyaml
 
 ## Linking to the Reference Manual
 
@@ -40,7 +48,7 @@
 Now the same in a code block:
 
 ```meson
-#@str executable('main', 
+#@str #executable('main', 
     'file_@0@.cpp'.format(#meson.version)
 )
 ```
@@ -107,7 +115,7 @@
 - Warnings are also optional.
 
 
-# To avoid duplicating documentation / code, argument inheritence is supported with
+# To avoid duplicating documentation / code, argument inheritance is supported with
 # the following optional keys:
 
 posargs_inherit: _build_target_base  # Use the posargs definition of `_build_target_base` here
@@ -115,6 +123,9 @@
 varargs_inherit: _build_target_base  # Use the varargs definition of `_build_target_base` here
 kwargs_inherit: _build_target_base   # Add all kwargs of `_build_target_base` to this function
 
+# Whether argument flattening (see Syntax.md) is enabled
+# for this function. Defaults to `true`.
+args_flattening: true
 
 posargs:
   arg_name:

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/_Sidebar.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/_Sidebar.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/_include_qt_base.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/_include_qt_base.md Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/howtox.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/howtox.md Changed

@@ -12,12 +12,12 @@
 $ CC=mycc meson <options>
 ```
 
-Note that environment variables like `CC` only works in native builds.
-The `CC` refers to the compiler for the host platform, that is the
-compiler used to compile programs that run on the machine we will
-eventually install the project on. The compiler used to build things
-that run on the machine we do the building can be specified with
-`CC_FOR_BUILD`. You can use it in cross builds.
+Note that environment variables like `CC` only refer to the host
+platform in cross builds. That is, `CC` refers to the compiler used to
+compile programs that run on the machine we will eventually install the
+project on. The compiler used to build things that run on the machine we
+do the building can be specified with `CC_FOR_BUILD`. You can use it in
+cross builds.
 
 Note that environment variables are never the idiomatic way to do
 anything with Meson, however. It is better to use the native and cross
@@ -141,7 +141,7 @@
 
 ## Generate configuration data from files
 
-`The fs module(#Fs-modules) offers the `read` function` which enables adding
+The fs module(#Fs-modules) offers the `read` function which enables adding
 the contents of arbitrary files to configuration data (among other uses):
 
 ```meson

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/i18n-module.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/i18n-module.md Changed

@@ -46,9 +46,12 @@
 ### i18n.merge_file()
 
 This merges translations into a text file using `msgfmt`. See
-@custom_tgt
+custom_target
 for normal keywords. In addition it accepts these keywords:
 
+* `output`: same as `custom_target` but only accepts one item
+* `install_dir`: same as `custom_target` but only accepts one item
+* `install_tag`: same as `custom_target` but only accepts one item
 * `data_dirs`: (*Added 0.41.0*) list of directories for its files (See
   also `i18n.gettext()`)
 * `po_dir`: directory containing translations, relative to current directory
@@ -56,3 +59,18 @@
 * `args`: (*Added 0.51.0*) list of extra arguments to pass to `msgfmt`
 
 *Added 0.37.0*
+
+### i18n.itstool_join()
+
+This joins translations into a XML file using `itstool`. See
+custom_target
+for normal keywords. In addition it accepts these keywords:
+
+* `output`: same as `custom_target` but only accepts one item
+* `install_dir`: same as `custom_target` but only accepts one item
+* `install_tag`: same as `custom_target` but only accepts one item
+* `its_files`: filenames of ITS files that should be used explicitly
+  (XML translation rules are autodetected otherwise).
+* `mo_targets` *required*: mo file generation targets as returned by `i18n.gettext()`.
+
+*Added 0.62.0*

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/images/gtksample.png -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/images/gtksample.png Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/markdown/index.md -> _service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/index.md Changed

_service:tar_scm:meson-1.0.1.tar.gz/docs/markdown/snippets/clang_cl_c++20.md Added

_service:tar_scm:meson-0.61.5.tar.gz/docs/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/docs/meson.build Changed

@@ -15,10 +15,12 @@
     build_by_default: true,
     install: false)
 
+sitemap = files('sitemap.txt')
+
 genrefman = find_program('./genrefman.py')
 refman_binary = custom_target(
     'gen_refman_bin',
-    input: files('sitemap.txt'),
+    input: sitemap,
     output: 'reference_manual.bin',
     depfile: 'reman_dep.d',
     command: 
@@ -39,7 +41,7 @@
         genrefman,
         '-l', 'pickle',
         '-g', 'md',
-        '-s', files('sitemap.txt'),
+        '-s', sitemap,
         '-i', '@INPUT@',
         '-o', '@OUTPUT0@',
         '--link-defs', '@OUTPUT1@',
@@ -47,6 +49,7 @@
         '--no-modules',
     ,
 )
+sitemap = refman_md0
 
 refman_json = custom_target(
     'gen_refman_json',
@@ -79,6 +82,18 @@
     ,
 )
 
+genrelnotes = custom_target(
+    output: 'sitemap-genrelnotes.txt',
+    build_always_stale: true,
+    command: find_program('genrelnotes.py'),
+        '--input-sitemap', sitemap,
+        '--output-sitemap', '@OUTPUT0@',
+        '--output-dir', meson.current_build_dir(),
+        '--source-dir', meson.current_source_dir(),
+    
+)
+sitemap = genrelnotes0
+
 test('validate_docs', find_program('./jsonvalidator.py'), args: refman_json)
 
 hotdoc_prog = find_program('hotdoc', version: '>=0.13.7')
@@ -86,7 +101,7 @@
 hotdoc = import('hotdoc')
 documentation = hotdoc.generate_doc(meson.project_name(),
     project_version: meson.project_version(),
-    sitemap: refman_md0,
+    sitemap: sitemap,
     build_by_default: true,
     depends: docs_gen,
     index: 'markdown/index.md',
@@ -109,4 +124,5 @@
       '--git-upload',
       '-vv',
     ,
+    depends: documentation,
 )

_service:tar_scm:meson-0.61.5.tar.gz/docs/refman/generatorjson.py -> _service:tar_scm:meson-1.0.1.tar.gz/docs/refman/generatorjson.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/refman/generatormd.py -> _service:tar_scm:meson-1.0.1.tar.gz/docs/refman/generatormd.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/refman/jsonschema.py -> _service:tar_scm:meson-1.0.1.tar.gz/docs/refman/jsonschema.py Changed

@@ -8,7 +8,7 @@
 # the Meson version
 
 VERSION_MAJOR = 1  # Changes here indicate breaking format changes (changes to existing keys)
-VERSION_MINOR = 0  # Changes here indicate non-breaking changes (only new keys are added to the existing structure)
+VERSION_MINOR = 1  # Changes here indicate non-breaking changes (only new keys are added to the existing structure)
 
 class BaseObject(T.TypedDict):
     '''
@@ -26,14 +26,14 @@
 
 class Type(T.TypedDict):
     obj:   str                 # References an object from `root.objects`
-    holds: T.Sequenceobject  # Mypy does not support recusive dicts, but this should be T.ListType...
+    holds: T.Sequenceobject  # Mypy does not support recursive dicts, but this should be T.ListType...
 
 class Argument(BaseObject):
     '''
-        Object that represents any type of a single function or method argumet.
+        Object that represents any type of a single function or method argument.
     '''
     type:        T.ListType  # A non-empty list of types that are supported.
-    type_str:    str           # Formated version of `type`. Is guranteed to not contain any whitespaces.
+    type_str:    str           # Formatted version of `type`. Is guaranteed to not contain any whitespaces.
     required:    bool
     default:     T.Optionalstr
     min_varargs: T.Optionalint  # Only relevant for varargs, must be `null` for all other types of arguments
@@ -43,13 +43,14 @@
     '''
         Represents a function or method.
     '''
-    returns:     T.ListType  # A non-empty list of types that are supported.
-    returns_str: str           # Formated version of `returns`. Is guranteed to not contain any whitespaces.
-    example:     T.Optionalstr
-    posargs:     T.Dictstr, Argument
-    optargs:     T.Dictstr, Argument
-    kwargs:      T.Dictstr, Argument
-    varargs:     T.OptionalArgument
+    returns:        T.ListType  # A non-empty list of types that are supported.
+    returns_str:    str           # Formatted version of `returns`. Is guaranteed to not contain any whitespaces.
+    example:        T.Optionalstr
+    posargs:        T.Dictstr, Argument
+    optargs:        T.Dictstr, Argument
+    kwargs:         T.Dictstr, Argument
+    varargs:        T.OptionalArgument
+    arg_flattening: bool
 
 class Object(BaseObject):
     '''

_service:tar_scm:meson-0.61.5.tar.gz/docs/refman/loaderbase.py -> _service:tar_scm:meson-1.0.1.tar.gz/docs/refman/loaderbase.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/refman/loaderyaml.py -> _service:tar_scm:meson-1.0.1.tar.gz/docs/refman/loaderyaml.py Changed

@@ -28,71 +28,132 @@
 from mesonbuild import mlog
 from mesonbuild import mesonlib
 
-from strictyaml import Map, MapPattern, Optional, Str, Seq, Int, Bool, load, EmptyList, OrValidator
 from pathlib import Path
 import typing as T
 
-d_named_object = {
-    'name': Str(),
-    'description': Str(),
-}
-
-d_feture_check = {
-    Optional('since', default=''): Str(),
-    Optional('deprecated', default=''): Str(),
-}
-
-s_posarg = Map({
-    **d_feture_check,
-    'description': Str(),
-    'type': Str(),
-    Optional('default', default=''): Str(),
-})
-
-s_varargs = Map({
-    **d_named_object, **d_feture_check,
-    'type': Str(),
-    Optional('min_varargs', default=-1): Int(),
-    Optional('max_varargs', default=-1): Int(),
-})
-
-s_kwarg = Map({
-    **d_feture_check,
-    'type': Str(),
-    'description': Str(),
-    Optional('required', default=False): Bool(),
-    Optional('default', default=''): Str(),
-})
-
-s_function = Map({
-    **d_named_object, **d_feture_check,
-    'returns': Str(),
-    Optional('notes', default=): OrValidator(Seq(Str()), EmptyList()),
-    Optional('warnings', default=): OrValidator(Seq(Str()), EmptyList()),
-    Optional('example', default=''): Str(),
-    Optional('posargs'): MapPattern(Str(), s_posarg),
-    Optional('optargs'): MapPattern(Str(), s_posarg),
-    Optional('varargs'): s_varargs,
-    Optional('posargs_inherit', default=''): Str(),
-    Optional('optargs_inherit', default=''): Str(),
-    Optional('varargs_inherit', default=''): Str(),
-    Optional('kwargs'): MapPattern(Str(), s_kwarg),
-    Optional('kwargs_inherit', default=): OrValidator(OrValidator(Seq(Str()), EmptyList()), Str()),
-})
-
-s_object = Map({
-    **d_named_object, **d_feture_check,
-    'long_name': Str(),
-    Optional('extends', default=''): Str(),
-    Optional('notes', default=): OrValidator(Seq(Str()), EmptyList()),
-    Optional('warnings', default=): OrValidator(Seq(Str()), EmptyList()),
-    Optional('example', default=''): Str(),
-    Optional('methods'): Seq(s_function),
-    Optional('is_container', default=False): Bool()
-})
+class Template:
+    d_feature_check: T.Dictstr, T.Any = {}
+    s_posarg: T.Dictstr, T.Any = {}
+    s_varargs: T.Dictstr, T.Any = {}
+    s_kwarg: T.Dictstr, T.Any = {}
+    s_function: T.Dictstr, T.Any = {}
+    s_object: T.Dictstr, T.Any = {}
+
+class StrictTemplate(Template):
+    def __init__(self) -> None:
+        from strictyaml import Map, MapPattern, Optional, Str, Seq, Int, Bool, EmptyList, OrValidator
+
+        d_named_object = {
+            'name': Str(),
+            'description': Str(),
+        }
+
+        d_feture_check = {
+            Optional('since', default=''): Str(),
+            Optional('deprecated', default=''): Str(),
+        }
+
+        self.s_posarg = Map({
+            **d_feture_check,
+            'description': Str(),
+            'type': Str(),
+            Optional('default', default=''): Str(),
+        })
+
+        self.s_varargs = Map({
+            **d_named_object, **d_feture_check,
+            'type': Str(),
+            Optional('min_varargs', default=-1): Int(),
+            Optional('max_varargs', default=-1): Int(),
+        })
+
+        self.s_kwarg = Map({
+            **d_feture_check,
+            'type': Str(),
+            'description': Str(),
+            Optional('required', default=False): Bool(),
+            Optional('default', default=''): Str(),
+        })
+
+        self.s_function = Map({
+            **d_named_object, **d_feture_check,
+            'returns': Str(),
+            Optional('notes', default=): OrValidator(Seq(Str()), EmptyList()),
+            Optional('warnings', default=): OrValidator(Seq(Str()), EmptyList()),
+            Optional('example', default=''): Str(),
+            Optional('posargs'): MapPattern(Str(), self.s_posarg),
+            Optional('optargs'): MapPattern(Str(), self.s_posarg),
+            Optional('varargs'): self.s_varargs,
+            Optional('posargs_inherit', default=''): Str(),
+            Optional('optargs_inherit', default=''): Str(),
+            Optional('varargs_inherit', default=''): Str(),
+            Optional('kwargs'): MapPattern(Str(), self.s_kwarg),
+            Optional('kwargs_inherit', default=): OrValidator(OrValidator(Seq(Str()), EmptyList()), Str()),
+            Optional('arg_flattening', default=True): Bool(),
+        })
+
+        self.s_object = Map({
+            **d_named_object, **d_feture_check,
+            'long_name': Str(),
+            Optional('extends', default=''): Str(),
+            Optional('notes', default=): OrValidator(Seq(Str()), EmptyList()),
+            Optional('warnings', default=): OrValidator(Seq(Str()), EmptyList()),
+            Optional('example', default=''): Str(),
+            Optional('methods'): Seq(self.s_function),
+            Optional('is_container', default=False): Bool()
+        })
+
+class FastTemplate(Template):
+    d_feature_check: T.Dictstr, T.Any = {
+        'since': '',
+        'deprecated': '',
+    }
+
+    s_posarg = {
+        **d_feature_check,
+        'default': '',
+    }
+
+    s_varargs: T.Dictstr, T.Any = {
+        **d_feature_check,
+        'min_varargs': -1,
+        'max_varargs': -1,
+    }
+
+    s_kwarg = {
+        **d_feature_check,
+        'required': False,
+        'default': '',
+    }
+
+    s_function = {
+        **d_feature_check,
+        'notes': ,
+        'warnings': ,
+        'example': '',
+        'posargs': {},
+        'optargs': {},
+        'varargs': None,
+        'posargs_inherit': '',
+        'optargs_inherit': '',
+        'varargs_inherit': '',
+        'kwargs': {},
+        'kwargs_inherit': ,
+        'arg_flattening': True,
+    }
+
+    s_object = {
+        **d_feature_check,
+        'extends': '',
+        'notes': ,
+        'warnings': ,
+        'example': '',
+        'methods': ,
+        'is_container': False,
+    }
 
 class LoaderYAML(LoaderBase):
-    def __init__(self, yaml_dir: Path) -> None:
+    def __init__(self, yaml_dir: Path, strict: bool=True) -> None:
         super().__init__()
         self.yaml_dir = yaml_dir
         self.func_dir = self.yaml_dir / 'functions'
@@ -100,8 +161,37 @@
         self.objs_dir = self.yaml_dir / 'objects'
         self.builtin_dir = self.yaml_dir / 'builtins'
         self.modules_dir = self.yaml_dir / 'modules'
+        self.strict = strict
+
+        template: Template
+        if self.strict:
+            import strictyaml
+            def loader(file: str, template: T.Any, label: str) -> T.Dict:
+                r: T.Dict = strictyaml.load(file, template, label=label).data
+                return r
+
+            self._load = loader
+            template = StrictTemplate()
+        else:
+            import yaml
+            from yaml import CLoader
+            def loader(file: str, template: T.Any, label: str) -> T.Dict:
+                return {**template, **yaml.load(file, Loader=CLoader)}
+
+            self._load = loader
+            template = FastTemplate()
 
-    def _process_function_base(self, raw: T.OrderedDict, obj: T.OptionalObject = None) -> Function:
+        self.template = template
+
+    def _fix_default(self, v: T.Dict) -> None:
+        if v"default" is False:
+            v"default" = "false"
+        elif v"default" is True:
+            v"default" = "true"
+        else:
+            v"default" = str(v"default")
+
+    def _process_function_base(self, raw: T.Dict, obj: T.OptionalObject = None) -> Function:
         # Handle arguments
         posargs = raw.pop('posargs', {})
         optargs = raw.pop('optargs', {})
@@ -119,18 +209,29 @@
         kwargs_mapped: T.Dictstr, Kwarg = {}
 
         for k, v in posargs.items():
+            if not self.strict:
+                v = {**self.template.s_posarg, **v}
+                self._fix_default(v)
             v'type' = Type(v'type')
             posargs_mapped += PosArg(name=k, **v)
 
         for k, v in optargs.items():
+            if not self.strict:
+                v = {**self.template.s_posarg, **v}
+                self._fix_default(v)
             v'type' = Type(v'type')
             optargs_mapped += PosArg(name=k, **v)
 
         for k, v in kwargs.items():
+            if not self.strict:
+                v = {**self.template.s_kwarg, **v}
+                self._fix_default(v)
             v'type' = Type(v'type')
             kwargs_mappedk = Kwarg(name=k, **v)
 
         if varargs is not None:
+            if not self.strict:
+                varargs = {**self.template.s_varargs, **varargs}
             varargs'type' = Type(varargs'type')
             varargs_mapped = VarArgs(**varargs)
 
@@ -157,13 +258,13 @@
     def _load_function(self, path: Path, obj: T.OptionalObject = None) -> Function:
         path_label = path.relative_to(self.yaml_dir).as_posix()
         mlog.log('Loading', mlog.bold(path_label))
-        raw = load(self.read_file(path), s_function, label=path_label).data
+        raw = self._load(self.read_file(path), self.template.s_function, label=path_label)
         return self._process_function_base(raw)
 
     def _load_object(self, obj_type: ObjectType, path: Path) -> Object:
         path_label = path.relative_to(self.yaml_dir).as_posix()
         mlog.log(f'Loading', mlog.bold(path_label))
-        raw = load(self.read_file(path), s_object, label=path_label).data
+        raw = self._load(self.read_file(path), self.template.s_object, label=path_label)
 
         def as_methods(mlist: T.ListFunction) -> T.ListMethod:
             res: T.ListMethod = 
@@ -174,7 +275,13 @@
 
         methods = raw.pop('methods', )
         obj = Object(methods=, obj_type=obj_type, **raw)
-        obj.methods = as_methods(self._process_function_base(x, obj) for x in methods)
+
+        newmethods = 
+        for x in methods:
+            if not self.strict:
+                x = {**self.template.s_function, **x}
+            newmethods += self._process_function_base(x, obj)
+        obj.methods = as_methods(newmethods)
         return obj
 
     def _load_module(self, path: Path) -> T.ListObject:
@@ -190,9 +297,9 @@
         return module, *objs
 
     def load_impl(self) -> ReferenceManual:
-        mlog.log('Loading YAML refererence manual')
+        mlog.log('Loading YAML reference manual')
         with mlog.nested():
-            return ReferenceManual(
+            manual = ReferenceManual(
                 functions=self._load_function(x) for x in self.func_dir.iterdir(),
                 objects=mesonlib.listify(
                     self._load_object(ObjectType.ELEMENTARY, x) for x in self.elem_dir.iterdir(),
@@ -201,3 +308,8 @@
                     self._load_module(x) for x in self.modules_dir.iterdir()
                 , flatten=True)
             )
+
+            if not self.strict:
+                mlog.warning('YAML reference manual loaded using the best-effort fastyaml loader.  Results are not guaranteed to be stable or correct.')
+
+            return manual

_service:tar_scm:meson-0.61.5.tar.gz/docs/refman/main.py -> _service:tar_scm:meson-1.0.1.tar.gz/docs/refman/main.py Changed

@@ -33,22 +33,27 @@
 
 def main() -> int:
     parser = argparse.ArgumentParser(description='Meson reference manual generator')
-    parser.add_argument('-l', '--loader', type=str, default='yaml', choices='yaml', 'pickle', help='Information loader backend')
+    parser.add_argument('-l', '--loader', type=str, default='yaml', choices='yaml', 'fastyaml', 'pickle', help='Information loader backend')
     parser.add_argument('-g', '--generator', type=str, choices='print', 'pickle', 'md', 'json', 'man', required=True, help='Generator backend')
     parser.add_argument('-s', '--sitemap', type=Path, default=meson_root / 'docs' / 'sitemap.txt', help='Path to the input sitemap.txt')
     parser.add_argument('-o', '--out', type=Path, required=True, help='Output directory for generated files')
     parser.add_argument('-i', '--input', type=Path, default=meson_root / 'docs' / 'yaml', help='Input path for the selected loader')
     parser.add_argument('--link-defs', type=Path, help='Output file for the MD generator link definition file')
     parser.add_argument('--depfile', type=Path, default=None, help='Set to generate a depfile')
+    parser.add_argument('-q', '--quiet', action='store_true', help='Suppress verbose output')
     parser.add_argument('--force-color', action='store_true', help='Force enable colors')
     parser.add_argument('--no-modules', action='store_true', help='Disable building modules')
     args = parser.parse_args()
 
+    if args.quiet:
+        mlog.set_quiet()
+
     if args.force_color:
         mlog.colorize_console = lambda: True
 
     loaders: T.Dictstr, T.Callable, LoaderBase = {
         'yaml': lambda: LoaderYAML(args.input),
+        'fastyaml': lambda: LoaderYAML(args.input, strict=False),
         'pickle': lambda: LoaderPickle(args.input),
     }

_service:tar_scm:meson-0.61.5.tar.gz/docs/refman/model.py -> _service:tar_scm:meson-1.0.1.tar.gz/docs/refman/model.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/refman/templates/args.mustache -> _service:tar_scm:meson-1.0.1.tar.gz/docs/refman/templates/args.mustache Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/refman/templates/func.mustache -> _service:tar_scm:meson-1.0.1.tar.gz/docs/refman/templates/func.mustache Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/refman/templates/root.mustache -> _service:tar_scm:meson-1.0.1.tar.gz/docs/refman/templates/root.mustache Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/sitemap.txt -> _service:tar_scm:meson-1.0.1.tar.gz/docs/sitemap.txt Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/theme/extra/templates/navbar_links.html -> _service:tar_scm:meson-1.0.1.tar.gz/docs/theme/extra/templates/navbar_links.html Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/builtins/meson.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/builtins/meson.yaml Changed

@@ -259,6 +259,7 @@
 
       This method is replaced by meson.get_external_property.
 
+    arg_flattening: false
     posargs_inherit: meson.get_external_property
     optargs_inherit: meson.get_external_property
 
@@ -269,6 +270,8 @@
       Returns the given property from a native or cross file.
       The optional fallback_value is returned if the given property is not found.
 
+    arg_flattening: false
+
     posargs:
       propname:
         type: str
@@ -400,6 +403,7 @@
 
   - name: project_license
     returns: liststr
+    since: 0.45.0
     description: Returns the array of licenses specified in project function call.
 
   - name: project_name
@@ -418,7 +422,7 @@
       to the list of environments that will be applied when using `meson devenv`(Commands.md#devenv)
       command line.
 
-      This is useful for developpers who wish to use the project without
+      This is useful for developers who wish to use the project without
       installing it, it is often needed to set for example the path to plugins
       directory, etc. Alternatively, a list or dictionary can be passed as first
       argument.
@@ -444,5 +448,25 @@
 
     posargs:
       env:
-        type: env
-        description: The @env object to add.
+        type: env | str | liststr | dictstr | dictliststr
+        description: |
+          The @env object to add.
+          Since *0.62.0* list of strings is allowed in dictionary values. In that
+          case values are joined using the separator.
+    kwargs:
+      separator:
+        type: str
+        since: 0.62.0
+        description: |
+          The separator to use for the initial values defined in
+          the first positional argument. If not explicitly specified, the default
+          path separator for the host operating system will be used, i.e. ';' for
+          Windows and ':' for UNIX/POSIX systems.
+      method:
+        type: str
+        since: 0.62.0
+        description: |
+          Must be one of 'set', 'prepend', or 'append'
+          (defaults to 'set'). Controls if initial values defined in the first
+          positional argument are prepended, appended or replace the current value
+          of the environment variable.

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/elementary/dict.yml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/elementary/dict.yml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/elementary/list.yml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/elementary/list.yml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/elementary/str.yml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/elementary/str.yml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/_build_target_base.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/_build_target_base.yaml Changed

@@ -39,7 +39,7 @@
 
 kwargs:
 <lang>_pch:
- type: str | file
+ type: str
 description: precompiled header file to use for the given language
 
 <lang>_args:
@@ -49,7 +49,7 @@
 eg: `cpp_args` for C++
 
 sources:
- type: str | file | custom_tgt | custom_idx | generated_list
+ type: str | file | custom_tgt | custom_idx | generated_list | structured_src
 description: Additional source files. Same as the source varargs.
 
 build_by_default:
@@ -63,6 +63,7 @@
 
 build_rpath:
 type: str
+ since: 0.42.0
 description: |
 A string to add to target's rpath definition in the build dir,
 but which will be removed on install
@@ -145,7 +146,7 @@
 type: bool
 since: 0.42.0
 default: true
- description: Controlls whether Meson adds the current source and build directories to the include path
+ description: Controls whether Meson adds the current source and build directories to the include path
 
 include_directories:
 type: listinc | str
@@ -161,10 +162,10 @@
 install_dir:
 type: str
 description: |
- override install directory for this file. The value is
- relative to the `prefix` specified. F.ex, if you want to install
- plugins into a subdir, you'd use something like this: `install_dir :
- get_option('libdir') / 'projectname-1.0'`.
+ override install directory for this file. If the value is a relative path,
+ it will be considered relative the `prefix` option.
+ For example, if you want to install plugins into a subdir, you'd use
+ something like this: `install_dir : get_option('libdir') / 'projectname-1.0'`.
 
 install_mode:
 type: liststr | int
@@ -190,11 +191,11 @@
 (but *not* before that). On Windows, this argument has no effect.
 
 objects:
- type: listextracted_obj
+ type: listextracted_obj | file | str
 description: |
- List of prebuilt object files (usually for third party
- products you don't have source to) that should be linked in this
- target, **never** use this for object files that you build yourself.
+ List of object files that should be linked in this target.
+ These can include third party products you don't have source to,
+ or object files produced by other build targets.
 
 name_prefix:
 type: str | listvoid
@@ -253,12 +254,14 @@
 description: When set to true, the D modules are compiled in debug mode.
 
 d_module_versions:
- type: liststr
+ type: liststr | int
 description: List of module version identifiers set when compiling D sources.
 
 d_debug:
 type: liststr
- description: List of module debug identifiers set when compiling D sources.
+ description: |
+ The D version identifiers(https://dlang.org/spec/version.html#version) to add
+ during the compilation of D source files.
 
 native:
 type: bool
@@ -276,3 +279,23 @@
 version specification such as `windows,6.0`. See MSDN
 documentation(https://docs.microsoft.com/en-us/cpp/build/reference/subsystem-specify-subsystem)
 for the full list.
+
+ rust_crate_type:
+ type: str
+ since: 0.42.0
+ description: |
+ Set the specific type of rust crate to compile (when compiling rust).
+
+ If the target is an executable this defaults to "bin", the only
+ allowed value.
+
+ If it is a static_library it defaults to "lib", and may be "lib",
+ "staticlib", or "rlib". If "lib" then Rustc will pick a default, "staticlib"
+ means a C ABI library, "rlib" means a Rust ABI.
+
+ If it is a shared_library it defaults to "lib", and may be "lib",
+ "dylib", "cdylib", or "proc-macro". If "lib" then Rustc will pick a
+ default, "cdylib" means a C ABI library, "dylib" means a Rust ABI, and
+ "proc-macro" is a special rust proceedural macro crate.
+
+ "proc-macro" is new in 0.62.0.

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/add_global_arguments.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/add_global_arguments.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/add_project_arguments.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/add_project_arguments.yaml Changed

_service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/add_project_dependencies.yaml Added

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/benchmark.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/benchmark.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/configuration_data.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/configuration_data.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/custom_target.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/custom_target.yaml Changed

@@ -6,7 +6,7 @@
   The name of custom target might not be used by every backends, for instance with
   the Ninja backend, `subdir/meson.build` containing the example below,
   `ninja -C builddir foo` or `ninja -C builddir subdir/foo` won't work,
-  it is instead `ninja -C builddir subdir/file.txt`. Howerver, `meson compile subdir/foo`
+  it is instead `ninja -C builddir subdir/file.txt`. However, `meson compile subdir/foo`
   is accepted.
   ```meson
   custom_target('foo', output: 'file.txt', ...)
@@ -135,7 +135,7 @@
       argument. Useful for adding regen dependencies.
 
   depends:
-    type: listtgt
+    type: listbuild_tgt | custom_tgt
     description: |
       Specifies that this target depends on the specified
       target(s), even though it does not take any of them as a command
@@ -161,10 +161,11 @@
 
   install:
     type: bool
-    description: When true, this target is installed during the install step.
+    description: When true, one or more files of this target are installed during
+      the install step (see `install_dir` for details).
 
   install_dir:
-    type: str | liststr
+    type: str | liststr | bool
     description: |
       If only one install_dir is provided, all outputs are installed there.
       *Since 0.40.0* Allows you to specify the installation directory for each
@@ -173,7 +174,7 @@
       custom_target('different-install-dirs',
         output : 'first.file', 'second.file',
         install : true,
-        install_dir : 'somedir', 'otherdir)
+        install_dir : 'somedir', 'otherdir')
       ```
       This would install `first.file` to `somedir` and `second.file` to `otherdir`.
 
@@ -183,7 +184,7 @@
           custom_target('only-install-second',
             output : 'first.file', 'second.file',
             install : true,
-            install_dir : false, 'otherdir)
+            install_dir : false, 'otherdir')
       ```
       This would install `second.file` to `otherdir` and not install `first.file`.

_service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/debug.yaml Added

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/declare_dependency.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/declare_dependency.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/dependency.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/dependency.yaml Changed

@@ -15,6 +15,11 @@
   of those name will return the same value. This is useful in case a dependency
   could have different names, such as `png` and `libpng`.
 
+  * Since *0.64.0* a dependency fallback can be provided by WrapDB. Simply download
+  the database locally using `meson wrap update-db` command and Meson will
+  automatically fallback to subprojects provided by WrapDB if the dependency is
+  not found on the system and the project does not ship their own `.wrap` file.
+
   Dependencies can also be resolved in two other ways:
 
   * if the same name was used in a `meson.override_dependency` prior to
@@ -61,7 +66,7 @@
   since: 0.60.0
   min_varargs: 1
   description: |
-    The names of the dependency too look up. The dependencies are looked up in
+    The names of the dependency to look up. The dependencies are looked up in
     the order they are provided here. The first found dependency will then be
     used. The fallback subproject will be used only if none of the names are
     found on the system. Once one of the name has been found, all other names
@@ -74,7 +79,7 @@
 kwargs:
   default_options:
     type: liststr
-    since: 0.37.0
+    since: 0.38.0
     description: |
       An array of default option values
       that override those set in the subproject's `meson_options.txt`
@@ -126,6 +131,7 @@
 
   method:
     type: str
+    since: 0.40.0
     default: "'auto'"
     description: |
       Defines the way the dependency is detected, the default is
@@ -152,9 +158,13 @@
     type: bool | feature
     default: true
     description: |
-      when set to false, Meson will proceed with the build
-      even if the dependency is not found. *(since 0.47.0)* The value of a
-      `feature`(Build-options.md#features) option can also be passed.
+      When set to `false`, Meson will proceed with the build
+      even if the dependency is not found.
+
+      When set to a `feature`(Build-options.md#features) option, the feature
+      will control if it is searched and whether to fail if not found.
+
+      *(since 0.47.0)* The value of a `feature` option can also be passed.
 
   static:
     type: bool

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/environment.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/environment.yaml Changed

@@ -3,10 +3,33 @@
 since: 0.35.0
 description: Returns an empty @env object.
 
+arg_flattening: false
+
 optargs:
   env:
-    type: dictstr
+    type: str | liststr | dictstr | dictliststr
     since: 0.52.0
     description: |
       If provided, each key/value pair is added into the @env object
       as if env.set method was called for each of them.
+      Since *0.62.0* list of strings is allowed in dictionary values. In that
+      case values are joined using the separator.
+
+kwargs:
+  separator:
+    type: str
+    since: 0.62.0
+    description: |
+      The separator to use for the initial values defined in
+      the first positional argument. If not explicitly specified, the default
+      path separator for the host operating system will be used, i.e. ';' for
+      Windows and ':' for UNIX/POSIX systems.
+
+  method:
+    type: str
+    since: 0.62.0
+    description: |
+      Must be one of 'set', 'prepend', or 'append'
+      (defaults to 'set'). Controls if initial values defined in the first
+      positional argument are prepended, appended or replace the current value
+      of the environment variable.

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/error.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/error.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/executable.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/executable.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/find_program.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/find_program.yaml Changed

@@ -24,7 +24,9 @@
   (because the command invocator will reject the command otherwise) and
   Unixes (if the script file does not have the executable bit set).
   Hence, you *must not* manually add the interpreter while using this
-  script as part of a list of commands.
+  script as part of a list of commands. Since *0.50.0* if the "python3"
+  program is requested and it is not found in the system, Meson will return
+  its current interpreter.
 
   If you need to check for a program in a non-standard location, you can
   just pass an absolute path to `find_program`, e.g.
@@ -44,15 +46,17 @@
 
 posargs:
   program_name:
-    type: str
-    description: The name of the program to search
+    type: str | file
+    description: |
+      The name of the program to search, or a @file object to be used
+      without searching.
 
 varargs:
   name: fallback
-  type: str
+  type: str | file
   since: 0.37.0
   description: |
-    These parameters are used as fallback strings to search for.
+    These parameters are used as fallback names to search for.
     This is meant to be used for cases where the
     program may have many alternative names, such as `foo` and
     `foo.py`. The function will check for the arguments one by one and the

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/get_option.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/get_option.yaml Changed

@@ -5,16 +5,14 @@
   specified in the positional argument.
 
   Note that the value returned for built-in options that end in `dir`
-  such as `bindir` and `libdir` is always a path relative to (and
-  inside) the `prefix`.
-
-  The only exceptions are: `sysconfdir`, `localstatedir`, and
-  `sharedstatedir` which will return the value passed during
-  configuration as-is, which may be absolute, or relative to `prefix`.
-  `install_dir` arguments(Installing.md) handles that as expected, but
-  if you need the absolute path to one of these e.g. to use in a define
-  etc., you should use `get_option('prefix') /
-  get_option('localstatedir')`
+  such as `bindir` and `libdir` is usually a path relative to (and
+  inside) the `prefix` but you should not rely on that, as it can also
+  be an absolute path in some cases(Builtin-options.md#universal-options).
+  `install_dir` arguments(Installing.md) handle that as expected
+  but if you need an absolute path, e.g. to use in a define etc.,
+  you should use the path concatenation operator like this:
+  `get_option('prefix') / get_option('localstatedir')`.
+  Never manually join paths as if they were strings.
 
   For options of type `feature` a
   @feature option object

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/get_variable.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/get_variable.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/import.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/import.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/install_data.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/install_data.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/install_headers.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/install_headers.yaml Changed

@@ -29,6 +29,13 @@
   install_headers('common.h', 'proj/kola.h', install_dir : 'cust', subdir : 'myproj')
   ```
 
+  This will install `common.h` into `/{prefix}/include` and `kola.h`
+  into `/{prefix}/include/proj/`:
+
+  ```meson
+  install_headers('common.h, 'proj/kola.h', preserve_path : true)
+  ```
+
 varargs:
   name: file
   type: file | str
@@ -37,11 +44,14 @@
 kwargs:
   install_dir:
     type: str
-    description: Where to install to
+    description: Where to install to.
 
   subdir:
     type: str
-    description: Use the `subdir` in the `install_dir`
+    description: |
+      Install to the `subdir` subdirectory of the default includedir.
+
+      Incompatible with the `install_dir` kwarg.
 
   install_mode:
     type: liststr | int
@@ -51,3 +61,12 @@
       and optionally the owner/uid and group/gid for the installed files.
 
       See the `install_mode` kwarg of install_data for more information.
+
+  preserve_path:
+    type: bool
+    since: 0.63.0
+    default: false
+    description: |
+      Disable stripping child-direcories from header files when installing.
+
+      This is equivalent to GNU Automake's `nobase` option.

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/is_disabler.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/is_disabler.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/is_variable.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/is_variable.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/jar.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/jar.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/message.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/message.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/project.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/project.yaml Changed

@@ -67,15 +67,23 @@
     type: str | liststr
     description: |
       Takes a string or array of strings describing the license(s) the code is under.
-      To avoid ambiguity it is recommended to use a standardized
-      license identifier from the SPDX license list(https://spdx.org/licenses/).
-      Usually this would be something like `license : 'GPL-2.0-or-later'`, but if
-      the code has multiple licenses you can specify them as an array like this:
-      `license : 'proprietary', 'GPL-3.0-only'`. Note that the text is informal
-      and is only written to the dependency manifest. Meson does not do any license
-      validation, you are responsible for verifying that you abide by all licensing
-      terms. You can access the value in your Meson build files with
-      `meson.project_license()`.
+
+      This *should* be an SPDX license expression(https://spdx.dev/ids/),
+      using the standardized license identifier from the SPDX license
+      list(https://spdx.org/licenses/).  Usually this would be something like
+      `license : 'GPL-2.0-or-later'`. If there are multiple licenses you can use the
+      `AND` and `OR` operators to join them: `license : 'Apache-2.0 OR GPL-2.0'`.
+
+      For backwards compatibility reasons you can also pass an array of
+      licenses here. This is not recommended, as it is ambiguous: `license :
+      'Apache-2.0', 'GPL-2.0-only'` instead use an SPDX espression: `license
+      : 'Apache-2.0 OR GPL-2.0-only'`, which makes it clear that the license
+      mean OR, not AND.
+
+      Note that the text is informal and is only written to the dependency
+      manifest. Meson does not do any license validation, you are responsible
+      for verifying that you abide by all licensing terms. You can access the
+      value in your Meson build files with `meson.project_license()`.
 
   subproject_dir:
     type: str

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/run_target.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/run_target.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/set_variable.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/set_variable.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/shared_library.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/shared_library.yaml Changed

_service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/structured_sources.yaml Added

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/subdir.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/subdir.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/subdir_done.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/subdir_done.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/subproject.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/subproject.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/summary.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/summary.yaml Changed

@@ -10,7 +10,7 @@
   the section keyword argument is omitted, those key/value pairs are
   implicitly grouped into a section with no title. key/value pairs can
   optionally be grouped into a dictionary, but keep in mind that
-  dictionaries does not guarantee ordering. `key` must be string,
+  dictionaries do not guarantee ordering. `key` must be string,
   `value` can be:
 
   - an integer, boolean or string
@@ -61,11 +61,36 @@
                        True
   ```
 
+arg_flattening: false
+
 posargs:
-  key:
-    type: str
-    description: The name of the new entry
+  key_or_dict:
+    type: str | dictstr | bool | int | dep | external_program | liststr | bool | int | dep | external_program
+    description: |
+      The name of the new entry, or a dict containing multiple entries.  If a
+      dict is passed it is equivalent to calling summary() once for each
+      key-value pair.  Keep in mind that dictionaries do not guarantee
+      ordering.
 
+optargs:
   value:
     type: str | bool | int | dep | external_program | liststr | bool | int | dep | external_program
-    description: The value to print for the `key`
+    description: |
+      The value to print for the `key`.  Only valid if `key_or_dict` is a str.
+
+kwargs:
+  bool_yn:
+    type: bool
+    default: false
+    description: Convert bool values to yes and no
+  section:
+    type: str
+    description: The section to put this summary information under.  If the
+      section keyword argument is omitted, key/value pairs are implicitly
+      grouped into a section with no title.
+  list_sep:
+    type: str
+    since: 0.54.0
+    description: |
+      The separator to use when printing list values in this summary.  If no
+      separator is given, each list item will be printed on its own line.

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/test.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/test.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/vcs_tag.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/vcs_tag.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/functions/warning.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/functions/warning.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/objects/cfg_data.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/objects/cfg_data.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/objects/compiler.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/objects/compiler.yaml Changed

@@ -37,7 +37,7 @@
         The source code to check.
 
         If a string is passed, the code is used directly. If a @file object
-        is passed, it's content is used for the compiler check.
+        is passed, its content is used for the compiler check.
 
 # Helper methods to pre-define common kwargs
 - name: _args
@@ -78,13 +78,15 @@
   description: You have found a bug if you can see this!
   kwargs:
     prefix:
-      type: str
+      type: str | liststr
       description: |
         Used to add `#include`s and other things that are required
-        for the symbol to be declared. System definitions should be
-        passed via compiler args (eg: `_GNU_SOURCE` is often required for
-        some symbols to be exposed on Linux, and it should be passed via
-        `args` keyword argument).
+        for the symbol to be declared. Since 1.0.0 an array is accepted
+        too. When an array is passed, the items are concatenated together
+        separated by a newline.
+        System definitions should be passed via compiler args
+        (eg: `_GNU_SOURCE` is often required for some symbols to be exposed
+        on Linux, and it should be passed via `args` keyword argument).
 
 - name: _no_builtin_args
   returns: void
@@ -105,7 +107,7 @@
         The name to use for printing a message about the compiler check.
         If this keyword argument is not passed, no message will be printed about the check.
 
-# Even more convinient
+# Even more convenient
 - name: _common
   returns: void
   description: You have found a bug if you can see this!
@@ -135,7 +137,11 @@
       type: bool | feature
       default: false
       since: 0.50.0
-      description: If set to `true`, Meson will halt if the header check fails.
+      description:
+        When set to `true`, Meson will halt if the header check fails.
+
+        When set to a `feature`(Build-options.md#features) option, the feature
+        will control if it is searched and whether to fail if not found.
 
 
 # Star of the actual functions
@@ -365,8 +371,10 @@
         be found. Otherwise, Meson will continue and the found method of the
         returned object will return `false`.
 
-        *(since 0.47.0)* The value of a `feature`(Build-options.md#features)
-        option can also be passed here.
+        When set to a `feature`(Build-options.md#features) option, the feature
+        will control if it is searched and whether to fail if not found.
+
+        *(since 0.47.0)* The value of a `feature` option can also be passed here.
 
     has_headers:
       type: liststr
@@ -564,7 +572,7 @@
   posargs:
     name:
       type: str
-      description: The attribute nane to check.
+      description: The attribute name to check.
 
 - name: get_supported_function_attributes
   returns: liststr
@@ -586,3 +594,26 @@
     gcc or msvc, but use the same argument syntax as one of those two compilers
     such as clang or icc, especially when they use different syntax on different
     operating systems.
+
+- name: preprocess
+  returns: listcustom_idx
+  since: 0.64.0
+  description: |
+    Preprocess a list of source files but do not compile them. The preprocessor
+    will receive the same arguments (include directories, defines, etc) as with
+    normal compilation. That includes for example args added with
+    `add_project_arguments()`, or on the command line with `-Dc_args=-DFOO`.
+  varargs_inherit: _build_target_base
+  kwargs_inherit:
+    - compiler._include_directories
+  kwargs:
+    output:
+      type: str
+      description: |
+        Template for name of preprocessed files: `@PLAINNAME@` is replaced by
+        the source filename and `@BASENAME@` is replaced by the source filename
+        without its extension.
+    compile_args:
+      type: liststr
+      description: |
+        Extra flags to pass to the preprocessor

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/objects/dep.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/objects/dep.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/objects/external_program.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/objects/external_program.yaml Changed

@@ -15,8 +15,12 @@
 
     Returns a string pointing to the script or executable.
 
-    **NOTE:** You should not need to use this method. Passing the object itself
-    should work in all cases.
+    **NOTE:** You should not usually need to use this method. Passing the
+    object itself should work in most contexts where a program can appear,
+    and allows Meson to setup inter-target dependencies correctly (for
+    example in cases where a program might be overridden by a build_tgt).
+    Only use this if you specifically need a string, such as when embedding
+    a program path into a header file.
 
     For example:
 
@@ -24,14 +28,26 @@
     run_command(find_program('foo'), 'arg1', 'arg2')
     ```
 
+- name: version
+  returns: str
+  since: 0.62.0
+  description: |
+    The version number as a string, for example `1.2.8`.
+
+    `unknown` if the program cannot determine the version via a `--version` argument.
+
 - name: full_path
   returns: str
   since: 0.55.0
   description: |
     Returns a string pointing to the script or executable.
 
-    **NOTE:** You should not need to use this method. Passing the object itself
-    should work in all cases.
+    **NOTE:** You should not usually need to use this method. Passing the
+    object itself should work in most contexts where a program can appear,
+    and allows Meson to setup inter-target dependencies correctly (for
+    example in cases where a program might be overridden by a build_tgt).
+    Only use this if you specifically need a string, such as when embedding
+    a program path into a header file.
 
     For example:

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/objects/feature.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/objects/feature.yaml Changed

_service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/objects/structured_src.yaml Added

_service:tar_scm:meson-0.61.5.tar.gz/docs/yaml/objects/subproject.yaml -> _service:tar_scm:meson-1.0.1.tar.gz/docs/yaml/objects/subproject.yaml Changed

_service:tar_scm:meson-0.61.5.tar.gz/man/meson.1 -> _service:tar_scm:meson-1.0.1.tar.gz/man/meson.1 Changed

_service:tar_scm:meson-1.0.1.tar.gz/manual tests/13 builddir upgrade Added

_service:tar_scm:meson-1.0.1.tar.gz/manual tests/13 builddir upgrade/data Added

_service:tar_scm:meson-1.0.1.tar.gz/manual tests/13 builddir upgrade/data/foo.dat Added

_service:tar_scm:meson-1.0.1.tar.gz/manual tests/13 builddir upgrade/foo.1 Added

_service:tar_scm:meson-1.0.1.tar.gz/manual tests/13 builddir upgrade/foo.c Added

_service:tar_scm:meson-1.0.1.tar.gz/manual tests/13 builddir upgrade/lib.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/manual tests/13 builddir upgrade/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/manual tests/13 builddir upgrade/mod.py Added

_service:tar_scm:meson-0.61.5.tar.gz/meson.py -> _service:tar_scm:meson-1.0.1.tar.gz/meson.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/_typing.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/_typing.py Changed

@@ -79,42 +79,3 @@
     def index(self, item: T) -> int: ...
 
     def copy(self) -> typing.ListT: ...
-
-
-class ImmutableSetProtocol(ProtocolT):
-
-    """A protocol for a set that cannot be mutated.
-
-    This provides for cases where mutation of the set is undesired. Although
-    this will be allowed at runtime, mypy (or another type checker), will see
-    any attempt to use mutative methods as an error.
-    """
-
-    def __iter__(self) -> typing.IteratorT: ...
-
-    def __contains__(self, item: T) -> bool: ...
-
-    def __len__(self) -> int: ...
-
-    def __add__(self, other: typing.SetT) -> typing.SetT: ...
-
-    def __eq__(self, other: typing.Any) -> bool: ...
-    def __ne__(self, other: typing.Any) -> bool: ...
-    def __le__(self, other: typing.Any) -> bool: ...
-    def __lt__(self, other: typing.Any) -> bool: ...
-    def __gt__(self, other: typing.Any) -> bool: ...
-    def __ge__(self, other: typing.Any) -> bool: ...
-
-    def copy(self) -> typing.SetT: ...
-
-    def difference(self, other: typing.SetT) -> typing.SetT: ...
-
-    def intersection(self, other: typing.SetT) -> typing.SetT: ...
-
-    def issubset(self, other: typing.SetT) -> bool: ...
-
-    def issuperset(self, other: typing.SetT) -> bool: ...
-
-    def symmetric_difference(self, other: typing.SetT) -> typing.SetT: ...
-
-    def union(self, other: typing.SetT) -> typing.SetT: ...

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/arglist.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/arglist.py Changed

@@ -12,6 +12,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from functools import lru_cache
 import collections
@@ -20,16 +21,12 @@
 import re
 import typing as T
 
-from . import mesonlib
-
 if T.TYPE_CHECKING:
     from .linkers import StaticLinker
     from .compilers import Compiler
 
-UNIXY_COMPILER_INTERNAL_LIBS = 'm', 'c', 'pthread', 'dl', 'rt'  # type: T.Liststr
-# execinfo is a compiler lib on FreeBSD and NetBSD
-if mesonlib.is_freebsd() or mesonlib.is_netbsd():
-    UNIXY_COMPILER_INTERNAL_LIBS.append('execinfo')
+# execinfo is a compiler lib on BSD
+UNIXY_COMPILER_INTERNAL_LIBS = 'm', 'c', 'pthread', 'dl', 'rt', 'execinfo'  # type: T.Liststr
 
 
 class Dedup(enum.Enum):
@@ -53,7 +50,7 @@
     OVERRIDDEN = 2
 
 
-class CompilerArgs(collections.abc.MutableSequence):
+class CompilerArgs(T.MutableSequencestr):
     '''
     List-like class that manages a list of compiler arguments. Should be used
     while constructing compiler arguments from various sources. Can be
@@ -119,7 +116,7 @@
     # This correctly deduplicates the entries after _can_dedup definition
     # Note: This function is designed to work without delete operations, as deletions are worsening the performance a lot.
     def flush_pre_post(self) -> None:
-        new = list()                      # type: T.Liststr
+        new =                           # type: T.Liststr
         pre_flush_set = set()             # type: T.Setstr
         post_flush = collections.deque()  # type: T.Dequestr
         post_flush_set = set()            # type: T.Setstr
@@ -324,10 +321,10 @@
         return NotImplemented
 
     def append(self, arg: str) -> None:
-        self.__iadd__(arg)
+        self += arg
 
     def extend(self, args: T.Iterablestr) -> None:
-        self.__iadd__(args)
+        self += args
 
     def __repr__(self) -> str:
         self.flush_pre_post()

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/ast/__init__.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/ast/__init__.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/ast/interpreter.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/ast/interpreter.py Changed

@@ -14,8 +14,12 @@
 
 # This class contains the basic functionality needed to run any interpreter
 # or an interpreter-based tool.
+from __future__ import annotations
+
+import os
+import sys
+import typing as T
 
-from .visitor import AstVisitor
 from .. import mparser, mesonlib
 from .. import environment
 
@@ -26,12 +30,9 @@
     BreakRequest,
     ContinueRequest,
     default_resolve_key,
-    TYPE_nvar,
-    TYPE_nkwargs,
 )
 
 from ..interpreter import (
-    Interpreter,
     StringHolder,
     BooleanHolder,
     IntegerHolder,
@@ -40,29 +41,33 @@
 )
 
 from ..mparser import (
-    AndNode,
     ArgumentNode,
     ArithmeticNode,
     ArrayNode,
     AssignmentNode,
     BaseNode,
-    ComparisonNode,
     ElementaryNode,
     EmptyNode,
-    ForeachClauseNode,
     IdNode,
-    IfClauseNode,
-    IndexNode,
     MethodNode,
     NotNode,
-    OrNode,
     PlusAssignmentNode,
     TernaryNode,
-    UMinusNode,
 )
 
-import os, sys
-import typing as T
+if T.TYPE_CHECKING:
+    from .visitor import AstVisitor
+    from ..interpreter import Interpreter
+    from ..interpreterbase import TYPE_nkwargs, TYPE_nvar
+    from ..mparser import (
+        AndNode,
+        ComparisonNode,
+        ForeachClauseNode,
+        IfClauseNode,
+        IndexNode,
+        OrNode,
+        UMinusNode,
+    )
 
 class DontCareObject(MesonInterpreterObject):
     pass
@@ -112,6 +117,7 @@
                            'add_global_arguments': self.func_do_nothing,
                            'add_global_link_arguments': self.func_do_nothing,
                            'add_project_arguments': self.func_do_nothing,
+                           'add_project_dependencies': self.func_do_nothing,
                            'add_project_link_arguments': self.func_do_nothing,
                            'message': self.func_do_nothing,
                            'generator': self.func_do_nothing,
@@ -154,6 +160,8 @@
                            'alias_target': self.func_do_nothing,
                            'summary': self.func_do_nothing,
                            'range': self.func_do_nothing,
+                           'structured_sources': self.func_do_nothing,
+                           'debug': self.func_do_nothing,
                            })
 
     def _unholder_args(self, args: _T, kwargs: _V) -> T.Tuple_T, _V:
@@ -357,10 +365,10 @@
                 result = not result
 
         elif isinstance(node, ArrayNode):
-            result = x for x in node.args.arguments
+            result = node.args.arguments.copy()
 
         elif isinstance(node, ArgumentNode):
-            result = x for x in node.arguments
+            result = node.arguments.copy()
 
         elif isinstance(node, ArithmeticNode):
             if node.operation != 'add':
@@ -378,15 +386,15 @@
             mkwargs = {} # type: T.Dictstr, TYPE_nvar
             try:
                 if isinstance(src, str):
-                    result = StringHolder(src, T.cast(Interpreter, self)).method_call(node.name, margs, mkwargs)
+                    result = StringHolder(src, T.cast('Interpreter', self)).method_call(node.name, margs, mkwargs)
                 elif isinstance(src, bool):
-                    result = BooleanHolder(src, T.cast(Interpreter, self)).method_call(node.name, margs, mkwargs)
+                    result = BooleanHolder(src, T.cast('Interpreter', self)).method_call(node.name, margs, mkwargs)
                 elif isinstance(src, int):
-                    result = IntegerHolder(src, T.cast(Interpreter, self)).method_call(node.name, margs, mkwargs)
+                    result = IntegerHolder(src, T.cast('Interpreter', self)).method_call(node.name, margs, mkwargs)
                 elif isinstance(src, list):
-                    result = ArrayHolder(src, T.cast(Interpreter, self)).method_call(node.name, margs, mkwargs)
+                    result = ArrayHolder(src, T.cast('Interpreter', self)).method_call(node.name, margs, mkwargs)
                 elif isinstance(src, dict):
-                    result = DictHolder(src, T.cast(Interpreter, self)).method_call(node.name, margs, mkwargs)
+                    result = DictHolder(src, T.cast('Interpreter', self)).method_call(node.name, margs, mkwargs)
             except mesonlib.MesonException:
                 return None

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/ast/introspection.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/ast/introspection.py Changed

@@ -15,20 +15,32 @@
 # This class contains the basic functionality needed to run any interpreter
 # or an interpreter-based tool
 
-from .interpreter import AstInterpreter
-from .visitor import AstVisitor
+from __future__ import annotations
+import argparse
+import copy
+import os
+import typing as T
+
 from .. import compilers, environment, mesonlib, optinterpreter
 from .. import coredata as cdata
+from ..build import Executable, Jar, SharedLibrary, SharedModule, StaticLibrary
+from ..compilers import detect_compiler_for
+from ..interpreterbase import InvalidArguments
 from ..mesonlib import MachineChoice, OptionKey
-from ..interpreterbase import InvalidArguments, TYPE_nvar
-from ..build import BuildTarget, Executable, Jar, SharedLibrary, SharedModule, StaticLibrary
 from ..mparser import BaseNode, ArithmeticNode, ArrayNode, ElementaryNode, IdNode, FunctionNode, StringNode
-from ..compilers import detect_compiler_for
-import typing as T
-import os
-import argparse
+from .interpreter import AstInterpreter
 
-build_target_functions = 'executable', 'jar', 'library', 'shared_library', 'shared_module', 'static_library', 'both_libraries'
+if T.TYPE_CHECKING:
+    from ..build import BuildTarget
+    from ..interpreterbase import TYPE_nvar
+    from .visitor import AstVisitor
+
+
+# TODO: it would be nice to not have to duplicate this
+BUILD_TARGET_FUNCTIONS = 
+    'executable', 'jar', 'library', 'shared_library', 'shared_module',
+    'static_library', 'both_libraries'
+
 
 class IntrospectionHelper(argparse.Namespace):
     # mimic an argparse namespace
@@ -129,8 +141,8 @@
         options = {k: v for k, v in self.environment.options.items() if k.is_backend()}
 
         self.coredata.set_options(options)
-        self._add_languages(proj_langs, MachineChoice.HOST)
-        self._add_languages(proj_langs, MachineChoice.BUILD)
+        self._add_languages(proj_langs, True, MachineChoice.HOST)
+        self._add_languages(proj_langs, True, MachineChoice.BUILD)
 
     def do_subproject(self, dirname: str) -> None:
         subproject_dir_abs = os.path.join(self.environment.get_source_dir(), self.subproject_dir)
@@ -145,14 +157,17 @@
 
     def func_add_languages(self, node: BaseNode, args: T.ListTYPE_nvar, kwargs: T.Dictstr, TYPE_nvar) -> None:
         kwargs = self.flatten_kwargs(kwargs)
+        required = kwargs.get('required', True)
+        if isinstance(required, cdata.UserFeatureOption):
+            required = required.is_enabled()
         if 'native' in kwargs:
             native = kwargs.get('native', False)
-            self._add_languages(args, MachineChoice.BUILD if native else MachineChoice.HOST)
+            self._add_languages(args, required, MachineChoice.BUILD if native else MachineChoice.HOST)
         else:
             for for_machine in MachineChoice.BUILD, MachineChoice.HOST:
-                self._add_languages(args, for_machine)
+                self._add_languages(args, required, for_machine)
 
-    def _add_languages(self, raw_langs: T.ListTYPE_nvar, for_machine: MachineChoice) -> None:
+    def _add_languages(self, raw_langs: T.ListTYPE_nvar, required: bool, for_machine: MachineChoice) -> None:
         langs =   # type: T.Liststr
         for l in self.flatten_args(raw_langs):
             if isinstance(l, str):
@@ -163,7 +178,21 @@
         for lang in sorted(langs, key=compilers.sort_clink):
             lang = lang.lower()
             if lang not in self.coredata.compilersfor_machine:
-                detect_compiler_for(self.environment, lang, for_machine)
+                try:
+                    comp = detect_compiler_for(self.environment, lang, for_machine)
+                except mesonlib.MesonException:
+                    # do we even care about introspecting this language?
+                    if required:
+                        raise
+                    else:
+                        continue
+                if self.subproject:
+                    options = {}
+                    for k in comp.get_options():
+                        v = copy.copy(self.coredata.optionsk)
+                        k = k.evolve(subproject=self.subproject)
+                        optionsk = v
+                    self.coredata.add_compiler_options(options, lang, for_machine, self.environment)
 
     def func_dependency(self, node: BaseNode, args: T.ListTYPE_nvar, kwargs: T.Dictstr, TYPE_nvar) -> None:
         args = self.flatten_args(args)
@@ -230,7 +259,7 @@
                     continue
                 arg_nodes = arg_node.arguments.copy()
                 # Pop the first element if the function is a build target function
-                if isinstance(curr, FunctionNode) and curr.func_name in build_target_functions:
+                if isinstance(curr, FunctionNode) and curr.func_name in BUILD_TARGET_FUNCTIONS:
                     arg_nodes.pop(0)
                 elemetary_nodes = x for x in arg_nodes if isinstance(x, (str, StringNode))
                 inqueue += x for x in arg_nodes if isinstance(x, (FunctionNode, ArrayNode, IdNode, ArithmeticNode))
@@ -242,14 +271,17 @@
         extraf_nodes = traverse_nodes(extra_queue)
 
         # Make sure nothing can crash when creating the build class
-        kwargs_reduced = {k: v for k, v in kwargs.items() if k in targetclass.known_kwargs and k in 'install', 'build_by_default', 'build_always'}
+        kwargs_reduced = {k: v for k, v in kwargs.items() if k in targetclass.known_kwargs and k in {'install', 'build_by_default', 'build_always'}}
         kwargs_reduced = {k: v.value if isinstance(v, ElementaryNode) else v for k, v in kwargs_reduced.items()}
         kwargs_reduced = {k: v for k, v in kwargs_reduced.items() if not isinstance(v, BaseNode)}
         for_machine = MachineChoice.HOST
         objects =         # type: T.ListT.Any
         empty_sources =   # type: T.ListT.Any
         # Passing the unresolved sources list causes errors
-        target = targetclass(name, self.subdir, self.subproject, for_machine, empty_sources, objects, self.environment, kwargs_reduced)
+        target = targetclass(name, self.subdir, self.subproject, for_machine, empty_sources, , objects,
+                             self.environment, self.coredata.compilersfor_machine, kwargs_reduced)
+        target.process_compilers()
+        target.process_compilers_late()
 
         new_target = {
             'name': target.get_basename(),

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/ast/postprocess.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/ast/postprocess.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/ast/printer.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/ast/printer.py Changed

@@ -14,6 +14,7 @@
 
 # This class contains the basic functionality needed to run any interpreter
 # or an interpreter-based tool
+from __future__ import annotations
 
 from .. import mparser
 from . import AstVisitor
@@ -29,13 +30,14 @@
 }
 
 class AstPrinter(AstVisitor):
-    def __init__(self, indent: int = 2, arg_newline_cutoff: int = 5):
+    def __init__(self, indent: int = 2, arg_newline_cutoff: int = 5, update_ast_line_nos: bool = False):
         self.result = ''
         self.indent = indent
         self.arg_newline_cutoff = arg_newline_cutoff
         self.ci = ''
         self.is_newline = True
         self.last_level = 0
+        self.curr_line = 1 if update_ast_line_nos else None
 
     def post_process(self) -> None:
         self.result = re.sub(r'\s+\n', '\n', self.result)
@@ -55,37 +57,52 @@
     def newline(self) -> None:
         self.result += '\n'
         self.is_newline = True
+        if self.curr_line is not None:
+            self.curr_line += 1
 
     def visit_BooleanNode(self, node: mparser.BooleanNode) -> None:
         self.append('true' if node.value else 'false', node)
+        node.lineno = self.curr_line or node.lineno
 
     def visit_IdNode(self, node: mparser.IdNode) -> None:
         assert isinstance(node.value, str)
         self.append(node.value, node)
+        node.lineno = self.curr_line or node.lineno
 
     def visit_NumberNode(self, node: mparser.NumberNode) -> None:
         self.append(str(node.value), node)
+        node.lineno = self.curr_line or node.lineno
+
+    def escape(self, val: str) -> str:
+        return val.translate(str.maketrans({'\'': '\\\'',
+                                            '\\': '\\\\'}))
 
     def visit_StringNode(self, node: mparser.StringNode) -> None:
         assert isinstance(node.value, str)
-        self.append("'" + node.value + "'", node)
+        self.append("'" + self.escape(node.value) + "'", node)
+        node.lineno = self.curr_line or node.lineno
 
     def visit_FormatStringNode(self, node: mparser.FormatStringNode) -> None:
         assert isinstance(node.value, str)
         self.append("f'" + node.value + "'", node)
+        node.lineno = self.curr_line or node.lineno
 
     def visit_ContinueNode(self, node: mparser.ContinueNode) -> None:
         self.append('continue', node)
+        node.lineno = self.curr_line or node.lineno
 
     def visit_BreakNode(self, node: mparser.BreakNode) -> None:
         self.append('break', node)
+        node.lineno = self.curr_line or node.lineno
 
     def visit_ArrayNode(self, node: mparser.ArrayNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         self.append('', node)
         node.args.accept(self)
         self.append('', node)
 
     def visit_DictNode(self, node: mparser.DictNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         self.append('{', node)
         node.args.accept(self)
         self.append('}', node)
@@ -93,61 +110,72 @@
     def visit_OrNode(self, node: mparser.OrNode) -> None:
         node.left.accept(self)
         self.append_padded('or', node)
+        node.lineno = self.curr_line or node.lineno
         node.right.accept(self)
 
     def visit_AndNode(self, node: mparser.AndNode) -> None:
         node.left.accept(self)
         self.append_padded('and', node)
+        node.lineno = self.curr_line or node.lineno
         node.right.accept(self)
 
     def visit_ComparisonNode(self, node: mparser.ComparisonNode) -> None:
         node.left.accept(self)
         self.append_padded(node.ctype, node)
+        node.lineno = self.curr_line or node.lineno
         node.right.accept(self)
 
     def visit_ArithmeticNode(self, node: mparser.ArithmeticNode) -> None:
         node.left.accept(self)
         self.append_padded(arithmic_mapnode.operation, node)
+        node.lineno = self.curr_line or node.lineno
         node.right.accept(self)
 
     def visit_NotNode(self, node: mparser.NotNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         self.append_padded('not', node)
         node.value.accept(self)
 
     def visit_CodeBlockNode(self, node: mparser.CodeBlockNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         for i in node.lines:
             i.accept(self)
             self.newline()
 
     def visit_IndexNode(self, node: mparser.IndexNode) -> None:
         node.iobject.accept(self)
+        node.lineno = self.curr_line or node.lineno
         self.append('', node)
         node.index.accept(self)
         self.append('', node)
 
     def visit_MethodNode(self, node: mparser.MethodNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         node.source_object.accept(self)
         self.append('.' + node.name + '(', node)
         node.args.accept(self)
         self.append(')', node)
 
     def visit_FunctionNode(self, node: mparser.FunctionNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         self.append(node.func_name + '(', node)
         node.args.accept(self)
         self.append(')', node)
 
     def visit_AssignmentNode(self, node: mparser.AssignmentNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         self.append(node.var_name + ' = ', node)
         node.value.accept(self)
 
     def visit_PlusAssignmentNode(self, node: mparser.PlusAssignmentNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         self.append(node.var_name + ' += ', node)
         node.value.accept(self)
 
     def visit_ForeachClauseNode(self, node: mparser.ForeachClauseNode) -> None:
-        varnames = x for x in node.varnames
+        node.lineno = self.curr_line or node.lineno
         self.append_padded('foreach', node)
-        self.append_padded(', '.join(varnames), node)
+        self.append_padded(', '.join(node.varnames), node)
         self.append_padded(':', node)
         node.items.accept(self)
         self.newline()
@@ -155,6 +183,7 @@
         self.append('endforeach', node)
 
     def visit_IfClauseNode(self, node: mparser.IfClauseNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         prefix = ''
         for i in node.ifs:
             self.append_padded(prefix + 'if', node)
@@ -166,15 +195,18 @@
         self.append('endif', node)
 
     def visit_UMinusNode(self, node: mparser.UMinusNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         self.append_padded('-', node)
         node.value.accept(self)
 
     def visit_IfNode(self, node: mparser.IfNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         node.condition.accept(self)
         self.newline()
         node.block.accept(self)
 
     def visit_TernaryNode(self, node: mparser.TernaryNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         node.condition.accept(self)
         self.append_padded('?', node)
         node.trueblock.accept(self)
@@ -182,6 +214,7 @@
         node.falseblock.accept(self)
 
     def visit_ArgumentNode(self, node: mparser.ArgumentNode) -> None:
+        node.lineno = self.curr_line or node.lineno
         break_args = (len(node.arguments) + len(node.kwargs)) > self.arg_newline_cutoff
         for i in node.arguments + list(node.kwargs.values()):
             if not isinstance(i, (mparser.ElementaryNode, mparser.IndexNode)):

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/ast/visitor.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/ast/visitor.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/backend/backends.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/backend/backends.py Changed

@@ -11,16 +11,20 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from collections import OrderedDict
+from dataclasses import dataclass, InitVar
 from functools import lru_cache
 from itertools import chain
 from pathlib import Path
+import copy
 import enum
 import json
 import os
 import pickle
 import re
+import shutil
 import typing as T
 import hashlib
 
@@ -31,8 +35,9 @@
 from .. import mlog
 from ..compilers import LANGUAGES_USING_LDFLAGS, detect
 from ..mesonlib import (
-    File, MachineChoice, MesonException, OptionType, OrderedSet, OptionOverrideProxy,
-    classify_unity_sources, OptionKey, join_args
+    File, MachineChoice, MesonException, OrderedSet,
+    classify_unity_sources, OptionKey, join_args,
+    ExecutableSerialisation
 )
 
 if T.TYPE_CHECKING:
@@ -43,14 +48,15 @@
     from ..interpreter import Interpreter, Test
     from ..linkers import StaticLinker
     from ..mesonlib import FileMode, FileOrString
-    from ..wrap import WrapMode
 
     from typing_extensions import TypedDict
 
+    _ALL_SOURCES_TYPE = T.ListT.UnionFile, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList
+
     class TargetIntrospectionData(TypedDict):
 
         language: str
-        compiler : T.Liststr
+        compiler: T.Liststr
         parameters: T.Liststr
         sources: T.Liststr
         generated_sources: T.Liststr
@@ -61,11 +67,11 @@
 # Assembly files cannot be unitified and neither can LLVM IR files
 LANGS_CANT_UNITY = ('d', 'fortran', 'vala')
 
+@dataclass(eq=False)
 class RegenInfo:
-    def __init__(self, source_dir: str, build_dir: str, depfiles: T.Liststr):
-        self.source_dir = source_dir
-        self.build_dir = build_dir
-        self.depfiles = depfiles
+    source_dir: str
+    build_dir: str
+    depfiles: T.Liststr
 
 class TestProtocol(enum.Enum):
 
@@ -97,28 +103,29 @@
         return 'tap'
 
 
+@dataclass(eq=False)
 class CleanTrees:
     '''
     Directories outputted by custom targets that have to be manually cleaned
     because on Linux `ninja clean` only deletes empty directories.
     '''
-    def __init__(self, build_dir: str, trees: T.Liststr):
-        self.build_dir = build_dir
-        self.trees = trees
+    build_dir: str
+    trees: T.Liststr
 
+@dataclass(eq=False)
 class InstallData:
-    def __init__(self, source_dir: str, build_dir: str, prefix: str, libdir: str,
-                 strip_bin: T.Liststr, install_umask: T.Unionstr, int,
-                 mesonintrospect: T.Liststr, version: str,
-                 is_cross_build: bool):
-        # TODO: in python 3.8 or with typing_Extensions install_umask could be:
-        # `T.UnionT.Literal'preserve', int`, which would be more accurate.
-        self.source_dir = source_dir
-        self.build_dir = build_dir
-        self.prefix = prefix
-        self.libdir = libdir
-        self.strip_bin = strip_bin
-        self.install_umask = install_umask
+    source_dir: str
+    build_dir: str
+    prefix: str
+    libdir: str
+    strip_bin: T.Liststr
+    # TODO: in python 3.8 or with typing_Extensions this could be:
+    # `T.UnionT.Literal'preserve', int`, which would be more accurate.
+    install_umask: T.Unionstr, int
+    mesonintrospect: T.Liststr
+    version: str
+
+    def __post_init__(self) -> None:
         self.targets: T.ListTargetInstallData = 
         self.headers: T.ListInstallDataBase = 
         self.man: T.ListInstallDataBase = 
@@ -127,59 +134,55 @@
         self.symlinks: T.ListInstallSymlinkData = 
         self.install_scripts: T.ListExecutableSerialisation = 
         self.install_subdirs: T.ListSubdirInstallData = 
-        self.mesonintrospect = mesonintrospect
-        self.version = version
-        self.is_cross_build = is_cross_build
 
+@dataclass(eq=False)
 class TargetInstallData:
-
+    fname: str
+    outdir: str
+    outdir_name: InitVarT.Optionalstr
+    strip: bool
+    install_name_mappings: T.Mappingstr, str
+    rpath_dirs_to_remove: T.Setbytes
+    install_rpath: str
     # TODO: install_mode should just always be a FileMode object
-
-    def __init__(self, fname: str, outdir: str, outdir_name: str, aliases: T.Dictstr, str,
-                 strip: bool, install_name_mappings: T.Mappingstr, str, rpath_dirs_to_remove: T.Setbytes,
-                 install_rpath: str, install_mode: T.Optional'FileMode',
-                 subproject: str, optional: bool = False, tag: T.Optionalstr = None):
-        self.fname = fname
-        self.outdir = outdir
-        self.out_name = os.path.join(outdir_name, os.path.basename(fname))
-        self.aliases = aliases
-        self.strip = strip
-        self.install_name_mappings = install_name_mappings
-        self.rpath_dirs_to_remove = rpath_dirs_to_remove
-        self.install_rpath = install_rpath
-        self.install_mode = install_mode
-        self.subproject = subproject
-        self.optional = optional
-        self.tag = tag
-
+    install_mode: T.Optional'FileMode'
+    subproject: str
+    optional: bool = False
+    tag: T.Optionalstr = None
+    can_strip: bool = False
+
+    def __post_init__(self, outdir_name: T.Optionalstr) -> None:
+        if outdir_name is None:
+            outdir_name = os.path.join('{prefix}', self.outdir)
+        self.out_name = os.path.join(outdir_name, os.path.basename(self.fname))
+
+@dataclass(eq=False)
 class InstallEmptyDir:
-    def __init__(self, path: str, install_mode: 'FileMode', subproject: str, tag: T.Optionalstr = None):
-        self.path = path
-        self.install_mode = install_mode
-        self.subproject = subproject
-        self.tag = tag
+    path: str
+    install_mode: 'FileMode'
+    subproject: str
+    tag: T.Optionalstr = None
 
+@dataclass(eq=False)
 class InstallDataBase:
-    def __init__(self, path: str, install_path: str, install_path_name: str,
-                 install_mode: 'FileMode', subproject: str, tag: T.Optionalstr = None,
-                 data_type: T.Optionalstr = None):
-        self.path = path
-        self.install_path = install_path
-        self.install_path_name = install_path_name
-        self.install_mode = install_mode
-        self.subproject = subproject
-        self.tag = tag
-        self.data_type = data_type
-
+    path: str
+    install_path: str
+    install_path_name: str
+    install_mode: 'FileMode'
+    subproject: str
+    tag: T.Optionalstr = None
+    data_type: T.Optionalstr = None
+
+@dataclass(eq=False)
 class InstallSymlinkData:
-    def __init__(self, target: str, name: str, install_path: str,
-                 subproject: str, tag: T.Optionalstr = None):
-        self.target = target
-        self.name = name
-        self.install_path = install_path
-        self.subproject = subproject
-        self.tag = tag
-
+    target: str
+    name: str
+    install_path: str
+    subproject: str
+    tag: T.Optionalstr = None
+    allow_missing: bool = False
+
+# cannot use dataclass here because "exclude" is out of order
 class SubdirInstallData(InstallDataBase):
     def __init__(self, path: str, install_path: str, install_path_name: str,
                  install_mode: 'FileMode', exclude: T.TupleT.Setstr, T.Setstr,
@@ -187,64 +190,34 @@
         super().__init__(path, install_path, install_path_name, install_mode, subproject, tag, data_type)
         self.exclude = exclude
 
-class ExecutableSerialisation:
-
-    # XXX: should capture and feed default to False, instead of None?
-
-    def __init__(self, cmd_args: T.Liststr,
-                 env: T.Optionalbuild.EnvironmentVariables = None,
-                 exe_wrapper: T.Optional'programs.ExternalProgram' = None,
-                 workdir: T.Optionalstr = None,
-                 extra_paths: T.OptionalT.List = None,
-                 capture: T.Optionalbool = None,
-                 feed: T.Optionalbool = None,
-                 tag: T.Optionalstr = None,
-                 verbose: bool = False,
-                 ) -> None:
-        self.cmd_args = cmd_args
-        self.env = env
-        if exe_wrapper is not None:
-            assert isinstance(exe_wrapper, programs.ExternalProgram)
-        self.exe_wrapper = exe_wrapper
-        self.workdir = workdir
-        self.extra_paths = extra_paths
-        self.capture = capture
-        self.feed = feed
-        self.pickled = False
-        self.skip_if_destdir = False
-        self.verbose = verbose
-        self.subproject = ''
-        self.tag = tag
 
+@dataclass(eq=False)
 class TestSerialisation:
-    def __init__(self, name: str, project: str, suite: T.Liststr, fname: T.Liststr,
-                 is_cross_built: bool, exe_wrapper: T.Optionalprograms.ExternalProgram,
-                 needs_exe_wrapper: bool, is_parallel: bool, cmd_args: T.Liststr,
-                 env: build.EnvironmentVariables, should_fail: bool,
-                 timeout: T.Optionalint, workdir: T.Optionalstr,
-                 extra_paths: T.Liststr, protocol: TestProtocol, priority: int,
-                 cmd_is_built: bool, depends: T.Liststr, version: str):
-        self.name = name
-        self.project_name = project
-        self.suite = suite
-        self.fname = fname
-        self.is_cross_built = is_cross_built
-        if exe_wrapper is not None:
-            assert isinstance(exe_wrapper, programs.ExternalProgram)
-        self.exe_wrapper = exe_wrapper
-        self.is_parallel = is_parallel
-        self.cmd_args = cmd_args
-        self.env = env
-        self.should_fail = should_fail
-        self.timeout = timeout
-        self.workdir = workdir
-        self.extra_paths = extra_paths
-        self.protocol = protocol
-        self.priority = priority
-        self.needs_exe_wrapper = needs_exe_wrapper
-        self.cmd_is_built = cmd_is_built
-        self.depends = depends
-        self.version = version
+    name: str
+    project_name: str
+    suite: T.Liststr
+    fname: T.Liststr
+    is_cross_built: bool
+    exe_wrapper: T.Optionalprograms.ExternalProgram
+    needs_exe_wrapper: bool
+    is_parallel: bool
+    cmd_args: T.Liststr
+    env: build.EnvironmentVariables
+    should_fail: bool
+    timeout: T.Optionalint
+    workdir: T.Optionalstr
+    extra_paths: T.Liststr
+    protocol: TestProtocol
+    priority: int
+    cmd_is_built: bool
+    cmd_is_exe: bool
+    depends: T.Liststr
+    version: str
+    verbose: bool
+
+    def __post_init__(self) -> None:
+        if self.exe_wrapper is not None:
+            assert isinstance(self.exe_wrapper, programs.ExternalProgram)
 
 
 def get_backend_from_name(backend: str, build: T.Optionalbuild.Build = None, interpreter: T.Optional'Interpreter' = None) -> T.Optional'Backend':
@@ -316,35 +289,13 @@
         elif isinstance(t, build.CustomTargetIndex):
             filename = t.get_outputs()0
         else:
-            assert isinstance(t, build.BuildTarget)
+            assert isinstance(t, build.BuildTarget), t
             filename = t.get_filename()
         return os.path.join(self.get_target_dir(t), filename)
 
     def get_target_filename_abs(self, target: T.Unionbuild.Target, build.CustomTargetIndex) -> str:
         return os.path.join(self.environment.get_build_dir(), self.get_target_filename(target))
 
-    def get_base_options_for_target(self, target: build.BuildTarget) -> OptionOverrideProxy:
-        return OptionOverrideProxy(target.option_overrides_base,
-                                   {k: v for k, v in self.environment.coredata.options.items()
-                                    if k.type in {OptionType.BASE, OptionType.BUILTIN}})
-
-    def get_compiler_options_for_target(self, target: build.BuildTarget) -> OptionOverrideProxy:
-        comp_reg = {k: v for k, v in self.environment.coredata.options.items() if k.is_compiler()}
-        comp_override = target.option_overrides_compiler
-        return OptionOverrideProxy(comp_override, comp_reg)
-
-    def get_option_for_target(self, option_name: 'OptionKey', target: build.BuildTarget) -> T.Unionstr, int, bool, 'WrapMode':
-        if option_name in target.option_overrides_base:
-            override = target.option_overrides_baseoption_name
-            v = self.environment.coredata.validate_option_value(option_name, override)
-        else:
-            v = self.environment.coredata.get_option(option_name.evolve(subproject=target.subproject))
-        # We don't actually have wrapmode here to do an assert, so just do a
-        # cast, we know what's in coredata anyway.
-        # TODO: if it's possible to annotate get_option or validate_option_value
-        # in the future we might be able to remove the cast here
-        return T.cast(T.Unionstr, int, bool, 'WrapMode', v)
-
     def get_source_dir_include_args(self, target: build.BuildTarget, compiler: 'Compiler', *, absolute_path: bool = False) -> T.Liststr:
         curdir = target.get_subdir()
         if absolute_path:
@@ -442,7 +393,7 @@
         abs_files: T.Liststr = 
         result: T.Listmesonlib.File = 
         compsrcs = classify_unity_sources(target.compilers.values(), unity_src)
-        unity_size = self.get_option_for_target(OptionKey('unity_size'), target)
+        unity_size = target.get_option(OptionKey('unity_size'))
         assert isinstance(unity_size, int), 'for mypy'
 
         def init_language_file(suffix: str, unity_file_number: int) -> T.TextIO:
@@ -485,14 +436,20 @@
         return os.path.relpath(os.path.join('dummyprefixdir', todir),
                                os.path.join('dummyprefixdir', fromdir))
 
-    def flatten_object_list(self, target: build.BuildTarget, proj_dir_to_build_root: str = '') -> T.Liststr:
-        obj_list = self._flatten_object_list(target, target.get_objects(), proj_dir_to_build_root)
+    def flatten_object_list(self, target: build.BuildTarget, proj_dir_to_build_root: str = ''
+                            ) -> T.TupleT.Liststr, T.Listbuild.BuildTargetTypes:
+        obj_list, deps = self._flatten_object_list(target, target.get_objects(), proj_dir_to_build_root)
+        return list(dict.fromkeys(obj_list)), deps
+
+    def determine_ext_objs(self, objects: build.ExtractedObjects, proj_dir_to_build_root: str = '') -> T.Liststr:
+        obj_list, _ = self._flatten_object_list(objects.target, objects, proj_dir_to_build_root)
         return list(dict.fromkeys(obj_list))
 
     def _flatten_object_list(self, target: build.BuildTarget,
                              objects: T.SequenceT.Unionstr, 'File', build.ExtractedObjects,
-                             proj_dir_to_build_root: str) -> T.Liststr:
+                             proj_dir_to_build_root: str) -> T.TupleT.Liststr, T.Listbuild.BuildTargetTypes:
         obj_list: T.Liststr = 
+        deps: T.Listbuild.BuildTargetTypes = 
         for obj in objects:
             if isinstance(obj, str):
                 o = os.path.join(proj_dir_to_build_root,
@@ -509,11 +466,14 @@
                     obj_list.append(obj.rel_to_builddir(o))
             elif isinstance(obj, build.ExtractedObjects):
                 if obj.recursive:
-                    obj_list += self._flatten_object_list(obj.target, obj.objlist, proj_dir_to_build_root)
-                obj_list += self.determine_ext_objs(obj, proj_dir_to_build_root)
+                    objs, d = self._flatten_object_list(obj.target, obj.objlist, proj_dir_to_build_root)
+                    obj_list.extend(objs)
+                    deps.extend(d)
+                obj_list.extend(self._determine_ext_objs(obj, proj_dir_to_build_root))
+                deps.append(obj.target)
             else:
                 raise MesonException('Unknown data type in object list.')
-        return obj_list
+        return obj_list, deps
 
     @staticmethod
     def is_swift_target(target: build.BuildTarget) -> bool:
@@ -628,9 +588,19 @@
         if any('\n' in c for c in es.cmd_args):
             reasons.append('because command contains newlines')
 
-        if es.env and es.env.varnames:
+        if env and env.varnames:
             reasons.append('to set env')
 
+        # force_serialize passed to this function means that the VS backend has
+        # decided it absolutely cannot use real commands. This is "always",
+        # because it's not clear what will work (other than compilers) and so
+        # we don't bother to handle a variety of common cases that probably do
+        # work.
+        #
+        # It's also overridden for a few conditions that can't be handled
+        # inside a command line
+
+        can_use_env = not force_serialize
         force_serialize = force_serialize or bool(reasons)
 
         if capture:
@@ -638,6 +608,12 @@
         if feed:
             reasons.append('to feed input')
 
+        if can_use_env and reasons == 'to set env' and shutil.which('env'):
+            envlist = 
+            for k, v in env.get_env({}).items():
+                envlist.append(f'{k}={v}')
+            return 'env' + envlist + es.cmd_args, ', '.join(reasons)
+
         if not force_serialize:
             if not capture and not feed:
                 return es.cmd_args, ''
@@ -805,12 +781,22 @@
 
     @staticmethod
     def canonicalize_filename(fname: str) -> str:
+        parts = Path(fname).parts
+        hashed = ''
+        if len(parts) > 5:
+            temp = '/'.join(parts-5:)
+            # is it shorter to hash the beginning of the path?
+            if len(fname) > len(temp) + 41:
+                hashed = hashlib.sha1(fname.encode('utf-8')).hexdigest() + '_'
+                fname = temp
         for ch in ('/', '\\', ':'):
             fname = fname.replace(ch, '_')
-        return fname
+        return hashed + fname
 
     def object_filename_from_source(self, target: build.BuildTarget, source: 'FileOrString') -> str:
         assert isinstance(source, mesonlib.File)
+        if isinstance(target, build.CompileTarget):
+            return target.sources_mapsource
         build_dir = self.environment.get_build_dir()
         rel_src = source.rel_to_builddir(self.build_to_src)
 
@@ -841,7 +827,7 @@
         machine = self.environment.machinestarget.for_machine
         return self.canonicalize_filename(gen_source) + '.' + machine.get_object_suffix()
 
-    def determine_ext_objs(self, extobj: 'build.ExtractedObjects', proj_dir_to_build_root: str) -> T.Liststr:
+    def _determine_ext_objs(self, extobj: 'build.ExtractedObjects', proj_dir_to_build_root: str) -> T.Liststr:
         result: T.Liststr = 
 
         # Merge sources and generated sources
@@ -855,7 +841,7 @@
         # Filter out headers and all non-source files
         sources: T.List'FileOrString' = 
         for s in raw_sources:
-            if self.environment.is_source(s) and not self.environment.is_header(s):
+            if self.environment.is_source(s):
                 sources.append(s)
             elif self.environment.is_object(s):
                 result.append(s.relative_name())
@@ -869,10 +855,10 @@
         # With unity builds, sources don't map directly to objects,
         # we only support extracting all the objects in this mode,
         # so just return all object files.
-        if self.is_unity(extobj.target):
+        if extobj.target.is_unity:
             compsrcs = classify_unity_sources(extobj.target.compilers.values(), sources)
             sources = 
-            unity_size = self.get_option_for_target(OptionKey('unity_size'), extobj.target)
+            unity_size = extobj.target.get_option(OptionKey('unity_size'))
             assert isinstance(unity_size, int), 'for mypy'
 
             for comp, srcs in compsrcs.items():
@@ -939,7 +925,7 @@
         # starting from hard-coded defaults followed by build options and so on.
         commands = compiler.compiler_args()
 
-        copt_proxy = self.get_compiler_options_for_target(target)
+        copt_proxy = target.get_options()
         # First, the trivial ones that are impossible to override.
         #
         # Add -nostdinc/-nostdinc++ if needed; can't be overridden
@@ -952,27 +938,27 @@
             commands += compiler.get_no_warn_args()
         else:
             # warning_level is a string, but mypy can't determine that
-            commands += compiler.get_warn_args(T.cast(str, self.get_option_for_target(OptionKey('warning_level'), target)))
+            commands += compiler.get_warn_args(T.cast('str', target.get_option(OptionKey('warning_level'))))
         # Add -Werror if werror=true is set in the build options set on the
         # command-line or default_options inside project(). This only sets the
         # action to be done for warnings if/when they are emitted, so it's ok
         # to set it after get_no_warn_args() or get_warn_args().
-        if self.get_option_for_target(OptionKey('werror'), target):
+        if target.get_option(OptionKey('werror')):
             commands += compiler.get_werror_args()
         # Add compile args for c_* or cpp_* build options set on the
         # command-line or default_options inside project().
         commands += compiler.get_option_compile_args(copt_proxy)
 
         # Add buildtype args: optimization level, debugging, etc.
-        buildtype = self.get_option_for_target(OptionKey('buildtype'), target)
+        buildtype = target.get_option(OptionKey('buildtype'))
         assert isinstance(buildtype, str), 'for mypy'
         commands += compiler.get_buildtype_args(buildtype)
 
-        optimization = self.get_option_for_target(OptionKey('optimization'), target)
+        optimization = target.get_option(OptionKey('optimization'))
         assert isinstance(optimization, str), 'for mypy'
         commands += compiler.get_optimization_args(optimization)
 
-        debug = self.get_option_for_target(OptionKey('debug'), target)
+        debug = target.get_option(OptionKey('debug'))
         assert isinstance(debug, bool), 'for mypy'
         commands += compiler.get_debug_args(debug)
 
@@ -981,15 +967,15 @@
         # Add compile args added using add_global_arguments()
         # These override per-project arguments
         commands += self.build.get_global_args(compiler, target.for_machine)
-        # Using both /ZI and /Zi at the same times produces a compiler warning.
-        # We do not add /ZI by default. If it is being used it is because the user has explicitly enabled it.
-        # /ZI needs to be removed in that case to avoid cl's warning to that effect (D9025 : overriding '/ZI' with '/Zi')
-        if ('/ZI' in commands) and ('/Zi' in commands):
-            commands.remove('/Zi')
         # Compile args added from the env: CFLAGS/CXXFLAGS, etc, or the cross
         # file. We want these to override all the defaults, but not the
         # per-target compile args.
         commands += self.environment.coredata.get_external_args(target.for_machine, compiler.get_language())
+        # Using both /Z7 or /ZI and /Zi at the same times produces a compiler warning.
+        # We do not add /Z7 or /ZI by default. If it is being used it is because the user has explicitly enabled it.
+        # /Zi needs to be removed in that case to avoid cl's warning to that effect (D9025 : overriding '/Zi' with '/ZI')
+        if ('/Zi' in commands) and (('/ZI' in commands) or ('/Z7' in commands)):
+            commands.remove('/Zi')
         # Always set -fPIC for shared libraries
         if isinstance(target, build.SharedLibrary):
             commands += compiler.get_pic_args()
@@ -1073,7 +1059,7 @@
         tests.
         """
         result: T.Setstr = set()
-        prospectives: T.Setbuild.Target = set()
+        prospectives: T.Setbuild.BuildTargetTypes = set()
         if isinstance(target, build.BuildTarget):
             prospectives.update(target.get_transitive_link_deps())
             # External deps
@@ -1122,10 +1108,7 @@
                         break
 
             is_cross = self.environment.is_cross_build(test_for_machine)
-            if is_cross and self.environment.need_exe_wrapper():
-                exe_wrapper = self.environment.get_exe_wrapper()
-            else:
-                exe_wrapper = None
+            exe_wrapper = self.environment.get_exe_wrapper()
             machine = self.environment.machinesexe.for_machine
             if machine.is_windows() or machine.is_cygwin():
                 extra_bdeps: T.ListT.Unionbuild.BuildTarget, build.CustomTarget = 
@@ -1156,14 +1139,28 @@
                     cmd_args.extend(self.construct_target_rel_paths(a, t.workdir))
                 else:
                     raise MesonException('Bad object in test command.')
+
+            t_env = copy.deepcopy(t.env)
+            if not machine.is_windows() and not machine.is_cygwin() and not machine.is_darwin():
+                ld_lib_path: T.Setstr = set()
+                for d in depends:
+                    if isinstance(d, build.BuildTarget):
+                        for l in d.get_all_link_deps():
+                            if isinstance(l, build.SharedLibrary):
+                                ld_lib_path.add(os.path.join(self.environment.get_build_dir(), l.get_subdir()))
+                if ld_lib_path:
+                    t_env.prepend('LD_LIBRARY_PATH', list(ld_lib_path), ':')
+
             ts = TestSerialisation(t.get_name(), t.project_name, t.suite, cmd, is_cross,
                                    exe_wrapper, self.environment.need_exe_wrapper(),
-                                   t.is_parallel, cmd_args, t.env,
+                                   t.is_parallel, cmd_args, t_env,
                                    t.should_fail, t.timeout, t.workdir,
                                    extra_paths, t.protocol, t.priority,
+                                   isinstance(exe, build.Target),
                                    isinstance(exe, build.Executable),
                                    x.get_id() for x in depends,
-                                   self.environment.coredata.version)
+                                   self.environment.coredata.version,
+                                   t.verbose)
             arr.append(ts)
         return arr
 
@@ -1207,7 +1204,7 @@
         '''List of all files whose alteration means that the build
         definition needs to be regenerated.'''
         deps = OrderedSet(str(Path(self.build_to_src) / df)
-                for df in self.interpreter.get_build_def_files())
+                           for df in self.interpreter.get_build_def_files())
         if self.environment.is_cross_build():
             deps.update(self.environment.coredata.cross_files)
         deps.update(self.environment.coredata.config_files)
@@ -1276,10 +1273,12 @@
         for name, b in self.build.get_targets().items():
             if b.build_by_default:
                 resultname = b
-        # Get all targets used as test executables and arguments. These must
-        # also be built by default. XXX: Sometime in the future these should be
-        # built only before running tests.
-        for t in self.build.get_tests():
+        return result
+
+    def get_testlike_targets(self, benchmark: bool = False) -> T.OrderedDictstr, T.Unionbuild.BuildTarget, build.CustomTarget:
+        result: T.OrderedDictstr, T.Unionbuild.BuildTarget, build.CustomTarget = OrderedDict()
+        targets = self.build.get_benchmarks() if benchmark else self.build.get_tests()
+        for t in targets:
             exe = t.exe
             if isinstance(exe, (build.CustomTarget, build.BuildTarget)):
                 resultexe.get_id() = exe
@@ -1309,10 +1308,6 @@
             libs.extend(self.get_custom_target_provided_by_generated_source(t))
         return libs
 
-    def is_unity(self, target: build.BuildTarget) -> bool:
-        optval = self.get_option_for_target(OptionKey('unity'), target)
-        return optval == 'on' or (optval == 'subprojects' and target.subproject != '')
-
     def get_custom_target_sources(self, target: build.CustomTarget) -> T.Liststr:
         '''
         Custom target sources can be of various object types; strings, File,
@@ -1330,8 +1325,11 @@
             elif isinstance(i, build.GeneratedList):
                 fname = os.path.join(self.get_target_private_dir(target), p) for p in i.get_outputs()
             elif isinstance(i, build.ExtractedObjects):
-                outputs = i.get_outputs(self)
-                fname = self.get_extracted_obj_paths(i.target, outputs)
+                fname = self.determine_ext_objs(i)
+            elif isinstance(i, programs.ExternalProgram):
+                assert i.found(), "This shouldn't be possible"
+                assert i.path is not None, 'for mypy'
+                fname = i.path
             else:
                 fname = i.rel_to_builddir(self.build_to_src)
             if target.absolute_paths:
@@ -1339,9 +1337,6 @@
             srcs += fname
         return srcs
 
-    def get_extracted_obj_paths(self, target: build.BuildTarget, outputs: T.Liststr) -> T.Liststr:
-        return os.path.join(self.get_target_private_dir(target), p) for p in outputs
-
     def get_custom_target_depend_files(self, target: build.CustomTarget, absolute_paths: bool = False) -> T.Liststr:
         deps: T.Liststr = 
         for i in target.depend_files:
@@ -1400,7 +1395,7 @@
 
     def eval_custom_target_command(
             self, target: build.CustomTarget, absolute_outputs: bool = False) -> \
-                T.TupleT.Liststr, T.Liststr, T.Liststr:
+            T.TupleT.Liststr, T.Liststr, T.Liststr:
         # We want the outputs to be absolute only when using the VS backend
         # XXX: Maybe allow the vs backend to use relative paths too?
         source_root = self.build_to_src
@@ -1478,11 +1473,12 @@
 
     def get_run_target_env(self, target: build.RunTarget) -> build.EnvironmentVariables:
         env = target.env if target.env else build.EnvironmentVariables()
-        introspect_cmd = join_args(self.environment.get_build_command() + 'introspect')
-        env.set('MESON_SOURCE_ROOT', self.environment.get_source_dir())
-        env.set('MESON_BUILD_ROOT', self.environment.get_build_dir())
-        env.set('MESON_SUBDIR', target.subdir)
-        env.set('MESONINTROSPECT', introspect_cmd)
+        if target.default_env:
+            introspect_cmd = join_args(self.environment.get_build_command() + 'introspect')
+            env.set('MESON_SOURCE_ROOT', self.environment.get_source_dir())
+            env.set('MESON_BUILD_ROOT', self.environment.get_build_dir())
+            env.set('MESON_SUBDIR', target.subdir)
+            env.set('MESONINTROSPECT', introspect_cmd)
         return env
 
     def run_postconf_scripts(self) -> None:
@@ -1498,6 +1494,7 @@
             mlog.log(f'Running postconf script {name!r}')
             run_exe(s, env)
 
+    @lru_cache(maxsize=1)
     def create_install_data(self) -> InstallData:
         strip_bin = self.environment.lookup_binary_entry(MachineChoice.HOST, 'strip')
         if strip_bin is None:
@@ -1517,8 +1514,7 @@
                         strip_bin,
                         umask,
                         self.environment.get_build_command() + 'introspect',
-                        self.environment.coredata.version,
-                        self.environment.is_cross_build())
+                        self.environment.coredata.version)
         self.generate_depmf_install(d)
         self.generate_target_install(d)
         self.generate_header_install(d)
@@ -1555,6 +1551,10 @@
             return 'devel'
         elif localedir in dest_path.parents:
             return 'i18n'
+        elif 'installed-tests' in dest_path.parts:
+            return 'tests'
+        elif 'systemtap' in dest_path.parts:
+            return 'systemtap'
         mlog.debug('Failed to guess install tag for', dest_path)
         return None
 
@@ -1562,16 +1562,20 @@
         for t in self.build.get_targets().values():
             if not t.should_install():
                 continue
-            outdirs, install_dir_name, custom_install_dir = t.get_install_dir(self.environment)
+            outdirs, install_dir_names, custom_install_dir = t.get_install_dir()
             # Sanity-check the outputs and install_dirs
             num_outdirs, num_out = len(outdirs), len(t.get_outputs())
-            if num_outdirs != 1 and num_outdirs != num_out:
+            if num_outdirs not in {1, num_out}:
                 m = 'Target {!r} has {} outputs: {!r}, but only {} "install_dir"s were found.\n' \
                     "Pass 'false' for outputs that should not be installed and 'true' for\n" \
                     'using the default installation directory for an output.'
                 raise MesonException(m.format(t.name, num_out, t.get_outputs(), num_outdirs))
             assert len(t.install_tag) == num_out
             install_mode = t.get_custom_install_mode()
+            # because mypy gets confused type narrowing in lists
+            first_outdir = outdirs0
+            first_outdir_name = install_dir_names0
+
             # Install the target output(s)
             if isinstance(t, build.BuildTarget):
                 # In general, stripping static archives is tricky and full of pitfalls.
@@ -1587,20 +1591,26 @@
                 #
                 # TODO: Create GNUStrip/AppleStrip/etc. hierarchy for more
                 #       fine-grained stripping of static archives.
-                should_strip = not isinstance(t, build.StaticLibrary) and self.get_option_for_target(OptionKey('strip'), t)
+                can_strip = not isinstance(t, build.StaticLibrary)
+                should_strip = can_strip and t.get_option(OptionKey('strip'))
                 assert isinstance(should_strip, bool), 'for mypy'
                 # Install primary build output (library/executable/jar, etc)
                 # Done separately because of strip/aliases/rpath
-                if outdirs0 is not False:
+                if first_outdir is not False:
                     tag = t.install_tag0 or ('devel' if isinstance(t, build.StaticLibrary) else 'runtime')
-                    mappings = t.get_link_deps_mapping(d.prefix, self.environment)
-                    i = TargetInstallData(self.get_target_filename(t), outdirs0,
-                                          install_dir_name, t.get_aliases(),
+                    mappings = t.get_link_deps_mapping(d.prefix)
+                    i = TargetInstallData(self.get_target_filename(t), first_outdir,
+                                          first_outdir_name,
                                           should_strip, mappings, t.rpath_dirs_to_remove,
                                           t.install_rpath, install_mode, t.subproject,
-                                          tag=tag)
+                                          tag=tag, can_strip=can_strip)
                     d.targets.append(i)
 
+                    for alias, to, tag in t.get_aliases():
+                        alias = os.path.join(first_outdir, alias)
+                        s = InstallSymlinkData(to, alias, first_outdir, t.subproject, tag, allow_missing=True)
+                        d.symlinks.append(s)
+
                     if isinstance(t, (build.SharedLibrary, build.SharedModule, build.Executable)):
                         # On toolchains/platforms that use an import library for
                         # linking (separate from the shared library with all the
@@ -1610,33 +1620,33 @@
                                 # If the DLL is installed into a custom directory,
                                 # install the import library into the same place so
                                 # it doesn't go into a surprising place
-                                implib_install_dir = outdirs0
+                                implib_install_dir = first_outdir
                             else:
                                 implib_install_dir = self.environment.get_import_lib_dir()
                             # Install the import library; may not exist for shared modules
                             i = TargetInstallData(self.get_target_filename_for_linking(t),
-                                                  implib_install_dir, install_dir_name,
-                                                  {}, False, {}, set(), '', install_mode,
+                                                  implib_install_dir, first_outdir_name,
+                                                  False, {}, set(), '', install_mode,
                                                   t.subproject, optional=isinstance(t, build.SharedModule),
                                                   tag='devel')
                             d.targets.append(i)
 
                         if not should_strip and t.get_debug_filename():
                             debug_file = os.path.join(self.get_target_dir(t), t.get_debug_filename())
-                            i = TargetInstallData(debug_file, outdirs0,
-                                                  install_dir_name,
-                                                  {}, False, {}, set(), '',
+                            i = TargetInstallData(debug_file, first_outdir,
+                                                  first_outdir_name,
+                                                  False, {}, set(), '',
                                                   install_mode, t.subproject,
                                                   optional=True, tag='devel')
                             d.targets.append(i)
                 # Install secondary outputs. Only used for Vala right now.
                 if num_outdirs > 1:
-                    for output, outdir, tag in zip(t.get_outputs()1:, outdirs1:, t.install_tag1:):
+                    for output, outdir, outdir_name, tag in zip(t.get_outputs()1:, outdirs1:, install_dir_names1:, t.install_tag1:):
                         # User requested that we not install this output
                         if outdir is False:
                             continue
                         f = os.path.join(self.get_target_dir(t), output)
-                        i = TargetInstallData(f, outdir, install_dir_name, {}, False, {}, set(), None,
+                        i = TargetInstallData(f, outdir, outdir_name, False, {}, set(), None,
                                               install_mode, t.subproject,
                                               tag=tag)
                         d.targets.append(i)
@@ -1648,32 +1658,37 @@
                 #
                 # To selectively install only some outputs, pass `false` as
                 # the install_dir for the corresponding output by index
+                #
+                # XXX: this wouldn't be needed if we just always matches outdirs
+                # to the length of outputs…
                 if num_outdirs == 1 and num_out > 1:
-                    for output, tag in zip(t.get_outputs(), t.install_tag):
-                        f = os.path.join(self.get_target_dir(t), output)
-                        if not install_dir_name:
-                            dir_name = os.path.join('{prefix}', outdirs0)
-                        i = TargetInstallData(f, outdirs0, dir_name, {},
-                                              False, {}, set(), None, install_mode,
-                                              t.subproject, optional=not t.build_by_default,
-                                              tag=tag)
-                        d.targets.append(i)
+                    if first_outdir is not False:
+                        for output, tag in zip(t.get_outputs(), t.install_tag):
+                            tag = tag or self.guess_install_tag(output, first_outdir)
+                            f = os.path.join(self.get_target_dir(t), output)
+                            i = TargetInstallData(f, first_outdir, first_outdir_name,
+                                                  False, {}, set(), None, install_mode,
+                                                  t.subproject, optional=not t.build_by_default,
+                                                  tag=tag)
+                            d.targets.append(i)
                 else:
-                    for output, outdir, tag in zip(t.get_outputs(), outdirs, t.install_tag):
+                    for output, outdir, outdir_name, tag in zip(t.get_outputs(), outdirs, install_dir_names, t.install_tag):
                         # User requested that we not install this output
                         if outdir is False:
                             continue
+                        tag = tag or self.guess_install_tag(output, outdir)
                         f = os.path.join(self.get_target_dir(t), output)
-                        if not install_dir_name:
-                            dir_name = os.path.join('{prefix}', outdir)
-                        i = TargetInstallData(f, outdir, dir_name,
-                                              {}, False, {}, set(), None, install_mode,
+                        i = TargetInstallData(f, outdir, outdir_name,
+                                              False, {}, set(), None, install_mode,
                                               t.subproject, optional=not t.build_by_default,
                                               tag=tag)
                         d.targets.append(i)
 
     def generate_custom_install_script(self, d: InstallData) -> None:
         d.install_scripts = self.build.install_scripts
+        for i in d.install_scripts:
+            if not i.tag:
+                mlog.debug('Failed to guess install tag for install script:', ' '.join(i.cmd_args))
 
     def generate_header_install(self, d: InstallData) -> None:
         incroot = self.environment.get_includedir()
@@ -1723,7 +1738,8 @@
     def generate_emptydir_install(self, d: InstallData) -> None:
         emptydir: T.Listbuild.EmptyDir = self.build.get_emptydir()
         for e in emptydir:
-            i = InstallEmptyDir(e.path, e.install_mode, e.subproject, e.install_tag)
+            tag = e.install_tag or self.guess_install_tag(e.path)
+            i = InstallEmptyDir(e.path, e.install_mode, e.subproject, tag)
             d.emptydir.append(i)
 
     def generate_data_install(self, d: InstallData) -> None:
@@ -1752,7 +1768,8 @@
             assert isinstance(l, build.SymlinkData)
             install_dir = l.install_dir
             name_abs = os.path.join(install_dir, l.name)
-            s = InstallSymlinkData(l.target, name_abs, install_dir, l.subproject, l.install_tag)
+            tag = l.install_tag or self.guess_install_tag(name_abs)
+            s = InstallSymlinkData(l.target, name_abs, install_dir, l.subproject, tag)
             d.symlinks.append(s)
 
     def generate_subdir_install(self, d: InstallData) -> None:
@@ -1767,10 +1784,13 @@
             dst_dir = os.path.join(self.environment.get_prefix(),
                                    sd.install_dir)
             dst_name = os.path.join('{prefix}', sd.install_dir)
+            if sd.install_dir != sd.install_dir_name:
+                dst_name = sd.install_dir_name
             if not sd.strip_directory:
                 dst_dir = os.path.join(dst_dir, os.path.basename(src_dir))
-                dst_name = os.path.join(dst_dir, os.path.basename(src_dir))
-            i = SubdirInstallData(src_dir, dst_dir, dst_name, sd.install_mode, sd.exclude, sd.subproject, sd.install_tag)
+                dst_name = os.path.join(dst_name, os.path.basename(src_dir))
+            tag = sd.install_tag or self.guess_install_tag(os.path.join(sd.install_dir, 'dummy'))
+            i = SubdirInstallData(src_dir, dst_dir, dst_name, sd.install_mode, sd.exclude, sd.subproject, tag)
             d.install_subdirs.append(i)
 
     def get_introspection_data(self, target_id: str, target: build.Target) -> T.List'TargetIntrospectionData':
@@ -1798,7 +1818,7 @@
                     source_list += os.path.join(self.source_dir, j)
                 elif isinstance(j, (build.CustomTarget, build.BuildTarget)):
                     source_list += os.path.join(self.build_dir, j.get_subdir(), o) for o in j.get_outputs()
-            source_list = list(map(lambda x: os.path.normpath(x), source_list))
+            source_list = os.path.normpath(s) for s in source_list
 
             compiler: T.Liststr = 
             if isinstance(target, build.CustomTarget):
@@ -1827,11 +1847,12 @@
         env = build.EnvironmentVariables()
         extra_paths = set()
         library_paths = set()
+        build_machine = self.environment.machinesMachineChoice.BUILD
+        host_machine = self.environment.machinesMachineChoice.HOST
+        need_wine = not build_machine.is_windows() and host_machine.is_windows()
         for t in self.build.get_targets().values():
-            cross_built = not self.environment.machines.matches_build_machine(t.for_machine)
-            can_run = not cross_built or not self.environment.need_exe_wrapper()
-            in_default_dir = t.should_install() and not t.get_install_dir(self.environment)2
-            if not can_run or not in_default_dir:
+            in_default_dir = t.should_install() and not t.get_install_dir()2
+            if t.for_machine != MachineChoice.HOST or not in_default_dir:
                 continue
             tdir = os.path.join(self.environment.get_build_dir(), self.get_target_dir(t))
             if isinstance(t, build.Executable):
@@ -1839,20 +1860,55 @@
                 # so they get used by default instead of searching on system when
                 # in developer environment.
                 extra_paths.add(tdir)
-                if mesonlib.is_windows() or mesonlib.is_cygwin():
+                if host_machine.is_windows() or host_machine.is_cygwin():
                     # On windows we cannot rely on rpath to run executables from build
                     # directory. We have to add in PATH the location of every DLL needed.
-                    extra_paths.update(self.determine_windows_extra_paths(t, ))
+                    library_paths.update(self.determine_windows_extra_paths(t, ))
             elif isinstance(t, build.SharedLibrary):
                 # Add libraries that are going to be installed in libdir into
                 # LD_LIBRARY_PATH. This allows running system applications using
                 # that library.
                 library_paths.add(tdir)
-        if mesonlib.is_windows() or mesonlib.is_cygwin():
-            extra_paths.update(library_paths)
-        elif mesonlib.is_osx():
-            env.prepend('DYLD_LIBRARY_PATH', list(library_paths))
-        else:
-            env.prepend('LD_LIBRARY_PATH', list(library_paths))
-        env.prepend('PATH', list(extra_paths))
+        if need_wine:
+            # Executable paths should be in both PATH and WINEPATH.
+            # - Having them in PATH makes bash completion find it,
+            #   and make running "foo.exe" find it when wine-binfmt is installed.
+            # - Having them in WINEPATH makes "wine foo.exe" find it.
+            library_paths.update(extra_paths)
+        if library_paths:
+            if need_wine:
+                env.prepend('WINEPATH', list(library_paths), separator=';')
+            elif host_machine.is_windows() or host_machine.is_cygwin():
+                extra_paths.update(library_paths)
+            elif host_machine.is_darwin():
+                env.prepend('DYLD_LIBRARY_PATH', list(library_paths))
+            else:
+                env.prepend('LD_LIBRARY_PATH', list(library_paths))
+        if extra_paths:
+            env.prepend('PATH', list(extra_paths))
         return env
+
+    def compiler_to_generator(self, target: build.BuildTarget,
+                              compiler: 'Compiler',
+                              sources: _ALL_SOURCES_TYPE,
+                              output_templ: str) -> build.GeneratedList:
+        '''
+        Some backends don't support custom compilers. This is a convenience
+        method to convert a Compiler to a Generator.
+        '''
+        exelist = compiler.get_exelist()
+        exe = programs.ExternalProgram(exelist0)
+        args = exelist1:
+        # FIXME: There are many other args missing
+        commands = self.generate_basic_compiler_args(target, compiler)
+        commands += compiler.get_dependency_gen_args('@OUTPUT@', '@DEPFILE@')
+        commands += compiler.get_output_args('@OUTPUT@')
+        commands += compiler.get_compile_only_args() + '@INPUT@'
+        commands += self.get_source_dir_include_args(target, compiler)
+        commands += self.get_build_dir_include_args(target, compiler)
+        generator = build.Generator(exe, args + commands.to_native(), output_templ, depfile='@PLAINNAME@.d')
+        return generator.process_files(sources, self.interpreter)
+
+    def compile_target_to_generator(self, target: build.CompileTarget) -> build.GeneratedList:
+        all_sources = T.cast('_ALL_SOURCES_TYPE', target.sources) + T.cast('_ALL_SOURCES_TYPE', target.generated)
+        return self.compiler_to_generator(target, target.compiler, all_sources, target.output_templ)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/backend/ninjabackend.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/backend/ninjabackend.py Changed

@@ -11,8 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from collections import OrderedDict
+from dataclasses import dataclass
 from enum import Enum, unique
 from functools import lru_cache
 from pathlib import PurePath, Path
@@ -28,18 +30,13 @@
 
 from . import backends
 from .. import modules
+from ..modules import gnome
 from .. import environment, mesonlib
 from .. import build
 from .. import mlog
 from .. import compilers
 from ..arglist import CompilerArgs
-from ..compilers import (
- Compiler, CCompiler,
- FortranCompiler,
- mixins,
- PGICCompiler,
- VisualStudioLikeCompiler,
-)
+from ..compilers import Compiler
 from ..linkers import ArLinker, RSPFileSyntax
 from ..mesonlib import (
 File, LibType, MachineChoice, MesonException, OrderedSet, PerMachine,
@@ -47,13 +44,19 @@
 )
 from ..mesonlib import get_compiler_for_source, has_path_sep, OptionKey
 from .backends import CleanTrees
-from ..build import GeneratedList, InvalidArguments, ExtractedObjects
-from ..interpreter import Interpreter
+from ..build import GeneratedList, InvalidArguments
 
 if T.TYPE_CHECKING:
+ from typing_extensions import Literal
+
 from .._typing import ImmutableListProtocol
+ from ..build import ExtractedObjects
+ from ..interpreter import Interpreter
 from ..linkers import DynamicLinker, StaticLinker
 from ..compilers.cs import CsCompiler
+ from ..compilers.fortran import FortranCompiler
+
+ RUST_EDITIONS = Literal'2015', '2018', '2021'
 
 
 FORTRAN_INCLUDE_PAT = r"^\s*#?include\s*'\"(\w+\.\w+)'\""
@@ -206,8 +209,8 @@
 return NinjaCommandArg(c)
 
 self.name = rule
- self.command = list(map(strToCommandArg, command)) # includes args which never go into a rspfile
- self.args = list(map(strToCommandArg, args)) # args which will go into a rspfile, if used
+ self.command = strToCommandArg(c) for c in command # includes args which never go into a rspfile
+ self.args = strToCommandArg(a) for a in args # args which will go into a rspfile, if used
 self.description = description
 self.deps = deps # depstyle 'gcc' or 'msvc'
 self.depfile = depfile
@@ -311,6 +314,7 @@
 self.orderdeps = OrderedSet()
 self.elems = 
 self.all_outputs = all_outputs
+ self.output_errors = ''
 
 def add_dep(self, dep):
 if isinstance(dep, list):
@@ -359,7 +363,8 @@
 self.rule.refcount += 1
 
 def write(self, outfile):
- self.check_outputs()
+ if self.output_errors:
+ raise MesonException(self.output_errors)
 ins = ' '.join(ninja_quote(i, True) for i in self.infilenames)
 outs = ' '.join(ninja_quote(i, True) for i in self.outfilenames)
 implicit_outs = ' '.join(ninja_quote(i, True) for i in self.implicit_outfilenames)
@@ -418,9 +423,59 @@
 def check_outputs(self):
 for n in self.outfilenames:
 if n in self.all_outputs:
- raise MesonException(f'Multiple producers for Ninja target "{n}". Please rename your targets.')
+ self.output_errors = f'Multiple producers for Ninja target "{n}". Please rename your targets.'
 self.all_outputsn = True
 
+@dataclass
+class RustDep:
+
+ name: str
+
+ # equal to the order value of the `RustCrate`
+ crate: int
+
+ def to_json(self) -> T.Dictstr, object:
+ return {
+ "crate": self.crate,
+ "name": self.name,
+ }
+
+@dataclass
+class RustCrate:
+
+ # When the json file is written, the list of Crates will be sorted by this
+ # value
+ order: int
+
+ display_name: str
+ root_module: str
+ edition: RUST_EDITIONS
+ deps: T.ListRustDep
+ cfg: T.Liststr
+ is_proc_macro: bool
+
+ # This is set to True for members of this project, and False for all
+ # subprojects
+ is_workspace_member: bool
+ proc_macro_dylib_path: T.Optionalstr = None
+
+ def to_json(self) -> T.Dictstr, object:
+ ret: T.Dictstr, object = {
+ "display_name": self.display_name,
+ "root_module": self.root_module,
+ "edition": self.edition,
+ "cfg": self.cfg,
+ "is_proc_macro": self.is_proc_macro,
+ "deps": d.to_json() for d in self.deps,
+ }
+
+ if self.is_proc_macro:
+ assert self.proc_macro_dylib_path is not None, "This shouldn't happen"
+ ret"proc_macro_dylib_path" = self.proc_macro_dylib_path
+
+ return ret
+
+
 class NinjaBackend(backends.Backend):
 
 def __init__(self, build: T.Optionalbuild.Build, interpreter: T.OptionalInterpreter):
@@ -431,19 +486,25 @@
 self.all_outputs = {}
 self.introspection_data = {}
 self.created_llvm_ir_rule = PerMachine(False, False)
+ self.rust_crates: T.Dictstr, RustCrate = {}
 
- def create_target_alias(self, to_target):
- # We need to use aliases for targets that might be used as directory
- # names to workaround a Ninja bug that breaks `ninja -t clean`.
- # This is used for 'reserved' targets such as 'test', 'install',
- # 'benchmark', etc, and also for RunTargets.
- # https://github.com/mesonbuild/meson/issues/1644
- if not to_target.startswith('meson-'):
- raise AssertionError(f'Invalid usage of create_target_alias with {to_target!r}')
- from_target = to_targetlen('meson-'):
- elem = NinjaBuildElement(self.all_outputs, from_target, 'phony', to_target)
+ def create_phony_target(self, all_outputs, dummy_outfile, rulename, phony_infilename, implicit_outs=None):
+ '''
+ We need to use aliases for targets that might be used as directory
+ names to workaround a Ninja bug that breaks `ninja -t clean`.
+ This is used for 'reserved' targets such as 'test', 'install',
+ 'benchmark', etc, and also for RunTargets.
+ https://github.com/mesonbuild/meson/issues/1644
+ '''
+ if dummy_outfile.startswith('meson-internal__'):
+ raise AssertionError(f'Invalid usage of create_phony_target with {dummy_outfile!r}')
+
+ to_name = f'meson-internal__{dummy_outfile}'
+ elem = NinjaBuildElement(all_outputs, dummy_outfile, 'phony', to_name)
 self.add_build(elem)
 
+ return NinjaBuildElement(all_outputs, to_name, rulename, phony_infilename, implicit_outs)
+
 def detect_vs_dep_prefix(self, tempfilename):
 '''VS writes its dependency in a locale dependent format.
 Detect the search prefix to use.'''
@@ -451,19 +512,20 @@
 for compiler in self.environment.coredata.compilers.host.values():
 # Have to detect the dependency format
 
- # IFort on windows is MSVC like, but doesn't have /showincludes
- if isinstance(compiler, FortranCompiler):
+ # IFort / masm on windows is MSVC like, but doesn't have /showincludes
+ if compiler.language in {'fortran', 'masm'}:
 continue
- if isinstance(compiler, PGICCompiler) and mesonlib.is_windows():
+ if compiler.id == 'pgi' and mesonlib.is_windows():
 # for the purpose of this function, PGI doesn't act enough like MSVC
 return open(tempfilename, 'a', encoding='utf-8')
- if isinstance(compiler, VisualStudioLikeCompiler):
+ if compiler.get_argument_syntax() == 'msvc':
 break
 else:
 # None of our compilers are MSVC, we're done.
 return open(tempfilename, 'a', encoding='utf-8')
+ filebase = 'incdetect.' + compilers.lang_suffixescompiler.language0
 filename = os.path.join(self.environment.get_scratch_dir(),
- 'incdetect.c')
+ filebase)
 with open(filename, 'w', encoding='utf-8') as f:
 f.write(dedent('''\
 #include<stdio.h>
@@ -475,7 +537,7 @@
 # Python strings leads to failure. We _must_ do this detection
 # in raw byte mode and write the result in raw bytes.
 pc = subprocess.Popen(compiler.get_exelist() +
- '/showIncludes', '/c', 'incdetect.c',
+ '/showIncludes', '/c', filebase,
 cwd=self.environment.get_scratch_dir(),
 stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 (stdout, stderr) = pc.communicate()
@@ -491,7 +553,7 @@
 # use backslashes, but without the leading drive name, so
 # allow the path to start with any path separator, i.e.
 # \MyDir\include\stdio.h.
- matchre = re.compile(rb"^(.*\s)(a-zA-Z:\\|\\\/).*stdio.h$")
+ matchre = re.compile(rb"^(.*\s)(a-zA-Z:\\/|\\\/).*stdio.h$")
 
 def detect_prefix(out):
 for line in re.split(rb'\r?\n', out):
@@ -508,7 +570,7 @@
 if result:
 return result
 
- raise MesonException('Could not determine vs dep dependency prefix string.')
+ raise MesonException(f'Could not determine vs dep dependency prefix string. output: {stderr} {stdout}')
 
 def generate(self):
 ninja = environment.detect_ninja_command_and_version(log=True)
@@ -585,6 +647,21 @@
 subprocess.call(self.ninja_command + '-t', 'restat')
 subprocess.call(self.ninja_command + '-t', 'cleandead')
 self.generate_compdb()
+ self.generate_rust_project_json()
+
+ def generate_rust_project_json(self) -> None:
+ """Generate a rust-analyzer compatible rust-project.json file."""
+ if not self.rust_crates:
+ return
+ with open(os.path.join(self.environment.get_build_dir(), 'rust-project.json'),
+ 'w', encoding='utf-8') as f:
+ json.dump(
+ {
+ "sysroot_src": os.path.join(self.environment.coredata.compilers.host'rust'.get_sysroot(),
+ 'lib/rustlib/src/rust/library/'),
+ "crates": c.to_json() for c in self.rust_crates.values(),
+ },
+ f, indent=4)
 
 # http://clang.llvm.org/docs/JSONCompilationDatabase.html
 def generate_compdb(self):
@@ -592,10 +669,10 @@
 # TODO: Rather than an explicit list here, rules could be marked in the
 # rule store as being wanted in compdb
 for for_machine in MachineChoice:
- for lang in self.environment.coredata.compilersfor_machine:
- rules += f"{rule}{ext}" for rule in self.get_compiler_rule_name(lang, for_machine)
+ for compiler in self.environment.coredata.compilersfor_machine.values():
+ rules += f"{rule}{ext}" for rule in self.compiler_to_rule_name(compiler)
 for ext in '', '_RSP'
- rules += f"{rule}{ext}" for rule in self.get_pch_rule_name(lang, for_machine)
+ rules += f"{rule}{ext}" for rule in self.compiler_to_pch_rule_name(compiler)
 for ext in '', '_RSP'
 compdb_options = '-x' if mesonlib.version_compare(self.ninja_version, '>=1.9') else 
 ninja_compdb = self.ninja_command + '-t', 'compdb' + compdb_options + rules
@@ -633,14 +710,14 @@
 def get_target_generated_sources(self, target: build.BuildTarget) -> T.MutableMappingstr, File:
 """
 Returns a dictionary with the keys being the path to the file
- (relative to the build directory) of that type and the value
- being the GeneratorList or CustomTarget that generated it.
+ (relative to the build directory) and the value being the File object
+ representing the same path.
 """
 srcs: T.MutableMappingstr, File = OrderedDict()
 for gensrc in target.get_generated_sources():
 for s in gensrc.get_outputs():
- f = self.get_target_generated_dir(target, gensrc, s)
- srcsf = s
+ rel_src = self.get_target_generated_dir(target, gensrc, s)
+ srcsrel_src = File.from_built_relative(rel_src)
 return srcs
 
 def get_target_sources(self, target: build.BuildTarget) -> T.MutableMappingstr, File:
@@ -784,7 +861,7 @@
 # Generate rules for building the remaining source files in this target
 outname = self.get_target_filename(target)
 obj_list = 
- is_unity = self.is_unity(target)
+ is_unity = target.is_unity
 header_deps = 
 unity_src = 
 unity_deps = # Generated sources that must be built before compiling a Unity target.
@@ -807,9 +884,8 @@
 # same time, also deal with generated sources that need to be compiled.
 generated_source_files = 
 for rel_src in generated_sources.keys():
- dirpart, fnamepart = os.path.split(rel_src)
- raw_src = File(True, dirpart, fnamepart)
- if self.environment.is_source(rel_src) and not self.environment.is_header(rel_src):
+ raw_src = File.from_built_relative(rel_src)
+ if self.environment.is_source(rel_src):
 if is_unity and self.get_target_source_can_unity(target, rel_src):
 unity_deps.append(raw_src)
 abs_src = os.path.join(self.environment.get_build_dir(), rel_src)
@@ -825,6 +901,11 @@
 # people generate files with weird suffixes (.inc, .fh) that they then include
 # in their source files.
 header_deps.append(raw_src)
+
+ # For D language, the object of generated source files are added
+ # as order only deps because other files may depend on them
+ d_generated_deps = 
+
 # These are the generated source files that need to be built for use by
 # this target. We create the Ninja build file elements for this here
 # because we need `header_deps` to be fully generated in the above loop.
@@ -837,6 +918,8 @@
 compiled_sources.append(s)
 source2objects = o
 obj_list.append(o)
+ if s.split('.')-1 in compilers.lang_suffixes'd':
+ d_generated_deps.append(o)
 
 use_pch = self.environment.coredata.options.get(OptionKey('b_pch'))
 if use_pch and target.has_pch():
@@ -844,6 +927,16 @@
 else:
 pch_objects = 
 
+ o, od = self.flatten_object_list(target)
+ obj_targets = t for t in od if t.uses_fortran()
+ obj_list.extend(o)
+
+ fortran_order_deps = self.get_target_filename(t) for t in obj_targets
+ fortran_inc_args: T.Liststr = 
+ if target.uses_fortran():
+ fortran_inc_args = mesonlib.listify(target.compilers'fortran'.get_include_args(
+ self.get_target_private_dir(t), is_system=False) for t in obj_targets)
+
 # Generate compilation targets for C sources generated from Vala
 # sources. This can be extended to other $LANG->C compilers later if
 # necessary. This needs to be separate for at least Vala
@@ -852,8 +945,7 @@
 # often contain duplicate symbols and will fail to compile properly
 vala_generated_source_files = 
 for src in transpiled_sources:
- dirpart, fnamepart = os.path.split(src)
- raw_src = File(True, dirpart, fnamepart)
+ raw_src = File.from_built_relative(src)
 # Generated targets are ordered deps because the must exist
 # before the sources compiling them are used. After the first
 # compile we get precise dependency info from dep files.
@@ -883,25 +975,30 @@
 src.rel_to_builddir(self.build_to_src))
 unity_src.append(abs_src)
 else:
- o, s = self.generate_single_compile(target, src, False, , header_deps)
+ o, s = self.generate_single_compile(target, src, False, ,
+ header_deps + d_generated_deps + fortran_order_deps,
+ fortran_inc_args)
 obj_list.append(o)
 compiled_sources.append(s)
 source2objects = o
 
- obj_list += self.flatten_object_list(target)
 if is_unity:
 for src in self.generate_unity_files(target, unity_src):
- o, s = self.generate_single_compile(target, src, True, unity_deps + header_deps)
+ o, s = self.generate_single_compile(target, src, True, unity_deps + header_deps + d_generated_deps,
+ fortran_order_deps, fortran_inc_args)
 obj_list.append(o)
 compiled_sources.append(s)
 source2objects = o
+ if isinstance(target, build.CompileTarget):
+ # Skip the link stage for this special type of target
+ return
 linker, stdlib_args = self.determine_linker_and_stdlib_args(target)
 if isinstance(target, build.StaticLibrary) and target.prelink:
 final_obj_list = self.generate_prelink(target, obj_list)
 else:
 final_obj_list = obj_list
 elem = self.generate_link(target, outname, final_obj_list, linker, pch_objects, stdlib_args=stdlib_args)
- self.generate_dependency_scan_target(target, compiled_sources, source2object, generated_source_files)
+ self.generate_dependency_scan_target(target, compiled_sources, source2object, generated_source_files, fortran_order_deps)
 self.add_build(elem)
 
 def should_use_dyndeps_for_target(self, target: 'build.BuildTarget') -> bool:
@@ -911,6 +1008,8 @@
 return True
 if 'cpp' not in target.compilers:
 return False
+ if '-fmodules-ts' in target.extra_args.get('cpp', ):
+ return True
 # Currently only the preview version of Visual Studio is supported.
 cpp = target.compilers'cpp'
 if cpp.get_id() != 'msvc':
@@ -924,7 +1023,8 @@
 return False
 return True
 
- def generate_dependency_scan_target(self, target, compiled_sources, source2object, generated_source_files: T.Listmesonlib.File):
+ def generate_dependency_scan_target(self, target, compiled_sources, source2object, generated_source_files: T.Listmesonlib.File,
+ object_deps: T.Liststr) -> None:
 if not self.should_use_dyndeps_for_target(target):
 return
 depscan_file = self.get_dep_scan_file_for(target)
@@ -946,6 +1046,7 @@
 # that those sources are present
 for g in generated_source_files:
 elem.orderdeps.add(g.relative_name())
+ elem.orderdeps.update(object_deps)
 scaninfo = TargetDependencyScannerInfo(self.get_target_private_dir(target), source2object)
 with open(pickle_abs, 'wb') as p:
 pickle.dump(scaninfo, p)
@@ -958,7 +1059,9 @@
 all_suffixes = set(compilers.lang_suffixes'cpp') | set(compilers.lang_suffixes'fortran')
 selected_sources = 
 for source in compiled_sources:
- ext = os.path.splitext(source)11:.lower()
+ ext = os.path.splitext(source)11:
+ if ext != 'C':
+ ext = ext.lower()
 if ext in all_suffixes:
 selected_sources.append(source)
 return selected_sources
@@ -1033,7 +1136,7 @@
 subproject_prefix = ''
 return f'{subproject_prefix}{target.name}'
 
- def generate_run_target(self, target):
+ def generate_run_target(self, target: build.RunTarget):
 target_name = self.build_run_target_name(target)
 if not target.command:
 # This is an alias target, it has no command, it just depends on
@@ -1043,16 +1146,13 @@
 target_env = self.get_run_target_env(target)
 _, _, cmd = self.eval_custom_target_command(target)
 meson_exe_cmd, reason = self.as_meson_exe_cmdline(target.command0, cmd1:,
- force_serialize=True, env=target_env,
+ env=target_env,
 verbose=True)
- cmd_type = f' (wrapped by meson {reason})'
- internal_target_name = f'meson-{target_name}'
- elem = NinjaBuildElement(self.all_outputs, internal_target_name, 'CUSTOM_COMMAND', )
+ cmd_type = f' (wrapped by meson {reason})' if reason else ''
+ elem = self.create_phony_target(self.all_outputs, target_name, 'CUSTOM_COMMAND', )
 elem.add_item('COMMAND', meson_exe_cmd)
 elem.add_item('description', f'Running external command {target.name}{cmd_type}')
 elem.add_item('pool', 'console')
- # Alias that runs the target defined above with the name the user specified
- self.create_target_alias(internal_target_name)
 deps = self.unwrap_dep_list(target)
 deps += self.get_custom_target_depend_files(target)
 elem.add_dep(deps)
@@ -1080,55 +1180,43 @@
 ('--use_llvm_cov' if use_llvm_cov else ))
 
 def generate_coverage_rules(self, gcovr_exe: T.Optionalstr, gcovr_version: T.Optionalstr):
- e = NinjaBuildElement(self.all_outputs, 'meson-coverage', 'CUSTOM_COMMAND', 'PHONY')
+ e = self.create_phony_target(self.all_outputs, 'coverage', 'CUSTOM_COMMAND', 'PHONY')
 self.generate_coverage_command(e, )
 e.add_item('description', 'Generates coverage reports')
 self.add_build(e)
- # Alias that runs the target defined above
- self.create_target_alias('meson-coverage')
 self.generate_coverage_legacy_rules(gcovr_exe, gcovr_version)
 
 def generate_coverage_legacy_rules(self, gcovr_exe: T.Optionalstr, gcovr_version: T.Optionalstr):
- e = NinjaBuildElement(self.all_outputs, 'meson-coverage-html', 'CUSTOM_COMMAND', 'PHONY')
+ e = self.create_phony_target(self.all_outputs, 'coverage-html', 'CUSTOM_COMMAND', 'PHONY')
 self.generate_coverage_command(e, '--html')
 e.add_item('description', 'Generates HTML coverage report')
 self.add_build(e)
- # Alias that runs the target defined above
- self.create_target_alias('meson-coverage-html')
 
 if gcovr_exe:
- e = NinjaBuildElement(self.all_outputs, 'meson-coverage-xml', 'CUSTOM_COMMAND', 'PHONY')
+ e = self.create_phony_target(self.all_outputs, 'coverage-xml', 'CUSTOM_COMMAND', 'PHONY')
 self.generate_coverage_command(e, '--xml')
 e.add_item('description', 'Generates XML coverage report')
 self.add_build(e)
- # Alias that runs the target defined above
- self.create_target_alias('meson-coverage-xml')
 
- e = NinjaBuildElement(self.all_outputs, 'meson-coverage-text', 'CUSTOM_COMMAND', 'PHONY')
+ e = self.create_phony_target(self.all_outputs, 'coverage-text', 'CUSTOM_COMMAND', 'PHONY')
 self.generate_coverage_command(e, '--text')
 e.add_item('description', 'Generates text coverage report')
 self.add_build(e)
- # Alias that runs the target defined above
- self.create_target_alias('meson-coverage-text')
 
 if mesonlib.version_compare(gcovr_version, '>=4.2'):
- e = NinjaBuildElement(self.all_outputs, 'meson-coverage-sonarqube', 'CUSTOM_COMMAND', 'PHONY')
+ e = self.create_phony_target(self.all_outputs, 'coverage-sonarqube', 'CUSTOM_COMMAND', 'PHONY')
 self.generate_coverage_command(e, '--sonarqube')
 e.add_item('description', 'Generates Sonarqube XML coverage report')
 self.add_build(e)
- # Alias that runs the target defined above
- self.create_target_alias('meson-coverage-sonarqube')
 
 def generate_install(self):
 self.create_install_data_files()
- elem = NinjaBuildElement(self.all_outputs, 'meson-install', 'CUSTOM_COMMAND', 'PHONY')
+ elem = self.create_phony_target(self.all_outputs, 'install', 'CUSTOM_COMMAND', 'PHONY')
 elem.add_dep('all')
 elem.add_item('DESC', 'Installing files.')
 elem.add_item('COMMAND', self.environment.get_build_command() + 'install', '--no-rebuild')
 elem.add_item('pool', 'console')
 self.add_build(elem)
- # Alias that runs the target defined above
- self.create_target_alias('meson-install')
 
 def generate_tests(self):
 self.serialize_tests()
@@ -1137,25 +1225,21 @@
 cmd += '--no-stdsplit'
 if self.environment.coredata.get_option(OptionKey('errorlogs')):
 cmd += '--print-errorlogs'
- elem = NinjaBuildElement(self.all_outputs, 'meson-test', 'CUSTOM_COMMAND', 'all', 'PHONY')
+ elem = self.create_phony_target(self.all_outputs, 'test', 'CUSTOM_COMMAND', 'all', 'PHONY')
 elem.add_item('COMMAND', cmd)
 elem.add_item('DESC', 'Running all tests.')
 elem.add_item('pool', 'console')
 self.add_build(elem)
- # Alias that runs the above-defined meson-test target
- self.create_target_alias('meson-test')
 
 # And then benchmarks.
 cmd = self.environment.get_build_command(True) + 
 'test', '--benchmark', '--logbase',
 'benchmarklog', '--num-processes=1', '--no-rebuild'
- elem = NinjaBuildElement(self.all_outputs, 'meson-benchmark', 'CUSTOM_COMMAND', 'all', 'PHONY')
+ elem = self.create_phony_target(self.all_outputs, 'benchmark', 'CUSTOM_COMMAND', 'all', 'PHONY')
 elem.add_item('COMMAND', cmd)
 elem.add_item('DESC', 'Running benchmark suite.')
 elem.add_item('pool', 'console')
 self.add_build(elem)
- # Alias that runs the above-defined meson-benchmark target
- self.create_target_alias('meson-benchmark')
 
 def generate_rules(self):
 self.rules = 
@@ -1176,14 +1260,14 @@
 self.add_rule(NinjaRule('CUSTOM_COMMAND_DEP', '$COMMAND', , '$DESC',
 deps='gcc', depfile='$DEPFILE',
 extra='restat = 1'))
+ self.add_rule(NinjaRule('COPY_FILE', self.environment.get_build_command() + '--internal', 'copy',
+ '$in', '$out', 'Copying $in to $out'))
 
 c = self.environment.get_build_command() + \
 '--internal',
 'regenerate',
 self.environment.get_source_dir(),
- self.environment.get_build_dir(),
- '--backend',
- 'ninja'
+ self.environment.get_build_dir()
 self.add_rule(NinjaRule('REGENERATE_BUILD',
 c, ,
 'Regenerating build files.',
@@ -1202,6 +1286,7 @@
 self.ruledictrule.name = rule
 
 def add_build(self, build):
+ build.check_outputs()
 self.build_elements.append(build)
 
 if build.rulename != 'phony':
@@ -1228,10 +1313,11 @@
 elem = NinjaBuildElement(self.all_outputs, 'PHONY', 'phony', '')
 self.add_build(elem)
 
- def generate_jar_target(self, target):
+ def generate_jar_target(self, target: build.Jar):
 fname = target.get_filename()
 outname_rel = os.path.join(self.get_target_dir(target), fname)
 src_list = target.get_sources()
+ resources = target.get_java_resources()
 class_list = 
 compiler = target.compilers'java'
 c = 'c'
@@ -1246,8 +1332,7 @@
 generated_sources = self.get_target_generated_sources(target)
 gen_src_list = 
 for rel_src in generated_sources.keys():
- dirpart, fnamepart = os.path.split(rel_src)
- raw_src = File(True, dirpart, fnamepart)
+ raw_src = File.from_built_relative(rel_src)
 if rel_src.endswith('.java'):
 gen_src_list.append(raw_src)
 
@@ -1277,6 +1362,9 @@
 commands += '-C', self.get_target_private_dir(target), '.'
 elem = NinjaBuildElement(self.all_outputs, outname_rel, jar_rule, )
 elem.add_dep(class_dep_list)
+ if resources:
+ # Copy all resources into the root of the jar.
+ elem.add_orderdep(self.__generate_sources_structure(Path(self.get_target_private_dir(target)), resources)0)
 elem.add_item('ARGS', commands)
 self.add_build(elem)
 # Create introspection information
@@ -1304,7 +1392,7 @@
 return args, deps
 
 def generate_cs_target(self, target: build.BuildTarget):
- buildtype = self.get_option_for_target(OptionKey('buildtype'), target)
+ buildtype = target.get_option(OptionKey('buildtype'))
 fname = target.get_filename()
 outname_rel = os.path.join(self.get_target_dir(target), fname)
 src_list = target.get_sources()
@@ -1313,8 +1401,8 @@
 deps = 
 commands = compiler.compiler_args(target.extra_args.get('cs', ))
 commands += compiler.get_buildtype_args(buildtype)
- commands += compiler.get_optimization_args(self.get_option_for_target(OptionKey('optimization'), target))
- commands += compiler.get_debug_args(self.get_option_for_target(OptionKey('debug'), target))
+ commands += compiler.get_optimization_args(target.get_option(OptionKey('optimization')))
+ commands += compiler.get_debug_args(target.get_option(OptionKey('debug')))
 if isinstance(target, build.Executable):
 commands.append('-target:exe')
 elif isinstance(target, build.SharedLibrary):
@@ -1345,7 +1433,7 @@
 commands += self.build.get_project_args(compiler, target.subproject, target.for_machine)
 commands += self.build.get_global_args(compiler, target.for_machine)
 
- elem = NinjaBuildElement(self.all_outputs, outputs, self.get_compiler_rule_name('cs', target.for_machine), rel_srcs + generated_rel_srcs)
+ elem = NinjaBuildElement(self.all_outputs, outputs, self.compiler_to_rule_name(compiler), rel_srcs + generated_rel_srcs)
 elem.add_dep(deps)
 elem.add_item('ARGS', commands)
 self.add_build(elem)
@@ -1355,7 +1443,7 @@
 
 def determine_single_java_compile_args(self, target, compiler):
 args = 
- args += compiler.get_buildtype_args(self.get_option_for_target(OptionKey('buildtype'), target))
+ args += compiler.get_buildtype_args(target.get_option(OptionKey('buildtype')))
 args += self.build.get_global_args(compiler, target.for_machine)
 args += self.build.get_project_args(compiler, target.subproject, target.for_machine)
 args += target.get_java_args()
@@ -1530,7 +1618,7 @@
 # Outputted header
 hname = os.path.join(self.get_target_dir(target), target.vala_header)
 args += '--header', hname
- if self.is_unity(target):
+ if target.is_unity:
 # Without this the declarations will get duplicated in the .c
 # files and cause a build failure when all of them are
 # #include-d in one .c file.
@@ -1562,7 +1650,7 @@
 target.install_dir3 = os.path.join(self.environment.get_datadir(), 'gir-1.0')
 # Detect gresources and add --gresources arguments for each
 for gensrc in other_src1.values():
- if isinstance(gensrc, modules.GResourceTarget):
+ if isinstance(gensrc, gnome.GResourceTarget):
 gres_xml, = self.get_custom_target_sources(gensrc)
 args += '--gresources=' + gres_xml
 extra_args = 
@@ -1598,25 +1686,23 @@
 
 cython = target.compilers'cython'
 
- opt_proxy = self.get_compiler_options_for_target(target)
-
 args: T.Liststr = 
 args += cython.get_always_args()
- args += cython.get_buildtype_args(self.get_option_for_target(OptionKey('buildtype'), target))
- args += cython.get_debug_args(self.get_option_for_target(OptionKey('debug'), target))
- args += cython.get_optimization_args(self.get_option_for_target(OptionKey('optimization'), target))
- args += cython.get_option_compile_args(opt_proxy)
+ args += cython.get_buildtype_args(target.get_option(OptionKey('buildtype')))
+ args += cython.get_debug_args(target.get_option(OptionKey('debug')))
+ args += cython.get_optimization_args(target.get_option(OptionKey('optimization')))
+ args += cython.get_option_compile_args(target.get_options())
 args += self.build.get_global_args(cython, target.for_machine)
 args += self.build.get_project_args(cython, target.subproject, target.for_machine)
 args += target.get_extra_args('cython')
 
- ext = opt_proxyOptionKey('language', machine=target.for_machine, lang='cython').value
+ ext = target.get_option(OptionKey('language', machine=target.for_machine, lang='cython'))
+
+ pyx_sources = # Keep track of sources we're adding to build
 
 for src in target.get_sources():
 if src.endswith('.pyx'):
 output = os.path.join(self.get_target_private_dir(target), f'{src}.{ext}')
- args = args.copy()
- args += cython.get_output_args(output)
 element = NinjaBuildElement(
 self.all_outputs, output,
 self.compiler_to_rule_name(cython),
@@ -1625,9 +1711,11 @@
 self.add_build(element)
 # TODO: introspection?
 cython_sources.append(output)
+ pyx_sources.append(element)
 else:
 static_sourcessrc.rel_to_builddir(self.build_to_src) = src
 
+ header_deps = # Keep track of generated headers for those sources
 for gen in target.get_generated_sources():
 for ssrc in gen.get_outputs():
 if isinstance(gen, GeneratedList):
@@ -1635,42 +1723,136 @@
 else:
 ssrc = os.path.join(gen.get_subdir(), ssrc)
 if ssrc.endswith('.pyx'):
- args = args.copy()
 output = os.path.join(self.get_target_private_dir(target), f'{ssrc}.{ext}')
- args += cython.get_output_args(output)
 element = NinjaBuildElement(
 self.all_outputs, output,
 self.compiler_to_rule_name(cython),
 ssrc)
 element.add_item('ARGS', args)
 self.add_build(element)
+ pyx_sources.append(element)
 # TODO: introspection?
 cython_sources.append(output)
 else:
 generated_sourcesssrc = mesonlib.File.from_built_file(gen.get_subdir(), ssrc)
+ # Following logic in L883-900 where we determine whether to add generated source
+ # as a header(order-only) dep to the .so compilation rule
+ if not self.environment.is_source(ssrc) and \
+ not self.environment.is_object(ssrc) and \
+ not self.environment.is_library(ssrc) and \
+ not modules.is_module_library(ssrc):
+ header_deps.append(ssrc)
+ for source in pyx_sources:
+ source.add_orderdep(header_deps)
 
 return static_sources, generated_sources, cython_sources
 
+ def _generate_copy_target(self, src: 'mesonlib.FileOrString', output: Path) -> None:
+ """Create a target to copy a source file from one location to another."""
+ if isinstance(src, File):
+ instr = src.absolute_path(self.environment.source_dir, self.environment.build_dir)
+ else:
+ instr = src
+ elem = NinjaBuildElement(self.all_outputs, str(output), 'COPY_FILE', instr)
+ elem.add_orderdep(instr)
+ self.add_build(elem)
+
+ def __generate_sources_structure(self, root: Path, structured_sources: build.StructuredSources) -> T.TupleT.Liststr, T.Optionalstr:
+ first_file: T.Optionalstr = None
+ orderdeps: T.Liststr = 
+ for path, files in structured_sources.sources.items():
+ for file in files:
+ if isinstance(file, File):
+ out = root / path / Path(file.fname).name
+ orderdeps.append(str(out))
+ self._generate_copy_target(file, out)
+ if first_file is None:
+ first_file = str(out)
+ else:
+ for f in file.get_outputs():
+ out = root / path / f
+ orderdeps.append(str(out))
+ self._generate_copy_target(str(Path(file.subdir) / f), out)
+ if first_file is None:
+ first_file = str(out)
+ return orderdeps, first_file
+
+ def _add_rust_project_entry(self, name: str, main_rust_file: str, args: CompilerArgs,
+ from_subproject: bool, is_proc_macro: bool,
+ output: str, deps: T.ListRustDep) -> None:
+ raw_edition: T.Optionalstr = mesonlib.first(reversed(args), lambda x: x.startswith('--edition'))
+ edition: RUST_EDITIONS = '2015' if not raw_edition else raw_edition.split('=')-1
+
+ cfg: T.Liststr = 
+ arg_itr: T.Iteratorstr = iter(args)
+ for arg in arg_itr:
+ if arg == '--cfg':
+ cfg.append(next(arg_itr))
+ elif arg.startswith('--cfg'):
+ cfg.append(arglen('--cfg'):)
+
+ crate = RustCrate(
+ len(self.rust_crates),
+ name,
+ main_rust_file,
+ edition,
+ deps,
+ cfg,
+ is_workspace_member=not from_subproject,
+ is_proc_macro=is_proc_macro,
+ proc_macro_dylib_path=output if is_proc_macro else None,
+ )
+
+ self.rust_cratesname = crate
+
 def generate_rust_target(self, target: build.BuildTarget) -> None:
 rustc = target.compilers'rust'
 # Rust compiler takes only the main file as input and
 # figures out what other files are needed via import
 # statements and magic.
- base_proxy = self.get_base_options_for_target(target)
+ base_proxy = target.get_options()
 args = rustc.compiler_args()
 # Compiler args for compiling this target
 args += compilers.get_base_compile_args(base_proxy, rustc)
 self.generate_generator_list_rules(target)
 
- # dependencies need to cause a relink, they're not just for odering
+ # dependencies need to cause a relink, they're not just for ordering
 deps = 
 os.path.join(t.subdir, t.get_filename())
 for t in itertools.chain(target.link_targets, target.link_whole_targets)
 
 
+ # Dependencies for rust-project.json
+ project_deps: T.ListRustDep = 
+
 orderdeps: T.Liststr = 
 
 main_rust_file = None
+ if target.structured_sources:
+ if target.structured_sources.needs_copy():
+ _ods, main_rust_file = self.__generate_sources_structure(Path(
+ self.get_target_private_dir(target)) / 'structured', target.structured_sources)
+ orderdeps.extend(_ods)
+ else:
+ # The only way to get here is to have only files in the "root"
+ # positional argument, which are all generated into the same
+ # directory
+ g = target.structured_sources.first_file()
+
+ if isinstance(g, File):
+ main_rust_file = g.rel_to_builddir(self.build_to_src)
+ elif isinstance(g, GeneratedList):
+ main_rust_file = os.path.join(self.get_target_private_dir(target), g.get_outputs()0)
+ else:
+ main_rust_file = os.path.join(g.get_subdir(), g.get_outputs()0)
+
+ for f in target.structured_sources.as_list():
+ if isinstance(f, File):
+ orderdeps.append(f.rel_to_builddir(self.build_to_src))
+ else:
+ orderdeps.extend(os.path.join(self.build_to_src, f.subdir, s)
+ for s in f.get_outputs())
+
 for i in target.get_sources():
 if not rustc.can_compile(i):
 raise InvalidArguments(f'Rust target {target.get_basename()} contains a non-rust source file.')
@@ -1710,21 +1892,24 @@
 args.extend(rustc.get_linker_always_args())
 
 args += self.generate_basic_compiler_args(target, rustc, False)
- # This matches rustc's default behavior.
- args += '--crate-name', target.name.replace('-', '_')
+ # Rustc replaces - with _. spaces are not allowed, so we replace them with underscores
+ args += '--crate-name', target.name.replace('-', '_').replace(' ', '_')
 depfile = os.path.join(target.subdir, target.name + '.d')
 args += '--emit', f'dep-info={depfile}', '--emit', 'link'
 args += target.get_extra_args('rust')
- args += rustc.get_output_args(os.path.join(target.subdir, target.get_filename()))
+ output = rustc.get_output_args(os.path.join(target.subdir, target.get_filename()))
+ args += output
 linkdirs = mesonlib.OrderedSet()
 external_deps = target.external_deps.copy()
- for d in itertools.chain(target.link_targets, target.link_whole_targets):
+ # TODO: we likely need to use verbatim to handle name_prefix and name_suffix
+ for d in target.link_targets:
 linkdirs.add(d.subdir)
 if d.uses_rust():
 # specify `extern CRATE_NAME=OUTPUT_FILE` for each Rust
 # dependency, so that collisions with libraries in rustc's
 # sysroot don't cause ambiguity
 args += '--extern', '{}={}'.format(d.name, os.path.join(d.subdir, d.filename))
+ project_deps.append(RustDep(d.name, self.rust_cratesd.name.order))
 elif d.typename == 'static library':
 # Rustc doesn't follow Meson's convention that static libraries
 # are called .a, and import libraries are .lib, so we have to
@@ -1738,6 +1923,55 @@
 # Rust uses -l for non rust dependencies, but we still need to
 # add dylib=foo
 args += '-l', f'dylib={d.name}'
+
+ # Since 1.61.0 Rust has a special modifier for whole-archive linking,
+ # before that it would treat linking two static libraries as
+ # whole-archive linking. However, to make this work we have to disable
+ # bundling, which can't be done until 1.63.0… So for 1.61–1.62 we just
+ # have to hope that the default cases of +whole-archive are sufficent.
+ # See: https://github.com/rust-lang/rust/issues/99429
+ if mesonlib.version_compare(rustc.version, '>= 1.63.0'):
+ whole_archive = ':+whole-archive,-bundle'
+ else:
+ whole_archive = ''
+
+ if mesonlib.version_compare(rustc.version, '>= 1.67.0'):
+ verbatim = ',+verbatim'
+ else:
+ verbatim = ''
+
+ for d in target.link_whole_targets:
+ linkdirs.add(d.subdir)
+ if d.uses_rust():
+ # specify `extern CRATE_NAME=OUTPUT_FILE` for each Rust
+ # dependency, so that collisions with libraries in rustc's
+ # sysroot don't cause ambiguity
+ args += '--extern', '{}={}'.format(d.name, os.path.join(d.subdir, d.filename))
+ project_deps.append(RustDep(d.name, self.rust_cratesd.name.order))
+ else:
+ if rustc.linker.id in {'link', 'lld-link'}:
+ if verbatim:
+ # If we can use the verbatim modifier, then everything is great
+ args += '-l', f'static{whole_archive}{verbatim}={d.get_outputs()0}'
+ elif isinstance(target, build.StaticLibrary):
+ # If we don't, for static libraries the only option is
+ # to make a copy, since we can't pass objects in, or
+ # directly affect the archiver. but we're not going to
+ # do that given how quickly rustc versions go out of
+ # support unless there's a compelling reason to do so.
+ # This only affects 1.61–1.66
+ mlog.warning('Due to limitations in Rustc versions 1.61–1.66 and meson library naming',
+ 'whole-archive linking with MSVC may or may not work. Upgrade rustc to',
+ '>= 1.67. A best effort is being made, but likely won\'t work')
+ args += '-l', f'static={d.name}'
+ else:
+ # When doing dynamic linking (binaries and cdylibs),
+ # we can instead just proxy the correct arguments to the linker
+ for link_whole_arg in rustc.linker.get_link_whole_for(self.get_target_filename_for_linking(d)):
+ args += '-C', f'link-arg={link_whole_arg}'
+ else:
+ args += '-l', f'static{whole_archive}={d.name}'
+ external_deps.extend(d.external_deps)
 for e in external_deps:
 for a in e.get_link_args():
 if a.endswith(('.dll', '.so', '.dylib')):
@@ -1786,7 +2020,13 @@
 # installations
 for rpath_arg in rpath_args:
 args += '-C', 'link-arg=' + rpath_arg + ':' + os.path.join(rustc.get_sysroot(), 'lib')
- compiler_name = self.get_compiler_rule_name('rust', target.for_machine)
+
+ self._add_rust_project_entry(target.name, main_rust_file, args, bool(target.subproject),
+ #XXX: There is a fix for this pending
+ getattr(target, 'rust_crate_type', '') == 'procmacro',
+ output, project_deps)
+
+ compiler_name = self.compiler_to_rule_name(rustc)
 element = NinjaBuildElement(self.all_outputs, target_name, compiler_name, main_rust_file)
 if orderdeps:
 element.add_orderdep(orderdeps)
@@ -1805,20 +2045,16 @@
 return PerMachine('_FOR_BUILD', '')for_machine
 
 @classmethod
- def get_compiler_rule_name(cls, lang: str, for_machine: MachineChoice) -> str:
- return '{}_COMPILER{}'.format(lang, cls.get_rule_suffix(for_machine))
-
- @classmethod
- def get_pch_rule_name(cls, lang: str, for_machine: MachineChoice) -> str:
- return '{}_PCH{}'.format(lang, cls.get_rule_suffix(for_machine))
+ def get_compiler_rule_name(cls, lang: str, for_machine: MachineChoice, mode: str = 'COMPILER') -> str:
+ return f'{lang}_{mode}{cls.get_rule_suffix(for_machine)}'
 
 @classmethod
 def compiler_to_rule_name(cls, compiler: Compiler) -> str:
- return cls.get_compiler_rule_name(compiler.get_language(), compiler.for_machine)
+ return cls.get_compiler_rule_name(compiler.get_language(), compiler.for_machine, compiler.mode)
 
 @classmethod
 def compiler_to_pch_rule_name(cls, compiler: Compiler) -> str:
- return cls.get_pch_rule_name(compiler.get_language(), compiler.for_machine)
+ return cls.get_compiler_rule_name(compiler.get_language(), compiler.for_machine, 'PCH')
 
 def swift_module_file_name(self, target):
 return os.path.join(self.get_target_private_dir(target),
@@ -1873,8 +2109,8 @@
 raise InvalidArguments(f'Swift target {target.get_basename()} contains a non-swift source file.')
 os.makedirs(self.get_target_private_dir_abs(target), exist_ok=True)
 compile_args = swiftc.get_compile_only_args()
- compile_args += swiftc.get_optimization_args(self.get_option_for_target(OptionKey('optimization'), target))
- compile_args += swiftc.get_debug_args(self.get_option_for_target(OptionKey('debug'), target))
+ compile_args += swiftc.get_optimization_args(target.get_option(OptionKey('optimization')))
+ compile_args += swiftc.get_debug_args(target.get_option(OptionKey('debug')))
 compile_args += swiftc.get_module_args(module_name)
 compile_args += self.build.get_project_args(swiftc, target.subproject, target.for_machine)
 compile_args += self.build.get_global_args(swiftc, target.for_machine)
@@ -1917,7 +2153,7 @@
 objects.append(oname)
 rel_objects.append(os.path.join(self.get_target_private_dir(target), oname))
 
- rulename = self.get_compiler_rule_name('swift', target.for_machine)
+ rulename = self.compiler_to_rule_name(swiftc)
 
 # Swiftc does not seem to be able to emit objects and module files in one go.
 elem = NinjaBuildElement(self.all_outputs, rel_objects, rulename, abssrc)
@@ -1926,9 +2162,7 @@
 elem.add_item('ARGS', compile_args + header_imports + abs_generated + module_includes)
 elem.add_item('RUNDIR', rundir)
 self.add_build(elem)
- elem = NinjaBuildElement(self.all_outputs, out_module_name,
- self.get_compiler_rule_name('swift', target.for_machine),
- abssrc)
+ elem = NinjaBuildElement(self.all_outputs, out_module_name, rulename, abssrc)
 elem.add_dep(in_module_files + rel_generated)
 elem.add_item('ARGS', compile_args + abs_generated + module_includes + swiftc.get_mod_gen_args())
 elem.add_item('RUNDIR', rundir)
@@ -1955,7 +2189,7 @@
 rsp_file_syntax() is only guaranteed to be implemented if
 can_linker_accept_rsp() returns True.
 """
- options = dict(rspable=tool.can_linker_accept_rsp())
+ options = {'rspable': tool.can_linker_accept_rsp()}
 if options'rspable':
 options'rspfile_quote_style' = tool.rsp_file_syntax()
 return options
@@ -2047,9 +2281,18 @@
 
 def generate_cython_compile_rules(self, compiler: 'Compiler') -> None:
 rule = self.compiler_to_rule_name(compiler)
- command = compiler.get_exelist() + '$ARGS', '$in'
 description = 'Compiling Cython source $in'
- self.add_rule(NinjaRule(rule, command, , description, extra='restat = 1'))
+ command = compiler.get_exelist()
+
+ depargs = compiler.get_dependency_gen_args('$out', '$DEPFILE')
+ depfile = '$out.dep' if depargs else None
+
+ args = depargs + '$ARGS', '$in'
+ args += NinjaCommandArg.list(compiler.get_output_args('$out'), Quoting.none)
+ self.add_rule(NinjaRule(rule, command + args, ,
+ description,
+ depfile=depfile,
+ extra='restat = 1'))
 
 def generate_rust_compile_rules(self, compiler):
 rule = self.compiler_to_rule_name(compiler)
@@ -2128,12 +2371,12 @@
 crstr = self.get_rule_suffix(compiler.for_machine)
 if langname == 'fortran':
 self.generate_fortran_dep_hack(crstr)
- rule = self.get_compiler_rule_name(langname, compiler.for_machine)
+ rule = self.compiler_to_rule_name(compiler)
 depargs = NinjaCommandArg.list(compiler.get_dependency_gen_args('$out', '$DEPFILE'), Quoting.none)
 command = compiler.get_exelist()
 args = '$ARGS' + depargs + NinjaCommandArg.list(compiler.get_output_args('$out'), Quoting.none) + compiler.get_compile_only_args() + '$in'
 description = f'Compiling {compiler.get_display_language()} object $out'
- if isinstance(compiler, VisualStudioLikeCompiler):
+ if compiler.get_argument_syntax() == 'msvc':
 deps = 'msvc'
 depfile = None
 else:
@@ -2144,18 +2387,18 @@
 deps=deps, depfile=depfile))
 
 def generate_pch_rule_for(self, langname, compiler):
- if langname != 'c' and langname != 'cpp':
+ if langname not in {'c', 'cpp'}:
 return
 rule = self.compiler_to_pch_rule_name(compiler)
 depargs = compiler.get_dependency_gen_args('$out', '$DEPFILE')
 
- if isinstance(compiler, VisualStudioLikeCompiler):
+ if compiler.get_argument_syntax() == 'msvc':
 output = 
 else:
 output = NinjaCommandArg.list(compiler.get_output_args('$out'), Quoting.none)
 command = compiler.get_exelist() + '$ARGS' + depargs + output + compiler.get_compile_only_args() + '$in'
 description = 'Precompiling header $in'
- if isinstance(compiler, VisualStudioLikeCompiler):
+ if compiler.get_argument_syntax() == 'msvc':
 deps = 'msvc'
 depfile = None
 else:
@@ -2184,6 +2427,8 @@
 self.generate_llvm_ir_compile_rule(compiler)
 self.generate_compile_rule_for(langname, compiler)
 self.generate_pch_rule_for(langname, compiler)
+ for mode in compiler.get_modes():
+ self.generate_compile_rule_for(langname, mode)
 
 def generate_generator_list_rules(self, target):
 # CustomTargets have already written their rules and
@@ -2208,11 +2453,10 @@
 args = x.replace('\\', '/') for x in args
 return args
 
- def generate_genlist_for_target(self, genlist, target):
+ def generate_genlist_for_target(self, genlist: build.GeneratedList, target: build.BuildTarget) -> None:
 generator = genlist.get_generator()
 subdir = genlist.subdir
 exe = generator.get_exe()
- exe_arr = self.build_target_to_cmd_array(exe)
 infilelist = genlist.get_inputs()
 outfilelist = genlist.get_outputs()
 extra_dependencies = self.get_custom_target_depend_files(genlist)
@@ -2240,8 +2484,8 @@
 if len(generator.outputs) > 1:
 outfilelist = outfilelistlen(generator.outputs):
 args = self.replace_paths(target, args, override_subdir=subdir)
- cmdlist = exe_arr + self.replace_extra_args(args, genlist)
- cmdlist, reason = self.as_meson_exe_cmdline(cmdlist0, cmdlist1:,
+ cmdlist, reason = self.as_meson_exe_cmdline(exe,
+ self.replace_extra_args(args, genlist),
 capture=outfiles0 if generator.capture else None)
 abs_pdir = os.path.join(self.environment.get_build_dir(), self.get_target_dir(target))
 os.makedirs(abs_pdir, exist_ok=True)
@@ -2304,7 +2548,7 @@
 if modname in module_files:
 raise InvalidArguments(
 f'Namespace collision: module {modname} defined in '
- 'two files {module_filesmodname} and {s}.')
+ f'two files {module_filesmodname} and {s}.')
 module_filesmodname = s
 else:
 submodmatch = submodre.match(line)
@@ -2315,8 +2559,8 @@
 
 if submodname in submodule_files:
 raise InvalidArguments(
- 'Namespace collision: submodule {submodname} defined in '
- 'two files {submodule_filessubmodname} and {s}.')
+ f'Namespace collision: submodule {submodname} defined in '
+ f'two files {submodule_filessubmodname} and {s}.')
 submodule_filessubmodname = s
 
 self.fortran_depstarget.get_basename() = {**module_files, **submodule_files}
@@ -2402,7 +2646,7 @@
 return linker.get_link_debugfile_args(outname)
 
 def generate_llvm_ir_compile(self, target, src):
- base_proxy = self.get_base_options_for_target(target)
+ base_proxy = target.get_options()
 compiler = get_compiler_for_source(target.compilers.values(), src)
 commands = compiler.compiler_args()
 # Compiler args for compiling this target
@@ -2462,7 +2706,7 @@
 return commands
 
 def _generate_single_compile_base_args(self, target: build.BuildTarget, compiler: 'Compiler') -> 'CompilerArgs':
- base_proxy = self.get_base_options_for_target(target)
+ base_proxy = target.get_options()
 # Create an empty commands list, and start adding arguments from
 # various sources in the order in which they must override each other
 commands = compiler.compiler_args()
@@ -2480,7 +2724,7 @@
 is_generated: bool = False) -> 'ImmutableListProtocolstr':
 # The code generated by valac is usually crap and has tons of unused
 # variables and such, so disable warnings for Vala C sources.
- no_warn_args = (is_generated == 'vala')
+ no_warn_args = is_generated == 'vala'
 # Add compiler args and include paths from several sources; defaults,
 # build options, external dependencies, etc.
 commands = self.generate_basic_compiler_args(target, compiler, no_warn_args)
@@ -2535,7 +2779,10 @@
 commands += compiler.get_include_args(self.get_target_private_dir(target), False)
 return commands
 
- def generate_single_compile(self, target, src, is_generated=False, header_deps=None, order_deps=None):
+ def generate_single_compile(self, target: build.BuildTarget, src,
+ is_generated=False, header_deps=None,
+ order_deps: T.OptionalT.Liststr = None,
+ extra_args: T.OptionalT.Liststr = None) -> None:
 """
 Compiles C/C++, ObjC/ObjC++, Fortran, and D sources
 """
@@ -2622,6 +2869,8 @@
 rel_obj)
 self.add_build(depelem)
 commands += compiler.get_module_outdir_args(self.get_target_private_dir(target))
+ if extra_args is not None:
+ commands.extend(extra_args)
 
 element = NinjaBuildElement(self.all_outputs, rel_obj, compiler_name, rel_src)
 self.add_header_deps(target, element, header_deps)
@@ -2636,7 +2885,8 @@
 element.add_dep(pch_dep)
 for i in self.get_fortran_orderdeps(target, compiler):
 element.add_orderdep(i)
- element.add_item('DEPFILE', dep_file)
+ if dep_file:
+ element.add_item('DEPFILE', dep_file)
 element.add_item('ARGS', commands)
 
 self.add_dependency_scanner_entries_to_element(target, compiler, element, src)
@@ -2649,7 +2899,9 @@
 if not self.should_use_dyndeps_for_target(target):
 return
 extension = os.path.splitext(src.fname)11:
- if not (extension.lower() in compilers.lang_suffixes'fortran' or extension in compilers.lang_suffixes'cpp'):
+ if extension != 'C':
+ extension = extension.lower()
+ if not (extension in compilers.lang_suffixes'fortran' or extension in compilers.lang_suffixes'cpp'):
 return
 dep_scan_file = self.get_dep_scan_file_for(target)
 element.add_item('dyndep', dep_scan_file)
@@ -2732,8 +2984,8 @@
 msg = f'Precompiled header of {target.get_basename()!r} must not be in the same ' \
 'directory as source, please put it in a subdirectory.'
 raise InvalidArguments(msg)
- compiler = target.compilerslang
- if isinstance(compiler, VisualStudioLikeCompiler):
+ compiler: Compiler = target.compilerslang
+ if compiler.get_argument_syntax() == 'msvc':
 (commands, dep, dst, objs, src) = self.generate_msvc_pch_command(target, compiler, pch)
 extradep = os.path.join(self.build_to_src, target.get_source_subdir(), pch0)
 elif compiler.id == 'intel':
@@ -2805,7 +3057,7 @@
 if target.import_filename:
 commands += linker.gen_import_library_args(self.get_import_filename(target))
 elif isinstance(target, build.StaticLibrary):
- commands += linker.get_std_link_args(not target.should_install())
+ commands += linker.get_std_link_args(self.environment, not target.should_install())
 else:
 raise RuntimeError('Unknown build target type.')
 return commands
@@ -2827,7 +3079,7 @@
 
 def get_link_whole_args(self, linker, target):
 use_custom = False
- if isinstance(linker, mixins.visualstudio.MSVCCompiler):
+ if linker.id == 'msvc':
 # Expand our object lists manually if we are on pre-Visual Studio 2015 Update 2
 # (incidentally, the "linker" here actually refers to cl.exe)
 if mesonlib.version_compare(linker.version, '<19.00.23918'):
@@ -2838,7 +3090,7 @@
 for dep in target.link_whole_targets:
 l = dep.extract_all_objects(False)
 objects_from_static_libs += self.determine_ext_objs(l, '')
- objects_from_static_libs.extend(self.flatten_object_list(dep))
+ objects_from_static_libs.extend(self.flatten_object_list(dep)0)
 
 return objects_from_static_libs
 else:
@@ -2847,6 +3099,7 @@
 
 @lru_cache(maxsize=None)
 def guess_library_absolute_path(self, linker, libname, search_dirs, patterns) -> Path:
+ from ..compilers.c import CCompiler
 for d in search_dirs:
 for p in patterns:
 trial = CCompiler._get_trials_from_pattern(p, d, libname)
@@ -2964,19 +3217,20 @@
 # options passed on the command-line, in default_options, etc.
 # These have the lowest priority.
 if isinstance(target, build.StaticLibrary):
- commands += linker.get_base_link_args(self.get_base_options_for_target(target))
+ commands += linker.get_base_link_args(target.get_options())
 else:
- commands += compilers.get_base_link_args(self.get_base_options_for_target(target),
+ commands += compilers.get_base_link_args(target.get_options(),
 linker,
- isinstance(target, build.SharedModule))
+ isinstance(target, build.SharedModule),
+ self.environment.get_build_dir())
 # Add -nostdlib if needed; can't be overridden
 commands += self.get_no_stdlib_link_args(target, linker)
 # Add things like /NOLOGO; usually can't be overridden
 commands += linker.get_linker_always_args()
 # Add buildtype linker args: optimization level, etc.
- commands += linker.get_buildtype_linker_args(self.get_option_for_target(OptionKey('buildtype'), target))
+ commands += linker.get_buildtype_linker_args(target.get_option(OptionKey('buildtype')))
 # Add /DEBUG and the pdb filename when using MSVC
- if self.get_option_for_target(OptionKey('debug'), target):
+ if target.get_option(OptionKey('debug')):
 commands += self.get_link_debugfile_args(linker, target, outname)
 debugfile = self.get_link_debugfile_name(linker, target, outname)
 if debugfile is not None:
@@ -3093,8 +3347,7 @@
 return self.get_target_filename(t)
 
 def generate_shlib_aliases(self, target, outdir):
- aliases = target.get_aliases()
- for alias, to in aliases.items():
+ for alias, to, tag in target.get_aliases():
 aliasfile = os.path.join(self.environment.get_build_dir(), outdir, alias)
 try:
 os.remove(aliasfile)
@@ -3108,33 +3361,27 @@
 mlog.debug("Library versioning disabled because we do not have symlink creation privileges.")
 
 def generate_custom_target_clean(self, trees: T.Liststr) -> str:
- e = NinjaBuildElement(self.all_outputs, 'meson-clean-ctlist', 'CUSTOM_COMMAND', 'PHONY')
+ e = self.create_phony_target(self.all_outputs, 'clean-ctlist', 'CUSTOM_COMMAND', 'PHONY')
 d = CleanTrees(self.environment.get_build_dir(), trees)
 d_file = os.path.join(self.environment.get_scratch_dir(), 'cleantrees.dat')
 e.add_item('COMMAND', self.environment.get_build_command() + '--internal', 'cleantrees', d_file)
 e.add_item('description', 'Cleaning custom target directories')
 self.add_build(e)
- # Alias that runs the target defined above
- self.create_target_alias('meson-clean-ctlist')
 # Write out the data file passed to the script
 with open(d_file, 'wb') as ofile:
 pickle.dump(d, ofile)
 return 'clean-ctlist'
 
 def generate_gcov_clean(self):
- gcno_elem = NinjaBuildElement(self.all_outputs, 'meson-clean-gcno', 'CUSTOM_COMMAND', 'PHONY')
+ gcno_elem = self.create_phony_target(self.all_outputs, 'clean-gcno', 'CUSTOM_COMMAND', 'PHONY')
 gcno_elem.add_item('COMMAND', mesonlib.get_meson_command() + '--internal', 'delwithsuffix', '.', 'gcno')
 gcno_elem.add_item('description', 'Deleting gcno files')
 self.add_build(gcno_elem)
- # Alias that runs the target defined above
- self.create_target_alias('meson-clean-gcno')
 
- gcda_elem = NinjaBuildElement(self.all_outputs, 'meson-clean-gcda', 'CUSTOM_COMMAND', 'PHONY')
+ gcda_elem = self.create_phony_target(self.all_outputs, 'clean-gcda', 'CUSTOM_COMMAND', 'PHONY')
 gcda_elem.add_item('COMMAND', mesonlib.get_meson_command() + '--internal', 'delwithsuffix', '.', 'gcda')
 gcda_elem.add_item('description', 'Deleting gcda files')
 self.add_build(gcda_elem)
- # Alias that runs the target defined above
- self.create_target_alias('meson-clean-gcda')
 
 def get_user_option_args(self):
 cmds = 
@@ -3147,28 +3394,24 @@
 return sorted(cmds)
 
 def generate_dist(self):
- elem = NinjaBuildElement(self.all_outputs, 'meson-dist', 'CUSTOM_COMMAND', 'PHONY')
+ elem = self.create_phony_target(self.all_outputs, 'dist', 'CUSTOM_COMMAND', 'PHONY')
 elem.add_item('DESC', 'Creating source packages')
 elem.add_item('COMMAND', self.environment.get_build_command() + 'dist')
 elem.add_item('pool', 'console')
 self.add_build(elem)
- # Alias that runs the target defined above
- self.create_target_alias('meson-dist')
 
 def generate_scanbuild(self):
 if not environment.detect_scanbuild():
 return
- if ('', 'scan-build') in self.build.run_target_names:
+ if 'scan-build' in self.all_outputs:
 return
 cmd = self.environment.get_build_command() + \
 '--internal', 'scanbuild', self.environment.source_dir, self.environment.build_dir + \
 self.environment.get_build_command() + self.get_user_option_args()
- elem = NinjaBuildElement(self.all_outputs, 'meson-scan-build', 'CUSTOM_COMMAND', 'PHONY')
+ elem = self.create_phony_target(self.all_outputs, 'scan-build', 'CUSTOM_COMMAND', 'PHONY')
 elem.add_item('COMMAND', cmd)
 elem.add_item('pool', 'console')
 self.add_build(elem)
- # Alias that runs the target defined above
- self.create_target_alias('meson-scan-build')
 
 def generate_clangtool(self, name, extra_arg=None):
 target_name = 'clang-' + name
@@ -3181,16 +3424,13 @@
 return
 if target_name in self.all_outputs:
 return
- if ('', target_name) in self.build.run_target_names:
- return
 cmd = self.environment.get_build_command() + \
 '--internal', 'clang' + name, self.environment.source_dir, self.environment.build_dir + \
 extra_args
- elem = NinjaBuildElement(self.all_outputs, 'meson-' + target_name, 'CUSTOM_COMMAND', 'PHONY')
+ elem = self.create_phony_target(self.all_outputs, target_name, 'CUSTOM_COMMAND', 'PHONY')
 elem.add_item('COMMAND', cmd)
 elem.add_item('pool', 'console')
 self.add_build(elem)
- self.create_target_alias('meson-' + target_name)
 
 def generate_clangformat(self):
 if not environment.detect_clangformat():
@@ -3208,18 +3448,14 @@
 import shutil
 if not shutil.which(tool):
 return
- if ('', target_name) in self.build.run_target_names:
- return
 if target_name in self.all_outputs:
 return
 cmd = self.environment.get_build_command() + \
 '--internal', 'tags', tool, self.environment.source_dir
- elem = NinjaBuildElement(self.all_outputs, 'meson-' + target_name, 'CUSTOM_COMMAND', 'PHONY')
+ elem = self.create_phony_target(self.all_outputs, target_name, 'CUSTOM_COMMAND', 'PHONY')
 elem.add_item('COMMAND', cmd)
 elem.add_item('pool', 'console')
 self.add_build(elem)
- # Alias that runs the target defined above
- self.create_target_alias('meson-' + target_name)
 
 # For things like scan-build and other helper tools we might have.
 def generate_utils(self):
@@ -3230,28 +3466,32 @@
 self.generate_tags('ctags', 'ctags')
 self.generate_tags('cscope', 'cscope')
 cmd = self.environment.get_build_command() + '--internal', 'uninstall'
- elem = NinjaBuildElement(self.all_outputs, 'meson-uninstall', 'CUSTOM_COMMAND', 'PHONY')
+ elem = self.create_phony_target(self.all_outputs, 'uninstall', 'CUSTOM_COMMAND', 'PHONY')
 elem.add_item('COMMAND', cmd)
 elem.add_item('pool', 'console')
 self.add_build(elem)
- # Alias that runs the target defined above
- self.create_target_alias('meson-uninstall')
 
 def generate_ending(self):
- targetlist = 
- for t in self.get_build_by_default_targets().values():
- # Add the first output of each target to the 'all' target so that
- # they are all built
- targetlist.append(os.path.join(self.get_target_dir(t), t.get_outputs()0))
+ for targ, deps in 
+ ('all', self.get_build_by_default_targets()),
+ ('meson-test-prereq', self.get_testlike_targets()),
+ ('meson-benchmark-prereq', self.get_testlike_targets(True)):
+ targetlist = 
+ # These must also be built by default.
+ # XXX: Sometime in the future these should be built only before running tests.
+ if targ == 'all':
+ targetlist.extend('meson-test-prereq', 'meson-benchmark-prereq')
+ for t in deps.values():
+ # Add the first output of each target to the 'all' target so that
+ # they are all built
+ targetlist.append(os.path.join(self.get_target_dir(t), t.get_outputs()0))
 
- elem = NinjaBuildElement(self.all_outputs, 'all', 'phony', targetlist)
- self.add_build(elem)
+ elem = NinjaBuildElement(self.all_outputs, targ, 'phony', targetlist)
+ self.add_build(elem)
 
- elem = NinjaBuildElement(self.all_outputs, 'meson-clean', 'CUSTOM_COMMAND', 'PHONY')
+ elem = self.create_phony_target(self.all_outputs, 'clean', 'CUSTOM_COMMAND', 'PHONY')
 elem.add_item('COMMAND', self.ninja_command + '-t', 'clean')
 elem.add_item('description', 'Cleaning')
- # Alias that runs the above-defined meson-clean target
- self.create_target_alias('meson-clean')
 
 # If we have custom targets in this project, add all their outputs to
 # the list that is passed to the `cleantrees.py` script. The script
@@ -3363,13 +3603,13 @@
 submodmatch = submodre.match(line)
 if submodmatch is not None:
 parents = submodmatch.group(1).lower().split(':')
- assert len(parents) in (1, 2), (
+ assert len(parents) in {1, 2}, (
 'submodule ancestry must be specified as'
 f' ancestor:parent but Meson found {parents}')
 
 ancestor_child = '_'.join(parents)
 if ancestor_child not in tdeps:
- raise MesonException("submodule {} relies on ancestor module {} that was not found.".format(submodmatch.group(2).lower(), ancestor_child.split('_')0))
+ raise MesonException("submodule {} relies on ancestor module {} that was not found.".format(submodmatch.group(2).lower(), ancestor_child.split('_', maxsplit=1)0))
 submodsrcfile = srcdir / tdepsancestor_child.fname # type: Path
 if not submodsrcfile.is_file():
 if submodsrcfile.name != src.name: # generated source file

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/backend/vs2010backend.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/backend/vs2010backend.py Changed

@@ -12,25 +12,30 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 import copy
+import itertools
 import os
 import xml.dom.minidom
 import xml.etree.ElementTree as ET
 import uuid
 import typing as T
 from pathlib import Path, PurePath
+import re
 
 from . import backends
 from .. import build
 from .. import dependencies
 from .. import mlog
 from .. import compilers
-from ..interpreter import Interpreter
 from ..mesonlib import (
     File, MesonException, replace_if_different, OptionKey, version_compare, MachineChoice
 )
 from ..environment import Environment, build_filename
 
+if T.TYPE_CHECKING:
+    from ..interpreter import Interpreter
+
 
 def autodetect_vs_version(build: T.Optionalbuild.Build, interpreter: T.OptionalInterpreter) -> backends.Backend:
     vs_version = os.getenv('VisualStudioVersion', None)
@@ -92,6 +97,8 @@
 def generate_guid_from_path(path, path_type):
     return str(uuid.uuid5(uuid.NAMESPACE_URL, 'meson-vs-' + path_type + ':' + str(path))).upper()
 
+def detect_microsoft_gdk(platform: str) -> bool:
+    return re.match(r'Gaming\.(Desktop|Xbox.XboxOne|Xbox.Scarlett)\.x64', platform, re.IGNORECASE)
 
 class Vs2010Backend(backends.Backend):
     def __init__(self, build: T.Optionalbuild.Build, interpreter: T.OptionalInterpreter):
@@ -130,7 +137,6 @@
                 infilelist = genlist.get_inputs()
                 outfilelist = genlist.get_outputs()
                 source_dir = os.path.join(down, self.build_to_src, genlist.subdir)
-                exe_arr = self.build_target_to_cmd_array(exe)
                 idgroup = ET.SubElement(parent_node, 'ItemGroup')
                 for i, curfile in enumerate(infilelist):
                     if len(infilelist) == len(outfilelist):
@@ -154,13 +160,12 @@
                              .replace("@BUILD_ROOT@", self.environment.get_build_dir())
                             for x in args
                     args = x.replace('\\', '/') for x in args
-                    cmd = exe_arr + self.replace_extra_args(args, genlist)
                     # Always use a wrapper because MSBuild eats random characters when
                     # there are many arguments.
                     tdir_abs = os.path.join(self.environment.get_build_dir(), self.get_target_dir(target))
                     cmd, _ = self.as_meson_exe_cmdline(
-                        cmd0,
-                        cmd1:,
+                        exe,
+                        self.replace_extra_args(args, genlist),
                         workdir=tdir_abs,
                         capture=outfiles0 if generator.capture else None,
                         force_serialize=True
@@ -176,13 +181,17 @@
 
     def generate(self):
         target_machine = self.interpreter.builtin'target_machine'.cpu_family_method(None, None)
-        if target_machine == '64' or target_machine == 'x86_64':
+        if target_machine in {'64', 'x86_64'}:
             # amd64 or x86_64
-            self.platform = 'x64'
+            target_system = self.interpreter.builtin'target_machine'.system_method(None, None)
+            if detect_microsoft_gdk(target_system):
+                self.platform = target_system
+            else:
+                self.platform = 'x64'
         elif target_machine == 'x86':
             # x86
             self.platform = 'Win32'
-        elif target_machine == 'aarch64' or target_machine == 'arm64':
+        elif target_machine in {'aarch64', 'arm64'}:
             target_cpu = self.interpreter.builtin'target_machine'.cpu_method(None, None)
             if target_cpu == 'arm64ec':
                 self.platform = 'arm64ec'
@@ -194,13 +203,13 @@
             raise MesonException('Unsupported Visual Studio platform: ' + target_machine)
 
         build_machine = self.interpreter.builtin'build_machine'.cpu_family_method(None, None)
-        if build_machine == '64' or build_machine == 'x86_64':
+        if build_machine in {'64', 'x86_64'}:
             # amd64 or x86_64
             self.build_platform = 'x64'
         elif build_machine == 'x86':
             # x86
             self.build_platform = 'Win32'
-        elif build_machine == 'aarch64' or build_machine == 'arm64':
+        elif build_machine in {'aarch64', 'arm64'}:
             target_cpu = self.interpreter.builtin'build_machine'.cpu_method(None, None)
             if target_cpu == 'arm64ec':
                 self.build_platform = 'arm64ec'
@@ -270,12 +279,15 @@
                 resulto.target.get_id() = o.target
         return result.items()
 
-    def get_target_deps(self, t, recursive=False):
-        all_deps = {}
+    def get_target_deps(self, t: T.DictT.Any, build.Target, recursive=False):
+        all_deps: T.Dictstr, build.Target = {}
         for target in t.values():
             if isinstance(target, build.CustomTarget):
                 for d in target.get_target_dependencies():
-                    all_depsd.get_id() = d
+                    # FIXME: this isn't strictly correct, as the target doesn't
+                    # Get dependencies on non-targets, such as Files
+                    if isinstance(d, build.Target):
+                        all_depsd.get_id() = d
             elif isinstance(target, build.RunTarget):
                 for d in target.get_dependencies():
                     all_depsd.get_id() = d
@@ -315,11 +327,13 @@
                     gen_exe = generator.get_exe()
                     if isinstance(gen_exe, build.Executable):
                         all_depsgen_exe.get_id() = gen_exe
-                    for d in generator.depends:
+                    for d in itertools.chain(generator.depends, gendep.depends):
                         if isinstance(d, build.CustomTargetIndex):
                             all_depsd.get_id() = d.target
-                        else:
+                        elif isinstance(d, build.Target):
                             all_depsd.get_id() = d
+                        # FIXME: we don't handle other kinds of deps correctly here, such
+                        # as GeneratedLists, StructuredSources, and generated File.
 
         if not t or not recursive:
             return all_deps
@@ -349,6 +363,7 @@
 
     def generate_solution(self, sln_filename, projlist):
         default_projlist = self.get_build_by_default_targets()
+        default_projlist.update(self.get_testlike_targets())
         sln_filename_tmp = sln_filename + '~'
         # Note using the utf-8 BOM requires the blank line, otherwise Visual Studio Version Selector fails.
         # Without the BOM, VSVS fails if there is a blank line.
@@ -651,7 +666,8 @@
                                                    capture=ofilenames0 if target.capture else None,
                                                    feed=srcs0 if target.feed else None,
                                                    force_serialize=True,
-                                                   env=target.env)
+                                                   env=target.env,
+                                                   verbose=target.console)
         if target.build_always_stale:
             # Use a nonexistent file to always consider the target out-of-date.
             ofilenames += self.nonexistent_file(os.path.join(self.environment.get_scratch_dir(),
@@ -665,6 +681,23 @@
         self.add_target_deps(root, target)
         self._prettyprint_vcxproj_xml(ET.ElementTree(root), ofname)
 
+    def gen_compile_target_vcxproj(self, target, ofname, guid):
+        if target.for_machine is MachineChoice.BUILD:
+            platform = self.build_platform
+        else:
+            platform = self.platform
+        (root, type_config) = self.create_basic_project(target.name,
+                                                        temp_dir=target.get_id(),
+                                                        guid=guid,
+                                                        target_platform=platform)
+        ET.SubElement(root, 'Import', Project=r'$(VCTargetsPath)\Microsoft.Cpp.targets')
+        target.generated = self.compile_target_to_generator(target)
+        target.sources = 
+        self.generate_custom_generator_commands(target, root)
+        self.add_regen_dependency(root)
+        self.add_target_deps(root, target)
+        self._prettyprint_vcxproj_xml(ET.ElementTree(root), ofname)
+
     @classmethod
     def lang_from_source_file(cls, src):
         ext = src.split('.')-1
@@ -817,13 +850,13 @@
 
     def _get_cl_compiler(self, target):
         for lang, c in target.compilers.items():
-            if lang in ('c', 'cpp'):
+            if lang in {'c', 'cpp'}:
                 return c
         # No source files, only objects, but we still need a compiler, so
         # return a found compiler
         if len(target.objects) > 0:
             for lang, c in self.environment.coredata.compilerstarget.for_machine.items():
-                if lang in ('c', 'cpp'):
+                if lang in {'c', 'cpp'}:
                     return c
         raise MesonException('Could not find a C or C++ compiler. MSVC can only build C/C++ projects.')
 
@@ -858,6 +891,8 @@
             return self.gen_custom_target_vcxproj(target, ofname, guid)
         elif isinstance(target, build.RunTarget):
             return self.gen_run_target_vcxproj(target, ofname, guid)
+        elif isinstance(target, build.CompileTarget):
+            return self.gen_compile_target_vcxproj(target, ofname, guid)
         else:
             raise MesonException(f'Unknown target type for {target.get_basename()}')
         # Prefix to use to access the build root from the vcxproj dir
@@ -867,7 +902,7 @@
         # Prefix to use to access the source tree's subdir from the vcxproj dir
         proj_to_src_dir = os.path.join(proj_to_src_root, self.get_target_dir(target))
         (sources, headers, objects, languages) = self.split_sources(target.sources)
-        if self.is_unity(target):
+        if target.is_unity:
             sources = self.generate_unity_files(target, sources)
         compiler = self._get_cl_compiler(target)
         build_args = compiler.get_buildtype_args(self.buildtype)
@@ -990,9 +1025,9 @@
         for l, comp in target.compilers.items():
             if l in file_args:
                 file_argsl += compilers.get_base_compile_args(
-                    self.get_base_options_for_target(target), comp)
+                    target.get_options(), comp)
                 file_argsl += comp.get_option_compile_args(
-                    self.environment.coredata.options)
+                    target.get_options())
 
         # Add compile args added using add_project_arguments()
         for l, args in self.build.projects_argstarget.for_machine.get(target.subproject, {}).items():
@@ -1032,8 +1067,12 @@
                 # reversed is used to keep order of includes
                 for i in reversed(d.get_incdirs()):
                     curdir = os.path.join(d.get_curdir(), i)
-                    args.append('-I' + self.relpath(curdir, target.subdir))  # build dir
-                    args.append('-I' + os.path.join(proj_to_src_root, curdir))  # src dir
+                    try:
+                        args.append('-I' + self.relpath(curdir, target.subdir)) # build dir
+                        args.append('-I' + os.path.join(proj_to_src_root, curdir))  # src dir
+                    except ValueError:
+                        # Include is on different drive
+                        args.append('-I' + os.path.normpath(curdir))
                 for i in d.get_extra_build_dirs():
                     curdir = os.path.join(d.get_curdir(), i)
                     args.append('-I' + self.relpath(curdir, target.subdir))  # build dir
@@ -1114,9 +1153,9 @@
         ET.SubElement(clconf, 'PreprocessorDefinitions').text = ';'.join(target_defines)
         ET.SubElement(clconf, 'FunctionLevelLinking').text = 'true'
         # Warning level
-        warning_level = self.get_option_for_target(OptionKey('warning_level'), target)
+        warning_level = target.get_option(OptionKey('warning_level'))
         ET.SubElement(clconf, 'WarningLevel').text = 'Level' + str(1 + int(warning_level))
-        if self.get_option_for_target(OptionKey('werror'), target):
+        if target.get_option(OptionKey('werror')):
             ET.SubElement(clconf, 'TreatWarningAsError').text = 'true'
         # Optimization flags
         o_flags = split_o_flags_args(build_args)
@@ -1137,7 +1176,8 @@
         # Size-preserving flags
         if '/Os' in o_flags:
             ET.SubElement(clconf, 'FavorSizeOrSpeed').text = 'Size'
-        else:
+        # Note: setting FavorSizeOrSpeed with clang-cl conflicts with /Od and can make debugging difficult, so don't.
+        elif '/Od' not in o_flags:
             ET.SubElement(clconf, 'FavorSizeOrSpeed').text = 'Speed'
         # Note: SuppressStartupBanner is /NOLOGO and is 'true' by default
         self.generate_lang_standard_info(file_args, clconf)
@@ -1231,14 +1271,14 @@
                     # Unfortunately, we can't use self.object_filename_from_source()
                     for gen in l.genlist:
                         for src in gen.get_outputs():
-                            if self.environment.is_source(src) and not self.environment.is_header(src):
+                            if self.environment.is_source(src):
                                 path = self.get_target_generated_dir(t, gen, src)
                                 gen_src_ext = '.' + os.path.splitext(path)11:
                                 extra_link_args.append(path:-len(gen_src_ext) + '.obj')
 
                     for src in l.srclist:
                         obj_basename = None
-                        if self.environment.is_source(src) and not self.environment.is_header(src):
+                        if self.environment.is_source(src):
                             obj_basename = self.object_filename_from_source(t, src)
                             target_private_dir = self.relpath(self.get_target_private_dir(t),
                                                               self.get_target_dir(t))
@@ -1268,7 +1308,7 @@
         for lib in self.get_custom_target_provided_libraries(target):
             additional_links.append(self.relpath(lib, self.get_target_dir(target)))
         additional_objects = 
-        for o in self.flatten_object_list(target, down):
+        for o in self.flatten_object_list(target, down)0:
             assert isinstance(o, str)
             additional_objects.append(o)
         for o in custom_objs:
@@ -1287,7 +1327,7 @@
         ofile.text = f'$(OutDir){target.get_filename()}'
         subsys = ET.SubElement(link, 'SubSystem')
         subsys.text = subsystem
-        if (isinstance(target, build.SharedLibrary) or isinstance(target, build.Executable)) and target.get_import_filename():
+        if isinstance(target, (build.SharedLibrary, build.Executable)) and target.get_import_filename():
             # DLLs built with MSVC always have an import library except when
             # they're data-only DLLs, but we don't support those yet.
             ET.SubElement(link, 'ImportLibrary').text = target.get_import_filename()
@@ -1301,12 +1341,12 @@
             pdb.text = f'$(OutDir){target_name}.pdb'
         targetmachine = ET.SubElement(link, 'TargetMachine')
         if target.for_machine is MachineChoice.BUILD:
-            targetplatform = platform
+            targetplatform = platform.lower()
         else:
             targetplatform = self.platform.lower()
         if targetplatform == 'win32':
             targetmachine.text = 'MachineX86'
-        elif targetplatform == 'x64':
+        elif targetplatform == 'x64' or detect_microsoft_gdk(targetplatform):
             targetmachine.text = 'MachineX64'
         elif targetplatform == 'arm':
             targetmachine.text = 'MachineARM'
@@ -1349,9 +1389,8 @@
                 relpath = os.path.join(down, h.rel_to_builddir(self.build_to_src))
                 if path_normalize_add(relpath, previous_includes):
                     ET.SubElement(inc_hdrs, 'CLInclude', Include=relpath)
-            for lang in pch_sources:
-                h = pch_sourceslang0
-                path = os.path.join(proj_to_src_dir, h)
+            for headers in pch_sources.values():
+                path = os.path.join(proj_to_src_dir, headers0)
                 if path_normalize_add(path, previous_includes):
                     ET.SubElement(inc_hdrs, 'CLInclude', Include=path)
 
@@ -1380,8 +1419,8 @@
                     s = File.from_built_file(target.get_subdir(), s)
                     ET.SubElement(inc_cl, 'ObjectFileName').text = "$(IntDir)" + \
                         self.object_filename_from_source(target, s)
-            for lang in pch_sources:
-                impl = pch_sourceslang1
+            for lang, headers in pch_sources.items():
+                impl = headers1
                 if impl and path_normalize_add(impl, previous_sources):
                     inc_cl = ET.SubElement(inc_src, 'CLCompile', Include=impl)
                     self.create_pch(pch_sources, lang, inc_cl)
@@ -1499,15 +1538,15 @@
             message.text = msg
         if not verify_files:
             ET.SubElement(custombuild, 'VerifyInputsAndOutputsExist').text = 'false'
-        ET.SubElement(custombuild, 'Command').text = f'''setlocal
-{command}
-if %%errorlevel%% neq 0 goto :cmEnd
-:cmEnd
-endlocal & call :cmErrorLevel %%errorlevel%% & goto :cmDone
-:cmErrorLevel
-exit /b %%1
-:cmDone
-if %%errorlevel%% neq 0 goto :VCEnd'''
+
+        # If a command ever were to change the current directory or set local
+        # variables this would need to be more complicated, as msbuild by
+        # default executes all CustomBuilds in a project using the same
+        # shell. Right now such tasks are all done inside the meson_exe
+        # wrapper. The trailing newline appears to be necessary to allow
+        # parallel custom builds to work.
+        ET.SubElement(custombuild, 'Command').text = f"{command}\n"
+
         if not outputs:
             # Use a nonexistent file to always consider the target out-of-date.
             outputs = self.nonexistent_file(os.path.join(self.environment.get_scratch_dir(),

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/backend/vs2012backend.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/backend/vs2012backend.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/backend/vs2013backend.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/backend/vs2013backend.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/backend/vs2015backend.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/backend/vs2015backend.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/backend/vs2017backend.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/backend/vs2017backend.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/backend/vs2019backend.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/backend/vs2019backend.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/backend/vs2022backend.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/backend/vs2022backend.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/backend/xcodebackend.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/backend/xcodebackend.py Changed

@@ -11,17 +11,20 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
+
+import uuid, os, operator
+import typing as T
 
 from . import backends
 from .. import build
 from .. import dependencies
 from .. import mesonlib
 from .. import mlog
-import uuid, os, operator
-import typing as T
-
 from ..mesonlib import MesonException, OptionKey
-from ..interpreter import Interpreter
+
+if T.TYPE_CHECKING:
+    from ..interpreter import Interpreter
 
 INDENT = '\t'
 XCODETYPEMAP = {'c': 'sourcecode.c.c',
@@ -49,7 +52,8 @@
                'objcpp': 'OBJCPLUSPLUS',
                'swift': 'SWIFT_'
                }
-OPT2XCODEOPT = {'0': '0',
+OPT2XCODEOPT = {'plain': None,
+                '0': '0',
                 'g': '0',
                 '1': '1',
                 '2': '2',
@@ -131,8 +135,8 @@
         self.items = 
 
     def add_item(self, key, value, comment=''):
-        item = PbxDictItem(key, value, comment)
         assert key not in self.keys
+        item = PbxDictItem(key, value, comment)
         self.keys.add(key)
         self.items.append(item)
 
@@ -256,9 +260,6 @@
         obj_path = f'{project}.build/{buildtype}/{tname}.build/Objects-normal/{arch}/{stem}.o'
         return obj_path
 
-    def get_extracted_obj_paths(self, target: build.BuildTarget, outputs: T.Liststr) -> T.Liststr:
-        return outputs
-
     def generate(self):
         self.serialize_tests()
         # Cache the result as the method rebuilds the array every time it is called.
@@ -540,7 +541,7 @@
         self.custom_aggregate_targets = {}
         self.build_all_tdep_id = self.gen_id()
         # FIXME: filter out targets that are not built by default.
-        target_dependencies = list(map(lambda t: self.pbx_dep_mapt, self.build_targets))
+        target_dependencies = self.pbx_dep_mapt for t in self.build_targets
         custom_target_dependencies = self.pbx_custom_dep_mapt for t in self.custom_targets
         aggregated_targets = 
         aggregated_targets.append((self.all_id, 'ALL_BUILD',
@@ -601,7 +602,9 @@
                 if isinstance(dep, dependencies.AppleFrameworks):
                     for f in dep.frameworks:
                         fw_dict = PbxDict()
-                        objects_dict.add_item(self.native_frameworksf, fw_dict, f'{f}.framework in Frameworks')
+                        fwkey = self.native_frameworksf
+                        if fwkey not in objects_dict.keys:
+                            objects_dict.add_item(fwkey, fw_dict, f'{f}.framework in Frameworks')
                         fw_dict.add_item('isa', 'PBXBuildFile')
                         fw_dict.add_item('fileRef', self.native_frameworks_filereff, f)
 
@@ -1177,7 +1180,8 @@
             (srcs, ofilenames, cmd) = self.eval_custom_target_command(t, absolute_outputs=True)
             fixed_cmd, _ = self.as_meson_exe_cmdline(cmd0,
                                                      cmd1:,
-                                                     #workdir=None,
+                                                     capture=ofilenames0 if t.capture else None,
+                                                     feed=srcs0 if t.feed else None,
                                                      env=t.env)
             custom_dict = PbxDict()
             objects_dict.add_item(self.shell_targetstname, custom_dict, f'/* Custom target {tname} */')
@@ -1215,6 +1219,8 @@
                     generator_id += 1
 
     def generate_single_generator_phase(self, tname, t, genlist, generator_id, objects_dict):
+        # TODO: this should be rewritten to use the meson wrapper, like the other generators do
+        # Currently it doesn't handle a host binary that requires an exe wrapper correctly.
         generator = genlist.get_generator()
         exe = generator.get_exe()
         exe_arr = self.build_target_to_cmd_array(exe)
@@ -1319,7 +1325,7 @@
 
         for t in self.custom_targets:
             idval = self.pbx_custom_dep_mapt
-            targets.append((idval, self.custom_aggregate_targetst, t, None))#self.containerproxy_mapt))
+            targets.append((idval, self.custom_aggregate_targetst, t, None)) # self.containerproxy_mapt))
 
         # Sort object by ID
         sorted_targets = sorted(targets, key=operator.itemgetter(0))
@@ -1463,7 +1469,7 @@
                 # Add extracted objects to the link line by hand.
                 if isinstance(o, build.ExtractedObjects):
                     added_objs = set()
-                    for objname_rel in o.get_outputs(self):
+                    for objname_rel in self.determine_ext_objs(o):
                         objname_abs = os.path.join(self.environment.get_build_dir(), o.target.subdir, objname_rel)
                         if objname_abs not in added_objs:
                             added_objs.add(objname_abs)
@@ -1503,8 +1509,8 @@
                 if compiler is None:
                     continue
                 # Start with warning args
-                warn_args = compiler.get_warn_args(self.get_option_for_target(OptionKey('warning_level'), target))
-                copt_proxy = self.get_compiler_options_for_target(target)
+                warn_args = compiler.get_warn_args(target.get_option(OptionKey('warning_level')))
+                copt_proxy = target.get_options()
                 std_args = compiler.get_option_compile_args(copt_proxy)
                 # Add compile args added using add_project_arguments()
                 pargs = self.build.projects_argstarget.for_machine.get(target.subproject, {}).get(lang, )
@@ -1556,9 +1562,11 @@
             if target.suffix:
                 suffix = '.' + target.suffix
                 settings_dict.add_item('EXECUTABLE_SUFFIX', suffix)
-            settings_dict.add_item('GCC_GENERATE_DEBUGGING_SYMBOLS', BOOL2XCODEBOOLself.get_option_for_target(OptionKey('debug'), target))
+            settings_dict.add_item('GCC_GENERATE_DEBUGGING_SYMBOLS', BOOL2XCODEBOOLtarget.get_option(OptionKey('debug')))
             settings_dict.add_item('GCC_INLINES_ARE_PRIVATE_EXTERN', 'NO')
-            settings_dict.add_item('GCC_OPTIMIZATION_LEVEL', OPT2XCODEOPTself.get_option_for_target(OptionKey('optimization'), target))
+            opt_flag = OPT2XCODEOPTtarget.get_option(OptionKey('optimization'))
+            if opt_flag is not None:
+                settings_dict.add_item('GCC_OPTIMIZATION_LEVEL', opt_flag)
             if target.has_pch:
                 # Xcode uses GCC_PREFIX_HEADER which only allows one file per target/executable. Precompiling various header files and
                 # applying a particular pch to each source file will require custom scripts (as a build phase) and build flags per each

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/build.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/build.py Changed

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from collections import OrderedDict
+from __future__ import annotations
+from collections import defaultdict, OrderedDict
+from dataclasses import dataclass, field
 from functools import lru_cache
 import copy
 import hashlib
@@ -23,6 +25,7 @@
 import textwrap
 import typing as T
 
+
 from . import environment
 from . import dependencies
 from . import mlog
@@ -32,25 +35,31 @@
 File, MesonException, MachineChoice, PerMachine, OrderedSet, listify,
 extract_as_list, typeslistify, stringlistify, classify_unity_sources,
 get_filenames_templates_dict, substitute_values, has_path_sep,
- OptionKey, PerMachineDefaultable,
- MesonBugException,
+ OptionKey, PerMachineDefaultable, OptionOverrideProxy,
+ MesonBugException, EnvironmentVariables, pickle_load,
 )
 from .compilers import (
- Compiler, is_object, clink_langs, sort_clink, lang_suffixes, all_languages,
- is_known_suffix, detect_static_linker, detect_compiler_for
+ is_object, clink_langs, sort_clink, all_languages,
+ is_known_suffix, detect_static_linker
 )
-from .linkers import StaticLinker
 from .interpreterbase import FeatureNew, FeatureDeprecated
 
 if T.TYPE_CHECKING:
- from ._typing import ImmutableListProtocol, ImmutableSetProtocol
+ from typing_extensions import Literal
+ from ._typing import ImmutableListProtocol
 from .backend.backends import Backend, ExecutableSerialisation
+ from .compilers import Compiler
 from .interpreter.interpreter import Test, SourceOutputs, Interpreter
+ from .interpreterbase import SubProject
+ from .linkers import StaticLinker
 from .mesonlib import FileMode, FileOrString
 from .modules import ModuleState
 from .mparser import BaseNode
+ from .wrap import WrapMode
 
 GeneratedTypes = T.Union'CustomTarget', 'CustomTargetIndex', 'GeneratedList'
+ LibTypes = T.Union'SharedLibrary', 'StaticLibrary', 'CustomTarget', 'CustomTargetIndex'
+ BuildTargetTypes = T.Union'BuildTarget', 'CustomTarget', 'CustomTargetIndex'
 
 pch_kwargs = {'c_pch', 'cpp_pch'}
 
@@ -106,7 +115,19 @@
 known_shlib_kwargs = known_build_target_kwargs | {'version', 'soversion', 'vs_module_defs', 'darwin_versions'}
 known_shmod_kwargs = known_build_target_kwargs | {'vs_module_defs'}
 known_stlib_kwargs = known_build_target_kwargs | {'pic', 'prelink'}
-known_jar_kwargs = known_exe_kwargs | {'main_class'}
+known_jar_kwargs = known_exe_kwargs | {'main_class', 'java_resources'}
+
+def _process_install_tag(install_tag: T.OptionalT.ListT.Optionalstr,
+ num_outputs: int) -> T.ListT.Optionalstr:
+ _install_tag: T.ListT.Optionalstr
+ if not install_tag:
+ _install_tag = None * num_outputs
+ elif len(install_tag) == 1:
+ _install_tag = install_tag * num_outputs
+ else:
+ _install_tag = install_tag
+ return _install_tag
+
 
 @lru_cache(maxsize=None)
 def get_target_macos_dylib_install_name(ld) -> str:
@@ -119,22 +140,19 @@
 class InvalidArguments(MesonException):
 pass
 
+@dataclass(eq=False)
 class DependencyOverride(HoldableObject):
- def __init__(self, dep: dependencies.Dependency, node: 'BaseNode', explicit: bool = True):
- self.dep = dep
- self.node = node
- self.explicit = explicit
+ dep: dependencies.Dependency
+ node: 'BaseNode'
+ explicit: bool = True
 
+@dataclass(eq=False)
 class Headers(HoldableObject):
-
- def __init__(self, sources: T.ListFile, install_subdir: T.Optionalstr,
- custom_install_dir: T.Optionalstr, custom_install_mode: 'FileMode',
- subproject: str):
- self.sources = sources
- self.install_subdir = install_subdir
- self.custom_install_dir = custom_install_dir
- self.custom_install_mode = custom_install_mode
- self.subproject = subproject
+ sources: T.ListFile
+ install_subdir: T.Optionalstr
+ custom_install_dir: T.Optionalstr
+ custom_install_mode: 'FileMode'
+ subproject: str
 
 # TODO: we really don't need any of these methods, but they're preserved to
 # keep APIs relying on them working.
@@ -155,16 +173,13 @@
 return self.custom_install_mode
 
 
+@dataclass(eq=False)
 class Man(HoldableObject):
-
- def __init__(self, sources: T.ListFile, custom_install_dir: T.Optionalstr,
- custom_install_mode: 'FileMode', subproject: str,
- locale: T.Optionalstr):
- self.sources = sources
- self.custom_install_dir = custom_install_dir
- self.custom_install_mode = custom_install_mode
- self.subproject = subproject
- self.locale = locale
+ sources: T.ListFile
+ custom_install_dir: T.Optionalstr
+ custom_install_mode: 'FileMode'
+ subproject: str
+ locale: T.Optionalstr
 
 def get_custom_install_dir(self) -> T.Optionalstr:
 return self.custom_install_dir
@@ -176,40 +191,31 @@
 return self.sources
 
 
+@dataclass(eq=False)
 class EmptyDir(HoldableObject):
-
- def __init__(self, path: str, install_mode: 'FileMode', subproject: str,
- install_tag: T.Optionalstr = None):
- self.path = path
- self.install_mode = install_mode
- self.subproject = subproject
- self.install_tag = install_tag
+ path: str
+ install_mode: 'FileMode'
+ subproject: str
+ install_tag: T.Optionalstr = None
 
 
+@dataclass(eq=False)
 class InstallDir(HoldableObject):
+ source_subdir: str
+ installable_subdir: str
+ install_dir: str
+ install_dir_name: str
+ install_mode: 'FileMode'
+ exclude: T.TupleT.Setstr, T.Setstr
+ strip_directory: bool
+ subproject: str
+ from_source_dir: bool = True
+ install_tag: T.Optionalstr = None
 
- def __init__(self, source_subdir: str, installable_subdir: str, install_dir: str,
- install_mode: 'FileMode',
- exclude: T.TupleT.Setstr, T.Setstr,
- strip_directory: bool, subproject: str,
- from_source_dir: bool = True,
- install_tag: T.Optionalstr = None):
- self.source_subdir = source_subdir
- self.installable_subdir = installable_subdir
- self.install_dir = install_dir
- self.install_mode = install_mode
- self.exclude = exclude
- self.strip_directory = strip_directory
- self.from_source_dir = from_source_dir
- self.subproject = subproject
- self.install_tag = install_tag
-
-
+@dataclass(eq=False)
 class DepManifest:
-
- def __init__(self, version: str, license: T.Liststr):
- self.version = version
- self.license = license
+ version: str
+ license: T.Liststr
 
 def to_json(self) -> T.Dictstr, T.Unionstr, T.Liststr:
 return {
@@ -218,6 +224,7 @@
 }
 
 
+# literally everything isn't dataclass stuff
 class Build:
 """A class that holds the status of one build including
 all dependencies and so on.
@@ -229,7 +236,6 @@
 self.environment = environment
 self.projects = {}
 self.targets: 'T.OrderedDictstr, T.UnionCustomTarget, BuildTarget' = OrderedDict()
- self.run_target_names: T.SetT.Tuplestr, str = set()
 self.global_args: PerMachineT.Dictstr, T.Liststr = PerMachine({}, {})
 self.global_link_args: PerMachineT.Dictstr, T.Liststr = PerMachine({}, {})
 self.projects_args: PerMachineT.Dictstr, T.Dictstr, T.Liststr = PerMachine({}, {})
@@ -254,7 +260,7 @@
 self.test_setups: T.Dictstr, TestSetup = {}
 self.test_setup_default_name = None
 self.find_overrides: T.Dictstr, T.Union'Executable', programs.ExternalProgram, programs.OverrideProgram = {}
- self.searched_programs = set() # The list of all programs that have been searched for.
+ self.searched_programs: T.Setstr = set() # The list of all programs that have been searched for.
 
 # If we are doing a cross build we need two caches, if we're doing a
 # build == host compilation the both caches should point to the same place.
@@ -278,7 +284,7 @@
 custom_targetsname = t
 return custom_targets
 
- def copy(self):
+ def copy(self) -> Build:
 other = Build(self.environment)
 for k, v in self.__dict__.items():
 if isinstance(v, (list, dict, set, OrderedDict)):
@@ -287,11 +293,11 @@
 other.__dict__k = v
 return other
 
- def merge(self, other):
+ def merge(self, other: Build) -> None:
 for k, v in other.__dict__.items():
 self.__dict__k = v
 
- def ensure_static_linker(self, compiler):
+ def ensure_static_linker(self, compiler: Compiler) -> None:
 if self.static_linkercompiler.for_machine is None and compiler.needs_static_linker():
 self.static_linkercompiler.for_machine = detect_static_linker(self.environment, compiler)
 
@@ -352,18 +358,17 @@
 
 return link_args.get(compiler.get_language(), )
 
+@dataclass(eq=False)
 class IncludeDirs(HoldableObject):
 
 """Internal representation of an include_directories call."""
 
- def __init__(self, curdir: str, incdirs: T.Liststr, is_system: bool, extra_build_dirs: T.OptionalT.Liststr = None):
- self.curdir = curdir
- self.incdirs = incdirs
- self.is_system = is_system
-
- # Interpreter has validated that all given directories
- # actually exist.
- self.extra_build_dirs: T.Liststr = extra_build_dirs or 
+ curdir: str
+ incdirs: T.Liststr
+ is_system: bool
+ # Interpreter has validated that all given directories
+ # actually exist.
+ extra_build_dirs: T.Liststr = field(default_factory=list)
 
 def __repr__(self) -> str:
 r = '<{} {}/{}>'
@@ -382,7 +387,7 @@
 """Convert IncludeDirs object to a list of strings.
 
 :param sourcedir: The absolute source directory
- :param builddir: The absolute build directory, option, buid dir will not
+ :param builddir: The absolute build directory, option, build dir will not
 be added if this is unset
 :returns: A list of strings (without compiler argument)
 """
@@ -393,21 +398,18 @@
 strlist.append(os.path.join(builddir, self.curdir, idir))
 return strlist
 
+@dataclass(eq=False)
 class ExtractedObjects(HoldableObject):
 '''
 Holds a list of sources for which the objects must be extracted
 '''
- def __init__(self, target: 'BuildTarget',
- srclist: T.OptionalT.ListFile = None,
- genlist: T.OptionalT.List'GeneratedTypes' = None,
- objlist: T.OptionalT.ListT.Unionstr, 'File', 'ExtractedObjects' = None,
- recursive: bool = True):
- self.target = target
- self.recursive = recursive
- self.srclist: T.ListFile = srclist if srclist is not None else 
- self.genlist: T.List'GeneratedTypes' = genlist if genlist is not None else 
- self.objlist: T.OptionalT.ListT.Unionstr, 'File', 'ExtractedObjects' = \
- objlist if objlist is not None else 
+ target: 'BuildTarget'
+ srclist: T.ListFile = field(default_factory=list)
+ genlist: T.List'GeneratedTypes' = field(default_factory=list)
+ objlist: T.ListT.Unionstr, 'File', 'ExtractedObjects' = field(default_factory=list)
+ recursive: bool = True
+
+ def __post_init__(self) -> None:
 if self.target.is_unity:
 self.check_unity_compatible()
 
@@ -427,9 +429,9 @@
 sources.append(s)
 
 # Filter out headers and all non-source files
- return s for s in sources if environment.is_source(s) and not environment.is_header(s)
+ return s for s in sources if environment.is_source(s)
 
- def classify_all_sources(self, sources: T.Liststr, generated_sources: T.Sequence'GeneratedTypes') -> T.Dict'Compiler', T.List'FileOrString':
+ def classify_all_sources(self, sources: T.ListFileOrString, generated_sources: T.Sequence'GeneratedTypes') -> T.Dict'Compiler', T.List'FileOrString':
 sources_ = self.get_sources(sources, generated_sources)
 return classify_unity_sources(self.target.compilers.values(), sources_)
 
@@ -449,94 +451,84 @@
 'in Unity builds. You can only extract all '
 'the object files for each compiler at once.')
 
- def get_outputs(self, backend: 'Backend') -> T.Liststr:
- return 
- backend.object_filename_from_source(self.target, source)
- for source in self.get_sources(self.srclist, self.genlist)
- 
-
-class EnvironmentVariables(HoldableObject):
- def __init__(self, values: T.OptionalT.Dictstr, str = None) -> None:
- self.envvars: T.ListT.TupleT.CallableT.Dictstr, str, str, T.Liststr, str, str, str, T.Liststr, str = 
- # The set of all env vars we have operations for. Only used for self.has_name()
- self.varnames: T.Setstr = set()
-
- if values:
- for name, value in values.items():
- self.set(name, value)
 
- def __repr__(self) -> str:
- repr_str = "<{0}: {1}>"
- return repr_str.format(self.__class__.__name__, self.envvars)
+@dataclass(eq=False, order=False)
+class StructuredSources(HoldableObject):
 
- def hash(self, hasher: T.Any):
- myenv = self.get_env({})
- for key in sorted(myenv.keys()):
- hasher.update(bytes(key, encoding='utf-8'))
- hasher.update(b',')
- hasher.update(bytes(myenvkey, encoding='utf-8'))
- hasher.update(b';')
-
- def has_name(self, name: str) -> bool:
- return name in self.varnames
-
- def set(self, name: str, values: T.Liststr, separator: str = os.pathsep) -> None:
- self.varnames.add(name)
- self.envvars.append((self._set, name, values, separator))
-
- def append(self, name: str, values: T.Liststr, separator: str = os.pathsep) -> None:
- self.varnames.add(name)
- self.envvars.append((self._append, name, values, separator))
-
- def prepend(self, name: str, values: T.Liststr, separator: str = os.pathsep) -> None:
- self.varnames.add(name)
- self.envvars.append((self._prepend, name, values, separator))
+ """A container for sources in languages that use filesystem hierarchy.
 
- @staticmethod
- def _set(env: T.Dictstr, str, name: str, values: T.Liststr, separator: str) -> str:
- return separator.join(values)
+ Languages like Rust and Cython rely on the layout of files in the filesystem
+ as part of the compiler implementation. This structure allows us to
+ represent the required filesystem layout.
+ """
 
- @staticmethod
- def _append(env: T.Dictstr, str, name: str, values: T.Liststr, separator: str) -> str:
- curr = env.get(name)
- return separator.join(values if curr is None else curr + values)
+ sources: T.DefaultDictstr, T.ListT.UnionFile, CustomTarget, CustomTargetIndex, GeneratedList = field(
+ default_factory=lambda: defaultdict(list))
 
- @staticmethod
- def _prepend(env: T.Dictstr, str, name: str, values: T.Liststr, separator: str) -> str:
- curr = env.get(name)
- return separator.join(values if curr is None else values + curr)
-
- def get_env(self, full_env: T.Dictstr, str) -> T.Dictstr, str:
- env = full_env.copy()
- for method, name, values, separator in self.envvars:
- envname = method(env, name, values, separator)
- return env
+ def __add__(self, other: StructuredSources) -> StructuredSources:
+ sources = self.sources.copy()
+ for k, v in other.sources.items():
+ sourcesk.extend(v)
+ return StructuredSources(sources)
+
+ def __bool__(self) -> bool:
+ return bool(self.sources)
+
+ def first_file(self) -> T.UnionFile, CustomTarget, CustomTargetIndex, GeneratedList:
+ """Get the first source in the root
 
+ :return: The first source in the root
+ """
+ return self.sources''0
+
+ def as_list(self) -> T.ListT.UnionFile, CustomTarget, CustomTargetIndex, GeneratedList:
+ return list(itertools.chain.from_iterable(self.sources.values()))
+
+ def needs_copy(self) -> bool:
+ """Do we need to create a structure in the build directory.
+
+ This allows us to avoid making copies if the structures exists in the
+ source dir. Which could happen in situations where a generated source
+ only exists in some configurations
+ """
+ for files in self.sources.values():
+ for f in files:
+ if isinstance(f, File):
+ if f.is_built:
+ return True
+ else:
+ return True
+ return False
+
+
+@dataclass(eq=False)
 class Target(HoldableObject):
 
 # TODO: should Target be an abc.ABCMeta?
 
- def __init__(self, name: str, subdir: str, subproject: str, build_by_default: bool, for_machine: MachineChoice):
- if has_path_sep(name):
+ name: str
+ subdir: str
+ subproject: 'SubProject'
+ build_by_default: bool
+ for_machine: MachineChoice
+ environment: environment.Environment
+
+ def __post_init__(self) -> None:
+ if has_path_sep(self.name):
 # Fix failing test 53 when this becomes an error.
 mlog.warning(textwrap.dedent(f'''\
- Target "{name}" has a path separator in its name.
+ Target "{self.name}" has a path separator in its name.
 This is not supported, it can cause unexpected failures and will become
- a hard error in the future.\
+ a hard error in the future.
 '''))
- self.name = name
- self.subdir = subdir
- self.subproject = subproject
- self.build_by_default = build_by_default
- self.for_machine = for_machine
 self.install = False
 self.build_always_stale = False
- self.option_overrides_base: T.DictOptionKey, str = {}
- self.option_overrides_compiler: T.DictOptionKey, str = {}
+ self.options = OptionOverrideProxy({}, self.environment.coredata.options, self.subproject)
 self.extra_files = # type: T.ListFile
 if not hasattr(self, 'typename'):
 raise RuntimeError(f'Target type is not set for target class "{type(self).__name__}". This is a bug')
 
+ # dataclass comparators?
 def __lt__(self, other: object) -> bool:
 if not isinstance(other, Target):
 return NotImplemented
@@ -557,31 +549,33 @@
 return NotImplemented
 return self.get_id() >= other.get_id()
 
- def get_default_install_dir(self, env: environment.Environment) -> T.Tuplestr, str:
+ def get_default_install_dir(self) -> T.Tuplestr, str:
 raise NotImplementedError
 
- def get_custom_install_dir(self) -> T.ListT.Unionstr, bool:
+ def get_custom_install_dir(self) -> T.ListT.Unionstr, LiteralFalse:
 raise NotImplementedError
 
- def get_install_dir(self, environment: environment.Environment) -> T.TupleT.Any, str, bool:
+ def get_install_dir(self) -> T.TupleT.ListT.Unionstr, LiteralFalse, str, LiteralFalse:
 # Find the installation directory.
- default_install_dir, install_dir_name = self.get_default_install_dir(environment)
+ default_install_dir, default_install_dir_name = self.get_default_install_dir()
 outdirs = self.get_custom_install_dir()
 if outdirs and outdirs0 != default_install_dir and outdirs0 is not True:
 # Either the value is set to a non-default value, or is set to
 # False (which means we want this specific output out of many
 # outputs to not be installed).
 custom_install_dir = True
+ install_dir_names = getattr(i, 'optname', None) for i in outdirs
 else:
 custom_install_dir = False
 # if outdirs is empty we need to set to something, otherwise we set
- # only the first value to the default
+ # only the first value to the default.
 if outdirs:
 outdirs0 = default_install_dir
 else:
 outdirs = default_install_dir
+ install_dir_names = default_install_dir_name * len(outdirs)
 
- return outdirs, install_dir_name, custom_install_dir
+ return outdirs, install_dir_names, custom_install_dir
 
 def get_basename(self) -> str:
 return self.name
@@ -635,13 +629,25 @@
 # set, use the value of 'install' if it's enabled.
 self.build_by_default = True
 
- option_overrides = self.parse_overrides(kwargs)
+ self.set_option_overrides(self.parse_overrides(kwargs))
 
+ def set_option_overrides(self, option_overrides: T.DictOptionKey, str) -> None:
+ self.options.overrides = {}
 for k, v in option_overrides.items():
 if k.lang:
- self.option_overrides_compilerk.evolve(machine=self.for_machine) = v
- continue
- self.option_overrides_basek = v
+ self.options.overridesk.evolve(machine=self.for_machine) = v
+ else:
+ self.options.overridesk = v
+
+ def get_options(self) -> OptionOverrideProxy:
+ return self.options
+
+ def get_option(self, key: 'OptionKey') -> T.Unionstr, int, bool, 'WrapMode':
+ # We don't actually have wrapmode here to do an assert, so just do a
+ # cast, we know what's in coredata anyway.
+ # TODO: if it's possible to annotate get_option or validate_option_value
+ # in the future we might be able to remove the cast here
+ return T.cast('T.Unionstr, int, bool, WrapMode', self.optionskey.value)
 
 @staticmethod
 def parse_overrides(kwargs: T.Dictstr, T.Any) -> T.DictOptionKey, str:
@@ -650,7 +656,7 @@
 # In this case we have an already parsed and ready to go dictionary
 # provided by typed_kwargs
 if isinstance(opts, dict):
- return T.cast(T.DictOptionKey, str, opts)
+ return T.cast('T.DictOptionKey, str', opts)
 
 result: T.DictOptionKey, str = {}
 overrides = stringlistify(opts)
@@ -675,21 +681,21 @@
 class BuildTarget(Target):
 known_kwargs = known_build_target_kwargs
 
- install_dir: T.ListT.Unionstr, bool
+ install_dir: T.ListT.Unionstr, LiteralFalse
 
- def __init__(self, name: str, subdir: str, subproject: str, for_machine: MachineChoice,
- sources: T.List'SourceOutputs', objects, environment: environment.Environment, kwargs):
- super().__init__(name, subdir, subproject, True, for_machine)
- unity_opt = environment.coredata.get_option(OptionKey('unity'))
- self.is_unity = unity_opt == 'on' or (unity_opt == 'subprojects' and subproject != '')
- self.environment = environment
+ def __init__(self, name: str, subdir: str, subproject: SubProject, for_machine: MachineChoice,
+ sources: T.List'SourceOutputs', structured_sources: T.OptionalStructuredSources,
+ objects, environment: environment.Environment, compilers: T.Dictstr, 'Compiler', kwargs):
+ super().__init__(name, subdir, subproject, True, for_machine, environment)
+ self.all_compilers = compilers
 self.compilers = OrderedDict() # type: OrderedDictstr, Compiler
 self.objects: T.ListT.Unionstr, 'File', 'ExtractedObjects' = 
+ self.structured_sources = structured_sources
 self.external_deps: T.Listdependencies.Dependency = 
 self.include_dirs: T.List'IncludeDirs' = 
 self.link_language = kwargs.get('link_language')
- self.link_targets: T.ListT.Union'BuildTarget', 'CustomTarget', 'CustomTargetIndex' = 
- self.link_whole_targets = 
+ self.link_targets: T.ListLibTypes = 
+ self.link_whole_targets: T.ListT.UnionStaticLibrary, CustomTarget, CustomTargetIndex = 
 self.link_depends = 
 self.added_deps = set()
 self.name_prefix_set = False
@@ -703,7 +709,7 @@
 self.extra_args: T.Dictstr, T.List'FileOrString' = {}
 self.sources: T.ListFile = 
 self.generated: T.List'GeneratedTypes' = 
- self.d_features = {}
+ self.d_features = defaultdict(list)
 self.pic = False
 self.pie = False
 # Track build_rpath entries so we can remove them at install time
@@ -713,16 +719,24 @@
 # 1. Pre-existing objects provided by the user with the `objects:` kwarg
 # 2. Compiled objects created by and extracted from another target
 self.process_objectlist(objects)
- self.process_kwargs(kwargs, environment)
+ self.process_kwargs(kwargs)
 self.check_unknown_kwargs(kwargs)
- self.process_compilers()
- if not any(self.sources, self.generated, self.objects, self.link_whole):
- raise InvalidArguments(f'Build target {name} has no sources.')
- self.process_compilers_late()
- self.validate_sources()
- self.validate_install(environment)
+ if not any(self.sources, self.generated, self.objects, self.link_whole_targets, self.structured_sources):
+ mlog.warning(f'Build target {name} has no sources. '
+ 'This was never supposed to be allowed but did because of a bug, '
+ 'support will be removed in a future release of Meson')
+ self.validate_install()
 self.check_module_linking()
 
+ def post_init(self) -> None:
+ ''' Initialisations and checks requiring the final list of compilers to be known
+ '''
+ self.validate_sources()
+ if self.structured_sources and any(self.sources, self.generated):
+ raise MesonException('cannot mix structured sources and unstructured sources')
+ if self.structured_sources and 'rust' not in self.compilers:
+ raise MesonException('structured sources are only supported in Rust targets')
+
 def __repr__(self):
 repr_str = "<{0} {1}: {2}>"
 return repr_str.format(self.__class__.__name__, self.get_id(), self.filename)
@@ -730,9 +744,14 @@
 def __str__(self):
 return f"{self.name}"
 
- def validate_install(self, environment):
+ @property
+ def is_unity(self) -> bool:
+ unity_opt = self.get_option(OptionKey('unity'))
+ return unity_opt == 'on' or (unity_opt == 'subprojects' and self.subproject != '')
+
+ def validate_install(self):
 if self.for_machine is MachineChoice.BUILD and self.need_install:
- if environment.is_cross_build():
+ if self.environment.is_cross_build():
 raise InvalidArguments('Tried to install a target for the build machine in a cross build.')
 else:
 mlog.warning('Installing target build for the build machine. This will fail in a cross build.')
@@ -791,15 +810,15 @@
 removed = True
 return removed
 
- def process_compilers_late(self):
+ def process_compilers_late(self, extra_languages: T.Liststr):
 """Processes additional compilers after kwargs have been evaluated.
 
 This can add extra compilers that might be required by keyword
 arguments, such as link_with or dependencies. It will also try to guess
 which compiler to use if one hasn't been selected already.
 """
- # Populate list of compilers
- compilers = self.environment.coredata.compilersself.for_machine
+ for lang in extra_languages:
+ self.compilerslang = self.all_compilerslang
 
 # did user override clink_langs for this target?
 link_langs = self.link_language if self.link_language else clink_langs
@@ -807,40 +826,54 @@
 # If this library is linked against another library we need to consider
 # the languages of those libraries as well.
 if self.link_targets or self.link_whole_targets:
- extra = set()
 for t in itertools.chain(self.link_targets, self.link_whole_targets):
- if isinstance(t, CustomTarget) or isinstance(t, CustomTargetIndex):
+ if isinstance(t, (CustomTarget, CustomTargetIndex)):
 continue # We can't know anything about these.
 for name, compiler in t.compilers.items():
- if name in link_langs:
- extra.add((name, compiler))
- for name, compiler in sorted(extra, key=lambda p: sort_clink(p0)):
- self.compilersname = compiler
+ if name in link_langs and name not in self.compilers:
+ self.compilersname = compiler
 
 if not self.compilers:
 # No source files or parent targets, target consists of only object
 # files of unknown origin. Just add the first clink compiler
 # that we have and hope that it can link these objects
 for lang in link_langs:
- if lang in compilers:
- self.compilerslang = compilerslang
+ if lang in self.all_compilers:
+ self.compilerslang = self.all_compilerslang
 break
 
- def process_compilers(self):
+ # Now that we have the final list of compilers we can sort it according
+ # to clink_langs and do sanity checks.
+ self.compilers = OrderedDict(sorted(self.compilers.items(),
+ key=lambda t: sort_clink(t0)))
+ self.post_init()
+
+ def process_compilers(self) -> T.Liststr:
 '''
 Populate self.compilers, which is the list of compilers that this
 target will use for compiling all its sources.
 We also add compilers that were used by extracted objects to simplify
 dynamic linker determination.
+ Returns a list of missing languages that we can add implicitly, such as
+ C/C++ compiler for cython.
 '''
- if not self.sources and not self.generated and not self.objects:
- return
- # Populate list of compilers
- compilers = self.environment.coredata.compilersself.for_machine
+ missing_languages: T.Liststr = 
+ if not any(self.sources, self.generated, self.objects, self.structured_sources):
+ return missing_languages
 # Pre-existing sources
- sources = list(self.sources)
+ sources: T.List'FileOrString' = list(self.sources)
+ generated = self.generated.copy()
+
+ if self.structured_sources:
+ for v in self.structured_sources.sources.values():
+ for src in v:
+ if isinstance(src, (str, File)):
+ sources.append(src)
+ else:
+ generated.append(src)
+
 # All generated sources
- for gensrc in self.generated:
+ for gensrc in generated:
 for s in gensrc.get_outputs():
 # Generated objects can't be compiled, so don't use them for
 # compiler detection. If our target only has generated objects,
@@ -857,12 +890,15 @@
 for o in self.objects:
 if not isinstance(o, ExtractedObjects):
 continue
- for s in o.srclist:
+ compsrcs = o.classify_all_sources(o.srclist, )
+ for comp in compsrcs:
 # Don't add Vala sources since that will pull in the Vala
 # compiler even though we will never use it since we are
 # dealing with compiled C code.
- if not s.endswith(lang_suffixes'vala'):
- sources.append(s)
+ if comp.language == 'vala':
+ continue
+ if comp.language not in self.compilers:
+ self.compilerscomp.language = comp
 if sources:
 # For each source, try to add one compiler that can compile it.
 #
@@ -873,75 +909,38 @@
 # are expected to be able to add arbitrary non-source files to the
 # sources list
 for s in sources:
- for lang, compiler in compilers.items():
+ for lang, compiler in self.all_compilers.items():
 if compiler.can_compile(s):
 if lang not in self.compilers:
 self.compilerslang = compiler
 break
 else:
 if is_known_suffix(s):
- raise MesonException('No {} machine compiler for "{}"'.
- format(self.for_machine.get_lower_case_name(), s))
-
- # Re-sort according to clink_langs
- self.compilers = OrderedDict(sorted(self.compilers.items(),
- key=lambda t: sort_clink(t0)))
+ path = pathlib.Path(str(s)).as_posix()
+ m = f'No {self.for_machine.get_lower_case_name()} machine compiler for {path!r}'
+ raise MesonException(m)
 
 # If all our sources are Vala, our target also needs the C compiler but
 # it won't get added above.
 if 'vala' in self.compilers and 'c' not in self.compilers:
- self.compilers'c' = compilers'c'
+ self.compilers'c' = self.all_compilers'c'
 if 'cython' in self.compilers:
 key = OptionKey('language', machine=self.for_machine, lang='cython')
- if key in self.option_overrides_compiler:
- value = self.option_overrides_compilerkey
- else:
- value = self.environment.coredata.optionskey.value
+ value = self.get_option(key)
 
 try:
- self.compilersvalue = compilersvalue
+ self.compilersvalue = self.all_compilersvalue
 except KeyError:
- # TODO: it would be nice to not have to do this here, but we
- # have two problems to work around:
- # 1. If this is set via an override we have no way to know
- # before now that we need a compiler for the non-default language
- # 2. Because Cython itself initializes the `cython_language`
- # option, we have no good place to insert that you need it
- # before now, so we just have to do it here.
- comp = detect_compiler_for(self.environment, value, self.for_machine)
-
- # This is copied verbatim from the interpreter
- if self.for_machine == MachineChoice.HOST or self.environment.is_cross_build():
- logger_fun = mlog.log
- else:
- logger_fun = mlog.debug
- logger_fun(comp.get_display_language(), 'compiler for the', self.for_machine.get_lower_case_name(), 'machine:',
- mlog.bold(' '.join(comp.get_exelist())), comp.get_version_string())
- if comp.linker is not None:
- logger_fun(comp.get_display_language(), 'linker for the', self.for_machine.get_lower_case_name(), 'machine:',
- mlog.bold(' '.join(comp.linker.get_exelist())), comp.linker.id, comp.linker.version)
- if comp is None:
- raise MesonException(f'Cannot find required compiler {value}')
- self.compilersvalue = comp
+ missing_languages.append(value)
+
+ return missing_languages
 
 def validate_sources(self):
- if not self.sources:
- return
- for lang in ('cs', 'java'):
- if lang in self.compilers:
- check_sources = list(self.sources)
- compiler = self.compilerslang
- if not self.can_compile_remove_sources(compiler, check_sources):
- raise InvalidArguments(f'No {lang} sources found in target {self.name!r}')
- if check_sources:
- m = '{0} targets can only contain {0} files:\n'.format(lang.capitalize())
- m += '\n'.join(repr(c) for c in check_sources)
- raise InvalidArguments(m)
- # CSharp and Java targets can't contain any other file types
- assert len(self.compilers) == 1
- return
+ if len(self.compilers) > 1 and any(lang in self.compilers for lang in 'cs', 'java'):
+ langs = ', '.join(self.compilers.keys())
+ raise InvalidArguments(f'Cannot mix those languages into a target: {langs}')
 
- def process_link_depends(self, sources, environment):
+ def process_link_depends(self, sources):
 """Process the link_depends keyword argument.
 
 This is designed to handle strings, Files, and the output of Custom
@@ -956,7 +955,7 @@
 self.link_depends.append(s)
 elif isinstance(s, str):
 self.link_depends.append(
- File.from_source_file(environment.source_dir, self.subdir, s))
+ File.from_source_file(self.environment.source_dir, self.subdir, s))
 elif hasattr(s, 'get_outputs'):
 self.link_depends.append(s)
 else:
@@ -1005,24 +1004,24 @@
 return ExtractedObjects(self, self.sources, self.generated, self.objects,
 recursive)
 
- def get_all_link_deps(self) -> 'ImmutableListProtocolTarget':
+ def get_all_link_deps(self) -> ImmutableListProtocolBuildTargetTypes:
 return self.get_transitive_link_deps()
 
 @lru_cache(maxsize=None)
- def get_transitive_link_deps(self) -> 'ImmutableListProtocolTarget':
+ def get_transitive_link_deps(self) -> ImmutableListProtocolBuildTargetTypes:
 result: T.ListTarget = 
 for i in self.link_targets:
 result += i.get_all_link_deps()
 return result
 
- def get_link_deps_mapping(self, prefix: str, environment: environment.Environment) -> T.Mappingstr, str:
- return self.get_transitive_link_deps_mapping(prefix, environment)
+ def get_link_deps_mapping(self, prefix: str) -> T.Mappingstr, str:
+ return self.get_transitive_link_deps_mapping(prefix)
 
 @lru_cache(maxsize=None)
- def get_transitive_link_deps_mapping(self, prefix: str, environment: environment.Environment) -> T.Mappingstr, str:
+ def get_transitive_link_deps_mapping(self, prefix: str) -> T.Mappingstr, str:
 result: T.Dictstr, str = {}
 for i in self.link_targets:
- mapping = i.get_link_deps_mapping(prefix, environment)
+ mapping = i.get_link_deps_mapping(prefix)
 #we are merging two dictionaries, while keeping the earlier one dominant
 result_tmp = mapping.copy()
 result_tmp.update(result)
@@ -1030,7 +1029,7 @@
 return result
 
 @lru_cache(maxsize=None)
- def get_link_dep_subdirs(self) -> 'ImmutableSetProtocolstr':
+ def get_link_dep_subdirs(self) -> T.AbstractSetstr:
 result: OrderedSetstr = OrderedSet()
 for i in self.link_targets:
 if not isinstance(i, StaticLibrary):
@@ -1038,16 +1037,16 @@
 result.update(i.get_link_dep_subdirs())
 return result
 
- def get_default_install_dir(self, environment: environment.Environment) -> T.Tuplestr, str:
- return environment.get_libdir(), '{libdir}'
+ def get_default_install_dir(self) -> T.Tuplestr, str:
+ return self.environment.get_libdir(), '{libdir}'
 
- def get_custom_install_dir(self) -> T.ListT.Unionstr, bool:
+ def get_custom_install_dir(self) -> T.ListT.Unionstr, LiteralFalse:
 return self.install_dir
 
 def get_custom_install_mode(self) -> T.Optional'FileMode':
 return self.install_mode
 
- def process_kwargs(self, kwargs, environment):
+ def process_kwargs(self, kwargs):
 self.process_kwargs_base(kwargs)
 self.copy_kwargs(kwargs)
 kwargs.get('modules', )
@@ -1060,7 +1059,7 @@
 is reserved for libraries built as part of this project. External
 libraries must be passed using the dependencies keyword argument
 instead, because they are conceptually "external dependencies",
- just like those detected with the dependency() function.\
+ just like those detected with the dependency() function.
 '''))
 self.link(linktarget)
 lwhole = extract_as_list(kwargs, 'link_whole')
@@ -1074,12 +1073,12 @@
 self.add_pch('c', extract_as_list(kwargs, 'c_pch'))
 self.add_pch('cpp', extract_as_list(kwargs, 'cpp_pch'))
 
- if not isinstance(self, Executable) or 'export_dynamic' in kwargs:
+ if not isinstance(self, Executable) or kwargs.get('export_dynamic', False):
 self.vala_header = kwargs.get('vala_header', self.name + '.h')
 self.vala_vapi = kwargs.get('vala_vapi', self.name + '.vapi')
 self.vala_gir = kwargs.get('vala_gir', None)
 
- dfeatures = dict()
+ dfeatures = defaultdict(list)
 dfeature_unittest = kwargs.get('d_unittest', False)
 if dfeature_unittest:
 dfeatures'unittest' = dfeature_unittest
@@ -1107,9 +1106,9 @@
 mlog.warning(textwrap.dedent('''\
 Please do not define rpath with a linker argument, use install_rpath
 or build_rpath properties instead.
- This will become a hard error in a future Meson release.\
+ This will become a hard error in a future Meson release.
 '''))
- self.process_link_depends(kwargs.get('link_depends', ), environment)
+ self.process_link_depends(kwargs.get('link_depends', ))
 # Target-specific include dirs must be added BEFORE include dirs from
 # internal deps (added inside self.add_deps()) to override them.
 inclist = extract_as_list(kwargs, 'include_directories')
@@ -1145,7 +1144,7 @@
 extra_files = extract_as_list(kwargs, 'extra_files')
 for i in extra_files:
 assert isinstance(i, File)
- trial = os.path.join(environment.get_source_dir(), i.subdir, i.fname)
+ trial = os.path.join(self.environment.get_source_dir(), i.subdir, i.fname)
 if not os.path.isfile(trial):
 raise InvalidArguments(f'Tried to add non-existing extra file {i}.')
 self.extra_files = extra_files
@@ -1159,7 +1158,7 @@
 for r in resources:
 if not isinstance(r, str):
 raise InvalidArguments('Resource argument is not a string.')
- trial = os.path.join(environment.get_source_dir(), self.subdir, r)
+ trial = os.path.join(self.environment.get_source_dir(), self.subdir, r)
 if not os.path.isfile(trial):
 raise InvalidArguments(f'Tried to add non-existing resource {r}.')
 self.resources = resources
@@ -1195,13 +1194,13 @@
 if m.is_darwin() or m.is_windows():
 self.pic = True
 else:
- self.pic = self._extract_pic_pie(kwargs, 'pic', environment, 'b_staticpic')
+ self.pic = self._extract_pic_pie(kwargs, 'pic', 'b_staticpic')
 if isinstance(self, Executable) or (isinstance(self, StaticLibrary) and not self.pic):
 # Executables must be PIE on Android
 if self.environment.machinesself.for_machine.is_android():
 self.pie = True
 else:
- self.pie = self._extract_pic_pie(kwargs, 'pie', environment, 'b_pie')
+ self.pie = self._extract_pic_pie(kwargs, 'pie', 'b_pie')
 self.implicit_include_directories = kwargs.get('implicit_include_directories', True)
 if not isinstance(self.implicit_include_directories, bool):
 raise InvalidArguments('Implicit_include_directories must be a boolean.')
@@ -1219,7 +1218,7 @@
 raise InvalidArguments(f'Invalid value for win_subsystem: {value}.')
 return value
 
- def _extract_pic_pie(self, kwargs, arg: str, environment, option: str):
+ def _extract_pic_pie(self, kwargs, arg: str, option: str):
 # Check if we have -fPIC, -fpic, -fPIE, or -fpie in cflags
 all_flags = self.extra_args'c' + self.extra_args'cpp'
 if '-f' + arg.lower() in all_flags or '-f' + arg.upper() in all_flags:
@@ -1229,8 +1228,8 @@
 k = OptionKey(option)
 if arg in kwargs:
 val = kwargsarg
- elif k in environment.coredata.options:
- val = environment.coredata.optionsk.value
+ elif k in self.environment.coredata.options:
+ val = self.environment.coredata.optionsk.value
 else:
 val = False
 
@@ -1288,6 +1287,7 @@
 for dep in deps:
 if dep in self.added_deps:
 continue
+
 if isinstance(dep, dependencies.InternalDependency):
 # Those parts that are internal.
 self.process_sourcelist(dep.sources)
@@ -1302,7 +1302,7 @@
 ,
 dep.get_compile_args(),
 dep.get_link_args(),
- , , , , {})
+ , , , , {}, , )
 self.external_deps.append(extpart)
 # Deps of deps.
 self.add_deps(dep.ext_deps)
@@ -1318,6 +1318,9 @@
 # This is a bit of a hack. We do not want Build to know anything
 # about the interpreter so we can't import it and use isinstance.
 # This should be reliable enough.
+ if hasattr(dep, 'held_object'):
+ # FIXME: subproject is not a real ObjectHolder so we have to do this by hand
+ dep = dep.held_object
 if hasattr(dep, 'project_args_frozen') or hasattr(dep, 'global_args_frozen'):
 raise InvalidArguments('Tried to use subproject object as a dependency.\n'
 'You probably wanted to use a dependency declared in it instead.\n'
@@ -1326,13 +1329,20 @@
 'either an external dependency (returned by find_library() or '
 'dependency()) or an internal dependency (returned by '
 'declare_dependency()).')
+
+ dep_d_features = dep.d_features
+
+ for feature in ('versions', 'import_dirs'):
+ if feature in dep_d_features:
+ self.d_featuresfeature.extend(dep_d_featuresfeature)
+
 self.added_deps.add(dep)
 
 def get_external_deps(self) -> T.Listdependencies.Dependency:
 return self.external_deps
 
 def is_internal(self) -> bool:
- return isinstance(self, StaticLibrary) and not self.need_install
+ return False
 
 def link(self, target):
 for t in listify(target):
@@ -1340,11 +1350,19 @@
 if isinstance(t, (CustomTarget, CustomTargetIndex)):
 if not t.should_install():
 mlog.warning(f'Try to link an installed static library target {self.name} with a'
- 'custom target that is not installed, this might cause problems'
- 'when you try to use this static library')
- elif t.is_internal():
+ 'custom target that is not installed, this might cause problems'
+ 'when you try to use this static library')
+ elif t.is_internal() and not t.uses_rust():
 # When we're a static library and we link_with to an
 # internal/convenience library, promote to link_whole.
+ #
+ # There are cases we cannot do this, however. In Rust, for
+ # example, this can't be done with Rust ABI libraries, though
+ # it could be done with C ABI libraries, though there are
+ # several meson issues that need to be fixed:
+ # https://github.com/mesonbuild/meson/issues/10722
+ # https://github.com/mesonbuild/meson/issues/10723
+ # https://github.com/mesonbuild/meson/issues/10724
 return self.link_whole(t)
 if not isinstance(t, (Target, CustomTargetIndex)):
 raise InvalidArguments(f'{t!r} is not a target.')
@@ -1367,8 +1385,8 @@
 if isinstance(t, (CustomTarget, CustomTargetIndex)):
 if not t.is_linkable_target():
 raise InvalidArguments(f'Custom target {t!r} is not linkable.')
- if not t.get_filename().endswith('.a'):
- raise InvalidArguments('Can only link_whole custom targets that are .a archives.')
+ if t.links_dynamically():
+ raise InvalidArguments('Can only link_whole custom targets that are static archives.')
 if isinstance(self, StaticLibrary):
 # FIXME: We could extract the .a archive to get object files
 raise InvalidArguments('Cannot link_whole a custom target into a static library')
@@ -1451,8 +1469,8 @@
 else:
 self.extra_argslanguage = args
 
- def get_aliases(self) -> T.Dictstr, str:
- return {}
+ def get_aliases(self) -> T.ListT.Tuplestr, str, str:
+ return 
 
 def get_langs_used_by_deps(self) -> T.Liststr:
 '''
@@ -1483,14 +1501,13 @@
 return langs
 
 def get_prelinker(self):
- all_compilers = self.environment.coredata.compilersself.for_machine
 if self.link_language:
- comp = all_compilersself.link_language
+ comp = self.all_compilersself.link_language
 return comp
 for l in clink_langs:
 if l in self.compilers:
 try:
- prelinker = all_compilersl
+ prelinker = self.all_compilersl
 except KeyError:
 raise MesonException(
 f'Could not get a prelinker linker for build target {self.name!r}. '
@@ -1509,17 +1526,27 @@
 that can link compiled C. We don't actually need to add an exception
 for Vala here because of that.
 '''
- # Populate list of all compilers, not just those being used to compile
- # sources in this target
- all_compilers = self.environment.coredata.compilersself.for_machine
-
 # If the user set the link_language, just return that.
 if self.link_language:
- comp = all_compilersself.link_language
+ comp = self.all_compilersself.link_language
 return comp, comp.language_stdlib_only_link_flags(self.environment)
 
+ # Since dependencies could come from subprojects, they could have
+ # languages we don't have in self.all_compilers. Use the global list of
+ # all compilers here.
+ all_compilers = self.environment.coredata.compilersself.for_machine
+
 # Languages used by dependencies
 dep_langs = self.get_langs_used_by_deps()
+
+ # This set contains all the languages a linker can link natively
+ # without extra flags. For instance, nvcc (cuda) can link C++
+ # without injecting -lc++/-lstdc++, see
+ # https://github.com/mesonbuild/meson/issues/10570
+ MASK_LANGS = frozenset(
+ # (language, linker)
+ ('cpp', 'cuda'),
+ )
 # Pick a compiler based on the language priority-order
 for l in clink_langs:
 if l in self.compilers or l in dep_langs:
@@ -1531,27 +1558,29 @@
 f'Requires a linker for language "{l}", but that is not '
 'a project language.')
 stdlib_args: T.Liststr = 
- added_languages: T.Setstr = set()
 for dl in itertools.chain(self.compilers, dep_langs):
- if dl != linker.language:
+ if dl != linker.language and (dl, linker.language) not in MASK_LANGS:
 stdlib_args += all_compilersdl.language_stdlib_only_link_flags(self.environment)
- added_languages.add(dl)
 # Type of var 'linker' is Compiler.
 # Pretty hard to fix because the return value is passed everywhere
 return linker, stdlib_args
 
+ # None of our compilers can do clink, this happens for example if the
+ # target only has ASM sources. Pick the first capable compiler.
+ for l in clink_langs:
+ try:
+ comp = self.all_compilersl
+ return comp, comp.language_stdlib_only_link_flags(self.environment)
+ except KeyError:
+ pass
+
 raise AssertionError(f'Could not get a dynamic linker for build target {self.name!r}')
 
 def uses_rust(self) -> bool:
- """Is this target a rust target."""
- if self.sources:
- first_file = self.sources0
- if first_file.fname.endswith('.rs'):
- return True
- elif self.generated:
- if self.generated0.get_outputs()0.endswith('.rs'):
- return True
- return False
+ return 'rust' in self.compilers
+
+ def uses_fortran(self) -> bool:
+ return 'fortran' in self.compilers
 
 def get_using_msvc(self) -> bool:
 '''
@@ -1573,7 +1602,7 @@
 '''
 # Rustc can use msvc style linkers
 if self.uses_rust():
- compiler = self.environment.coredata.compilersself.for_machine'rust'
+ compiler = self.all_compilers'rust'
 else:
 compiler, _ = self.get_clink_dynamic_linker_and_stdlibs()
 # Mixing many languages with MSVC is not supported yet so ignore stdlibs.
@@ -1595,18 +1624,19 @@
 link_target.force_soname = True
 else:
 mlog.deprecation(f'target {self.name} links against shared module {link_target.name}, which is incorrect.'
- '\n '
- f'This will be an error in the future, so please use shared_library() for {link_target.name} instead.'
- '\n '
- f'If shared_module() was used for {link_target.name} because it has references to undefined symbols,'
- '\n '
- 'use shared_libary() with `override_options: \'b_lundef=false\'` instead.')
+ '\n '
+ f'This will be an error in the future, so please use shared_library() for {link_target.name} instead.'
+ '\n '
+ f'If shared_module() was used for {link_target.name} because it has references to undefined symbols,'
+ '\n '
+ 'use shared_libary() with `override_options: \'b_lundef=false\'` instead.')
 link_target.force_soname = True
 
 class Generator(HoldableObject):
 def __init__(self, exe: T.Union'Executable', programs.ExternalProgram,
 arguments: T.Liststr,
 output: T.Liststr,
+ # how2dataclass
 *,
 depfile: T.Optionalstr = None,
 capture: bool = False,
@@ -1663,7 +1693,7 @@
 output.depends.add(e.target)
 
 if isinstance(e, (CustomTarget, CustomTargetIndex, GeneratedList)):
- self.depends.append(e) # BUG: this should go in the GeneratedList object, not this object.
+ output.depends.add(e)
 fs = File.from_built_file(state.subdir, f) for f in e.get_outputs()
 elif isinstance(e, str):
 fs = File.from_source_file(state.environment.source_dir, state.subdir, e)
@@ -1679,24 +1709,27 @@
 return output
 
 
+@dataclass(eq=False)
 class GeneratedList(HoldableObject):
 
 """The output of generator.process."""
 
- def __init__(self, generator: Generator, subdir: str,
- preserve_path_from: T.Optionalstr,
- extra_args: T.Liststr):
- self.generator = generator
- self.name = generator.exe
- self.depends: T.Set'CustomTarget' = set() # Things this target depends on (because e.g. a custom target was used as input)
- self.subdir = subdir
+ generator: Generator
+ subdir: str
+ preserve_path_from: T.Optionalstr
+ extra_args: T.Liststr
+
+ def __post_init__(self) -> None:
+ self.name = self.generator.exe
+ self.depends: T.SetGeneratedTypes = set()
 self.infilelist: T.List'File' = 
 self.outfilelist: T.Liststr = 
 self.outmap: T.DictFile, T.Liststr = {}
 self.extra_depends = # XXX: Doesn't seem to be used?
 self.depend_files: T.ListFile = 
- self.preserve_path_from = preserve_path_from
- self.extra_args: T.Liststr = extra_args if extra_args is not None else 
+
+ if self.extra_args is None:
+ self.extra_args: T.Liststr = 
 
 if isinstance(self.generator.exe, programs.ExternalProgram):
 if not self.generator.exe.found():
@@ -1747,37 +1780,59 @@
 class Executable(BuildTarget):
 known_kwargs = known_exe_kwargs
 
+ typename = 'executable'
+
 def __init__(self, name: str, subdir: str, subproject: str, for_machine: MachineChoice,
- sources: T.ListFile, objects, environment: environment.Environment, kwargs):
- self.typename = 'executable'
+ sources: T.ListSourceOutputs, structured_sources: T.Optional'StructuredSources',
+ objects, environment: environment.Environment, compilers: T.Dictstr, 'Compiler',
+ kwargs):
 key = OptionKey('b_pie')
 if 'pie' not in kwargs and key in environment.coredata.options:
 kwargs'pie' = environment.coredata.optionskey.value
- super().__init__(name, subdir, subproject, for_machine, sources, objects, environment, kwargs)
+ super().__init__(name, subdir, subproject, for_machine, sources, structured_sources, objects,
+ environment, compilers, kwargs)
+ # Check for export_dynamic
+ self.export_dynamic = kwargs.get('export_dynamic', False)
+ if not isinstance(self.export_dynamic, bool):
+ raise InvalidArguments('"export_dynamic" keyword argument must be a boolean')
+ self.implib = kwargs.get('implib')
+ if not isinstance(self.implib, (bool, str, type(None))):
+ raise InvalidArguments('"export_dynamic" keyword argument must be a boolean or string')
+ if self.implib:
+ self.export_dynamic = True
+ if self.export_dynamic and self.implib is False:
+ raise InvalidArguments('"implib" keyword argument must not be false for if "export_dynamic" is true')
+ # Only linkwithable if using export_dynamic
+ self.is_linkwithable = self.export_dynamic
+ # Remember that this exe was returned by `find_program()` through an override
+ self.was_returned_by_find_program = False
+
+ def post_init(self) -> None:
+ super().post_init()
+ machine = self.environment.machinesself.for_machine
 # Unless overridden, executables have no suffix or prefix. Except on
 # Windows and with C#/Mono executables where the suffix is 'exe'
 if not hasattr(self, 'prefix'):
 self.prefix = ''
 if not hasattr(self, 'suffix'):
- machine = environment.machinesfor_machine
 # Executable for Windows or C#/Mono
 if machine.is_windows() or machine.is_cygwin() or 'cs' in self.compilers:
 self.suffix = 'exe'
 elif machine.system.startswith('wasm') or machine.system == 'emscripten':
 self.suffix = 'js'
- elif ('c' in self.compilers and self.compilers'c'.get_id().startswith('arm') or
- 'cpp' in self.compilers and self.compilers'cpp'.get_id().startswith('arm')):
+ elif ('c' in self.compilers and self.compilers'c'.get_id().startswith('armclang') or
+ 'cpp' in self.compilers and self.compilers'cpp'.get_id().startswith('armclang')):
 self.suffix = 'axf'
 elif ('c' in self.compilers and self.compilers'c'.get_id().startswith('ccrx') or
 'cpp' in self.compilers and self.compilers'cpp'.get_id().startswith('ccrx')):
 self.suffix = 'abs'
 elif ('c' in self.compilers and self.compilers'c'.get_id().startswith('xc16')):
 self.suffix = 'elf'
- elif ('c' in self.compilers and self.compilers'c'.get_id().startswith('c2000') or
- 'cpp' in self.compilers and self.compilers'cpp'.get_id().startswith('c2000')):
+ elif ('c' in self.compilers and self.compilers'c'.get_id() in {'ti', 'c2000'} or
+ 'cpp' in self.compilers and self.compilers'cpp'.get_id() in {'ti', 'c2000'}):
 self.suffix = 'out'
 else:
- self.suffix = environment.machinesfor_machine.get_exe_suffix()
+ self.suffix = machine.get_exe_suffix()
 self.filename = self.name
 if self.suffix:
 self.filename += '.' + self.suffix
@@ -1792,25 +1847,12 @@
 # The debugging information file this target will generate
 self.debug_filename = None
 
- # Check for export_dynamic
- self.export_dynamic = False
- if kwargs.get('export_dynamic'):
- if not isinstance(kwargs'export_dynamic', bool):
- raise InvalidArguments('"export_dynamic" keyword argument must be a boolean')
- self.export_dynamic = True
- if kwargs.get('implib'):
- self.export_dynamic = True
- if self.export_dynamic and kwargs.get('implib') is False:
- raise InvalidArguments('"implib" keyword argument must not be false for if "export_dynamic" is true')
-
- m = environment.machinesfor_machine
-
 # If using export_dynamic, set the import library name
 if self.export_dynamic:
 implib_basename = self.name + '.exe'
- if not isinstance(kwargs.get('implib', False), bool):
- implib_basename = kwargs'implib'
- if m.is_windows() or m.is_cygwin():
+ if isinstance(self.implib, str):
+ implib_basename = self.implib
+ if machine.is_windows() or machine.is_cygwin():
 self.vs_import_filename = f'{implib_basename}.lib'
 self.gcc_import_filename = f'lib{implib_basename}.a'
 if self.get_using_msvc():
@@ -1818,19 +1860,13 @@
 else:
 self.import_filename = self.gcc_import_filename
 
- if m.is_windows() and ('cs' in self.compilers or
- self.uses_rust() or
- self.get_using_msvc()):
+ if machine.is_windows() and ('cs' in self.compilers or
+ self.uses_rust() or
+ self.get_using_msvc()):
 self.debug_filename = self.name + '.pdb'
 
- # Only linkwithable if using export_dynamic
- self.is_linkwithable = self.export_dynamic
-
- # Remember that this exe was returned by `find_program()` through an override
- self.was_returned_by_find_program = False
-
- def get_default_install_dir(self, environment: environment.Environment) -> T.Tuplestr, str:
- return environment.get_bindir(), '{bindir}'
+ def get_default_install_dir(self) -> T.Tuplestr, str:
+ return self.environment.get_bindir(), '{bindir}'
 
 def description(self):
 '''Human friendly description of the executable'''
@@ -1873,9 +1909,20 @@
 class StaticLibrary(BuildTarget):
 known_kwargs = known_stlib_kwargs
 
- def __init__(self, name, subdir, subproject, for_machine: MachineChoice, sources, objects, environment, kwargs):
- self.typename = 'static library'
- super().__init__(name, subdir, subproject, for_machine, sources, objects, environment, kwargs)
+ typename = 'static library'
+
+ def __init__(self, name: str, subdir: str, subproject: str, for_machine: MachineChoice,
+ sources: T.ListSourceOutputs, structured_sources: T.Optional'StructuredSources',
+ objects, environment: environment.Environment, compilers: T.Dictstr, 'Compiler',
+ kwargs):
+ self.prelink = kwargs.get('prelink', False)
+ if not isinstance(self.prelink, bool):
+ raise InvalidArguments('Prelink keyword argument must be a boolean.')
+ super().__init__(name, subdir, subproject, for_machine, sources, structured_sources, objects,
+ environment, compilers, kwargs)
+
+ def post_init(self) -> None:
+ super().post_init()
 if 'cs' in self.compilers:
 raise InvalidArguments('Static libraries not supported for C#.')
 if 'rust' in self.compilers:
@@ -1906,21 +1953,18 @@
 self.suffix = 'a'
 self.filename = self.prefix + self.name + '.' + self.suffix
 self.outputs = self.filename
- self.prelink = kwargs.get('prelink', False)
- if not isinstance(self.prelink, bool):
- raise InvalidArguments('Prelink keyword argument must be a boolean.')
 
- def get_link_deps_mapping(self, prefix: str, environment: environment.Environment) -> T.Mappingstr, str:
+ def get_link_deps_mapping(self, prefix: str) -> T.Mappingstr, str:
 return {}
 
- def get_default_install_dir(self, environment) -> T.Tuplestr, str:
- return environment.get_static_lib_dir(), '{libdir_static}'
+ def get_default_install_dir(self) -> T.Tuplestr, str:
+ return self.environment.get_static_lib_dir(), '{libdir_static}'
 
 def type_suffix(self):
 return "@sta"
 
- def process_kwargs(self, kwargs, environment):
- super().process_kwargs(kwargs, environment)
+ def process_kwargs(self, kwargs):
+ super().process_kwargs(kwargs)
 if 'rust_crate_type' in kwargs:
 rust_crate_type = kwargs'rust_crate_type'
 if isinstance(rust_crate_type, str):
@@ -1931,11 +1975,18 @@
 def is_linkable_target(self):
 return True
 
+ def is_internal(self) -> bool:
+ return not self.need_install
+
 class SharedLibrary(BuildTarget):
 known_kwargs = known_shlib_kwargs
 
- def __init__(self, name, subdir, subproject, for_machine: MachineChoice, sources, objects, environment, kwargs):
- self.typename = 'shared library'
+ typename = 'shared library'
+
+ def __init__(self, name: str, subdir: str, subproject: str, for_machine: MachineChoice,
+ sources: T.ListSourceOutputs, structured_sources: T.Optional'StructuredSources',
+ objects, environment: environment.Environment, compilers: T.Dictstr, 'Compiler',
+ kwargs):
 self.soversion = None
 self.ltversion = None
 # Max length 2, first element is compatibility_version, second is current_version
@@ -1951,38 +2002,42 @@
 self.debug_filename = None
 # Use by the pkgconfig module
 self.shared_library_only = False
- super().__init__(name, subdir, subproject, for_machine, sources, objects, environment, kwargs)
+ super().__init__(name, subdir, subproject, for_machine, sources, structured_sources, objects,
+ environment, compilers, kwargs)
+
+ def post_init(self) -> None:
+ super().post_init()
 if 'rust' in self.compilers:
 # If no crate type is specified, or it's the generic lib type, use dylib
 if not hasattr(self, 'rust_crate_type') or self.rust_crate_type == 'lib':
 mlog.debug('Defaulting Rust dynamic library target crate type to "dylib"')
 self.rust_crate_type = 'dylib'
 # Don't let configuration proceed with a non-dynamic crate type
- elif self.rust_crate_type not in 'dylib', 'cdylib':
- raise InvalidArguments(f'Crate type "{self.rust_crate_type}" invalid for dynamic libraries; must be "dylib" or "cdylib"')
+ elif self.rust_crate_type not in 'dylib', 'cdylib', 'proc-macro':
+ raise InvalidArguments(f'Crate type "{self.rust_crate_type}" invalid for dynamic libraries; must be "dylib", "cdylib", or "proc-macro"')
 if not hasattr(self, 'prefix'):
 self.prefix = None
 if not hasattr(self, 'suffix'):
 self.suffix = None
 self.basic_filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
- self.determine_filenames(environment)
+ self.determine_filenames()
 
- def get_link_deps_mapping(self, prefix: str, environment: environment.Environment) -> T.Mappingstr, str:
+ def get_link_deps_mapping(self, prefix: str) -> T.Mappingstr, str:
 result: T.Dictstr, str = {}
- mappings = self.get_transitive_link_deps_mapping(prefix, environment)
+ mappings = self.get_transitive_link_deps_mapping(prefix)
 old = get_target_macos_dylib_install_name(self)
 if old not in mappings:
 fname = self.get_filename()
- outdirs, _, _ = self.get_install_dir(self.environment)
+ outdirs, _, _ = self.get_install_dir()
 new = os.path.join(prefix, outdirs0, fname)
 result.update({old: new})
 mappings.update(result)
 return mappings
 
- def get_default_install_dir(self, environment) -> T.Tuplestr, str:
- return environment.get_shared_lib_dir(), '{libdir_shared}'
+ def get_default_install_dir(self) -> T.Tuplestr, str:
+ return self.environment.get_shared_lib_dir(), '{libdir_shared}'
 
- def determine_filenames(self, env):
+ def determine_filenames(self):
 """
 See https://github.com/mesonbuild/meson/pull/417 for details.
 
@@ -2017,7 +2072,7 @@
 # C, C++, Swift, Vala
 # Only Windows uses a separate import library for linking
 # For all other targets/platforms import_filename stays None
- elif env.machinesself.for_machine.is_windows():
+ elif self.environment.machinesself.for_machine.is_windows():
 suffix = 'dll'
 self.vs_import_filename = '{}{}.lib'.format(self.prefix if self.prefix is not None else '', self.name)
 self.gcc_import_filename = '{}{}.dll.a'.format(self.prefix if self.prefix is not None else 'lib', self.name)
@@ -2026,13 +2081,15 @@
 prefix = ''
 # Import library is called foo.dll.lib
 self.import_filename = f'{self.name}.dll.lib'
- create_debug_file = True
+ # Debug files(.pdb) is only created with debug buildtype
+ create_debug_file = self.environment.coredata.get_option(OptionKey("debug"))
 elif self.get_using_msvc():
 # Shared library is of the form foo.dll
 prefix = ''
 # Import library is called foo.lib
 self.import_filename = self.vs_import_filename
- create_debug_file = True
+ # Debug files(.pdb) is only created with debug buildtype
+ create_debug_file = self.environment.coredata.get_option(OptionKey("debug"))
 # Assume GCC-compatible naming
 else:
 # Shared library is of the form libfoo.dll
@@ -2044,7 +2101,7 @@
 self.filename_tpl = '{0.prefix}{0.name}-{0.soversion}.{0.suffix}'
 else:
 self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
- elif env.machinesself.for_machine.is_cygwin():
+ elif self.environment.machinesself.for_machine.is_cygwin():
 suffix = 'dll'
 self.gcc_import_filename = '{}{}.dll.a'.format(self.prefix if self.prefix is not None else 'lib', self.name)
 # Shared library is of the form cygfoo.dll
@@ -2056,7 +2113,7 @@
 self.filename_tpl = '{0.prefix}{0.name}-{0.soversion}.{0.suffix}'
 else:
 self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
- elif env.machinesself.for_machine.is_darwin():
+ elif self.environment.machinesself.for_machine.is_darwin():
 prefix = 'lib'
 suffix = 'dylib'
 # On macOS, the filename can only contain the major version
@@ -2066,7 +2123,7 @@
 else:
 # libfoo.dylib
 self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
- elif env.machinesself.for_machine.is_android():
+ elif self.environment.machinesself.for_machine.is_android():
 prefix = 'lib'
 suffix = 'so'
 # Android doesn't support shared_library versioning
@@ -2088,7 +2145,9 @@
 if self.suffix is None:
 self.suffix = suffix
 self.filename = self.filename_tpl.format(self)
- self.outputs = self.filename
+ # There may have been more outputs added by the time we get here, so
+ # only replace the first entry
+ self.outputs0 = self.filename
 if create_debug_file:
 self.debug_filename = os.path.splitext(self.filename)0 + '.pdb'
 
@@ -2116,10 +2175,10 @@
 raise InvalidArguments('Shared library darwin_versions: must be X.Y.Z where '
 'X, Y, Z are numbers, and Y and Z are optional')
 parts = v.split('.')
- if len(parts) in (1, 2, 3) and int(parts0) > 65535:
+ if len(parts) in {1, 2, 3} and int(parts0) > 65535:
 raise InvalidArguments('Shared library darwin_versions: must be X.Y.Z '
 'where X is 0, 65535 and Y, Z are optional')
- if len(parts) in (2, 3) and int(parts1) > 255:
+ if len(parts) in {2, 3} and int(parts1) > 255:
 raise InvalidArguments('Shared library darwin_versions: must be X.Y.Z '
 'where Y is 0, 255 and Y, Z are optional')
 if len(parts) == 3 and int(parts2) > 255:
@@ -2130,15 +2189,10 @@
 raise InvalidArguments('Shared library darwin_versions: value is invalid')
 return darwin_versions
 
- def process_kwargs(self, kwargs, environment):
- super().process_kwargs(kwargs, environment)
+ def process_kwargs(self, kwargs):
+ super().process_kwargs(kwargs)
 
 if not self.environment.machinesself.for_machine.is_android():
- supports_versioning = True
- else:
- supports_versioning = False
-
- if supports_versioning:
 # Shared library version
 if 'version' in kwargs:
 self.ltversion = kwargs'version'
@@ -2172,7 +2226,7 @@
 if os.path.isabs(path):
 self.vs_module_defs = File.from_absolute_file(path)
 else:
- self.vs_module_defs = File.from_source_file(environment.source_dir, self.subdir, path)
+ self.vs_module_defs = File.from_source_file(self.environment.source_dir, self.subdir, path)
 elif isinstance(path, File):
 # When passing a generated file.
 self.vs_module_defs = path
@@ -2183,7 +2237,7 @@
 raise InvalidArguments(
 'Shared library vs_module_defs must be either a string, '
 'a file object or a Custom Target')
- self.process_link_depends(path, environment)
+ self.process_link_depends(path)
 
 if 'rust_crate_type' in kwargs:
 rust_crate_type = kwargs'rust_crate_type'
@@ -2191,6 +2245,8 @@
 self.rust_crate_type = rust_crate_type
 else:
 raise InvalidArguments(f'Invalid rust_crate_type "{rust_crate_type}": must be a string.')
+ if rust_crate_type == 'proc-macro':
+ FeatureNew.single_use('Rust crate type "proc-macro"', '0.62.0', self.subproject)
 
 def get_import_filename(self) -> T.Optionalstr:
 """
@@ -2216,7 +2272,7 @@
 def get_all_link_deps(self):
 return self + self.get_transitive_link_deps()
 
- def get_aliases(self) -> T.Dictstr, str:
+ def get_aliases(self) -> T.ListT.Tuplestr, str, str:
 """
 If the versioned library name is libfoo.so.0.100.0, aliases are:
 * libfoo.so.0 (soversion) -> libfoo.so.0.100.0
@@ -2224,7 +2280,7 @@
 Same for dylib:
 * libfoo.dylib (unversioned; for linking) -> libfoo.0.dylib
 """
- aliases: T.Dictstr, str = {}
+ aliases: T.ListT.Tuplestr, str, str = 
 # Aliases are only useful with .so and .dylib libraries. Also if
 # there's no self.soversion (no versioning), we don't need aliases.
 if self.suffix not in ('so', 'dylib') or not self.soversion:
@@ -2236,14 +2292,16 @@
 if self.suffix == 'so' and self.ltversion and self.ltversion != self.soversion:
 alias_tpl = self.filename_tpl.replace('ltversion', 'soversion')
 ltversion_filename = alias_tpl.format(self)
- aliasesltversion_filename = self.filename
+ tag = self.install_tag0 or 'runtime'
+ aliases.append((ltversion_filename, self.filename, tag))
 # libfoo.so.0/libfoo.0.dylib is the actual library
 else:
 ltversion_filename = self.filename
 # Unversioned alias:
 # libfoo.so -> libfoo.so.0
 # libfoo.dylib -> libfoo.0.dylib
- aliasesself.basic_filename_tpl.format(self) = ltversion_filename
+ tag = self.install_tag0 or 'devel'
+ aliases.append((self.basic_filename_tpl.format(self), ltversion_filename, tag))
 return aliases
 
 def type_suffix(self):
@@ -2257,19 +2315,24 @@
 class SharedModule(SharedLibrary):
 known_kwargs = known_shmod_kwargs
 
- def __init__(self, name, subdir, subproject, for_machine: MachineChoice, sources, objects, environment, kwargs):
+ typename = 'shared module'
+
+ def __init__(self, name: str, subdir: str, subproject: str, for_machine: MachineChoice,
+ sources: T.ListSourceOutputs, structured_sources: T.Optional'StructuredSources',
+ objects, environment: environment.Environment,
+ compilers: T.Dictstr, 'Compiler', kwargs):
 if 'version' in kwargs:
 raise MesonException('Shared modules must not specify the version kwarg.')
 if 'soversion' in kwargs:
 raise MesonException('Shared modules must not specify the soversion kwarg.')
- super().__init__(name, subdir, subproject, for_machine, sources, objects, environment, kwargs)
- self.typename = 'shared module'
+ super().__init__(name, subdir, subproject, for_machine, sources,
+ structured_sources, objects, environment, compilers, kwargs)
 # We need to set the soname in cases where build files link the module
 # to build targets, see: https://github.com/mesonbuild/meson/issues/9492
 self.force_soname = False
 
- def get_default_install_dir(self, environment) -> T.Tuplestr, str:
- return environment.get_shared_module_dir(), '{moduledir_shared}'
+ def get_default_install_dir(self) -> T.Tuplestr, str:
+ return self.environment.get_shared_module_dir(), '{moduledir_shared}'
 
 class BothLibraries(SecondLevelHolder):
 def __init__(self, shared: SharedLibrary, static: StaticLibrary) -> None:
@@ -2294,7 +2357,7 @@
 dependencies: T.ListT.UnionBuildTarget, 'CustomTarget'
 subproject: str
 
- def flatten_command(self, cmd: T.SequenceT.Unionstr, File, programs.ExternalProgram, 'BuildTarget', 'CustomTarget', 'CustomTargetIndex') -> \
+ def flatten_command(self, cmd: T.SequenceT.Unionstr, File, programs.ExternalProgram, BuildTargetTypes) -> \
 T.ListT.Unionstr, File, BuildTarget, 'CustomTarget':
 cmd = listify(cmd)
 final_cmd: T.ListT.Unionstr, File, BuildTarget, 'CustomTarget' = 
@@ -2327,63 +2390,82 @@
 return final_cmd
 
 class CustomTarget(Target, CommandBase):
- known_kwargs = {
- 'input',
- 'output',
- 'command',
- 'capture',
- 'feed',
- 'install',
- 'install_dir',
- 'install_mode',
- 'install_tag',
- 'build_always',
- 'build_always_stale',
- 'depends',
- 'depend_files',
- 'depfile',
- 'build_by_default',
- 'override_options',
- 'console',
- 'env',
- }
-
- install_dir: T.ListT.Unionstr, bool
-
- def __init__(self, name: str, subdir: str, subproject: str, kwargs: T.Mappingstr, T.Any,
- absolute_paths: bool = False, backend: T.Optional'Backend' = None):
- self.typename = 'custom'
+
+ typename = 'custom'
+
+ def __init__(self,
+ name: T.Optionalstr,
+ subdir: str,
+ subproject: str,
+ environment: environment.Environment,
+ command: T.SequenceT.Union
+ str, BuildTargetTypes, GeneratedList,
+ programs.ExternalProgram, File,
+ sources: T.SequenceT.Union
+ str, File, BuildTargetTypes, ExtractedObjects,
+ GeneratedList, programs.ExternalProgram,
+ outputs: T.Liststr,
+ *,
+ build_always_stale: bool = False,
+ build_by_default: T.Optionalbool = None,
+ capture: bool = False,
+ console: bool = False,
+ depend_files: T.OptionalT.SequenceFileOrString = None,
+ extra_depends: T.OptionalT.SequenceT.Unionstr, SourceOutputs = None,
+ depfile: T.Optionalstr = None,
+ env: T.OptionalEnvironmentVariables = None,
+ feed: bool = False,
+ install: bool = False,
+ install_dir: T.OptionalT.ListT.Unionstr, LiteralFalse = None,
+ install_mode: T.OptionalFileMode = None,
+ install_tag: T.OptionalT.ListT.Optionalstr = None,
+ absolute_paths: bool = False,
+ backend: T.Optional'Backend' = None,
+ ):
 # TODO expose keyword arg to make MachineChoice.HOST configurable
- super().__init__(name, subdir, subproject, False, MachineChoice.HOST)
+ super().__init__(name, subdir, subproject, False, MachineChoice.HOST, environment)
+ self.sources = list(sources)
+ self.outputs = substitute_values(
+ outputs, get_filenames_templates_dict(
+ get_sources_string_names(sources, backend),
+ ))
+ self.build_by_default = build_by_default if build_by_default is not None else install
+ self.build_always_stale = build_always_stale
+ self.capture = capture
+ self.console = console
+ self.depend_files = list(depend_files or )
 self.dependencies: T.ListT.UnionCustomTarget, BuildTarget = 
- self.extra_depends: T.ListT.UnionCustomTarget, BuildTarget = 
- self.depend_files = # Files that this target depends on but are not on the command line.
- self.depfile = None
- self.process_kwargs(kwargs, backend)
+ # must be after depend_files and dependencies
+ self.command = self.flatten_command(command)
+ self.depfile = depfile
+ self.env = env or EnvironmentVariables()
+ self.extra_depends = list(extra_depends or )
+ self.feed = feed
+ self.install = install
+ self.install_dir = list(install_dir or )
+ self.install_mode = install_mode
+ self.install_tag = _process_install_tag(install_tag, len(self.outputs))
+ self.name = name if name else self.outputs0
+
 # Whether to use absolute paths for all files on the commandline
 self.absolute_paths = absolute_paths
- unknowns = 
- for k in kwargs:
- if k not in CustomTarget.known_kwargs:
- unknowns.append(k)
- if unknowns:
- mlog.warning('Unknown keyword arguments in target {}: {}'.format(self.name, ', '.join(unknowns)))
 
- def get_default_install_dir(self, environment) -> T.Tuplestr, str:
+ def get_default_install_dir(self) -> T.Tuplestr, str:
 return None, None
 
 def __repr__(self):
 repr_str = "<{0} {1}: {2}>"
 return repr_str.format(self.__class__.__name__, self.get_id(), self.command)
 
- def get_target_dependencies(self) -> T.ListT.Union'BuildTarget', 'CustomTarget':
- deps = self.dependencies:
- deps += self.extra_depends
+ def get_target_dependencies(self) -> T.ListT.UnionSourceOutputs, str:
+ deps: T.ListT.UnionSourceOutputs, str = 
+ deps.extend(self.dependencies)
+ deps.extend(self.extra_depends)
 for c in self.sources:
- if isinstance(c, (BuildTarget, CustomTarget)):
- deps.append(c)
 if isinstance(c, CustomTargetIndex):
 deps.append(c.target)
+ elif not isinstance(c, programs.ExternalProgram):
+ deps.append(c)
 return deps
 
 def get_transitive_build_target_deps(self) -> T.SetT.UnionBuildTarget, 'CustomTarget':
@@ -2404,126 +2486,13 @@
 bdeps.update(d.get_transitive_build_target_deps())
 return bdeps
 
- def process_kwargs(self, kwargs, backend):
- self.process_kwargs_base(kwargs)
- self.sources = extract_as_list(kwargs, 'input')
- if 'output' not in kwargs:
- raise InvalidArguments('Missing keyword argument "output".')
- self.outputs = listify(kwargs'output')
- # This will substitute values from the input into output and return it.
- inputs = get_sources_string_names(self.sources, backend)
- values = get_filenames_templates_dict(inputs, )
- for i in self.outputs:
- if not isinstance(i, str):
- raise InvalidArguments('Output argument not a string.')
- if i == '':
- raise InvalidArguments('Output must not be empty.')
- if i.strip() == '':
- raise InvalidArguments('Output must not consist only of whitespace.')
- if has_path_sep(i):
- raise InvalidArguments(f'Output {i!r} must not contain a path segment.')
- if '@INPUT@' in i or '@INPUT0@' in i:
- m = 'Output cannot contain @INPUT@ or @INPUT0@, did you ' \
- 'mean @PLAINNAME@ or @BASENAME@?'
- raise InvalidArguments(m)
- # We already check this during substitution, but the error message
- # will be unclear/confusing, so check it here.
- if len(inputs) != 1 and ('@PLAINNAME@' in i or '@BASENAME@' in i):
- m = "Output cannot contain @PLAINNAME@ or @BASENAME@ when " \
- "there is more than one input (we can't know which to use)"
- raise InvalidArguments(m)
- self.outputs = substitute_values(self.outputs, values)
- if not self.name:
- self.name = self.outputs0
- self.capture = kwargs.get('capture', False)
- if self.capture and len(self.outputs) != 1:
- raise InvalidArguments('Capturing can only output to a single file.')
- self.feed = kwargs.get('feed', False)
- if self.feed and len(self.sources) != 1:
- raise InvalidArguments('Feeding can only input from a single file.')
- self.console = kwargs.get('console', False)
- if not isinstance(self.console, bool):
- raise InvalidArguments('"console" kwarg only accepts booleans')
- if self.capture and self.console:
- raise InvalidArguments("Can't both capture output and output to console")
- if 'command' not in kwargs:
- raise InvalidArguments('Missing keyword argument "command".')
- if kwargs.get('depfile') is not None:
- depfile = kwargs'depfile'
- if not isinstance(depfile, str):
- raise InvalidArguments('Depfile must be a string.')
- if os.path.basename(depfile) != depfile:
- raise InvalidArguments('Depfile must be a plain filename without a subdirectory.')
- self.depfile = depfile
- self.command = self.flatten_command(kwargs'command')
- for c in self.command:
- if self.capture and isinstance(c, str) and '@OUTPUT@' in c:
- raise InvalidArguments('@OUTPUT@ is not allowed when capturing output.')
- if self.feed and isinstance(c, str) and '@INPUT@' in c:
- raise InvalidArguments('@INPUT@ is not allowed when feeding input.')
- if 'install' in kwargs:
- self.install = kwargs'install'
- if not isinstance(self.install, bool):
- raise InvalidArguments('"install" must be boolean.')
- if self.install:
- if not kwargs.get('install_dir', False):
- raise InvalidArguments('"install_dir" must be specified '
- 'when installing a target')
-
- if isinstance(kwargs'install_dir', list):
- FeatureNew.single_use('multiple install_dir for custom_target', '0.40.0', self.subproject)
- # If an item in this list is False, the output corresponding to
- # the list index of that item will not be installed
- self.install_dir = typeslistify(kwargs'install_dir', (str, bool))
- self.install_mode = kwargs.get('install_mode', None)
- # If only one tag is provided, assume all outputs have the same tag.
- # Otherwise, we must have as much tags as outputs.
- install_tag: T.ListT.Unionstr, bool, None = typeslistify(kwargs.get('install_tag', ), (str, bool, type(None)))
- if not install_tag:
- self.install_tag = None * len(self.outputs)
- elif len(install_tag) == 1:
- self.install_tag = install_tag * len(self.outputs)
- elif install_tag and len(install_tag) != len(self.outputs):
- m = f'Target {self.name!r} has {len(self.outputs)} outputs but {len(install_tag)} "install_tag"s were found.'
- raise InvalidArguments(m)
- else:
- self.install_tag = install_tag
- else:
- self.install = False
- self.install_dir = 
- self.install_mode = None
- self.install_tag = 
- if kwargs.get('build_always') is not None and kwargs.get('build_always_stale') is not None:
- raise InvalidArguments('build_always and build_always_stale are mutually exclusive. Combine build_by_default and build_always_stale.')
- elif kwargs.get('build_always') is not None:
- if kwargs.get('build_by_default') is not None:
- self.build_by_default = kwargs'build_always'
- self.build_always_stale = kwargs'build_always'
- elif kwargs.get('build_always_stale') is not None:
- self.build_always_stale = kwargs'build_always_stale'
- if not isinstance(self.build_always_stale, bool):
- raise InvalidArguments('Argument build_always_stale must be a boolean.')
- extra_deps, depend_files = (extract_as_list(kwargs, c, pop=False) for c in 'depends', 'depend_files')
- for ed in extra_deps:
- if not isinstance(ed, (CustomTarget, BuildTarget)):
- raise InvalidArguments('Can only depend on toplevel targets: custom_target or build_target '
- f'(executable or a library) got: {type(ed)}({ed})')
- self.extra_depends.append(ed)
- for i in depend_files:
- if isinstance(i, (File, str)):
- self.depend_files.append(i)
- else:
- mlog.debug(i)
- raise InvalidArguments(f'Unknown type {type(i).__name__!r} in depend_files.')
- self.env = kwargs.get('env')
-
 def get_dependencies(self):
 return self.dependencies
 
 def should_install(self) -> bool:
 return self.install
 
- def get_custom_install_dir(self) -> T.ListT.Unionstr, bool:
+ def get_custom_install_dir(self) -> T.ListT.Unionstr, LiteralFalse:
 return self.install_dir
 
 def get_custom_install_mode(self) -> T.Optional'FileMode':
@@ -2535,7 +2504,7 @@
 def get_filename(self) -> str:
 return self.outputs0
 
- def get_sources(self) -> T.ListT.Unionstr, File, 'CustomTarget', 'CustomTargetIndex', 'GeneratedList', 'ExtractedObjects':
+ def get_sources(self) -> T.ListT.Unionstr, File, BuildTarget, GeneratedTypes, ExtractedObjects, programs.ExternalProgram:
 return self.sources
 
 def get_generated_lists(self) -> T.ListGeneratedList:
@@ -2566,10 +2535,20 @@
 suf = os.path.splitext(self.outputs0)-1
 return suf in {'.a', '.dll', '.lib', '.so', '.dylib'}
 
- def get_link_deps_mapping(self, prefix: str, environment: environment.Environment) -> T.Mappingstr, str:
+ def links_dynamically(self) -> bool:
+ """Whether this target links dynamically or statically
+
+ Does not assert the target is linkable, just that it is not shared
+
+ :return: True if is dynamically linked, otherwise False
+ """
+ suf = os.path.splitext(self.outputs0)-1
+ return suf not in {'.a', '.lib'}
+
+ def get_link_deps_mapping(self, prefix: str) -> T.Mappingstr, str:
 return {}
 
- def get_link_dep_subdirs(self):
+ def get_link_dep_subdirs(self) -> T.AbstractSetstr:
 return OrderedSet()
 
 def get_all_link_deps(self):
@@ -2577,7 +2556,7 @@
 
 def is_internal(self) -> bool:
 '''
- Returns True iif this is a not installed static library.
+ Returns True if this is a not installed static library.
 '''
 if len(self.outputs) != 1:
 return False
@@ -2605,22 +2584,64 @@
 def __len__(self) -> int:
 return len(self.outputs)
 
+class CompileTarget(BuildTarget):
+ '''
+ Target that only compile sources without linking them together.
+ It can be used as preprocessor, or transpiler.
+ '''
+
+ typename = 'compile'
+
+ def __init__(self,
+ name: str,
+ subdir: str,
+ subproject: str,
+ environment: environment.Environment,
+ sources: T.ListFile,
+ output_templ: str,
+ compiler: Compiler,
+ kwargs):
+ compilers = {compiler.get_language(): compiler}
+ super().__init__(name, subdir, subproject, compiler.for_machine,
+ sources, None, , environment, compilers, kwargs)
+ self.filename = name
+ self.compiler = compiler
+ self.output_templ = output_templ
+ self.outputs = 
+ for f in sources:
+ plainname = os.path.basename(f.fname)
+ basename = os.path.splitext(plainname)0
+ self.outputs.append(output_templ.replace('@BASENAME@', basename).replace('@PLAINNAME@', plainname))
+ self.sources_map = dict(zip(sources, self.outputs))
+
+ def type_suffix(self) -> str:
+ return "@compile"
+
+ @property
+ def is_unity(self) -> bool:
+ return False
+
+
 class RunTarget(Target, CommandBase):
 
+ typename = 'run'
+
 def __init__(self, name: str,
- command: T.SequenceT.Unionstr, File, BuildTarget, 'CustomTarget', 'CustomTargetIndex', programs.ExternalProgram,
- dependencies: T.SequenceT.UnionBuildTarget, 'CustomTarget',
+ command: T.SequenceT.Unionstr, File, BuildTargetTypes, programs.ExternalProgram,
+ dependencies: T.SequenceTarget,
 subdir: str,
 subproject: str,
- env: T.Optional'EnvironmentVariables' = None):
- self.typename = 'run'
+ environment: environment.Environment,
+ env: T.Optional'EnvironmentVariables' = None,
+ default_env: bool = True):
 # These don't produce output artifacts
- super().__init__(name, subdir, subproject, False, MachineChoice.BUILD)
+ super().__init__(name, subdir, subproject, False, MachineChoice.BUILD, environment)
 self.dependencies = dependencies
 self.depend_files = 
 self.command = self.flatten_command(command)
 self.absolute_paths = False
 self.env = env
+ self.default_env = default_env
 
 def __repr__(self) -> str:
 repr_str = "<{0} {1}: {2}>"
@@ -2653,9 +2674,9 @@
 return "@run"
 
 class AliasTarget(RunTarget):
- def __init__(self, name: str, dependencies: T.SequenceT.UnionBuildTarget, 'CustomTarget',
- subdir: str, subproject: str):
- super().__init__(name, , dependencies, subdir, subproject)
+ def __init__(self, name: str, dependencies: T.Sequence'Target',
+ subdir: str, subproject: str, environment: environment.Environment):
+ super().__init__(name, , dependencies, subdir, subproject, environment)
 
 def __repr__(self):
 repr_str = "<{0} {1}>"
@@ -2664,18 +2685,26 @@
 class Jar(BuildTarget):
 known_kwargs = known_jar_kwargs
 
- def __init__(self, name, subdir, subproject, for_machine: MachineChoice, sources, objects, environment, kwargs):
- self.typename = 'jar'
- super().__init__(name, subdir, subproject, for_machine, sources, objects, environment, kwargs)
+ typename = 'jar'
+
+ def __init__(self, name: str, subdir: str, subproject: str, for_machine: MachineChoice,
+ sources: T.ListSourceOutputs, structured_sources: T.Optional'StructuredSources',
+ objects, environment: environment.Environment, compilers: T.Dictstr, 'Compiler',
+ kwargs):
+ super().__init__(name, subdir, subproject, for_machine, sources, structured_sources, objects,
+ environment, compilers, kwargs)
 for s in self.sources:
 if not s.endswith('.java'):
 raise InvalidArguments(f'Jar source {s} is not a java file.')
 for t in self.link_targets:
 if not isinstance(t, Jar):
 raise InvalidArguments(f'Link target {t} is not a jar target.')
+ if self.structured_sources:
+ raise InvalidArguments('structured sources are not supported in Java targets.')
 self.filename = self.name + '.jar'
 self.outputs = self.filename
 self.java_args = kwargs.get('java_args', )
+ self.java_resources: T.OptionalStructuredSources = kwargs.get('java_resources', None)
 
 def get_main_class(self):
 return self.main_class
@@ -2686,7 +2715,10 @@
 def get_java_args(self):
 return self.java_args
 
- def validate_install(self, environment):
+ def get_java_resources(self) -> T.OptionalStructuredSources:
+ return self.java_resources
+
+ def validate_install(self):
 # All jar targets are installable.
 pass
 
@@ -2700,6 +2732,10 @@
 return '-cp', os.pathsep.join(cp_paths)
 return 
 
+ def get_default_install_dir(self) -> T.Tuplestr, str:
+ return self.environment.get_jar_dir(), '{jardir}'
+
+@dataclass(eq=False)
 class CustomTargetIndex(HoldableObject):
 
 """A special opaque object returned by indexing a CustomTarget. This object
@@ -2708,19 +2744,20 @@
 the sources.
 """
 
- def __init__(self, target: CustomTarget, output: str):
- self.typename = 'custom'
- self.target = target
- self.output = output
- self.for_machine = target.for_machine
+ typename: T.ClassVarstr = 'custom'
+
+ target: T.UnionCustomTarget, CompileTarget
+ output: str
+
+ def __post_init__(self) -> None:
+ self.for_machine = self.target.for_machine
 
 @property
 def name(self) -> str:
 return f'{self.target.name}{self.output}'
 
 def __repr__(self):
- return '<CustomTargetIndex: {!r}{}>'.format(
- self.target, self.target.get_outputs().index(self.output))
+ return '<CustomTargetIndex: {!r}{}>'.format(self.target, self.output)
 
 def get_outputs(self) -> T.Liststr:
 return self.output
@@ -2737,22 +2774,32 @@
 def get_all_link_deps(self):
 return self.target.get_all_link_deps()
 
- def get_link_deps_mapping(self, prefix: str, environment: environment.Environment) -> T.Mappingstr, str:
- return self.target.get_link_deps_mapping(prefix, environment)
+ def get_link_deps_mapping(self, prefix: str) -> T.Mappingstr, str:
+ return self.target.get_link_deps_mapping(prefix)
 
- def get_link_dep_subdirs(self):
+ def get_link_dep_subdirs(self) -> T.AbstractSetstr:
 return self.target.get_link_dep_subdirs()
 
 def is_linkable_target(self) -> bool:
 suf = os.path.splitext(self.output)-1
- return suf in {'.a', '.dll', '.lib', '.so'}
+ return suf in {'.a', '.dll', '.lib', '.so', '.dylib'}
+
+ def links_dynamically(self) -> bool:
+ """Whether this target links dynamically or statically
+
+ Does not assert the target is linkable, just that it is not shared
+
+ :return: True if is dynamically linked, otherwise False
+ """
+ suf = os.path.splitext(self.output)-1
+ return suf not in {'.a', '.lib'}
 
 def should_install(self) -> bool:
 return self.target.should_install()
 
 def is_internal(self) -> bool:
 '''
- Returns True iif this is a not installed static library
+ Returns True if this is a not installed static library
 '''
 suf = os.path.splitext(self.output)-1
 return suf in {'.a', '.lib'} and not self.should_install()
@@ -2760,26 +2807,28 @@
 def extract_all_objects_recurse(self) -> T.ListT.Unionstr, 'ExtractedObjects':
 return self.target.extract_all_objects_recurse()
 
- def get_custom_install_dir(self) -> T.ListT.Unionstr, bool:
+ def get_custom_install_dir(self) -> T.ListT.Unionstr, LiteralFalse:
 return self.target.get_custom_install_dir()
 
 class ConfigurationData(HoldableObject):
- def __init__(self) -> None:
+ def __init__(self, initial_values: T.OptionalT.Union
+ T.Dictstr, T.TupleT.Unionstr, int, bool, T.Optionalstr,
+ T.Dictstr, T.Unionstr, int, bool
+ = None):
 super().__init__()
- self.values: T.Dict
- str,
- T.Tuple
- T.Unionstr, int, bool,
- T.Optionalstr
- 
- = {}
+ self.values: T.Dictstr, T.TupleT.Unionstr, int, bool, T.Optionalstr = \
+ {k: v if isinstance(v, tuple) else (v, None) for k, v in initial_values.items()} if initial_values else {}
+ self.used: bool = False
 
- def __repr__(self):
+ def __repr__(self) -> str:
 return repr(self.values)
 
 def __contains__(self, value: str) -> bool:
 return value in self.values
 
+ def __bool__(self) -> bool:
+ return bool(self.values)
+
 def get(self, name: str) -> T.TupleT.Unionstr, int, bool, T.Optionalstr:
 return self.valuesname # (val, desc)
 
@@ -2788,45 +2837,41 @@
 
 # A bit poorly named, but this represents plain data files to copy
 # during install.
+@dataclass(eq=False)
 class Data(HoldableObject):
- def __init__(self, sources: T.ListFile, install_dir: str, install_dir_name: str,
- install_mode: 'FileMode', subproject: str,
- rename: T.Liststr = None,
- install_tag: T.Optionalstr = None,
- data_type: str = None):
- self.sources = sources
- self.install_dir = install_dir
- self.install_dir_name = install_dir_name
- self.install_mode = install_mode
- self.install_tag = install_tag
- if rename is None:
+ sources: T.ListFile
+ install_dir: str
+ install_dir_name: str
+ install_mode: 'FileMode'
+ subproject: str
+ rename: T.Liststr = None
+ install_tag: T.Optionalstr = None
+ data_type: str = None
+
+ def __post_init__(self) -> None:
+ if self.rename is None:
 self.rename = os.path.basename(f.fname) for f in self.sources
- else:
- self.rename = rename
- self.subproject = subproject
- self.data_type = data_type
 
+@dataclass(eq=False)
 class SymlinkData(HoldableObject):
- def __init__(self, target: str, name: str, install_dir: str,
- subproject: str, install_tag: T.Optionalstr = None):
- self.target = target
- if name != os.path.basename(name):
- raise InvalidArguments(f'Link name is "{name}", but link names cannot contain path separators. '
+ target: str
+ name: str
+ install_dir: str
+ subproject: str
+ install_tag: T.Optionalstr = None
+
+ def __post_init__(self) -> None:
+ if self.name != os.path.basename(self.name):
+ raise InvalidArguments(f'Link name is "{self.name}", but link names cannot contain path separators. '
 'The dir part should be in install_dir.')
- self.name = name
- self.install_dir = install_dir
- self.subproject = subproject
- self.install_tag = install_tag
 
+@dataclass(eq=False)
 class TestSetup:
- def __init__(self, exe_wrapper: T.Liststr, gdb: bool,
- timeout_multiplier: int, env: EnvironmentVariables,
- exclude_suites: T.Liststr):
- self.exe_wrapper = exe_wrapper
- self.gdb = gdb
- self.timeout_multiplier = timeout_multiplier
- self.env = env
- self.exclude_suites = exclude_suites
+ exe_wrapper: T.Liststr
+ gdb: bool
+ timeout_multiplier: int
+ env: EnvironmentVariables
+ exclude_suites: T.Liststr
 
 def get_sources_string_names(sources, backend):
 '''
@@ -2840,7 +2885,7 @@
 elif isinstance(s, (BuildTarget, CustomTarget, CustomTargetIndex, GeneratedList)):
 names += s.get_outputs()
 elif isinstance(s, ExtractedObjects):
- names += s.get_outputs(backend)
+ names += backend.determine_ext_objs(s)
 elif isinstance(s, File):
 names.append(s.fname)
 else:
@@ -2849,24 +2894,11 @@
 
 def load(build_dir: str) -> Build:
 filename = os.path.join(build_dir, 'meson-private', 'build.dat')
- load_fail_msg = f'Build data file {filename!r} is corrupted. Try with a fresh build tree.'
- nonexisting_fail_msg = f'No such build data file as "{filename!r}".'
 try:
- with open(filename, 'rb') as f:
- obj = pickle.load(f)
+ return pickle_load(filename, 'Build data', Build)
 except FileNotFoundError:
- raise MesonException(nonexisting_fail_msg)
- except (pickle.UnpicklingError, EOFError):
- raise MesonException(load_fail_msg)
- except AttributeError:
- raise MesonException(
- f"Build data file {filename!r} references functions or classes that don't "
- "exist. This probably means that it was generated with an old "
- "version of meson. Try running from the source directory "
- f"meson {build_dir} --wipe")
- if not isinstance(obj, Build):
- raise MesonException(load_fail_msg)
- return obj
+ raise MesonException(f'No such build data file as {filename!r}.')
+
 
 def save(obj: Build, filename: str) -> None:
 with open(filename, 'wb') as f:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/cmake/__init__.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/cmake/__init__.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/cmake/common.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/cmake/common.py Changed

@@ -14,6 +14,7 @@
 
 # This class contains the basic functionality needed to run any interpreter
 # or an interpreter-based tool.
+from __future__ import annotations
 
 from ..mesonlib import MesonException, OptionKey
 from .. import mlog
@@ -100,9 +101,9 @@
             escape = False
         elif i == '\\':
             escape = True
-        elif i in '"', "'":
+        elif i in {'"', "'"}:
             in_string = not in_string
-        elif i in ' ', '\n':
+        elif i in {' ', '\n'}:
             if in_string:
                 curr += i
             else:
@@ -111,7 +112,7 @@
         else:
             curr += i
     res += curr
-    res = list(filter(lambda x: len(x) > 0, res))
+    res = r for r in res if len(r) > 0
     return res
 
 def cmake_get_generator_args(env: 'Environment') -> T.Liststr:
@@ -151,7 +152,7 @@
     dis = '-D' + x for x in blacklist_cmake_defs
     assert dis  # Ensure that dis is not empty.
     for i in args:
-        if any(i.startswith(x) for x in dis):
+        if any(i.startswith(x) for x in dis):
             mlog.warning('Setting', mlog.bold(i), 'is not supported. See the meson docs for cross compilation support:')
             mlog.warning('  - URL: https://mesonbuild.com/CMake-module.html#cross-compilation')
             mlog.warning('  --> Ignoring this option')
@@ -161,7 +162,7 @@
 
 class CMakeInclude:
     def __init__(self, path: Path, isSystem: bool = False):
-        self.path     = path
+        self.path = path
         self.isSystem = isSystem
 
     def __repr__(self) -> str:
@@ -169,11 +170,11 @@
 
 class CMakeFileGroup:
     def __init__(self, data: T.Dictstr, T.Any) -> None:
-        self.defines      = data.get('defines', '')                       # type: str
-        self.flags        = _flags_to_list(data.get('compileFlags', ''))  # type: T.Liststr
+        self.defines = data.get('defines', '')                       # type: str
+        self.flags = _flags_to_list(data.get('compileFlags', ''))  # type: T.Liststr
         self.is_generated = data.get('isGenerated', False)                # type: bool
-        self.language     = data.get('language', 'C')                     # type: str
-        self.sources      = Path(x) for x in data.get('sources', )    # type: T.ListPath
+        self.language = data.get('language', 'C')                     # type: str
+        self.sources = Path(x) for x in data.get('sources', )    # type: T.ListPath
 
         # Fix the include directories
         self.includes =   # type: T.ListCMakeInclude
@@ -199,21 +200,21 @@
 
 class CMakeTarget:
     def __init__(self, data: T.Dictstr, T.Any) -> None:
-        self.artifacts               = Path(x) for x in data.get('artifacts', )         # type: T.ListPath
-        self.src_dir                 = Path(data.get('sourceDirectory', ''))                # type: Path
-        self.build_dir               = Path(data.get('buildDirectory', ''))                 # type: Path
-        self.name                    = data.get('name', '')                                 # type: str
-        self.full_name               = data.get('fullName', '')                             # type: str
-        self.install                 = data.get('hasInstallRule', False)                    # type: bool
-        self.install_paths           = Path(x) for x in set(data.get('installPaths', )) # type: T.ListPath
-        self.link_lang               = data.get('linkerLanguage', '')                       # type: str
-        self.link_libraries          = _flags_to_list(data.get('linkLibraries', ''))        # type: T.Liststr
-        self.link_flags              = _flags_to_list(data.get('linkFlags', ''))            # type: T.Liststr
-        self.link_lang_flags         = _flags_to_list(data.get('linkLanguageFlags', ''))    # type: T.Liststr
-        # self.link_path             = Path(data.get('linkPath', ''))                       # type: Path
-        self.type                    = data.get('type', 'EXECUTABLE')                       # type: str
-        # self.is_generator_provided = data.get('isGeneratorProvided', False)               # type: bool
-        self.files                   =                                                    # type: T.ListCMakeFileGroup
+        self.artifacts = Path(x) for x in data.get('artifacts', )               # type: T.ListPath
+        self.src_dir = Path(data.get('sourceDirectory', ''))                        # type: Path
+        self.build_dir = Path(data.get('buildDirectory', ''))                       # type: Path
+        self.name = data.get('name', '')                                            # type: str
+        self.full_name = data.get('fullName', '')                                   # type: str
+        self.install = data.get('hasInstallRule', False)                            # type: bool
+        self.install_paths = Path(x) for x in set(data.get('installPaths', ))   # type: T.ListPath
+        self.link_lang = data.get('linkerLanguage', '')                             # type: str
+        self.link_libraries = _flags_to_list(data.get('linkLibraries', ''))         # type: T.Liststr
+        self.link_flags = _flags_to_list(data.get('linkFlags', ''))                 # type: T.Liststr
+        self.link_lang_flags = _flags_to_list(data.get('linkLanguageFlags', ''))    # type: T.Liststr
+        # self.link_path = Path(data.get('linkPath', ''))                             # type: Path
+        self.type = data.get('type', 'EXECUTABLE')                                  # type: str
+        # self.is_generator_provided = data.get('isGeneratorProvided', False)         # type: bool
+        self.files =                                                              # type: T.ListCMakeFileGroup
 
         for i in data.get('fileGroups', ):
             self.files += CMakeFileGroup(i)
@@ -240,10 +241,10 @@
 
 class CMakeProject:
     def __init__(self, data: T.Dictstr, T.Any) -> None:
-        self.src_dir   = Path(data.get('sourceDirectory', ''))   # type: Path
-        self.build_dir = Path(data.get('buildDirectory', ''))    # type: Path
-        self.name      = data.get('name', '')                    # type: str
-        self.targets   =                                       # type: T.ListCMakeTarget
+        self.src_dir = Path(data.get('sourceDirectory', ''))    # type: Path
+        self.build_dir = Path(data.get('buildDirectory', ''))   # type: Path
+        self.name = data.get('name', '')                        # type: str
+        self.targets =                                        # type: T.ListCMakeTarget
 
         for i in data.get('targets', ):
             self.targets += CMakeTarget(i)
@@ -259,8 +260,8 @@
 
 class CMakeConfiguration:
     def __init__(self, data: T.Dictstr, T.Any) -> None:
-        self.name     = data.get('name', '')   # type: str
-        self.projects =                      # type: T.ListCMakeProject
+        self.name = data.get('name', '')        # type: str
+        self.projects =                       # type: T.ListCMakeProject
         for i in data.get('projects', ):
             self.projects += CMakeProject(i)

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/cmake/data/__init__.py Added

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/cmake/executor.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/cmake/executor.py Changed

@@ -14,24 +14,27 @@
 
 # This class contains the basic functionality needed to run any interpreter
 # or an interpreter-based tool.
+from __future__ import annotations
 
 import subprocess as S
-from pathlib import Path
 from threading import Thread
 import typing as T
 import re
 import os
 
 from .. import mlog
-from ..mesonlib import PerMachine, Popen_safe, version_compare, MachineChoice, is_windows, OptionKey
+from ..mesonlib import PerMachine, Popen_safe, version_compare, is_windows, OptionKey
 from ..programs import find_external_program, NonExistingExternalProgram
 
 if T.TYPE_CHECKING:
+    from pathlib import Path
+
     from ..environment import Environment
+    from ..mesonlib import MachineChoice
     from ..programs import ExternalProgram
 
-TYPE_result    = T.Tupleint, T.Optionalstr, T.Optionalstr
-TYPE_cache_key = T.Tuplestr, T.Tuplestr, ..., str, T.FrozenSetT.Tuplestr, str
+    TYPE_result = T.Tupleint, T.Optionalstr, T.Optionalstr
+    TYPE_cache_key = T.Tuplestr, T.Tuplestr, ..., str, T.FrozenSetT.Tuplestr, str
 
 class CMakeExecutor:
     # The class's copy of the CMake path. Avoids having to search for it
@@ -105,23 +108,29 @@
             mlog.log(f'Did not find CMake {cmakebin.name!r}')
             return None
         try:
-            p, out = Popen_safe(cmakebin.get_command() + '--version')0:2
+            cmd = cmakebin.get_command()
+            p, out = Popen_safe(cmd + '--version')0:2
             if p.returncode != 0:
                 mlog.warning('Found CMake {!r} but couldn\'t run it'
-                             ''.format(' '.join(cmakebin.get_command())))
+                             ''.format(' '.join(cmd)))
                 return None
         except FileNotFoundError:
             mlog.warning('We thought we found CMake {!r} but now it\'s not there. How odd!'
-                         ''.format(' '.join(cmakebin.get_command())))
+                         ''.format(' '.join(cmd)))
             return None
         except PermissionError:
-            msg = 'Found CMake {!r} but didn\'t have permissions to run it.'.format(' '.join(cmakebin.get_command()))
+            msg = 'Found CMake {!r} but didn\'t have permissions to run it.'.format(' '.join(cmd))
             if not is_windows():
                 msg += '\n\nOn Unix-like systems this is often caused by scripts that are not executable.'
             mlog.warning(msg)
             return None
-        cmvers = re.search(r'(cmake|cmake3)\s*version\s*(\d.+)', out).group(2)
-        return cmvers
+
+        cmvers = re.search(r'(cmake|cmake3)\s*version\s*(\d.+)', out)
+        if cmvers is not None:
+            return cmvers.group(2)
+        mlog.warning(f'We thought we found CMake {cmd!r}, but it was missing the expected '
+                     'version string in its output.')
+        return None
 
     def set_exec_mode(self, print_cmout: T.Optionalbool = None, always_capture_stderr: T.Optionalbool = None) -> None:
         if print_cmout is not None:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/cmake/fileapi.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/cmake/fileapi.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from .common import CMakeException, CMakeBuildFile, CMakeConfiguration
 import typing as T
@@ -23,13 +24,13 @@
 
 class CMakeFileAPI:
     def __init__(self, build_dir: Path):
-        self.build_dir            = build_dir
-        self.api_base_dir         = self.build_dir / '.cmake' / 'api' / 'v1'
-        self.request_dir          = self.api_base_dir / 'query' / 'client-meson'
-        self.reply_dir            = self.api_base_dir / 'reply'
-        self.cmake_sources        =    # type: T.ListCMakeBuildFile
+        self.build_dir = build_dir
+        self.api_base_dir = self.build_dir / '.cmake' / 'api' / 'v1'
+        self.request_dir = self.api_base_dir / 'query' / 'client-meson'
+        self.reply_dir = self.api_base_dir / 'reply'
+        self.cmake_sources =    # type: T.ListCMakeBuildFile
         self.cmake_configurations =    # type: T.ListCMakeConfiguration
-        self.kind_resolver_map    = {
+        self.kind_resolver_map = {
             'codemodel': self._parse_codemodel,
             'cmakeFiles': self._parse_cmakeFiles,
         }
@@ -103,7 +104,7 @@
             src_dir = Path(dir_entry.get('source', '.'))
             bld_dir = Path(dir_entry.get('build', '.'))
             src_dir = src_dir if src_dir.is_absolute() else source_dir / src_dir
-            bld_dir = bld_dir if bld_dir.is_absolute() else build_dir  / bld_dir
+            bld_dir = bld_dir if bld_dir.is_absolute() else build_dir / bld_dir
             src_dir = src_dir.resolve()
             bld_dir = bld_dir.resolve()

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/cmake/generator.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/cmake/generator.py Changed

@@ -11,11 +11,22 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from .. import mesonlib
+from .. import mlog
+from .common import cmake_is_debug
 import typing as T
 
-def parse_generator_expressions(raw: str) -> str:
+if T.TYPE_CHECKING:
+ from .traceparser import CMakeTraceParser, CMakeTarget
+
+def parse_generator_expressions(
+ raw: str,
+ trace: 'CMakeTraceParser',
+ *,
+ context_tgt: T.Optional'CMakeTarget' = None,
+ ) -> str:
 '''Parse CMake generator expressions
 
 Most generator expressions are simply ignored for
@@ -44,13 +55,58 @@
 else:
 return '1' if mesonlib.version_compare(arg:col_pos, '{}{}'.format(op, argcol_pos + 1:)) else '0'
 
+ def target_property(arg: str) -> str:
+ # We can't really support this since we don't have any context
+ if ',' not in arg:
+ if context_tgt is None:
+ return ''
+ return ';'.join(context_tgt.properties.get(arg, ))
+
+ args = arg.split(',')
+ props = trace.targetsargs0.properties.get(args1, ) if args0 in trace.targets else 
+ return ';'.join(props)
+
+ def target_file(arg: str) -> str:
+ if arg not in trace.targets:
+ mlog.warning(f"Unable to evaluate the cmake variable '$<TARGET_FILE:{arg}>'.")
+ return ''
+ tgt = trace.targetsarg
+
+ cfgs = 
+ cfg = ''
+
+ if 'IMPORTED_CONFIGURATIONS' in tgt.properties:
+ cfgs = x for x in tgt.properties'IMPORTED_CONFIGURATIONS' if x
+ cfg = cfgs0
+
+ if cmake_is_debug(trace.env):
+ if 'DEBUG' in cfgs:
+ cfg = 'DEBUG'
+ elif 'RELEASE' in cfgs:
+ cfg = 'RELEASE'
+ else:
+ if 'RELEASE' in cfgs:
+ cfg = 'RELEASE'
+
+ if f'IMPORTED_IMPLIB_{cfg}' in tgt.properties:
+ return ';'.join(x for x in tgt.propertiesf'IMPORTED_IMPLIB_{cfg}' if x)
+ elif 'IMPORTED_IMPLIB' in tgt.properties:
+ return ';'.join(x for x in tgt.properties'IMPORTED_IMPLIB' if x)
+ elif f'IMPORTED_LOCATION_{cfg}' in tgt.properties:
+ return ';'.join(x for x in tgt.propertiesf'IMPORTED_LOCATION_{cfg}' if x)
+ elif 'IMPORTED_LOCATION' in tgt.properties:
+ return ';'.join(x for x in tgt.properties'IMPORTED_LOCATION' if x)
+ return ''
+
 supported = {
 # Boolean functions
- 'BOOL': lambda x: '0' if x.upper() in '0', 'FALSE', 'OFF', 'N', 'NO', 'IGNORE', 'NOTFOUND' or x.endswith('-NOTFOUND') else '1',
- 'AND': lambda x: '1' if all(y == '1' for y in x.split(',')) else '0',
- 'OR': lambda x: '1' if any(y == '1' for y in x.split(',')) else '0',
+ 'BOOL': lambda x: '0' if x.upper() in {'0', 'FALSE', 'OFF', 'N', 'NO', 'IGNORE', 'NOTFOUND'} or x.endswith('-NOTFOUND') else '1',
+ 'AND': lambda x: '1' if all(y == '1' for y in x.split(',')) else '0',
+ 'OR': lambda x: '1' if any(y == '1' for y in x.split(',')) else '0',
 'NOT': lambda x: '0' if x == '1' else '1',
 
+ 'IF': lambda x: x.split(',')1 if x.split(',')0 == '1' else x.split(',')2,
+
 '0': lambda x: '',
 '1': lambda x: x,
 
@@ -78,6 +134,12 @@
 'ANGLE-R': lambda x: '>',
 'COMMA': lambda x: ',',
 'SEMICOLON': lambda x: ';',
+
+ # Target related expressions
+ 'TARGET_EXISTS': lambda x: '1' if x in trace.targets else '0',
+ 'TARGET_NAME_IF_EXISTS': lambda x: x if x in trace.targets else '',
+ 'TARGET_PROPERTY': target_property,
+ 'TARGET_FILE': target_file,
 } # type: T.Dictstr, T.Callablestr, str
 
 # Recursively evaluate generator expressions

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/cmake/interpreter.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/cmake/interpreter.py Changed

@@ -14,28 +14,26 @@
 
 # This class contains the basic functionality needed to run any interpreter
 # or an interpreter-based tool.
+from __future__ import annotations
 
-from .common import CMakeException, CMakeTarget, TargetOptions, CMakeConfiguration, language_map, backend_generator_map, cmake_get_generator_args, check_cmake_args
-from .client import CMakeClient, RequestCMakeInputs, RequestConfigure, RequestCompute, RequestCodeModel, ReplyCMakeInputs, ReplyCodeModel
+from functools import lru_cache
+from os import environ
+from pathlib import Path
+import re
+import typing as T
+
+from .common import CMakeException, CMakeTarget, language_map, cmake_get_generator_args, check_cmake_args
 from .fileapi import CMakeFileAPI
 from .executor import CMakeExecutor
 from .toolchain import CMakeToolchain, CMakeExecScope
-from .traceparser import CMakeTraceParser, CMakeGeneratorTarget
+from .traceparser import CMakeTraceParser
 from .tracetargets import resolve_cmake_trace_targets
 from .. import mlog, mesonlib
-from ..mesonlib import MachineChoice, OrderedSet, version_compare, path_is_in_root, relative_to_if_possible, OptionKey
-from ..mesondata import mesondata
+from ..mesonlib import MachineChoice, OrderedSet, path_is_in_root, relative_to_if_possible, OptionKey
+from ..mesondata import DataFile
 from ..compilers.compilers import assembler_suffixes, lang_suffixes, header_suffixes, obj_suffixes, lib_suffixes, is_header
 from ..programs import ExternalProgram
 from ..coredata import FORBIDDEN_TARGET_NAMES
-from enum import Enum
-from functools import lru_cache
-from pathlib import Path
-import typing as T
-import re
-import textwrap
-from os import environ
-
 from ..mparser import (
 Token,
 BaseNode,
@@ -54,14 +52,16 @@
 
 
 if T.TYPE_CHECKING:
+ from .common import CMakeConfiguration, TargetOptions
+ from .traceparser import CMakeGeneratorTarget
 from .._typing import ImmutableListProtocol
 from ..build import Build
 from ..backend.backends import Backend
 from ..environment import Environment
 
-TYPE_mixed = T.Unionstr, int, bool, Path, BaseNode
-TYPE_mixed_list = T.UnionTYPE_mixed, T.SequenceTYPE_mixed
-TYPE_mixed_kwargs = T.Dictstr, TYPE_mixed_list
+ TYPE_mixed = T.Unionstr, int, bool, Path, BaseNode
+ TYPE_mixed_list = T.UnionTYPE_mixed, T.SequenceTYPE_mixed
+ TYPE_mixed_kwargs = T.Dictstr, TYPE_mixed_list
 
 # Disable all warnings automatically enabled with --trace and friends
 # See https://cmake.org/cmake/help/latest/variable/CMAKE_POLICY_WARNING_CMPNNNN.html
@@ -131,7 +131,7 @@
 rm_so_version = re.compile(r'(\.0-9+)+$')
 
 def __init__(self, build_dir: Path):
- self.tgt_map = {} # type: T.Dictstr, T.Union'ConverterTarget', 'ConverterCustomTarget'
+ self.tgt_map: T.Dictstr, T.Union'ConverterTarget', 'ConverterCustomTarget' = {}
 self.build_dir = build_dir
 
 def add(self, tgt: T.Union'ConverterTarget', 'ConverterCustomTarget') -> None:
@@ -210,48 +210,48 @@
 
 class ConverterTarget:
 def __init__(self, target: CMakeTarget, env: 'Environment', for_machine: MachineChoice) -> None:
- self.env = env
- self.for_machine = for_machine
- self.artifacts = target.artifacts
- self.src_dir = target.src_dir
- self.build_dir = target.build_dir
- self.name = target.name
- self.cmake_name = target.name
- self.full_name = target.full_name
- self.type = target.type
- self.install = target.install
- self.install_dir = None # type: T.OptionalPath
+ self.env = env
+ self.for_machine = for_machine
+ self.artifacts = target.artifacts
+ self.src_dir = target.src_dir
+ self.build_dir = target.build_dir
+ self.name = target.name
+ self.cmake_name = target.name
+ self.full_name = target.full_name
+ self.type = target.type
+ self.install = target.install
+ self.install_dir: T.OptionalPath = None
 self.link_libraries = target.link_libraries
- self.link_flags = target.link_flags + target.link_lang_flags
- self.depends_raw = # type: T.Liststr
- self.depends = # type: T.ListT.UnionConverterTarget, ConverterCustomTarget
+ self.link_flags = target.link_flags + target.link_lang_flags
+ self.depends_raw: T.Liststr = 
+ self.depends: T.ListT.UnionConverterTarget, ConverterCustomTarget = 
 
 if target.install_paths:
 self.install_dir = target.install_paths0
 
- self.languages = set() # type: T.Setstr
- self.sources = # type: T.ListPath
- self.generated = # type: T.ListPath
- self.generated_ctgt = # type: T.ListCustomTargetReference
- self.includes = # type: T.ListPath
- self.sys_includes = # type: T.ListPath
- self.link_with = # type: T.ListT.UnionConverterTarget, ConverterCustomTarget
- self.object_libs = # type: T.ListConverterTarget
- self.compile_opts = {} # type: T.Dictstr, T.Liststr
- self.public_compile_opts = # type: T.Liststr
- self.pie = False
+ self.languages: T.Setstr = set()
+ self.sources: T.ListPath = 
+ self.generated: T.ListPath = 
+ self.generated_ctgt: T.ListCustomTargetReference = 
+ self.includes: T.ListPath = 
+ self.sys_includes: T.ListPath = 
+ self.link_with: T.ListT.UnionConverterTarget, ConverterCustomTarget = 
+ self.object_libs: T.ListConverterTarget = 
+ self.compile_opts: T.Dictstr, T.Liststr = {}
+ self.public_compile_opts: T.Liststr = 
+ self.pie = False
 
 # Project default override options (c_std, cpp_std, etc.)
- self.override_options = # type: T.Liststr
+ self.override_options: T.Liststr = 
 
 # Convert the target name to a valid meson target name
 self.name = _sanitize_cmake_name(self.name)
 
- self.generated_raw = # type: T.ListPath
+ self.generated_raw: T.ListPath = 
 
 for i in target.files:
- languages = set() # type: T.Setstr
- src_suffixes = set() # type: T.Setstr
+ languages: T.Setstr = set()
+ src_suffixes: T.Setstr = set()
 
 # Insert suffixes
 for j in i.sources:
@@ -320,7 +320,7 @@
 )
 continue
 self.override_options += f'{i}_std={std}'
- elif j in '-fPIC', '-fpic', '-fPIE', '-fpie':
+ elif j in {'-fPIC', '-fpic', '-fPIE', '-fpie'}:
 self.pie = True
 elif isinstance(ctgt, ConverterCustomTarget):
 # Sometimes projects pass generated source files as compiler
@@ -345,10 +345,10 @@
 self.depends_raw = trace.targetsself.cmake_name.depends
 
 rtgt = resolve_cmake_trace_targets(self.cmake_name, trace, self.env)
- self.includes += Path(x) for x in rtgt.include_directories
- self.link_flags += rtgt.link_flags
+ self.includes += Path(x) for x in rtgt.include_directories
+ self.link_flags += rtgt.link_flags
 self.public_compile_opts += rtgt.public_compile_opts
- self.link_libraries += rtgt.libraries
+ self.link_libraries += rtgt.libraries
 
 elif self.type.upper() not in 'EXECUTABLE', 'OBJECT_LIBRARY':
 mlog.warning('CMake: Target', mlog.bold(self.cmake_name), 'not found in CMake trace. This can lead to build errors')
@@ -372,8 +372,8 @@
 for i in self.languages:
 supported += list(lang_suffixesi)
 supported = f'.{x}' for x in supported
- self.sources = x for x in self.sources if any(x.name.endswith(y) for y in supported)
- self.generated_raw = x for x in self.generated_raw if any(x.name.endswith(y) for y in supported)
+ self.sources = x for x in self.sources if any(x.name.endswith(y) for y in supported)
+ self.generated_raw = x for x in self.generated_raw if any(x.name.endswith(y) for y in supported)
 
 # Make paths relative
 def rel_path(x: Path, is_header: bool, is_generated: bool) -> T.OptionalPath:
@@ -381,7 +381,7 @@
 x = self.src_dir / x
 x = x.resolve()
 assert x.is_absolute()
- if not x.exists() and not any(x.name.endswith(y) for y in obj_suffixes) and not is_generated:
+ if not x.exists() and not any(x.name.endswith(y) for y in obj_suffixes) and not is_generated:
 if path_is_in_root(x, Path(self.env.get_build_dir()), resolve=True):
 x.mkdir(parents=True, exist_ok=True)
 return x.relative_to(Path(self.env.get_build_dir()) / subdir)
@@ -397,7 +397,7 @@
 path_is_in_root(x, root_src_dir) or
 path_is_in_root(x, Path(self.env.get_build_dir()))
 )
- ):
+ ):
 mlog.warning('CMake: path', mlog.bold(x.as_posix()), 'is inside the root project but', mlog.bold('not'), 'inside the subproject.')
 mlog.warning(' --> Ignoring. This can lead to build errors.')
 return None
@@ -425,9 +425,9 @@
 self.generated += gen_file
 
 # Remove delete entries
- self.includes = x for x in self.includes if x is not None
+ self.includes = x for x in self.includes if x is not None
 self.sys_includes = x for x in self.sys_includes if x is not None
- self.sources = x for x in self.sources if x is not None
+ self.sources = x for x in self.sources if x is not None
 
 # Make sure '.' is always in the include directories
 if Path('.') not in self.includes:
@@ -461,7 +461,7 @@
 return res
 
 self.link_libraries = handle_frameworks(self.link_libraries)
- self.link_flags = handle_frameworks(self.link_flags)
+ self.link_flags = handle_frameworks(self.link_flags)
 
 # Handle explicit CMake add_dependency() calls
 for i in self.depends_raw:
@@ -471,7 +471,7 @@
 
 def process_object_libs(self, obj_target_list: T.List'ConverterTarget', linker_workaround: bool) -> None:
 # Try to detect the object library(s) from the generated input sources
- temp = x for x in self.generated if any(x.name.endswith('.' + y) for y in obj_suffixes)
+ temp = x for x in self.generated if any(x.name.endswith('.' + y) for y in obj_suffixes)
 stem = x.stem for x in temp
 exts = self._all_source_suffixes()
 # Temp now stores the source filenames of the object files
@@ -483,11 +483,11 @@
 # suffix and just produces object files like `foo.obj`. Thus we have to do our best to
 # undo this step and guess the correct language suffix of the object file. This is done
 # by trying all language suffixes meson knows and checking if one of them fits.
- candidates = j # type: T.Liststr
- if not any(j.endswith('.' + x) for x in exts):
+ candidates = j
+ if not any(j.endswith('.' + x) for x in exts):
 mlog.warning('Object files do not contain source file extensions, thus falling back to guessing them.', once=True)
 candidates += f'{j}.{x}' for x in exts
- if any(x in source_files for x in candidates):
+ if any(x in source_files for x in candidates):
 if linker_workaround:
 self._append_objlib_sources(i)
 else:
@@ -497,17 +497,17 @@
 break
 
 # Filter out object files from the sources
- self.generated = x for x in self.generated if not any(x.name.endswith('.' + y) for y in obj_suffixes)
+ self.generated = x for x in self.generated if not any(x.name.endswith('.' + y) for y in obj_suffixes)
 
 def _append_objlib_sources(self, tgt: 'ConverterTarget') -> None:
- self.includes += tgt.includes
- self.sources += tgt.sources
- self.generated += tgt.generated
+ self.includes += tgt.includes
+ self.sources += tgt.sources
+ self.generated += tgt.generated
 self.generated_ctgt += tgt.generated_ctgt
- self.includes = list(OrderedSet(self.includes))
- self.sources = list(OrderedSet(self.sources))
- self.generated = list(OrderedSet(self.generated))
- self.generated_ctgt = list(OrderedSet(self.generated_ctgt))
+ self.includes = list(OrderedSet(self.includes))
+ self.sources = list(OrderedSet(self.sources))
+ self.generated = list(OrderedSet(self.generated))
+ self.generated_ctgt = list(OrderedSet(self.generated_ctgt))
 
 # Inherit compiler arguments since they may be required for building
 for lang, opts in tgt.compile_opts.items():
@@ -517,9 +517,9 @@
 
 @lru_cache(maxsize=None)
 def _all_source_suffixes(self) -> 'ImmutableListProtocolstr':
- suffixes = # type: T.Liststr
+ suffixes: T.Liststr = 
 for exts in lang_suffixes.values():
- suffixes += x for x in exts
+ suffixes.extend(exts)
 return suffixes
 
 @lru_cache(maxsize=None)
@@ -583,8 +583,8 @@
 
 class CustomTargetReference:
 def __init__(self, ctgt: 'ConverterCustomTarget', index: int) -> None:
- self.ctgt = ctgt # type: ConverterCustomTarget
- self.index = index # type: int
+ self.ctgt = ctgt
+ self.index = index
 
 def __repr__(self) -> str:
 if self.valid():
@@ -599,8 +599,8 @@
 return self.ctgt.outputsself.index
 
 class ConverterCustomTarget:
- tgt_counter = 0 # type: int
- out_counter = 0 # type: int
+ tgt_counter = 0
+ out_counter = 0
 
 def __init__(self, target: CMakeGeneratorTarget, env: 'Environment', for_machine: MachineChoice) -> None:
 assert target.current_bin_dir is not None
@@ -609,20 +609,20 @@
 if not self.name:
 self.name = f'custom_tgt_{ConverterCustomTarget.tgt_counter}'
 ConverterCustomTarget.tgt_counter += 1
- self.cmake_name = str(self.name)
+ self.cmake_name = str(self.name)
 self.original_outputs = list(target.outputs)
- self.outputs = x.name for x in self.original_outputs
- self.conflict_map = {} # type: T.Dictstr, str
- self.command = # type: T.ListT.ListT.Unionstr, ConverterTarget
- self.working_dir = target.working_dir
- self.depends_raw = target.depends
- self.inputs = # type: T.ListT.Unionstr, CustomTargetReference
- self.depends = # type: T.ListT.UnionConverterTarget, ConverterCustomTarget
- self.current_bin_dir = target.current_bin_dir # type: Path
- self.current_src_dir = target.current_src_dir # type: Path
- self.env = env
- self.for_machine = for_machine
- self._raw_target = target
+ self.outputs = x.name for x in self.original_outputs
+ self.conflict_map: T.Dictstr, str = {}
+ self.command: T.ListT.ListT.Unionstr, ConverterTarget = 
+ self.working_dir = target.working_dir
+ self.depends_raw = target.depends
+ self.inputs: T.ListT.Unionstr, CustomTargetReference = 
+ self.depends: T.ListT.UnionConverterTarget, ConverterCustomTarget = 
+ self.current_bin_dir = target.current_bin_dir
+ self.current_src_dir = target.current_src_dir
+ self.env = env
+ self.for_machine = for_machine
+ self._raw_target = target
 
 # Convert the target name to a valid meson target name
 self.name = _sanitize_cmake_name(self.name)
@@ -652,7 +652,7 @@
 # Ensure that there is no duplicate output in the project so
 # that meson can handle cases where the same filename is
 # generated in multiple directories
- temp_outputs = # type: T.Liststr
+ temp_outputs: T.Liststr = 
 for i in self.outputs:
 if i in all_outputs:
 old = str(i)
@@ -664,10 +664,11 @@
 self.outputs = temp_outputs
 
 # Check if the command is a build target
- commands = # type: T.ListT.ListT.Unionstr, ConverterTarget
+ commands: T.ListT.ListT.Unionstr, ConverterTarget = 
 for curr_cmd in self._raw_target.command:
 assert isinstance(curr_cmd, list)
- cmd = # type: T.ListT.Unionstr, ConverterTarget
+ assert curr_cmd0 != '', "An empty string is not a valid executable"
+ cmd: T.ListT.Unionstr, ConverterTarget = 
 
 for j in curr_cmd:
 if not j:
@@ -717,7 +718,7 @@
 # targets, etc. This reduces the chance of misdetecting input files
 # as outputs from other targets.
 # See https://github.com/mesonbuild/meson/issues/6632
- if not raw.is_absolute() and (self.current_src_dir / raw).exists():
+ if not raw.is_absolute() and (self.current_src_dir / raw).is_file():
 self.inputs += (self.current_src_dir / raw).relative_to(root_src_dir).as_posix()
 elif raw.is_absolute() and raw.exists() and rel_to_root is not None:
 self.inputs += rel_to_root.as_posix()
@@ -763,42 +764,36 @@
 mlog.log(' -- inputs: ', mlog.bold(str(self.inputs)))
 mlog.log(' -- depends: ', mlog.bold(str(self.depends)))
 
-class CMakeAPI(Enum):
- SERVER = 1
- FILE = 2
-
 class CMakeInterpreter:
 def __init__(self, build: 'Build', subdir: Path, src_dir: Path, install_prefix: Path, env: 'Environment', backend: 'Backend'):
- self.build = build
- self.subdir = subdir
- self.src_dir = src_dir
- self.build_dir_rel = subdir / '__CMake_build'
- self.build_dir = Path(env.get_build_dir()) / self.build_dir_rel
+ self.build = build
+ self.subdir = subdir
+ self.src_dir = src_dir
+ self.build_dir_rel = subdir / '__CMake_build'
+ self.build_dir = Path(env.get_build_dir()) / self.build_dir_rel
 self.install_prefix = install_prefix
- self.env = env
- self.for_machine = MachineChoice.HOST # TODO make parameter
- self.backend_name = backend.name
- self.linkers = set() # type: T.Setstr
- self.cmake_api = CMakeAPI.SERVER
- self.client = CMakeClient(self.env)
- self.fileapi = CMakeFileAPI(self.build_dir)
+ self.env = env
+ self.for_machine = MachineChoice.HOST # TODO make parameter
+ self.backend_name = backend.name
+ self.linkers: T.Setstr = set()
+ self.fileapi = CMakeFileAPI(self.build_dir)
 
 # Raw CMake results
- self.bs_files = # type: T.ListPath
- self.codemodel_configs = None # type: T.OptionalT.ListCMakeConfiguration
- self.raw_trace = None # type: T.Optionalstr
+ self.bs_files: T.ListPath = 
+ self.codemodel_configs: T.OptionalT.ListCMakeConfiguration = None
+ self.cmake_stderr: T.Optionalstr = None
 
 # Analysed data
- self.project_name = ''
- self.languages = # type: T.Liststr
- self.targets = # type: T.ListConverterTarget
- self.custom_targets = # type: T.ListConverterCustomTarget
+ self.project_name = ''
+ self.languages: T.Liststr = 
+ self.targets: T.ListConverterTarget = 
+ self.custom_targets: T.ListConverterCustomTarget = 
 self.trace: CMakeTraceParser
 self.output_target_map = OutputTargetMap(self.build_dir)
 
 # Generated meson data
- self.generated_targets = {} # type: T.Dictstr, T.Dictstr, T.Optionalstr
- self.internal_name_map = {} # type: T.Dictstr, str
+ self.generated_targets: T.Dictstr, T.Dictstr, T.Optionalstr = {}
+ self.internal_name_map: T.Dictstr, str = {}
 
 # Do some special handling for object libraries for certain configurations
 self._object_lib_workaround = False
@@ -811,12 +806,12 @@
 def configure(self, extra_cmake_options: T.Liststr) -> CMakeExecutor:
 # Find CMake
 # TODO: Using MachineChoice.BUILD should always be correct here, but also evaluate the use of self.for_machine
- cmake_exe = CMakeExecutor(self.env, '>=3.7', MachineChoice.BUILD)
+ cmake_exe = CMakeExecutor(self.env, '>=3.14', MachineChoice.BUILD)
 if not cmake_exe.found():
 raise CMakeException('Unable to find CMake')
- self.trace = CMakeTraceParser(cmake_exe.version(), self.build_dir, permissive=True)
+ self.trace = CMakeTraceParser(cmake_exe.version(), self.build_dir, self.env, permissive=True)
 
- preload_file = mesondata'cmake/data/preload.cmake'.write_to_private(self.env)
+ preload_file = DataFile('cmake/data/preload.cmake').write_to_private(self.env)
 toolchain = CMakeToolchain(cmake_exe, self.env, self.for_machine, CMakeExecScope.SUBPROJECT, self.build_dir, preload_file)
 toolchain_file = toolchain.write()
 
@@ -830,22 +825,7 @@
 trace_args = self.trace.trace_args()
 cmcmp_args = f'-DCMAKE_POLICY_WARNING_{x}=OFF' for x in disable_policy_warnings
 
- if version_compare(cmake_exe.version(), '>=3.14'):
- self.cmake_api = CMakeAPI.FILE
- self.fileapi.setup_request()
- else:
- mlog.deprecation(f'Support for CMake <3.14 (Meson found {cmake_exe.version()}) is deprecated since Meson 0.61.0')
-
- if version_compare(cmake_exe.version(), '<3.17.0'):
- mlog.warning(textwrap.dedent(f'''\
- The minimum recommended CMake version is 3.17.0.
- |
- | However, Meson was only able to find CMake {cmake_exe.version()} at {cmake_exe.cmakebin.command}.
- |
- | Support for all CMake versions below 3.17.0 will be deprecated and
- | removed once newer CMake versions are more widely adopted. If you encounter
- | any errors please try upgrading CMake to a newer version first.
- '''))
+ self.fileapi.setup_request()
 
 # Run CMake
 mlog.log()
@@ -865,62 +845,36 @@
 final_args = cmake_args + trace_args + cmcmp_args + toolchain.get_cmake_args() + self.src_dir.as_posix()
 
 cmake_exe.set_exec_mode(print_cmout=True, always_capture_stderr=self.trace.requires_stderr())
- rc, _, self.raw_trace = cmake_exe.call(final_args, self.build_dir, env=os_env, disable_cache=True)
+ rc, _, self.cmake_stderr = cmake_exe.call(final_args, self.build_dir, env=os_env, disable_cache=True)
 
 mlog.log()
 h = mlog.green('SUCCEEDED') if rc == 0 else mlog.red('FAILED')
 mlog.log('CMake configuration:', h)
 if rc != 0:
- raise CMakeException('Failed to configure the CMake subproject')
+ # get the last CMake error - We only need the message function for this:
+ self.trace.functions = {'message': self.trace.functions'message'}
+ self.trace.parse(self.cmake_stderr)
+ error = f': {self.trace.errors-1}' if self.trace.errors else ''
+ raise CMakeException(f'Failed to configure the CMake subproject{error}')
 
 return cmake_exe
 
 def initialise(self, extra_cmake_options: T.Liststr) -> None:
- # Run configure the old way because doing it
- # with the server doesn't work for some reason
- # Additionally, the File API requires a configure anyway
- cmake_exe = self.configure(extra_cmake_options)
-
- # Continue with the file API If supported
- if self.cmake_api is CMakeAPI.FILE:
- # Parse the result
- self.fileapi.load_reply()
-
- # Load the buildsystem file list
- cmake_files = self.fileapi.get_cmake_sources()
- self.bs_files = x.file for x in cmake_files if not x.is_cmake and not x.is_temp
- self.bs_files = relative_to_if_possible(x, Path(self.env.get_source_dir())) for x in self.bs_files
- self.bs_files = x for x in self.bs_files if not path_is_in_root(x, Path(self.env.get_build_dir()), resolve=True)
- self.bs_files = list(OrderedSet(self.bs_files))
-
- # Load the codemodel configurations
- self.codemodel_configs = self.fileapi.get_cmake_configurations()
- return
-
- with self.client.connect(cmake_exe):
- generator = backend_generator_mapself.backend_name
- self.client.do_handshake(self.src_dir, self.build_dir, generator, 1)
-
- # Do a second configure to initialise the server
- self.client.query_checked(RequestConfigure(), 'CMake server configure')
-
- # Generate the build system files
- self.client.query_checked(RequestCompute(), 'Generating build system files')
-
- # Get CMake build system files
- bs_reply = self.client.query_checked(RequestCMakeInputs(), 'Querying build system files')
- assert isinstance(bs_reply, ReplyCMakeInputs)
-
- # Now get the CMake code model
- cm_reply = self.client.query_checked(RequestCodeModel(), 'Querying the CMake code model')
- assert isinstance(cm_reply, ReplyCodeModel)
-
- src_dir = bs_reply.src_dir
- self.bs_files = x.file for x in bs_reply.build_files if not x.is_cmake and not x.is_temp
- self.bs_files = relative_to_if_possible(src_dir / x, Path(self.env.get_source_dir()), resolve=True) for x in self.bs_files
+ # Configure the CMake project to generate the file API data
+ self.configure(extra_cmake_options)
+
+ # Parse the result
+ self.fileapi.load_reply()
+
+ # Load the buildsystem file list
+ cmake_files = self.fileapi.get_cmake_sources()
+ self.bs_files = x.file for x in cmake_files if not x.is_cmake and not x.is_temp
+ self.bs_files = relative_to_if_possible(x, Path(self.env.get_source_dir())) for x in self.bs_files
 self.bs_files = x for x in self.bs_files if not path_is_in_root(x, Path(self.env.get_build_dir()), resolve=True)
 self.bs_files = list(OrderedSet(self.bs_files))
- self.codemodel_configs = cm_reply.configs
+
+ # Load the codemodel configurations
+ self.codemodel_configs = self.fileapi.get_cmake_configurations()
 
 def analyse(self) -> None:
 if self.codemodel_configs is None:
@@ -933,10 +887,10 @@
 self.custom_targets = 
 
 # Parse the trace
- self.trace.parse(self.raw_trace)
+ self.trace.parse(self.cmake_stderr)
 
 # Find all targets
- added_target_names = # type: T.Liststr
+ added_target_names: T.Liststr = 
 for i_0 in self.codemodel_configs:
 for j_0 in i_0.projects:
 if not self.project_name:
@@ -973,7 +927,7 @@
 
 # First pass: Basic target cleanup
 object_libs = 
- custom_target_outputs = # type: T.Liststr
+ custom_target_outputs: T.Liststr = 
 for ctgt in self.custom_targets:
 ctgt.postprocess(self.output_target_map, self.src_dir, custom_target_outputs, self.trace)
 for tgt in self.targets:
@@ -1072,9 +1026,9 @@
 # Add the run script for custom commands
 
 # Add the targets
- processing = # type: T.Liststr
- processed = {} # type: T.Dictstr, T.Dictstr, T.Optionalstr
- name_map = {} # type: T.Dictstr, str
+ processing: T.Liststr = 
+ processed: T.Dictstr, T.Dictstr, T.Optionalstr = {}
+ name_map: T.Dictstr, str = {}
 
 def extract_tgt(tgt: T.UnionConverterTarget, ConverterCustomTarget, CustomTargetReference) -> IdNode:
 tgt_name = None
@@ -1102,13 +1056,13 @@
 detect_cycle(tgt)
 
 # First handle inter target dependencies
- link_with = # type: T.ListIdNode
- objec_libs = # type: T.ListIdNode
- sources = # type: T.ListPath
- generated = # type: T.ListT.UnionIdNode, IndexNode
- generated_filenames = # type: T.Liststr
- custom_targets = # type: T.ListConverterCustomTarget
- dependencies = # type: T.ListIdNode
+ link_with: T.ListIdNode = 
+ objec_libs: T.ListIdNode = 
+ sources: T.ListPath = 
+ generated: T.ListT.UnionIdNode, IndexNode = 
+ generated_filenames: T.Liststr = 
+ custom_targets: T.ListConverterCustomTarget = 
+ dependencies: T.ListIdNode = 
 for i in tgt.link_with:
 assert isinstance(i, ConverterTarget)
 if i.name not in processed:
@@ -1169,7 +1123,7 @@
 install_tgt = options.get_install(tgt.cmake_name, tgt.install)
 
 # Generate target kwargs
- tgt_kwargs = {
+ tgt_kwargs: TYPE_mixed_kwargs = {
 'build_by_default': install_tgt,
 'link_args': options.get_link_args(tgt.cmake_name, tgt.link_flags + tgt.link_libraries),
 'link_with': link_with,
@@ -1177,7 +1131,7 @@
 'install': install_tgt,
 'override_options': options.get_override_options(tgt.cmake_name, tgt.override_options),
 'objects': method(x, 'extract_all_objects') for x in objec_libs,
- } # type: TYPE_mixed_kwargs
+ }
 
 # Only set if installed and only override if it is set
 if install_tgt and tgt.install_dir:
@@ -1194,12 +1148,12 @@
 tgt_kwargs'pic' = tgt.pie
 
 # declare_dependency kwargs
- dep_kwargs = {
+ dep_kwargs: TYPE_mixed_kwargs = {
 'link_args': tgt.link_flags + tgt.link_libraries,
 'link_with': id_node(tgt_var),
 'compile_args': tgt.public_compile_opts,
 'include_directories': id_node(inc_var),
- } # type: TYPE_mixed_kwargs
+ }
 
 if dependencies:
 generated += dependencies
@@ -1219,10 +1173,10 @@
 src_node = assign(src_var, function('files', sources))
 tgt_node = assign(tgt_var, function(tgt_func, tgt_var, id_node(src_var), *generated, tgt_kwargs))
 node_list += src_node, tgt_node
- if tgt_func in 'static_library', 'shared_library':
+ if tgt_func in {'static_library', 'shared_library'}:
 dep_node = assign(dep_var, function('declare_dependency', kwargs=dep_kwargs))
 node_list += dep_node
- elif tgt_func in 'shared_module':
+ elif tgt_func == 'shared_module':
 del dep_kwargs'link_with'
 dep_node = assign(dep_var, function('declare_dependency', kwargs=dep_kwargs))
 node_list += dep_node
@@ -1241,7 +1195,7 @@
 # directory.
 
 detect_cycle(tgt)
- tgt_var = tgt.name # type: str
+ tgt_var = tgt.name
 
 def resolve_source(x: T.Unionstr, ConverterTarget, ConverterCustomTarget, CustomTargetReference) -> T.Unionstr, IdNode, IndexNode:
 if isinstance(x, ConverterTarget):
@@ -1260,7 +1214,7 @@
 return x
 
 # Generate the command list
- command = # type: T.ListT.Unionstr, IdNode, IndexNode
+ command: T.ListT.Unionstr, IdNode, IndexNode = 
 command += mesonlib.get_meson_command()
 command += '--internal', 'cmake_run_ctgt'
 command += '-o', '@OUTPUT@'
@@ -1272,12 +1226,12 @@
 for cmd in tgt.command:
 command += resolve_source(x) for x in cmd + ';;;'
 
- tgt_kwargs = {
+ tgt_kwargs: TYPE_mixed_kwargs = {
 'input': resolve_source(x) for x in tgt.inputs,
 'output': tgt.outputs,
 'command': command,
 'depends': resolve_source(x) for x in tgt.depends,
- } # type: TYPE_mixed_kwargs
+ }
 
 root_cb.lines += assign(tgt_var, function('custom_target', tgt.name, tgt_kwargs))
 processedtgt.name = {'inc': None, 'src': None, 'dep': None, 'tgt': tgt_var, 'func': 'custom_target'}

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/cmake/toolchain.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/cmake/toolchain.py Changed

@@ -11,12 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from pathlib import Path
 from .traceparser import CMakeTraceParser
 from ..envconfig import CMakeSkipCompilerTest
-from ..mesonlib import MachineChoice
-from ..compilers import VisualStudioLikeCompiler
 from .common import language_map, cmake_get_generator_args
 from .. import mlog
 
@@ -29,6 +28,7 @@
     from .executor import CMakeExecutor
     from ..environment import Environment
     from ..compilers import Compiler
+    from ..mesonlib import MachineChoice
 
 class CMakeExecScope(Enum):
     SUBPROJECT = 'subproject'
@@ -36,20 +36,20 @@
 
 class CMakeToolchain:
     def __init__(self, cmakebin: 'CMakeExecutor', env: 'Environment', for_machine: MachineChoice, exec_scope: CMakeExecScope, build_dir: Path, preload_file: T.OptionalPath = None) -> None:
-        self.env            = env
-        self.cmakebin       = cmakebin
-        self.for_machine    = for_machine
-        self.exec_scope     = exec_scope
-        self.preload_file   = preload_file
-        self.build_dir      = build_dir
-        self.build_dir      = self.build_dir.resolve()
+        self.env = env
+        self.cmakebin = cmakebin
+        self.for_machine = for_machine
+        self.exec_scope = exec_scope
+        self.preload_file = preload_file
+        self.build_dir = build_dir
+        self.build_dir = self.build_dir.resolve()
         self.toolchain_file = build_dir / 'CMakeMesonToolchainFile.cmake'
-        self.cmcache_file   = build_dir / 'CMakeCache.txt'
-        self.minfo          = self.env.machinesself.for_machine
-        self.properties     = self.env.propertiesself.for_machine
-        self.compilers      = self.env.coredata.compilersself.for_machine
-        self.cmakevars      = self.env.cmakevarsself.for_machine
-        self.cmakestate     = self.env.coredata.cmake_cacheself.for_machine
+        self.cmcache_file = build_dir / 'CMakeCache.txt'
+        self.minfo = self.env.machinesself.for_machine
+        self.properties = self.env.propertiesself.for_machine
+        self.compilers = self.env.coredata.compilersself.for_machine
+        self.cmakevars = self.env.cmakevarsself.for_machine
+        self.cmakestate = self.env.coredata.cmake_cacheself.for_machine
 
         self.variables = self.get_defaults()
         self.variables.update(self.cmakevars.get_variables())
@@ -164,7 +164,7 @@
         # Only set these in a cross build. Otherwise CMake will trip up in native
         # builds and thing they are cross (which causes TRY_RUN() to break)
         if self.env.is_cross_build(when_building_for=self.for_machine):
-            defaults'CMAKE_SYSTEM_NAME'      = SYSTEM_MAP.get(self.minfo.system, self.minfo.system)
+            defaults'CMAKE_SYSTEM_NAME' = SYSTEM_MAP.get(self.minfo.system, self.minfo.system)
             defaults'CMAKE_SYSTEM_PROCESSOR' = self.minfo.cpu_family
 
         defaults'CMAKE_SIZEOF_VOID_P' = '8' if self.minfo.is_64_bit else '4'
@@ -203,7 +203,7 @@
 
     @staticmethod
     def is_cmdline_option(compiler: 'Compiler', arg: str) -> bool:
-        if isinstance(compiler, VisualStudioLikeCompiler):
+        if compiler.get_argument_syntax() == 'msvc':
             return arg.startswith('/')
         else:
             return arg.startswith('-')
@@ -215,8 +215,8 @@
 
         # Generate the CMakeLists.txt
         mlog.debug('CMake Toolchain: Calling CMake once to generate the compiler state')
-        languages     = list(self.compilers.keys())
-        lang_ids      = language_map.get(x, x.upper()) for x in languages
+        languages = list(self.compilers.keys())
+        lang_ids = language_map.get(x, x.upper()) for x in languages
         cmake_content = dedent(f'''
             cmake_minimum_required(VERSION 3.7)
             project(CompInfo {' '.join(lang_ids)})
@@ -232,7 +232,7 @@
         temp_toolchain_file.write_text(CMakeToolchain._print_vars(self.variables), encoding='utf-8')
 
         # Configure
-        trace = CMakeTraceParser(self.cmakebin.version(), build_dir)
+        trace = CMakeTraceParser(self.cmakebin.version(), build_dir, self.env)
         self.cmakebin.set_exec_mode(print_cmout=False, always_capture_stderr=trace.requires_stderr())
         cmake_args = 
         cmake_args += trace.trace_args()
@@ -252,7 +252,7 @@
 
         for lang in languages:
             lang_cmake = language_map.get(lang, lang.upper())
-            file_name  = f'CMake{lang_cmake}Compiler.cmake'
+            file_name = f'CMake{lang_cmake}Compiler.cmake'
             vars = vars_by_file.setdefault(file_name, {})
             varsf'CMAKE_{lang_cmake}_COMPILER_FORCED' = '1'
             self.cmakestate.update(lang, vars)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/cmake/traceparser.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/cmake/traceparser.py Changed

@@ -14,6 +14,7 @@
 
 # This class contains the basic functionality needed to run any interpreter
 # or an interpreter-based tool.
+from __future__ import annotations
 
 from .common import CMakeException
 from .generator import parse_generator_expressions
@@ -27,6 +28,9 @@
 import json
 import textwrap
 
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+
 class CMakeTraceLine:
 def __init__(self, file_str: str, line: int, func: str, args: T.Liststr) -> None:
 self.file = CMakeTraceLine._to_path(file_str)
@@ -53,17 +57,17 @@
 name: str,
 target_type: str,
 properties: T.OptionalT.Dictstr, T.Liststr = None,
- imported: bool = False,
- tline: T.OptionalCMakeTraceLine = None
+ imported: bool = False,
+ tline: T.OptionalCMakeTraceLine = None
 ):
 if properties is None:
 properties = {}
- self.name = name
- self.type = target_type
- self.properties = properties
- self.imported = imported
- self.tline = tline
- self.depends = # type: T.Liststr
+ self.name = name
+ self.type = target_type
+ self.properties = properties
+ self.imported = imported
+ self.tline = tline
+ self.depends = # type: T.Liststr
 self.current_bin_dir = None # type: T.OptionalPath
 self.current_src_dir = None # type: T.OptionalPath
 
@@ -80,20 +84,21 @@
 return
 for key, val in self.properties.items():
 self.propertieskey = x.strip() for x in val
- assert all(';' not in x for x in self.propertieskey)
+ assert all(';' not in x for x in self.propertieskey)
 
 class CMakeGeneratorTarget(CMakeTarget):
 def __init__(self, name: str) -> None:
 super().__init__(name, 'CUSTOM', {})
 self.outputs = # type: T.ListPath
+ self._outputs_str = # type: T.Liststr
 self.command = # type: T.ListT.Liststr
 self.working_dir = None # type: T.OptionalPath
 
 class CMakeTraceParser:
- def __init__(self, cmake_version: str, build_dir: Path, permissive: bool = True) -> None:
- self.vars: T.Dictstr, T.Liststr = {}
- self.vars_by_file: T.DictPath, T.Dictstr, T.Liststr = {}
- self.targets: T.Dictstr, CMakeTarget = {}
+ def __init__(self, cmake_version: str, build_dir: Path, env: 'Environment', permissive: bool = True) -> None:
+ self.vars: T.Dictstr, T.Liststr = {}
+ self.vars_by_file: T.DictPath, T.Dictstr, T.Liststr = {}
+ self.targets: T.Dictstr, CMakeTarget = {}
 self.cache: T.Dictstr, CMakeCacheEntry = {}
 
 self.explicit_headers = set() # type: T.SetPath
@@ -101,12 +106,15 @@
 # T.List of targes that were added with add_custom_command to generate files
 self.custom_targets = # type: T.ListCMakeGeneratorTarget
 
+ self.env = env
 self.permissive = permissive # type: bool
 self.cmake_version = cmake_version # type: str
 self.trace_file = 'cmake_trace.txt'
 self.trace_file_path = build_dir / self.trace_file
 self.trace_format = 'json-v1' if version_compare(cmake_version, '>=3.17') else 'human'
 
+ self.errors: T.Liststr = 
+
 # State for delayed command execution. Delayed command execution is realised
 # with a custom CMake file that overrides some functions and adds some
 # introspection information to the trace.
@@ -129,6 +137,7 @@
 'target_link_libraries': self._cmake_target_link_libraries,
 'target_link_options': self._cmake_target_link_options,
 'add_dependencies': self._cmake_add_dependencies,
+ 'message': self._cmake_message,
 
 # Special functions defined in the preload script.
 # These functions do nothing in the CMake code, but have special
@@ -138,6 +147,17 @@
 'meson_ps_disabled_function': self._meson_ps_disabled_function,
 } # type: T.Dictstr, T.CallableCMakeTraceLine, None
 
+ if version_compare(self.cmake_version, '<3.17.0'):
+ mlog.deprecation(textwrap.dedent(f'''\
+ CMake support for versions <3.17 is deprecated since Meson 0.62.0.
+ |
+ | However, Meson was only able to find CMake {self.cmake_version}.
+ |
+ | Support for all CMake versions below 3.17.0 will be removed once
+ | newer CMake versions are more widely adopted. If you encounter
+ | any errors please try upgrading CMake to a newer version first.
+ '''), once=True)
+
 def trace_args(self) -> T.Liststr:
 arg_map = {
 'human': '--trace', '--trace-expand',
@@ -183,6 +203,44 @@
 if fn:
 fn(l)
 
+ # Evaluate generator expressions
+ strlist_gen: T.CallableT.Liststr, T.Liststr = lambda strlist: parse_generator_expressions(';'.join(strlist), self).split(';') if strlist else 
+ pathlist_gen: T.CallableT.Liststr, T.ListPath = lambda strlist: Path(x) for x in parse_generator_expressions(';'.join(strlist), self).split(';') if strlist else 
+
+ self.vars = {k: strlist_gen(v) for k, v in self.vars.items()}
+ self.vars_by_file = {
+ p: {k: strlist_gen(v) for k, v in d.items()}
+ for p, d in self.vars_by_file.items()
+ }
+ self.explicit_headers = {Path(parse_generator_expressions(str(x), self)) for x in self.explicit_headers}
+ self.cache = {
+ k: CMakeCacheEntry(
+ strlist_gen(v.value),
+ v.type
+ )
+ for k, v in self.cache.items()
+ }
+
+ for tgt in self.targets.values():
+ tgtlist_gen: T.CallableT.Liststr, CMakeTarget, T.Liststr = lambda strlist, t: parse_generator_expressions(';'.join(strlist), self, context_tgt=t).split(';') if strlist else 
+ tgt.name = parse_generator_expressions(tgt.name, self, context_tgt=tgt)
+ tgt.type = parse_generator_expressions(tgt.type, self, context_tgt=tgt)
+ tgt.properties = {
+ k: tgtlist_gen(v, tgt) for k, v in tgt.properties.items()
+ } if tgt.properties is not None else None
+ tgt.depends = tgtlist_gen(tgt.depends, tgt)
+
+ for ctgt in self.custom_targets:
+ ctgt.outputs = pathlist_gen(ctgt._outputs_str)
+ temp = ctgt.command
+ ctgt.command = strlist_gen(x) for x in ctgt.command
+ for command, src in zip(ctgt.command, temp):
+ if command0 == "":
+ raise CMakeException(
+ "We evaluated the cmake variable '{}' to an empty string, which is not a valid path to an executable.".format(src0)
+ )
+ ctgt.working_dir = Path(parse_generator_expressions(str(ctgt.working_dir), self)) if ctgt.working_dir is not None else None
+
 # Postprocess
 for tgt in self.targets.values():
 tgt.strip_properties()
@@ -246,10 +304,10 @@
 """
 # DOC: https://cmake.org/cmake/help/latest/command/set.html
 
- cache_type = None
+ cache_type = None
 cache_force = 'FORCE' in tline.args
 try:
- cache_idx = tline.args.index('CACHE')
+ cache_idx = tline.args.index('CACHE')
 cache_type = tline.argscache_idx + 1
 except (ValueError, IndexError):
 pass
@@ -366,7 +424,7 @@
 target = CMakeGeneratorTarget(name)
 
 def handle_output(key: str, target: CMakeGeneratorTarget) -> None:
- target.outputs += Path(key)
+ target._outputs_str += key
 
 def handle_command(key: str, target: CMakeGeneratorTarget) -> None:
 if key == 'ARGS':
@@ -377,6 +435,7 @@
 target.depends += key
 
 working_dir = None
+
 def handle_working_dir(key: str, target: CMakeGeneratorTarget) -> None:
 nonlocal working_dir
 if working_dir is None:
@@ -408,10 +467,10 @@
 cbinary_dir = self.var_to_str('MESON_PS_CMAKE_CURRENT_BINARY_DIR')
 csource_dir = self.var_to_str('MESON_PS_CMAKE_CURRENT_SOURCE_DIR')
 
- target.working_dir = Path(working_dir) if working_dir else None
+ target.working_dir = Path(working_dir) if working_dir else None
 target.current_bin_dir = Path(cbinary_dir) if cbinary_dir else None
 target.current_src_dir = Path(csource_dir) if csource_dir else None
- target.outputs = Path(x) for x in self._guess_files(str(y) for y in target.outputs)
+ target._outputs_str = self._guess_files(target._outputs_str)
 target.depends = self._guess_files(target.depends)
 target.command = self._guess_files(x) for x in target.command
 
@@ -440,7 +499,7 @@
 curr = args.pop(0)
 # XXX: APPEND_STRING is specifically *not* supposed to create a
 # list, is treating them as aliases really okay?
- if curr == 'APPEND' or curr == 'APPEND_STRING':
+ if curr in {'APPEND', 'APPEND_STRING'}:
 append = True
 continue
 
@@ -591,6 +650,18 @@
 # DOC: https://cmake.org/cmake/help/latest/command/target_link_libraries.html
 self._parse_common_target_options('target_link_options', 'LINK_LIBRARIES', 'INTERFACE_LINK_LIBRARIES', tline)
 
+ def _cmake_message(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/message.html
+ args = list(tline.args)
+
+ if len(args) < 1:
+ return self._gen_exception('message', 'takes at least 1 argument', tline)
+
+ if args0.upper().strip() not in 'FATAL_ERROR', 'SEND_ERROR':
+ return
+
+ self.errors += ' '.join(args1:)
+
 def _parse_common_target_options(self, func: str, private_prop: str, interface_prop: str, tline: CMakeTraceLine, ignore: T.OptionalT.Liststr = None, paths: bool = False) -> None:
 if ignore is None:
 ignore = 'BEFORE'
@@ -612,14 +683,14 @@
 if i in ignore:
 continue
 
- if i in 'INTERFACE', 'LINK_INTERFACE_LIBRARIES', 'PUBLIC', 'PRIVATE', 'LINK_PUBLIC', 'LINK_PRIVATE':
+ if i in {'INTERFACE', 'LINK_INTERFACE_LIBRARIES', 'PUBLIC', 'PRIVATE', 'LINK_PUBLIC', 'LINK_PRIVATE'}:
 mode = i
 continue
 
- if mode in 'INTERFACE', 'LINK_INTERFACE_LIBRARIES', 'PUBLIC', 'LINK_PUBLIC':
+ if mode in {'INTERFACE', 'LINK_INTERFACE_LIBRARIES', 'PUBLIC', 'LINK_PUBLIC'}:
 interface += i.split(';')
 
- if mode in 'PUBLIC', 'PRIVATE', 'LINK_PRIVATE':
+ if mode in {'PUBLIC', 'PRIVATE', 'LINK_PRIVATE'}:
 private += i.split(';')
 
 if paths:
@@ -676,9 +747,8 @@
 line = mo_file_line.group(3)
 func = mo_file_line.group(4)
 args = mo_file_line.group(5)
- args = parse_generator_expressions(args)
 argl = args.split(' ')
- argl = list(map(lambda x: x.strip(), argl))
+ argl = a.strip() for a in argl
 
 yield CMakeTraceLine(file, int(line), func, argl)
 
@@ -694,7 +764,6 @@
 args = data'args'
 for j in args:
 assert isinstance(j, str)
- args = parse_generator_expressions(x) for x in args
 yield CMakeTraceLine(data'file', data'line', data'cmd', args)
 
 def _flatten_args(self, args: T.Liststr) -> T.Liststr:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/cmake/tracetargets.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/cmake/tracetargets.py Changed

@@ -1,5 +1,6 @@
 # SPDX-License-Identifer: Apache-2.0
 # Copyright 2021 The Meson development team
+from __future__ import annotations
 
 from .common import cmake_is_debug
 from .. import mlog
@@ -12,6 +13,7 @@
     from .traceparser import CMakeTraceParser
     from ..environment import Environment
     from ..compilers import Compiler
+    from ..dependencies import MissingCompiler
 
 class ResolvedTarget:
     def __init__(self) -> None:
@@ -24,7 +26,7 @@
                                 trace: 'CMakeTraceParser',
                                 env: 'Environment',
                                 *,
-                                clib_compiler: T.Optional'Compiler' = None,
+                                clib_compiler: T.Union'MissingCompiler', 'Compiler' = None,
                                 not_found_warning: T.Callablestr, None = lambda x: None) -> ResolvedTarget:
     res = ResolvedTarget()
     targets = target_name
@@ -48,7 +50,7 @@
                 res.libraries += curr
             elif Path(curr).is_absolute() and Path(curr).exists():
                 res.libraries += curr
-            elif env.machines.build.is_windows() and reg_is_maybe_bare_lib.match(curr) and clib_compiler is not None:
+            elif env.machines.build.is_windows() and reg_is_maybe_bare_lib.match(curr) and clib_compiler:
                 # On Windows, CMake library dependencies can be passed as bare library names,
                 # CMake brute-forces a combination of prefix/suffix combinations to find the
                 # right library. Assume any bare argument passed which is not also a CMake
@@ -110,8 +112,8 @@
         processed_targets += curr
 
     res.include_directories = sorted(set(res.include_directories))
-    res.link_flags          = sorted(set(res.link_flags))
+    res.link_flags = sorted(set(res.link_flags))
     res.public_compile_opts = sorted(set(res.public_compile_opts))
-    res.libraries           = sorted(set(res.libraries))
+    res.libraries = sorted(set(res.libraries))
 
     return res

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/__init__.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/__init__.py Changed

@@ -52,81 +52,6 @@
     'detect_rust_compiler',
     'detect_d_compiler',
     'detect_swift_compiler',
-
-    'AppleClangCCompiler',
-    'AppleClangCPPCompiler',
-    'AppleClangObjCCompiler',
-    'AppleClangObjCPPCompiler',
-    'ArmCCompiler',
-    'ArmCPPCompiler',
-    'ArmclangCCompiler',
-    'ArmclangCPPCompiler',
-    'CCompiler',
-    'ClangCCompiler',
-    'ClangCompiler',
-    'ClangCPPCompiler',
-    'ClangObjCCompiler',
-    'ClangObjCPPCompiler',
-    'ClangClCCompiler',
-    'ClangClCPPCompiler',
-    'CPPCompiler',
-    'DCompiler',
-    'DmdDCompiler',
-    'FortranCompiler',
-    'G95FortranCompiler',
-    'GnuCCompiler',
-    'ElbrusCCompiler',
-    'EmscriptenCCompiler',
-    'GnuCompiler',
-    'GnuLikeCompiler',
-    'GnuCPPCompiler',
-    'ElbrusCPPCompiler',
-    'EmscriptenCPPCompiler',
-    'GnuDCompiler',
-    'GnuFortranCompiler',
-    'ElbrusFortranCompiler',
-    'FlangFortranCompiler',
-    'GnuObjCCompiler',
-    'GnuObjCPPCompiler',
-    'IntelGnuLikeCompiler',
-    'IntelVisualStudioLikeCompiler',
-    'IntelCCompiler',
-    'IntelCPPCompiler',
-    'IntelClCCompiler',
-    'IntelClCPPCompiler',
-    'IntelFortranCompiler',
-    'IntelClFortranCompiler',
-    'JavaCompiler',
-    'LLVMDCompiler',
-    'MonoCompiler',
-    'CudaCompiler',
-    'VisualStudioCsCompiler',
-    'NAGFortranCompiler',
-    'ObjCCompiler',
-    'ObjCPPCompiler',
-    'Open64FortranCompiler',
-    'PathScaleFortranCompiler',
-    'NvidiaHPC_CCompiler',
-    'NvidiaHPC_CPPCompiler',
-    'NvidiaHPC_FortranCompiler',
-    'PGICCompiler',
-    'PGICPPCompiler',
-    'PGIFortranCompiler',
-    'RustCompiler',
-    'ClippyRustCompiler',
-    'CcrxCCompiler',
-    'CcrxCPPCompiler',
-    'Xc16CCompiler',
-    'CompCertCCompiler',
-    'C2000CCompiler',
-    'C2000CPPCompiler',
-    'SunFortranCompiler',
-    'SwiftCompiler',
-    'ValaCompiler',
-    'VisualStudioLikeCompiler',
-    'VisualStudioCCompiler',
-    'VisualStudioCPPCompiler',
-    'CythonCompiler',
 
 
 # Bring symbols from each module into compilers sub-package namespace
@@ -170,85 +95,3 @@
     detect_d_compiler,
     detect_swift_compiler,
 )
-from .c import (
-    CCompiler,
-    AppleClangCCompiler,
-    ArmCCompiler,
-    ArmclangCCompiler,
-    ClangCCompiler,
-    ClangClCCompiler,
-    GnuCCompiler,
-    ElbrusCCompiler,
-    EmscriptenCCompiler,
-    IntelCCompiler,
-    IntelClCCompiler,
-    NvidiaHPC_CCompiler,
-    PGICCompiler,
-    CcrxCCompiler,
-    Xc16CCompiler,
-    CompCertCCompiler,
-    C2000CCompiler,
-    VisualStudioCCompiler,
-)
-from .cpp import (
-    CPPCompiler,
-    AppleClangCPPCompiler,
-    ArmCPPCompiler,
-    ArmclangCPPCompiler,
-    ClangCPPCompiler,
-    ClangClCPPCompiler,
-    GnuCPPCompiler,
-    ElbrusCPPCompiler,
-    EmscriptenCPPCompiler,
-    IntelCPPCompiler,
-    IntelClCPPCompiler,
-    NvidiaHPC_CPPCompiler,
-    PGICPPCompiler,
-    CcrxCPPCompiler,
-    C2000CPPCompiler,
-    VisualStudioCPPCompiler,
-)
-from .cs import MonoCompiler, VisualStudioCsCompiler
-from .d import (
-    DCompiler,
-    DmdDCompiler,
-    GnuDCompiler,
-    LLVMDCompiler,
-)
-from .cuda import CudaCompiler
-from .fortran import (
-    FortranCompiler,
-    G95FortranCompiler,
-    GnuFortranCompiler,
-    ElbrusFortranCompiler,
-    FlangFortranCompiler,
-    IntelFortranCompiler,
-    IntelClFortranCompiler,
-    NAGFortranCompiler,
-    Open64FortranCompiler,
-    PathScaleFortranCompiler,
-    NvidiaHPC_FortranCompiler,
-    PGIFortranCompiler,
-    SunFortranCompiler,
-)
-from .java import JavaCompiler
-from .objc import (
-    ObjCCompiler,
-    AppleClangObjCCompiler,
-    ClangObjCCompiler,
-    GnuObjCCompiler,
-)
-from .objcpp import (
-    ObjCPPCompiler,
-    AppleClangObjCPPCompiler,
-    ClangObjCPPCompiler,
-    GnuObjCPPCompiler,
-)
-from .rust import RustCompiler, ClippyRustCompiler
-from .swift import SwiftCompiler
-from .vala import ValaCompiler
-from .mixins.visualstudio import VisualStudioLikeCompiler
-from .mixins.gnu import GnuCompiler, GnuLikeCompiler
-from .mixins.intel import IntelGnuLikeCompiler, IntelVisualStudioLikeCompiler
-from .mixins.clang import ClangCompiler
-from .cython import CythonCompiler

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/asm.py Added

@@ -0,0 +1,231 @@
+import os
+import typing as T
+
+from ..mesonlib import EnvironmentException, get_meson_command
+from .compilers import Compiler
+
+if T.TYPE_CHECKING:
+    from ..environment import Environment
+
+nasm_optimization_args = {
+    'plain': ,
+    '0': '-O0',
+    'g': '-O0',
+    '1': '-O1',
+    '2': '-Ox',
+    '3': '-Ox',
+    's': '-Ox',
+}  # type: T.Dictstr, T.Liststr
+
+
+class NasmCompiler(Compiler):
+    language = 'nasm'
+    id = 'nasm'
+
+    def needs_static_linker(self) -> bool:
+        return True
+
+    def get_always_args(self) -> T.Liststr:
+        cpu = '64' if self.info.is_64_bit else '32'
+        if self.info.is_windows() or self.info.is_cygwin():
+            plat = 'win'
+            define = f'WIN{cpu}'
+        elif self.info.is_darwin():
+            plat = 'macho'
+            define = 'MACHO'
+        else:
+            plat = 'elf'
+            define = 'ELF'
+        args = '-f', f'{plat}{cpu}', f'-D{define}'
+        if self.info.is_64_bit:
+            args.append('-D__x86_64__')
+        return args
+
+    def get_werror_args(self) -> T.Liststr:
+        return '-Werror'
+
+    def get_output_args(self, outputname: str) -> T.Liststr:
+        return '-o', outputname
+
+    def unix_args_to_native(self, args: T.Liststr) -> T.Liststr:
+        outargs = 
+        for arg in args:
+            if arg == '-pthread':
+                continue
+            outargs.append(arg)
+        return outargs
+
+    def get_optimization_args(self, optimization_level: str) -> T.Liststr:
+        return nasm_optimization_argsoptimization_level
+
+    def get_debug_args(self, is_debug: bool) -> T.Liststr:
+        if is_debug:
+            if self.info.is_windows():
+                return 
+            return '-g', '-F', 'dwarf'
+        return 
+
+    def get_depfile_suffix(self) -> str:
+        return 'd'
+
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.Liststr:
+        return '-MD', outfile, '-MQ', outtarget
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        if self.info.cpu_family not in {'x86', 'x86_64'}:
+            raise EnvironmentException(f'ASM compiler {self.id!r} does not support {self.info.cpu_family} CPU family')
+
+    def get_buildtype_args(self, buildtype: str) -> T.Liststr:
+        # FIXME: Not implemented
+        return 
+
+    def get_pic_args(self) -> T.Liststr:
+        return 
+
+    def get_include_args(self, path: str, is_system: bool) -> T.Liststr:
+        if not path:
+            path = '.'
+        return '-I' + path
+
+    def compute_parameters_with_absolute_paths(self, parameter_list: T.Liststr,
+                                               build_dir: str) -> T.Liststr:
+        for idx, i in enumerate(parameter_list):
+            if i:2 == '-I':
+                parameter_listidx = i:2 + os.path.normpath(os.path.join(build_dir, i2:))
+        return parameter_list
+
+    def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.Liststr:
+        return 
+
+class YasmCompiler(NasmCompiler):
+    id = 'yasm'
+
+    def get_exelist(self, ccache: bool = True) -> T.Liststr:
+        # Wrap yasm executable with an internal script that will write depfile.
+        exelist = super().get_exelist(ccache)
+        return get_meson_command() + '--internal', 'yasm' + exelist
+
+    def get_debug_args(self, is_debug: bool) -> T.Liststr:
+        if is_debug:
+            if self.info.is_windows():
+                return '-g', 'null'
+            return '-g', 'dwarf2'
+        return 
+
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.Liststr:
+        return '--depfile', outfile
+
+# https://learn.microsoft.com/en-us/cpp/assembler/masm/ml-and-ml64-command-line-reference
+class MasmCompiler(Compiler):
+    language = 'masm'
+    id = 'ml'
+
+    def get_compile_only_args(self) -> T.Liststr:
+        return '/c'
+
+    def get_argument_syntax(self) -> str:
+        return 'msvc'
+
+    def needs_static_linker(self) -> bool:
+        return True
+
+    def get_always_args(self) -> T.Liststr:
+        return '/nologo'
+
+    def get_werror_args(self) -> T.Liststr:
+        return '/WX'
+
+    def get_output_args(self, outputname: str) -> T.Liststr:
+        return '/Fo', outputname
+
+    def get_optimization_args(self, optimization_level: str) -> T.Liststr:
+        return 
+
+    def get_debug_args(self, is_debug: bool) -> T.Liststr:
+        if is_debug:
+            return '/Zi'
+        return 
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        if self.info.cpu_family not in {'x86', 'x86_64'}:
+            raise EnvironmentException(f'ASM compiler {self.id!r} does not support {self.info.cpu_family} CPU family')
+
+    def get_buildtype_args(self, buildtype: str) -> T.Liststr:
+        # FIXME: Not implemented
+        return 
+
+    def get_pic_args(self) -> T.Liststr:
+        return 
+
+    def get_include_args(self, path: str, is_system: bool) -> T.Liststr:
+        if not path:
+            path = '.'
+        return '-I' + path
+
+    def compute_parameters_with_absolute_paths(self, parameter_list: T.Liststr,
+                                               build_dir: str) -> T.Liststr:
+        for idx, i in enumerate(parameter_list):
+            if i:2 == '-I' or i:2 == '/I':
+                parameter_listidx = i:2 + os.path.normpath(os.path.join(build_dir, i2:))
+        return parameter_list
+
+    def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.Liststr:
+        return 
+
+    def depfile_for_object(self, objfile: str) -> T.Optionalstr:
+        return None
+
+
+# https://learn.microsoft.com/en-us/cpp/assembler/arm/arm-assembler-command-line-reference
+class MasmARMCompiler(Compiler):
+    language = 'masm'
+    id = 'armasm'
+
+    def needs_static_linker(self) -> bool:
+        return True
+
+    def get_always_args(self) -> T.Liststr:
+        return '-nologo'
+
+    def get_werror_args(self) -> T.Liststr:
+        return 
+
+    def get_output_args(self, outputname: str) -> T.Liststr:
+        return '-o', outputname
+
+    def get_optimization_args(self, optimization_level: str) -> T.Liststr:
+        return 
+
+    def get_debug_args(self, is_debug: bool) -> T.Liststr:
+        if is_debug:
+            return '-g'
+        return 
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        if self.info.cpu_family not in {'arm', 'aarch64'}:
+            raise EnvironmentException(f'ASM compiler {self.id!r} does not support {self.info.cpu_family} CPU family')
+
+    def get_buildtype_args(self, buildtype: str) -> T.Liststr:
+        # FIXME: Not implemented
+        return 
+
+    def get_pic_args(self) -> T.Liststr:
+        return 
+
+    def get_include_args(self, path: str, is_system: bool) -> T.Liststr:
+        if not path:
+            path = '.'
+        return '-i' + path
+
+    def compute_parameters_with_absolute_paths(self, parameter_list: T.Liststr,
+                                               build_dir: str) -> T.Liststr:
+        for idx, i in enumerate(parameter_list):
+            if i:2 == '-I':
+                parameter_listidx = i:2 + os.path.normpath(os.path.join(build_dir, i2:))
+        return parameter_list
+
+    def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.Liststr:
+        return 
+
+    def depfile_for_object(self, objfile: str) -> T.Optionalstr:
+        return None

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/c.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/c.py Changed

@@ -11,22 +11,24 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import os.path
 import typing as T
 
 from .. import coredata
 from .. import mlog
-from ..mesonlib import MachineChoice, MesonException, version_compare, OptionKey
+from ..mesonlib import MesonException, version_compare, OptionKey
 from .c_function_attributes import C_FUNC_ATTRIBUTES
 from .mixins.clike import CLikeCompiler
 from .mixins.ccrx import CcrxCompiler
 from .mixins.xc16 import Xc16Compiler
 from .mixins.compcert import CompCertCompiler
-from .mixins.c2000 import C2000Compiler
+from .mixins.ti import TICompiler
 from .mixins.arm import ArmCompiler, ArmclangCompiler
 from .mixins.visualstudio import MSVCCompiler, ClangClCompiler
 from .mixins.gnu import GnuCompiler
+from .mixins.gnu import gnu_common_warning_args, gnu_c_warning_args
 from .mixins.intel import IntelGnuLikeCompiler, IntelVisualStudioLikeCompiler
 from .mixins.clang import ClangCompiler
 from .mixins.elbrus import ElbrusCompiler
@@ -39,11 +41,12 @@
 )
 
 if T.TYPE_CHECKING:
-    from ..coredata import KeyedOptionDictType
+    from ..coredata import MutableKeyedOptionDictType, KeyedOptionDictType
     from ..dependencies import Dependency
     from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
     from ..programs import ExternalProgram
     from .compilers import CompileCheckMode
 
@@ -53,9 +56,7 @@
 
 
 class CCompiler(CLikeCompiler, Compiler):
-
-    @staticmethod
-    def attribute_check_func(name: str) -> str:
+    def attribute_check_func(self, name: str) -> str:
         try:
             return C_FUNC_ATTRIBUTESname
         except KeyError:
@@ -63,12 +64,12 @@
 
     language = 'c'
 
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
         # If a child ObjC or CPP class has already set it, don't set it ourselves
-        Compiler.__init__(self, exelist, version, for_machine, info,
+        Compiler.__init__(self, ccache, exelist, version, for_machine, info,
                           is_cross=is_cross, full_version=full_version, linker=linker)
         CLikeCompiler.__init__(self, exe_wrapper)
 
@@ -96,7 +97,7 @@
         return self.compiles(t.format(**fargs), env, extra_args=extra_args,
                              dependencies=dependencies)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         opts.update({
             OptionKey('std', machine=self.for_machine, lang=self.language): coredata.UserComboOption(
@@ -120,7 +121,7 @@
     _C18_VERSION = '>=8.0.0'
     _C2X_VERSION = '>=9.0.0'
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         c_stds = 'c89', 'c99', 'c11'
         g_stds = 'gnu89', 'gnu99', 'gnu11'
@@ -141,20 +142,21 @@
 
 class ClangCCompiler(_ClangCStds, ClangCompiler, CCompiler):
 
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross, info, exe_wrapper, linker=linker, full_version=full_version)
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, info, exe_wrapper, linker=linker, full_version=full_version)
         ClangCompiler.__init__(self, defines)
         default_warn_args = '-Wall', '-Winvalid-pch'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': '-Weverything'}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         if self.info.is_windows() or self.info.is_cygwin():
             opts.update({
@@ -183,6 +185,11 @@
         return 
 
 
+class ArmLtdClangCCompiler(ClangCCompiler):
+
+    id = 'armltdclang'
+
+
 class AppleClangCCompiler(ClangCCompiler):
 
     """Handle the differences between Apple Clang and Vanilla Clang.
@@ -197,34 +204,43 @@
 
 
 class EmscriptenCCompiler(EmscriptenMixin, ClangCCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+
+    id = 'emscripten'
+
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  full_version: T.Optionalstr = None):
         if not is_cross:
             raise MesonException('Emscripten compiler can only be used for cross compilation.')
-        ClangCCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        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, exe_wrapper=exe_wrapper, linker=linker,
                                 defines=defines, full_version=full_version)
-        self.id = 'emscripten'
 
 
 class ArmclangCCompiler(ArmclangCompiler, CCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    '''
+    Keil armclang
+    '''
+
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker, full_version=full_version)
         ArmclangCompiler.__init__(self)
         default_warn_args = '-Wall', '-Winvalid-pch'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': '-Weverything'}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'c90', 'c99', 'c11', 'gnu90', 'gnu99', 'gnu11'
@@ -247,12 +263,12 @@
     _C2X_VERSION = '>=9.0.0'
     _INVALID_PCH_VERSION = ">=3.4.0"
 
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross, info, exe_wrapper, linker=linker, full_version=full_version)
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, info, exe_wrapper, linker=linker, full_version=full_version)
         GnuCompiler.__init__(self, defines)
         default_warn_args = '-Wall'
         if version_compare(self.version, self._INVALID_PCH_VERSION):
@@ -260,9 +276,12 @@
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': (default_warn_args + '-Wextra', '-Wpedantic' +
+                                         self.supported_warn_args(gnu_common_warning_args) +
+                                         self.supported_warn_args(gnu_c_warning_args))}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CCompiler.get_options(self)
         c_stds = 'c89', 'c99', 'c11'
         g_stds = 'gnu89', 'gnu99', 'gnu11'
@@ -305,37 +324,39 @@
 
 
 class PGICCompiler(PGICompiler, CCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker, full_version=full_version)
         PGICompiler.__init__(self)
 
 
 class NvidiaHPC_CCompiler(PGICompiler, CCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+
+    id = 'nvidia_hpc'
+
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker, full_version=full_version)
         PGICompiler.__init__(self)
-        self.id = 'nvidia_hpc'
 
 
 class ElbrusCCompiler(ElbrusCompiler, CCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker, full_version=full_version)
         ElbrusCompiler.__init__(self)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CCompiler.get_options(self)
         stds = 'c89', 'c9x', 'c99', 'gnu89', 'gnu9x', 'gnu99'
         stds += 'iso9899:1990', 'iso9899:199409', 'iso9899:1999'
@@ -364,21 +385,22 @@
 
 
 class IntelCCompiler(IntelGnuLikeCompiler, CCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker, full_version=full_version)
         IntelGnuLikeCompiler.__init__(self)
         self.lang_header = 'c-header'
-        default_warn_args = '-Wall', '-w3', '-diag-disable:remark'
+        default_warn_args = '-Wall', '-w3'
         self.warn_args = {'0': ,
-                          '1': default_warn_args,
-                          '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra'}
+                          '1': default_warn_args + '-diag-disable:remark',
+                          '2': default_warn_args + '-Wextra', '-diag-disable:remark',
+                          '3': default_warn_args + '-Wextra', '-diag-disable:remark',
+                          'everything': default_warn_args + '-Wextra'}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CCompiler.get_options(self)
         c_stds = 'c89', 'c99'
         g_stds = 'gnu89', 'gnu99'
@@ -395,11 +417,16 @@
         return args
 
 
+class IntelLLVMCCompiler(ClangCCompiler):
+
+    id = 'intel-llvm'
+
+
 class VisualStudioLikeCCompilerMixin(CompilerMixinBase):
 
     """Shared methods that apply to MSVC-like C compilers."""
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         opts.update({
             OptionKey('winlibs', machine=self.for_machine, lang=self.language): coredata.UserArrayOption(
@@ -424,17 +451,17 @@
     _C11_VERSION = '>=19.28'
     _C17_VERSION = '>=19.28'
 
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo', target: str,
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker,
                            full_version=full_version)
         MSVCCompiler.__init__(self, target)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         c_stds = 'c89', 'c99'
         # Need to have these to be compatible with projects
@@ -473,7 +500,7 @@
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, , exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker,
                            full_version=full_version)
         ClangClCompiler.__init__(self, target)
@@ -495,12 +522,12 @@
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, , exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker,
                            full_version=full_version)
         IntelVisualStudioLikeCompiler.__init__(self, target)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'c89', 'c99', 'c11'
@@ -517,18 +544,23 @@
         return args
 
 
+class IntelLLVMClCCompiler(IntelClCCompiler):
+
+    id = 'intel-llvm-cl'
+
+
 class ArmCCompiler(ArmCompiler, CCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker,
                            full_version=full_version)
         ArmCompiler.__init__(self)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'c89', 'c99', 'c11'
@@ -544,12 +576,12 @@
 
 
 class CcrxCCompiler(CcrxCompiler, CCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker, full_version=full_version)
         CcrxCompiler.__init__(self)
 
@@ -557,7 +589,7 @@
     def get_always_args(self) -> T.Liststr:
         return '-nologo'
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'c89', 'c99'
@@ -595,16 +627,16 @@
 
 
 class Xc16CCompiler(Xc16Compiler, CCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker, full_version=full_version)
         Xc16Compiler.__init__(self)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'c89', 'c99', 'gnu89', 'gnu99'
@@ -640,16 +672,16 @@
         return '-I' + path
 
 class CompCertCCompiler(CompCertCompiler, CCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker, full_version=full_version)
         CompCertCompiler.__init__(self)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'c89', 'c99'
@@ -672,21 +704,21 @@
             path = '.'
         return '-I' + path
 
-class C2000CCompiler(C2000Compiler, CCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+class TICCompiler(TICompiler, CCompiler):
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                            info, exe_wrapper, linker=linker, full_version=full_version)
-        C2000Compiler.__init__(self)
+        TICompiler.__init__(self)
 
     # Override CCompiler.get_always_args
     def get_always_args(self) -> T.Liststr:
         return 
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'c89', 'c99', 'c11'
@@ -703,19 +735,6 @@
             args.append('--' + std.value)
         return args
 
-    def get_compile_only_args(self) -> T.Liststr:
-        return 
-
-    def get_no_optimization_args(self) -> T.Liststr:
-        return '-Ooff'
-
-    def get_output_args(self, target: str) -> T.Liststr:
-        return f'--output_file={target}'
-
-    def get_werror_args(self) -> T.Liststr:
-        return '-change_message=error'
-
-    def get_include_args(self, path: str, is_system: bool) -> T.Liststr:
-        if path == '':
-            path = '.'
-        return '--include_path=' + path
+class C2000CCompiler(TICCompiler):
+    # Required for backwards compat with projects created before ti-cgt support existed
+    id = 'c2000'

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/c_function_attributes.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/c_function_attributes.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/compilers.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/compilers.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2012-2019 The Meson development team
+# Copyright 2012-2022 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import abc
 import contextlib, os.path, re
@@ -24,7 +25,7 @@
 from .. import mesonlib
 from ..mesonlib import (
 HoldableObject,
- EnvironmentException, MachineChoice, MesonException,
+ EnvironmentException, MesonException,
 Popen_safe, LibType, TemporaryDirectoryWinProof, OptionKey,
 )
 
@@ -32,10 +33,11 @@
 
 if T.TYPE_CHECKING:
 from ..build import BuildTarget
- from ..coredata import KeyedOptionDictType
+ from ..coredata import MutableKeyedOptionDictType, KeyedOptionDictType
 from ..envconfig import MachineInfo
 from ..environment import Environment
 from ..linkers import DynamicLinker, RSPFileSyntax
+ from ..mesonlib import MachineChoice
 from ..dependencies import Dependency
 
 CompilerType = T.TypeVar('CompilerType', bound='Compiler')
@@ -45,12 +47,13 @@
 about. To support a new compiler, add its information below.
 Also add corresponding autodetection code in environment.py."""
 
-header_suffixes = ('h', 'hh', 'hpp', 'hxx', 'H', 'ipp', 'moc', 'vapi', 'di') # type: T.Tuplestr, ...
-obj_suffixes = ('o', 'obj', 'res') # type: T.Tuplestr, ...
+header_suffixes = {'h', 'hh', 'hpp', 'hxx', 'H', 'ipp', 'moc', 'vapi', 'di'}
+obj_suffixes = {'o', 'obj', 'res'}
 # To the emscripten compiler, .js files are libraries
-lib_suffixes = ('a', 'lib', 'dll', 'dll.a', 'dylib', 'so', 'js') # type: T.Tuplestr, ...
+lib_suffixes = {'a', 'lib', 'dll', 'dll.a', 'dylib', 'so', 'js'}
 # Mapping of language to suffixes of files that should always be in that language
 # This means we can't include .h headers here since they could be C, C++, ObjC, etc.
+# First suffix is the language's default.
 lang_suffixes = {
 'c': ('c',),
 'cpp': ('cpp', 'cc', 'cxx', 'c++', 'hh', 'hpp', 'ipp', 'hxx', 'ino', 'ixx', 'C'),
@@ -67,23 +70,26 @@
 'swift': ('swift',),
 'java': ('java',),
 'cython': ('pyx', ),
-} # type: T.Dictstr, T.Tuplestr, ...
+ 'nasm': ('asm',),
+ 'masm': ('masm',),
+}
 all_languages = lang_suffixes.keys()
-cpp_suffixes = lang_suffixes'cpp' + ('h',) # type: T.Tuplestr, ...
-c_suffixes = lang_suffixes'c' + ('h',) # type: T.Tuplestr, ...
+c_cpp_suffixes = {'h'}
+cpp_suffixes = set(lang_suffixes'cpp') | c_cpp_suffixes
+c_suffixes = set(lang_suffixes'c') | c_cpp_suffixes
+assembler_suffixes = {'s', 'S', 'asm', 'masm'}
+llvm_ir_suffixes = {'ll'}
+all_suffixes = set(itertools.chain(*lang_suffixes.values(), assembler_suffixes, llvm_ir_suffixes, c_cpp_suffixes))
+source_suffixes = all_suffixes - header_suffixes
 # List of languages that by default consume and output libraries following the
 # C ABI; these can generally be used interchangeably
-clib_langs = ('objcpp', 'cpp', 'objc', 'c', 'fortran',) # type: T.Tuplestr, ...
-# List of assembler suffixes that can be linked with C code directly by the linker
-assembler_suffixes: T.Tuplestr, ... = ('s', 'S')
+# This must be sorted, see sort_clink().
+clib_langs = ('objcpp', 'cpp', 'objc', 'c', 'fortran')
 # List of languages that can be linked with C code directly by the linker
 # used in build.py:process_compilers() and build.py:get_dynamic_linker()
-clink_langs = ('d', 'cuda') + clib_langs # type: T.Tuplestr, ...
-clink_suffixes = tuple() # type: T.Tuplestr, ...
-for _l in clink_langs + ('vala',):
- clink_suffixes += lang_suffixes_l
-clink_suffixes += ('h', 'll', 's')
-all_suffixes = set(itertools.chain(*lang_suffixes.values(), clink_suffixes)) # type: T.Setstr
+# This must be sorted, see sort_clink().
+clink_langs = ('d', 'cuda') + clib_langs
+
 SUFFIX_TO_LANG = dict(itertools.chain(*(
 (suffix, lang) for suffix in v for lang, v in lang_suffixes.items()))) # type: T.Dictstr, str
 
@@ -105,6 +111,7 @@
 'vala': 'VALAFLAGS',
 'rust': 'RUSTFLAGS',
 'cython': 'CYTHONFLAGS',
+ 'cs': 'CSFLAGS', # This one might not be standard.
 }
 
 # All these are only for C-linkable languages; see `clink_langs` above.
@@ -130,17 +137,19 @@
 if isinstance(fname, mesonlib.File):
 fname = fname.fname
 suffix = fname.split('.')-1.lower()
- return suffix in clink_suffixes
+ return suffix in source_suffixes
 
 def is_assembly(fname: 'mesonlib.FileOrString') -> bool:
 if isinstance(fname, mesonlib.File):
 fname = fname.fname
- return fname.split('.')-1.lower() == 's'
+ suffix = fname.split('.')-1
+ return suffix in assembler_suffixes
 
 def is_llvm_ir(fname: 'mesonlib.FileOrString') -> bool:
 if isinstance(fname, mesonlib.File):
 fname = fname.fname
- return fname.split('.')-1 == 'll'
+ suffix = fname.split('.')-1
+ return suffix in llvm_ir_suffixes
 
 @lru_cache(maxsize=None)
 def cached_by_name(fname: 'mesonlib.FileOrString') -> bool:
@@ -247,7 +256,8 @@
 'winspool.lib', 'shell32.lib', 'ole32.lib', 'oleaut32.lib',
 'uuid.lib', 'comdlg32.lib', 'advapi32.lib' # type: T.Liststr
 
-clike_optimization_args = {'0': ,
+clike_optimization_args = {'plain': ,
+ '0': ,
 'g': ,
 '1': '-O1',
 '2': '-O2',
@@ -255,7 +265,8 @@
 's': '-Os',
 } # type: T.Dictstr, T.Liststr
 
-cuda_optimization_args = {'0': ,
+cuda_optimization_args = {'plain': ,
+ '0': ,
 'g': '-O0',
 '1': '-O1',
 '2': '-O2',
@@ -272,13 +283,14 @@
 base_options: 'KeyedOptionDictType' = {
 OptionKey('b_pch'): coredata.UserBooleanOption('Use precompiled headers', True),
 OptionKey('b_lto'): coredata.UserBooleanOption('Use link time optimization', False),
- OptionKey('b_lto'): coredata.UserBooleanOption('Use link time optimization', False),
 OptionKey('b_lto_threads'): coredata.UserIntegerOption('Use multiple threads for Link Time Optimization', (None, None, 0)),
 OptionKey('b_lto_mode'): coredata.UserComboOption('Select between different LTO modes.',
 'default', 'thin',
 'default'),
+ OptionKey('b_thinlto_cache'): coredata.UserBooleanOption('Use LLVM ThinLTO caching for faster incremental builds', False),
+ OptionKey('b_thinlto_cache_dir'): coredata.UserStringOption('Directory to store ThinLTO cache objects', ''),
 OptionKey('b_sanitize'): coredata.UserComboOption('Code sanitizer to use',
- 'none', 'address', 'thread', 'undefined', 'memory', 'address,undefined',
+ 'none', 'address', 'thread', 'undefined', 'memory', 'leak', 'address,undefined',
 'none'),
 OptionKey('b_lundef'): coredata.UserBooleanOption('Use -Wl,--no-undefined when linking', True),
 OptionKey('b_asneeded'): coredata.UserBooleanOption('Use -Wl,--as-needed when linking', True),
@@ -374,13 +386,19 @@
 return args
 
 def get_base_link_args(options: 'KeyedOptionDictType', linker: 'Compiler',
- is_shared_module: bool) -> T.Liststr:
+ is_shared_module: bool, build_dir: str) -> T.Liststr:
 args = # type: T.Liststr
 try:
 if optionsOptionKey('b_lto').value:
+ thinlto_cache_dir = None
+ if get_option_value(options, OptionKey('b_thinlto_cache'), False):
+ thinlto_cache_dir = get_option_value(options, OptionKey('b_thinlto_cache_dir'), '')
+ if thinlto_cache_dir == '':
+ thinlto_cache_dir = os.path.join(build_dir, 'meson-private', 'thinlto-cache')
 args.extend(linker.get_lto_link_args(
 threads=get_option_value(options, OptionKey('b_lto_threads'), 0),
- mode=get_option_value(options, OptionKey('b_lto_mode'), 'default')))
+ mode=get_option_value(options, OptionKey('b_lto_mode'), 'default'),
+ thinlto_cache_dir=thinlto_cache_dir))
 except KeyError:
 pass
 try:
@@ -450,22 +468,18 @@
 """The result of Compiler.compiles (and friends)."""
 
 def __init__(self, stdo: T.Optionalstr = None, stde: T.Optionalstr = None,
- args: T.OptionalT.Liststr = None,
- returncode: int = 999, pid: int = -1,
- text_mode: bool = True,
+ command: T.OptionalT.Liststr = None,
+ returncode: int = 999,
 input_name: T.Optionalstr = None,
 output_name: T.Optionalstr = None,
- command: T.OptionalT.Liststr = None, cached: bool = False):
+ cached: bool = False):
 self.stdout = stdo
 self.stderr = stde
 self.input_name = input_name
 self.output_name = output_name
 self.command = command or 
- self.args = args or 
 self.cached = cached
 self.returncode = returncode
- self.pid = pid
- self.text_mode = text_mode
 
 
 class Compiler(HoldableObject, metaclass=abc.ABCMeta):
@@ -482,12 +496,14 @@
 language: str
 id: str
 warn_args: T.Dictstr, T.Liststr
+ mode: str = 'COMPILER'
 
- def __init__(self, exelist: T.Liststr, version: str,
+ def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str,
 for_machine: MachineChoice, info: 'MachineInfo',
 linker: T.Optional'DynamicLinker' = None,
 full_version: T.Optionalstr = None, is_cross: bool = False):
- self.exelist = exelist
+ self.exelist = ccache + exelist
+ self.exelist_no_ccache = exelist
 # In case it's been overridden by a child class already
 if not hasattr(self, 'file_suffixes'):
 self.file_suffixes = lang_suffixesself.language
@@ -501,6 +517,7 @@
 self.linker = linker
 self.info = info
 self.is_cross = is_cross
+ self.modes: T.ListCompiler = 
 
 def __repr__(self) -> str:
 repr_str = "<{0}: v{1} `{2}`>"
@@ -519,6 +536,9 @@
 def get_id(self) -> str:
 return self.id
 
+ def get_modes(self) -> T.ListCompiler:
+ return self.modes
+
 def get_linker_id(self) -> str:
 # There is not guarantee that we have a dynamic linker instance, as
 # some languages don't have separate linkers and compilers. In those
@@ -574,8 +594,8 @@
 def symbols_have_underscore_prefix(self, env: 'Environment') -> bool:
 raise EnvironmentException('%s does not support symbols_have_underscore_prefix ' % self.get_id())
 
- def get_exelist(self) -> T.Liststr:
- return self.exelist.copy()
+ def get_exelist(self, ccache: bool = True) -> T.Liststr:
+ return self.exelist.copy() if ccache else self.exelist_no_ccache.copy()
 
 def get_linker_exelist(self) -> T.Liststr:
 return self.linker.get_exelist()
@@ -618,7 +638,7 @@
 """
 return 
 
- def get_options(self) -> 'KeyedOptionDictType':
+ def get_options(self) -> 'MutableKeyedOptionDictType':
 return {}
 
 def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.Liststr:
@@ -690,10 +710,14 @@
 """
 raise EnvironmentException('Language %s does not support function checks.' % self.get_display_language())
 
- def unix_args_to_native(self, args: T.Liststr) -> T.Liststr:
+ @classmethod
+ def _unix_args_to_native(cls, args: T.Liststr, info: MachineInfo) -> T.Liststr:
 "Always returns a copy that can be independently mutated"
 return args.copy()
 
+ def unix_args_to_native(self, args: T.Liststr) -> T.Liststr:
+ return self._unix_args_to_native(args, self.info)
+
 @classmethod
 def native_args_to_unix(cls, args: T.Liststr) -> T.Liststr:
 "Always returns a copy that can be independently mutated"
@@ -792,7 +816,7 @@
 if extra_args:
 commands += extra_args
 # Generate full command-line with the exelist
- command_list = self.get_exelist() + commands.to_native()
+ command_list = self.get_exelist(ccache=not no_ccache) + commands.to_native()
 mlog.debug('Running compile:')
 mlog.debug('Working directory: ', tmpdirname)
 mlog.debug('Command line: ', ' '.join(command_list), '\n')
@@ -805,7 +829,7 @@
 mlog.debug('Compiler stdout:\n', stdo)
 mlog.debug('Compiler stderr:\n', stde)
 
- result = CompileResult(stdo, stde, list(commands), p.returncode, p.pid, input_name=srcname)
+ result = CompileResult(stdo, stde, command_list, p.returncode, input_name=srcname)
 if want_output:
 result.output_name = output
 yield result
@@ -823,7 +847,7 @@
 
 # Check if not cached, and generate, otherwise get from the cache
 if key in cdata.compiler_check_cache:
- p = cdata.compiler_check_cachekey # type: CompileResult
+ p = cdata.compiler_check_cachekey
 p.cached = True
 mlog.debug('Using cached compile:')
 mlog.debug('Cached command line: ', ' '.join(p.command), '\n')
@@ -966,7 +990,8 @@
 def get_lto_compile_args(self, *, threads: int = 0, mode: str = 'default') -> T.Liststr:
 return 
 
- def get_lto_link_args(self, *, threads: int = 0, mode: str = 'default') -> T.Liststr:
+ def get_lto_link_args(self, *, threads: int = 0, mode: str = 'default',
+ thinlto_cache_dir: T.Optionalstr = None) -> T.Liststr:
 return self.linker.get_lto_args()
 
 def sanitizer_compile_args(self, value: str) -> T.Liststr:
@@ -1007,7 +1032,7 @@
 return dep.get_link_args()
 
 @classmethod
- def use_linker_args(cls, linker: str) -> T.Liststr:
+ def use_linker_args(cls, linker: str, version: str) -> T.Liststr:
 """Get a list of arguments to pass to the compiler to set the linker.
 """
 return 
@@ -1033,6 +1058,9 @@
 def get_preprocess_only_args(self) -> T.Liststr:
 raise EnvironmentException('This compiler does not have a preprocessor')
 
+ def get_preprocess_to_file_args(self) -> T.Liststr:
+ return self.get_preprocess_only_args()
+
 def get_default_include_dirs(self) -> T.Liststr:
 # TODO: This is a candidate for returning an immutable list
 return 
@@ -1121,7 +1149,7 @@
 def get_include_args(self, path: str, is_system: bool) -> T.Liststr:
 return 
 
- def depfile_for_object(self, objfile: str) -> str:
+ def depfile_for_object(self, objfile: str) -> T.Optionalstr:
 return objfile + '.' + self.get_depfile_suffix()
 
 def get_depfile_suffix(self) -> str:
@@ -1224,7 +1252,7 @@
 yield r
 
 def compiles(self, code: 'mesonlib.FileOrString', env: 'Environment', *,
- extra_args: T.UnionNone, T.Liststr, CompilerArgs, T.CallableCompileCheckMode, T.Liststr = None,
+ extra_args: T.UnionNone, T.Liststr, CompilerArgs, T.CallableCompileCheckMode, T.Liststr = None,
 dependencies: T.OptionalT.List'Dependency' = None,
 mode: str = 'compile',
 disable_cache: bool = False) -> T.Tuplebool, bool:
@@ -1270,6 +1298,13 @@
 """Arguments to completely disable warnings."""
 return 
 
+ def needs_static_linker(self) -> bool:
+ raise NotImplementedError(f'There is no static linker for {self.language}')
+
+ def get_preprocessor(self) -> Compiler:
+ """Get compiler's preprocessor.
+ """
+ raise EnvironmentException(f'{self.get_id()} does not support preprocessor')
 
 def get_global_options(lang: str,
 comp: T.TypeCompiler,

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/cpp.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/cpp.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import copy
 import functools
@@ -19,21 +20,20 @@
 
 from .. import coredata
 from .. import mlog
-from ..mesonlib import MesonException, MachineChoice, version_compare, OptionKey
+from ..mesonlib import MesonException, version_compare, OptionKey
 
 from .compilers import (
     gnu_winlibs,
     msvc_winlibs,
     Compiler,
-    CompileCheckMode,
 )
 from .c_function_attributes import CXX_FUNC_ATTRIBUTES, C_FUNC_ATTRIBUTES
 from .mixins.clike import CLikeCompiler
 from .mixins.ccrx import CcrxCompiler
-from .mixins.c2000 import C2000Compiler
+from .mixins.ti import TICompiler
 from .mixins.arm import ArmCompiler, ArmclangCompiler
 from .mixins.visualstudio import MSVCCompiler, ClangClCompiler
-from .mixins.gnu import GnuCompiler
+from .mixins.gnu import GnuCompiler, gnu_common_warning_args, gnu_cpp_warning_args
 from .mixins.intel import IntelGnuLikeCompiler, IntelVisualStudioLikeCompiler
 from .mixins.clang import ClangCompiler
 from .mixins.elbrus import ElbrusCompiler
@@ -41,11 +41,13 @@
 from .mixins.emscripten import EmscriptenMixin
 
 if T.TYPE_CHECKING:
-    from ..coredata import KeyedOptionDictType
+    from .compilers import CompileCheckMode
+    from ..coredata import MutableKeyedOptionDictType, KeyedOptionDictType
     from ..dependencies import Dependency
     from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
     from ..programs import ExternalProgram
     CompilerMixinBase = CLikeCompiler
 else:
@@ -55,14 +57,12 @@
 def non_msvc_eh_options(eh: str, args: T.Liststr) -> None:
     if eh == 'none':
         args.append('-fno-exceptions')
-    elif eh == 's' or eh == 'c':
+    elif eh in {'s', 'c'}:
         mlog.warning('non-MSVC compilers do not support ' + eh + ' exception handling.' +
                      'You may want to set eh to \'default\'.')
 
 class CPPCompiler(CLikeCompiler, Compiler):
-
-    @classmethod
-    def attribute_check_func(cls, name: str) -> str:
+    def attribute_check_func(self, name: str) -> str:
         try:
             return CXX_FUNC_ATTRIBUTES.get(name, C_FUNC_ATTRIBUTESname)
         except KeyError:
@@ -70,12 +70,12 @@
 
     language = 'cpp'
 
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
         # If a child ObjCPP class has already set it, don't set it ourselves
-        Compiler.__init__(self, exelist, version, for_machine, info,
+        Compiler.__init__(self, ccache, exelist, version, for_machine, info,
                           is_cross=is_cross, linker=linker,
                           full_version=full_version)
         CLikeCompiler.__init__(self, exe_wrapper)
@@ -155,7 +155,7 @@
         }
 
         # Currently, remapping is only supported for Clang, Elbrus and GCC
-        assert self.id in frozenset('clang', 'lcc', 'gcc', 'emscripten')
+        assert self.id in frozenset('clang', 'lcc', 'gcc', 'emscripten', 'armltdclang', 'intel-llvm')
 
         if cpp_std not in CPP_FALLBACKS:
             # 'c++03' and 'c++98' don't have fallback types
@@ -168,7 +168,7 @@
 
         raise MesonException(f'C++ Compiler does not support -std={cpp_std}')
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         opts.update({
@@ -182,21 +182,22 @@
 
 
 class ClangCPPCompiler(ClangCompiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         ClangCompiler.__init__(self, defines)
-        default_warn_args = '-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor'
+        default_warn_args = '-Wall', '-Winvalid-pch'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': '-Weverything'}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CPPCompiler.get_options(self)
         key = OptionKey('key', machine=self.for_machine, lang=self.language)
         opts.update({
@@ -257,6 +258,11 @@
         return search_dirs + '-lstdc++'
 
 
+class ArmLtdClangCPPCompiler(ClangCPPCompiler):
+
+    id = 'armltdclang'
+
+
 class AppleClangCPPCompiler(ClangCPPCompiler):
     def language_stdlib_only_link_flags(self, env: 'Environment') -> T.Liststr:
         # We need to apply the search prefix here, as these link arguments may
@@ -270,17 +276,21 @@
 
 
 class EmscriptenCPPCompiler(EmscriptenMixin, ClangCPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+
+    id = 'emscripten'
+
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  full_version: T.Optionalstr = None):
         if not is_cross:
             raise MesonException('Emscripten compiler can only be used for cross compilation.')
-        ClangCPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        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, exe_wrapper=exe_wrapper, linker=linker,
                                   defines=defines, full_version=full_version)
-        self.id = 'emscripten'
 
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.Liststr:
         args = 
@@ -292,20 +302,25 @@
 
 
 class ArmclangCPPCompiler(ArmclangCompiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    '''
+    Keil armclang
+    '''
+
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         ArmclangCompiler.__init__(self)
-        default_warn_args = '-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor'
+        default_warn_args = '-Wall', '-Winvalid-pch'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': '-Weverything'}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CPPCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         opts.update({
@@ -337,21 +352,24 @@
 
 
 class GnuCPPCompiler(GnuCompiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         GnuCompiler.__init__(self, defines)
-        default_warn_args = '-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor'
+        default_warn_args = '-Wall', '-Winvalid-pch'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': (default_warn_args + '-Wextra', '-Wpedantic' +
+                                         self.supported_warn_args(gnu_common_warning_args) +
+                                         self.supported_warn_args(gnu_cpp_warning_args))}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         opts = CPPCompiler.get_options(self)
         opts.update({
@@ -422,38 +440,39 @@
 
 
 class PGICPPCompiler(PGICompiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         PGICompiler.__init__(self)
 
 
 class NvidiaHPC_CPPCompiler(PGICompiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+
+    id = 'nvidia_hpc'
+
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         PGICompiler.__init__(self)
 
-        self.id = 'nvidia_hpc'
-
 
 class ElbrusCPPCompiler(ElbrusCompiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         ElbrusCompiler.__init__(self)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CPPCompiler.get_options(self)
 
         cpp_stds = 'none', 'c++98', 'gnu++98'
@@ -515,22 +534,22 @@
 
 
 class IntelCPPCompiler(IntelGnuLikeCompiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         IntelGnuLikeCompiler.__init__(self)
         self.lang_header = 'c++-header'
-        default_warn_args = '-Wall', '-w3', '-diag-disable:remark',
-                             '-Wpch-messages', '-Wnon-virtual-dtor'
+        default_warn_args = '-Wall', '-w3', '-Wpch-messages'
         self.warn_args = {'0': ,
-                          '1': default_warn_args,
-                          '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra'}
+                          '1': default_warn_args + '-diag-disable:remark',
+                          '2': default_warn_args + '-Wextra', '-diag-disable:remark',
+                          '3': default_warn_args + '-Wextra', '-diag-disable:remark',
+                          'everything': default_warn_args + '-Wextra'}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CPPCompiler.get_options(self)
         # Every Unix compiler under the sun seems to accept -std=c++03,
         # with the exception of ICC. Instead of preventing the user from
@@ -583,6 +602,11 @@
         return 
 
 
+class IntelLLVMCPPCompiler(ClangCPPCompiler):
+
+    id = 'intel-llvm'
+
+
 class VisualStudioLikeCPPCompilerMixin(CompilerMixinBase):
 
     """Mixin for C++ specific method overrides in MSVC-like compilers."""
@@ -604,9 +628,9 @@
     def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.Liststr:
         # need a typeddict for this
         key = OptionKey('winlibs', machine=self.for_machine, lang=self.language)
-        return T.cast(T.Liststr, optionskey.value:)
+        return T.cast('T.Liststr', optionskey.value:)
 
-    def _get_options_impl(self, opts: 'KeyedOptionDictType', cpp_stds: T.Liststr) -> 'KeyedOptionDictType':
+    def _get_options_impl(self, opts: 'MutableKeyedOptionDictType', cpp_stds: T.Liststr) -> 'MutableKeyedOptionDictType':
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         opts.update({
             key.evolve('eh'): coredata.UserComboOption(
@@ -681,17 +705,25 @@
 
 
 class VisualStudioCPPCompiler(CPP11AsCPP14Mixin, VisualStudioLikeCPPCompilerMixin, MSVCCompiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+
+    id = 'msvc'
+
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo', target: str,
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         MSVCCompiler.__init__(self, target)
-        self.id = 'msvc'
 
-    def get_options(self) -> 'KeyedOptionDictType':
+        # By default, MSVC has a broken __cplusplus define that pretends to be c++98:
+        # https://docs.microsoft.com/en-us/cpp/build/reference/zc-cplusplus?view=msvc-160
+        # Pass the flag to enable a truthful define, if possible.
+        if version_compare(self.version, '>= 19.14.26428'):
+            self.always_args = self.always_args + '/Zc:__cplusplus'
+
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         cpp_stds = 'none', 'c++11', 'vc++11'
         # Visual Studio 2015 and later
         if version_compare(self.version, '>=19'):
@@ -721,18 +753,20 @@
         return args
 
 class ClangClCPPCompiler(CPP11AsCPP14Mixin, VisualStudioLikeCPPCompilerMixin, ClangClCompiler, CPPCompiler):
+
+    id = 'clang-cl'
+
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo', target: str,
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, , exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         ClangClCompiler.__init__(self, target)
-        self.id = 'clang-cl'
 
-    def get_options(self) -> 'KeyedOptionDictType':
-        cpp_stds = 'none', 'c++11', 'vc++11', 'c++14', 'vc++14', 'c++17', 'vc++17', 'c++latest'
+    def get_options(self) -> 'MutableKeyedOptionDictType':
+        cpp_stds = 'none', 'c++11', 'vc++11', 'c++14', 'vc++14', 'c++17', 'vc++17', 'c++20', 'vc++20', 'c++latest'
         return self._get_options_impl(super().get_options(), cpp_stds)
 
 
@@ -743,11 +777,11 @@
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, , exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         IntelVisualStudioLikeCompiler.__init__(self, target)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         # This has only been tested with version 19.0,
         cpp_stds = 'none', 'c++11', 'vc++11', 'c++14', 'vc++14', 'c++17', 'vc++17', 'c++latest'
         return self._get_options_impl(super().get_options(), cpp_stds)
@@ -757,16 +791,21 @@
         return IntelVisualStudioLikeCompiler.get_compiler_check_args(self, mode)
 
 
+class IntelLLVMClCPPCompiler(IntelClCPPCompiler):
+
+    id = 'intel-llvm-cl'
+
+
 class ArmCPPCompiler(ArmCompiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         ArmCompiler.__init__(self)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CPPCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'c++03', 'c++11'
@@ -790,11 +829,11 @@
 
 
 class CcrxCPPCompiler(CcrxCompiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
         CcrxCompiler.__init__(self)
 
@@ -817,16 +856,16 @@
     def get_compiler_check_args(self, mode: CompileCheckMode) -> T.Liststr:
         return 
 
-class C2000CPPCompiler(C2000Compiler, CPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
+class TICPPCompiler(TICompiler, CPPCompiler):
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        CPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                              info, exe_wrapper, linker=linker, full_version=full_version)
-        C2000Compiler.__init__(self)
+        TICompiler.__init__(self)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = CPPCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'c++03'
@@ -840,13 +879,12 @@
             args.append('--' + std.value)
         return args
 
-    def get_no_optimization_args(self) -> T.Liststr:
-        return '-Ooff'
+    def get_always_args(self) -> T.Liststr:
+        return 
 
-    def get_output_args(self, target: str) -> T.Liststr:
-        return f'--output_file={target}'
+    def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.Liststr:
+        return 
 
-    def get_include_args(self, path: str, is_system: bool) -> T.Liststr:
-        if path == '':
-            path = '.'
-        return '--include_path=' + path
+class C2000CPPCompiler(TICPPCompiler):
+    # Required for backwards compat with projects created before ti-cgt support existed
+    id = 'c2000'

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/cs.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/cs.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import os.path, subprocess
 import textwrap
@@ -19,14 +20,17 @@
 from ..mesonlib import EnvironmentException
 from ..linkers import RSPFileSyntax
 
-from .compilers import Compiler, MachineChoice, mono_buildtype_args
+from .compilers import Compiler, mono_buildtype_args
 from .mixins.islinker import BasicLinkerIsCompilerMixin
 
 if T.TYPE_CHECKING:
     from ..envconfig import MachineInfo
     from ..environment import Environment
+    from ..mesonlib import MachineChoice
 
-cs_optimization_args = {'0': ,
+cs_optimization_args = {
+                        'plain': ,
+                        '0': ,
                         'g': ,
                         '1': '-optimize+',
                         '2': '-optimize+',
@@ -40,9 +44,8 @@
     language = 'cs'
 
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
-                 info: 'MachineInfo', comp_id: str, runner: T.Optionalstr = None):
-        super().__init__(exelist, version, for_machine, info)
-        self.id = comp_id
+                 info: 'MachineInfo', runner: T.Optionalstr = None):
+        super().__init__(, exelist, version, for_machine, info)
         self.runner = runner
 
     @classmethod
@@ -121,19 +124,20 @@
 
 
 class MonoCompiler(CsCompiler):
+
+    id = 'mono'
+
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  info: 'MachineInfo'):
-        super().__init__(exelist, version, for_machine, info, 'mono',
-                         runner='mono')
+        super().__init__(exelist, version, for_machine, info, runner='mono')
 
     def rsp_file_syntax(self) -> 'RSPFileSyntax':
         return RSPFileSyntax.GCC
 
 
 class VisualStudioCsCompiler(CsCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
-                 info: 'MachineInfo'):
-        super().__init__(exelist, version, for_machine, info, 'csc')
+
+    id = 'csc'
 
     def get_buildtype_args(self, buildtype: str) -> T.Liststr:
         res = mono_buildtype_argsbuildtype

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/cuda.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/cuda.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import enum
 import os.path
@@ -20,19 +21,21 @@
 from .. import coredata
 from .. import mlog
 from ..mesonlib import (
-    EnvironmentException, MachineChoice, Popen_safe, OptionOverrideProxy,
-    is_windows, LibType, OptionKey,
+    EnvironmentException, Popen_safe, OptionOverrideProxy,
+    is_windows, LibType, OptionKey, version_compare,
 )
 from .compilers import (Compiler, cuda_buildtype_args, cuda_optimization_args,
-                        cuda_debug_args, CompileCheckMode)
+                        cuda_debug_args)
 
 if T.TYPE_CHECKING:
+    from .compilers import CompileCheckMode
     from ..build import BuildTarget
-    from ..coredata import KeyedOptionDictType
+    from ..coredata import MutableKeyedOptionDictType, KeyedOptionDictType
     from ..dependencies import Dependency
     from ..environment import Environment  # noqa: F401
     from ..envconfig import MachineInfo
     from ..linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
     from ..programs import ExternalProgram
 
 
@@ -173,16 +176,17 @@
     # Reverse map -short to --long options.
     _FLAG_SHORT2LONG_WITHARGS = {v: k for k, v in _FLAG_LONG2SHORT_WITHARGS.items()}
 
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    id = 'nvcc'
+
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, exe_wrapper: T.Optional'ExternalProgram',
                  host_compiler: Compiler, info: 'MachineInfo',
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        super().__init__(exelist, version, for_machine, info, linker=linker, full_version=full_version, is_cross=is_cross)
+        super().__init__(ccache, exelist, version, for_machine, info, linker=linker, full_version=full_version, is_cross=is_cross)
         self.exe_wrapper = exe_wrapper
         self.host_compiler = host_compiler
         self.base_options = host_compiler.base_options
-        self.id = 'nvcc'
         self.warn_args = {level: self._to_host_flags(flags) for level, flags in host_compiler.warn_args.items()}
 
     @classmethod
@@ -226,7 +230,7 @@
             instring = False
             argit = iter(arg)
             for c in argit:
-                if   c == CM and not instring:
+                if c == CM and not instring:
                     l.append('')
                 elif c == DQ:
                     l-1 += c
@@ -258,10 +262,13 @@
 
         def is_xcompiler_flag_isolated(flag: str) -> bool:
             return flag == '-Xcompiler'
+
         def is_xcompiler_flag_glued(flag: str) -> bool:
             return flag.startswith('-Xcompiler=')
+
         def is_xcompiler_flag(flag: str) -> bool:
             return is_xcompiler_flag_isolated(flag) or is_xcompiler_flag_glued(flag)
+
         def get_xcompiler_val(flag: str, flagit: T.Iteratorstr) -> str:
             if is_xcompiler_flag_glued(flag):
                 return flaglen('-Xcompiler='):
@@ -357,7 +364,7 @@
                 continue
 
             # Handle breakup of flag-values into a flag-part and value-part.
-            if   flag:1 not in '-/':
+            if flag:1 not in '-/':
                 # This is not a flag. It's probably a file input. Pass it through.
                 xflags.append(flag)
                 continue
@@ -372,7 +379,7 @@
                 # This is a single-letter short option. These options (with the
                 # exception of -o) are allowed to receive their argument with neither
                 # space nor = sign before them. Detect and separate them in that event.
-                if   flag2:3 == '':            # -I something
+                if flag2:3 == '':            # -I something
                     try:
                         val = next(flagit)
                     except StopIteration:
@@ -383,7 +390,7 @@
                     val = flag2:
                 flag = flag:2                  # -I
             elif flag in self._FLAG_LONG2SHORT_WITHARGS or \
-                 flag in self._FLAG_SHORT2LONG_WITHARGS:
+                    flag in self._FLAG_SHORT2LONG_WITHARGS:
                 # This is either -o or a multi-letter flag, and it is receiving its
                 # value isolated.
                 try:
@@ -391,7 +398,7 @@
                 except StopIteration:
                     pass
             elif flag.split('=', 1)0 in self._FLAG_LONG2SHORT_WITHARGS or \
-                 flag.split('=', 1)0 in self._FLAG_SHORT2LONG_WITHARGS:
+                    flag.split('=', 1)0 in self._FLAG_SHORT2LONG_WITHARGS:
                 # This is either -o or a multi-letter flag, and it is receiving its
                 # value after an = sign.
                 flag, val = flag.split('=', 1)    # -o=something
@@ -405,7 +412,7 @@
                 # We do not know whether this GCC-speak flag takes an isolated
                 # argument. Assuming it does not (the vast majority indeed don't),
                 # wrap this argument in an -Xcompiler flag and send it down to NVCC.
-                if   flag == '-ffast-math':
+                if flag == '-ffast-math':
                     xflags.append('-use_fast_math')
                     xflags.append('-Xcompiler='+flag)
                 elif flag == '-fno-fast-math':
@@ -429,7 +436,7 @@
             # Take care of the various NVCC-supported flags that need special handling.
             flag = self._FLAG_LONG2SHORT_WITHARGS.get(flag, flag)
 
-            if   flag in {'-include', '-isystem', '-I', '-L', '-l'}:
+            if flag in {'-include', '-isystem', '-I', '-L', '-l'}:
                 # These flags are known to GCC, but list-valued in NVCC. They potentially
                 # require double-quoting to prevent NVCC interpreting the flags as lists
                 # when GCC would not have done so.
@@ -449,7 +456,7 @@
                     xflags.append(self._shield_nvcc_list_arg(val))
             elif flag == '-O':
                 # Handle optimization levels GCC knows about that NVCC does not.
-                if   val == 'fast':
+                if val == 'fast':
                     xflags.append('-O3')
                     xflags.append('-use_fast_math')
                     xflags.append('-Xcompiler')
@@ -608,13 +615,26 @@
         }}'''
         return self.compiles(t.format_map(fargs), env, extra_args=extra_args, dependencies=dependencies)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    _CPP14_VERSION = '>=9.0'
+    _CPP17_VERSION = '>=11.0'
+    _CPP20_VERSION = '>=12.0'
+
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
-        std_key      = OptionKey('std',      machine=self.for_machine, lang=self.language)
+        std_key = OptionKey('std', machine=self.for_machine, lang=self.language)
         ccbindir_key = OptionKey('ccbindir', machine=self.for_machine, lang=self.language)
+
+        cpp_stds = 'none', 'c++03', 'c++11'
+        if version_compare(self.version, self._CPP14_VERSION):
+            cpp_stds += 'c++14'
+        if version_compare(self.version, self._CPP17_VERSION):
+            cpp_stds += 'c++17'
+        if version_compare(self.version, self._CPP20_VERSION):
+            cpp_stds += 'c++20'
+
         opts.update({
             std_key:      coredata.UserComboOption('C++ language standard to use with CUDA',
-                                                   'none', 'c++03', 'c++11', 'c++14', 'c++17', 'none'),
+                                                   cpp_stds, 'none'),
             ccbindir_key: coredata.UserStringOption('CUDA non-default toolchain directory to use (-ccbin)',
                                                     ''),
         })
@@ -740,7 +760,7 @@
         # native option to override it; override it with /NODEFAULTLIB
         host_link_arg_overrides = 
         host_crt_compile_args = self.host_compiler.get_crt_compile_args(crt_val, buildtype)
-        if any(arg in '/MDd', '/MD', '/MTd' for arg in host_crt_compile_args):
+        if any(arg in {'/MDd', '/MD', '/MTd'} for arg in host_crt_compile_args):
             host_link_arg_overrides += '/NODEFAULTLIB:LIBCMT.lib'
         return self._to_host_flags(host_link_arg_overrides + self.host_compiler.get_crt_link_args(crt_val, buildtype), _Phase.LINKER)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/cython.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/cython.py Changed

@@ -1,16 +1,17 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright © 2021 Intel Corporation
+from __future__ import annotations
 
 """Abstraction for Cython language compilers."""
 
 import typing as T
 
 from .. import coredata
-from ..mesonlib import EnvironmentException, OptionKey
+from ..mesonlib import EnvironmentException, OptionKey, version_compare
 from .compilers import Compiler
 
 if T.TYPE_CHECKING:
-    from ..coredata import KeyedOptionDictType
+    from ..coredata import MutableKeyedOptionDictType, KeyedOptionDictType
     from ..environment import Environment
 
 
@@ -39,6 +40,14 @@
         # compiler might though
         return 
 
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.Liststr:
+        if version_compare(self.version, '>=0.29.33'):
+            return '-M'
+        return 
+
+    def get_depfile_suffix(self) -> str:
+        return 'dep'
+
     def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
         code = 'print("hello world")'
         with self.cached_compile(code, environment.coredata) as p:
@@ -61,7 +70,7 @@
 
         return new
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         opts.update({
             OptionKey('version', machine=self.for_machine, lang=self.language): coredata.UserComboOption(

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/d.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/d.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2012-2017 The Meson development team
+# Copyright 2012-2022 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,32 +11,40 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import os.path
 import re
 import subprocess
 import typing as T
 
+from .. import mesonlib
+from .. import mlog
+from ..arglist import CompilerArgs
+from ..linkers import RSPFileSyntax
 from ..mesonlib import (
-    EnvironmentException, MachineChoice, version_compare, OptionKey, is_windows
+    EnvironmentException, version_compare, OptionKey, is_windows
 )
 
-from ..arglist import CompilerArgs
-from ..linkers import RSPFileSyntax
+from . import compilers
 from .compilers import (
     d_dmd_buildtype_args,
     d_gdc_buildtype_args,
     d_ldc_buildtype_args,
     clike_debug_args,
     Compiler,
+    CompileCheckMode,
 )
 from .mixins.gnu import GnuCompiler
+from .mixins.gnu import gnu_common_warning_args
 
 if T.TYPE_CHECKING:
+    from ..dependencies import Dependency
     from ..programs import ExternalProgram
     from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
 
     CompilerMixinBase = Compiler
 else:
@@ -59,7 +67,8 @@
                            }
                   }  # type: T.Dictstr, T.Dictstr, str
 
-ldc_optimization_args = {'0': ,
+ldc_optimization_args = {'plain': ,
+                         '0': ,
                          'g': ,
                          '1': '-O1',
                          '2': '-O2',
@@ -67,7 +76,8 @@
                          's': '-Oz',
                          }  # type: T.Dictstr, T.Liststr
 
-dmd_optimization_args = {'0': ,
+dmd_optimization_args = {'plain': ,
+                         '0': ,
                          'g': ,
                          '1': '-O',
                          '2': '-O',
@@ -276,7 +286,8 @@
         return super().build_rpath_args(
             env, build_dir, from_dir, rpath_paths, build_rpath, install_rpath)
 
-    def _translate_args_to_nongnu(self, args: T.Liststr) -> T.Liststr:
+    @classmethod
+    def _translate_args_to_nongnu(cls, args: T.Liststr, info: MachineInfo, link_id: str) -> T.Liststr:
         # Translate common arguments to flags the LDC/DMD compilers
         # can understand.
         # The flags might have been added by pkg-config files,
@@ -291,10 +302,10 @@
         for arg in args:
             # Translate OS specific arguments first.
             osargs =   # type: T.Liststr
-            if self.info.is_windows():
-                osargs = self.translate_arg_to_windows(arg)
-            elif self.info.is_darwin():
-                osargs = self._translate_arg_to_osx(arg)
+            if info.is_windows():
+                osargs = cls.translate_arg_to_windows(arg)
+            elif info.is_darwin():
+                osargs = cls._translate_arg_to_osx(arg)
             if osargs:
                 dcargs.extend(osargs)
                 continue
@@ -304,7 +315,9 @@
                 continue
             if arg.startswith('-fstack-protector'):
                 continue
-            if arg.startswith('-D'):
+            if arg.startswith('-D') and not (arg == '-D' or arg.startswith(('-Dd', '-Df'))):
+                # ignore all '-D*' flags (like '-D_THREAD_SAFE')
+                # unless they are related to documentation
                 continue
             if arg.startswith('-Wl,'):
                 # Translate linker arguments here.
@@ -379,7 +392,7 @@
                     continue
 
                 # linker flag such as -L=/DEBUG must pass through
-                if self.linker.id == 'link' and self.info.is_windows() and suffix.startswith('/'):
+                if info.is_windows() and link_id == 'link' and suffix.startswith('/'):
                     dcargs.append(arg)
                     continue
 
@@ -433,6 +446,10 @@
             args.append('-L=' + arg)
         return args
 
+    @classmethod
+    def _unix_args_to_native(cls, args: T.Liststr, info: MachineInfo, link_id: str = '') -> T.Liststr:
+        return cls._translate_args_to_nongnu(args, info, link_id)
+
     def get_debug_args(self, is_debug: bool) -> T.Liststr:
         ddebug_args = 
         if is_debug:
@@ -446,7 +463,7 @@
 
         if crt_val in self.mscrt_args:
             return self.mscrt_argscrt_val
-        assert crt_val in 'from_buildtype', 'static_from_buildtype'
+        assert crt_val in {'from_buildtype', 'static_from_buildtype'}
 
         dbg = 'mdd'
         rel = 'md'
@@ -529,7 +546,7 @@
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None,
                  is_cross: bool = False):
-        super().__init__(exelist, version, for_machine, info, linker=linker,
+        super().__init__(, exelist, version, for_machine, info, linker=linker,
                          full_version=full_version, is_cross=is_cross)
         self.arch = arch
         self.exe_wrapper = exe_wrapper
@@ -678,11 +695,104 @@
     def get_crt_link_args(self, crt_val: str, buildtype: str) -> T.Liststr:
         return 
 
+    def _get_compile_extra_args(self, extra_args: T.UnionT.Liststr, T.CallableCompileCheckMode, T.Liststr, None = None) -> T.Liststr:
+        args = self._get_target_arch_args()
+        if extra_args:
+            if callable(extra_args):
+                extra_args = extra_args(CompileCheckMode.COMPILE)
+            if isinstance(extra_args, list):
+                args.extend(extra_args)
+            elif isinstance(extra_args, str):
+                args.append(extra_args)
+        return args
+
+    def run(self, code: 'mesonlib.FileOrString', env: 'Environment', *,
+            extra_args: T.UnionT.Liststr, T.CallableCompileCheckMode, T.Liststr, None = None,
+            dependencies: T.OptionalT.List'Dependency' = None) -> compilers.RunResult:
+        need_exe_wrapper = env.need_exe_wrapper(self.for_machine)
+        if need_exe_wrapper and self.exe_wrapper is None:
+            raise compilers.CrossNoRunException('Can not run test applications in this cross environment.')
+        extra_args = self._get_compile_extra_args(extra_args)
+        with self._build_wrapper(code, env, extra_args, dependencies, mode='link', want_output=True) as p:
+            if p.returncode != 0:
+                mlog.debug(f'Could not compile test file {p.input_name}: {p.returncode}\n')
+                return compilers.RunResult(False)
+            if need_exe_wrapper:
+                cmdlist = self.exe_wrapper.get_command() + p.output_name
+            else:
+                cmdlist = p.output_name
+            try:
+                pe, so, se = mesonlib.Popen_safe(cmdlist)
+            except Exception as e:
+                mlog.debug(f'Could not run: {cmdlist} (error: {e})\n')
+                return compilers.RunResult(False)
+
+        mlog.debug('Program stdout:\n')
+        mlog.debug(so)
+        mlog.debug('Program stderr:\n')
+        mlog.debug(se)
+        return compilers.RunResult(True, pe.returncode, so, se)
+
+    def sizeof(self, typename: str, prefix: str, env: 'Environment', *,
+               extra_args: T.UnionNone, T.Liststr, T.CallableCompileCheckMode, T.Liststr = None,
+               dependencies: T.OptionalT.List'Dependency' = None) -> int:
+        if extra_args is None:
+            extra_args = 
+        t = f'''
+        import std.stdio : writeln;
+        {prefix}
+        void main() {{
+            writeln(({typename}).sizeof);
+        }}
+        '''
+        res = self.run(t, env, extra_args=extra_args,
+                       dependencies=dependencies)
+        if not res.compiled:
+            return -1
+        if res.returncode != 0:
+            raise mesonlib.EnvironmentException('Could not run sizeof test binary.')
+        return int(res.stdout)
+
+    def alignment(self, typename: str, prefix: str, env: 'Environment', *,
+                  extra_args: T.OptionalT.Liststr = None,
+                  dependencies: T.OptionalT.List'Dependency' = None) -> int:
+        if extra_args is None:
+            extra_args = 
+        t = f'''
+        import std.stdio : writeln;
+        {prefix}
+        void main() {{
+            writeln(({typename}).alignof);
+        }}
+        '''
+        res = self.run(t, env, extra_args=extra_args,
+                       dependencies=dependencies)
+        if not res.compiled:
+            raise mesonlib.EnvironmentException('Could not compile alignment test.')
+        if res.returncode != 0:
+            raise mesonlib.EnvironmentException('Could not run alignment test binary.')
+        align = int(res.stdout)
+        if align == 0:
+            raise mesonlib.EnvironmentException(f'Could not determine alignment of {typename}. Sorry. You might want to file a bug.')
+        return align
+
+    def has_header(self, hname: str, prefix: str, env: 'Environment', *,
+                   extra_args: T.UnionNone, T.Liststr, T.Callable'CompileCheckMode', T.Liststr = None,
+                   dependencies: T.OptionalT.List'Dependency' = None,
+                   disable_cache: bool = False) -> T.Tuplebool, bool:
+
+        extra_args = self._get_compile_extra_args(extra_args)
+        code = f'''{prefix}
+        import {hname};
+        '''
+        return self.compiles(code, env, extra_args=extra_args,
+                             dependencies=dependencies, mode='compile', disable_cache=disable_cache)
 
 class GnuDCompiler(GnuCompiler, DCompiler):
 
     # we mostly want DCompiler, but that gives us the Compiler.LINKER_PREFIX instead
     LINKER_PREFIX = GnuCompiler.LINKER_PREFIX
+    id = 'gcc'
 
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  info: 'MachineInfo', arch: str, *,
@@ -694,12 +804,14 @@
                            exe_wrapper=exe_wrapper, linker=linker,
                            full_version=full_version, is_cross=is_cross)
         GnuCompiler.__init__(self, {})
-        self.id = 'gcc'
         default_warn_args = '-Wall', '-Wdeprecated'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': (default_warn_args + '-Wextra', '-Wpedantic' +
+                                         self.supported_warn_args(gnu_common_warning_args))}
+
         self.base_options = {
             OptionKey(o) for o in 
              'b_colorout', 'b_sanitize', 'b_staticpic', 'b_vscrt',
@@ -762,6 +874,8 @@
 
 class LLVMDCompiler(DmdLikeCompilerMixin, DCompiler):
 
+    id = 'llvm'
+
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  info: 'MachineInfo', arch: str, *,
                  exe_wrapper: T.Optional'ExternalProgram' = None,
@@ -772,7 +886,6 @@
                            exe_wrapper=exe_wrapper, linker=linker,
                            full_version=full_version, is_cross=is_cross)
         DmdLikeCompilerMixin.__init__(self, dmd_frontend_version=find_ldc_dmd_frontend_version(version_output))
-        self.id = 'llvm'
         self.base_options = {OptionKey(o) for o in 'b_coverage', 'b_colorout', 'b_vscrt', 'b_ndebug'}
 
     def get_colorout_args(self, colortype: str) -> T.Liststr:
@@ -799,13 +912,13 @@
         return self._get_crt_args(crt_val, buildtype)
 
     def unix_args_to_native(self, args: T.Liststr) -> T.Liststr:
-        return self._translate_args_to_nongnu(args)
+        return self._unix_args_to_native(args, self.info, self.linker.id)
 
     def get_optimization_args(self, optimization_level: str) -> T.Liststr:
         return ldc_optimization_argsoptimization_level
 
     @classmethod
-    def use_linker_args(cls, linker: str) -> T.Liststr:
+    def use_linker_args(cls, linker: str, version: str) -> T.Liststr:
         return f'-linker={linker}'
 
     def get_linker_always_args(self) -> T.Liststr:
@@ -826,6 +939,8 @@
 
 class DmdDCompiler(DmdLikeCompilerMixin, DCompiler):
 
+    id = 'dmd'
+
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  info: 'MachineInfo', arch: str, *,
                  exe_wrapper: T.Optional'ExternalProgram' = None,
@@ -836,7 +951,6 @@
                            exe_wrapper=exe_wrapper, linker=linker,
                            full_version=full_version, is_cross=is_cross)
         DmdLikeCompilerMixin.__init__(self, version)
-        self.id = 'dmd'
         self.base_options = {OptionKey(o) for o in 'b_coverage', 'b_colorout', 'b_vscrt', 'b_ndebug'}
 
     def get_colorout_args(self, colortype: str) -> T.Liststr:
@@ -887,7 +1001,7 @@
         return self._get_crt_args(crt_val, buildtype)
 
     def unix_args_to_native(self, args: T.Liststr) -> T.Liststr:
-        return self._translate_args_to_nongnu(args)
+        return self._unix_args_to_native(args, self.info, self.linker.id)
 
     def get_optimization_args(self, optimization_level: str) -> T.Liststr:
         return dmd_optimization_argsoptimization_level

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/detect.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/detect.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2012-2021 The Meson development team
+# Copyright 2012-2022 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,125 +11,16 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from ..mesonlib import (
-    MachineChoice, MesonException, EnvironmentException,
+    MesonException, EnvironmentException, MachineChoice, join_args,
     search_version, is_windows, Popen_safe, windows_proof_rm,
 )
 from ..envconfig import BinaryTable
 from .. import mlog
 
-from ..linkers import (
-    guess_win_linker,
-    guess_nix_linker,
-    AIXArLinker,
-    ArLinker,
-    ArmarLinker,
-    ArmClangDynamicLinker,
-    ArmDynamicLinker,
-    CcrxLinker,
-    CcrxDynamicLinker,
-    CompCertLinker,
-    CompCertDynamicLinker,
-    C2000Linker,
-    C2000DynamicLinker,
-    DLinker,
-    NAGDynamicLinker,
-    NvidiaHPC_DynamicLinker,
-    PGIDynamicLinker,
-    PGIStaticLinker,
-    StaticLinker,
-    Xc16Linker,
-    Xc16DynamicLinker,
-    XilinkDynamicLinker,
-    CudaLinker,
-    IntelVisualStudioLinker,
-    VisualStudioLinker,
-    VisualStudioLikeLinkerMixin,
-    WASMDynamicLinker,
-)
-from .compilers import Compiler
-from .c import (
-    CCompiler,
-    AppleClangCCompiler,
-    ArmCCompiler,
-    ArmclangCCompiler,
-    ClangCCompiler,
-    ClangClCCompiler,
-    GnuCCompiler,
-    ElbrusCCompiler,
-    EmscriptenCCompiler,
-    IntelCCompiler,
-    IntelClCCompiler,
-    NvidiaHPC_CCompiler,
-    PGICCompiler,
-    CcrxCCompiler,
-    Xc16CCompiler,
-    CompCertCCompiler,
-    C2000CCompiler,
-    VisualStudioCCompiler,
-)
-from .cpp import (
-    CPPCompiler,
-    AppleClangCPPCompiler,
-    ArmCPPCompiler,
-    ArmclangCPPCompiler,
-    ClangCPPCompiler,
-    ClangClCPPCompiler,
-    GnuCPPCompiler,
-    ElbrusCPPCompiler,
-    EmscriptenCPPCompiler,
-    IntelCPPCompiler,
-    IntelClCPPCompiler,
-    NvidiaHPC_CPPCompiler,
-    PGICPPCompiler,
-    CcrxCPPCompiler,
-    C2000CPPCompiler,
-    VisualStudioCPPCompiler,
-)
-from .cs import MonoCompiler, VisualStudioCsCompiler
-from .d import (
-    DCompiler,
-    DmdDCompiler,
-    GnuDCompiler,
-    LLVMDCompiler,
-)
-from .cuda import CudaCompiler
-from .fortran import (
-    FortranCompiler,
-    G95FortranCompiler,
-    GnuFortranCompiler,
-    ElbrusFortranCompiler,
-    FlangFortranCompiler,
-    IntelFortranCompiler,
-    IntelClFortranCompiler,
-    NAGFortranCompiler,
-    Open64FortranCompiler,
-    PathScaleFortranCompiler,
-    NvidiaHPC_FortranCompiler,
-    PGIFortranCompiler,
-    SunFortranCompiler,
-)
-from .java import JavaCompiler
-from .objc import (
-    ObjCCompiler,
-    AppleClangObjCCompiler,
-    ClangObjCCompiler,
-    GnuObjCCompiler,
-)
-from .objcpp import (
-    ObjCPPCompiler,
-    AppleClangObjCPPCompiler,
-    ClangObjCPPCompiler,
-    GnuObjCPPCompiler,
-)
-from .cython import CythonCompiler
-from .rust import RustCompiler, ClippyRustCompiler
-from .swift import SwiftCompiler
-from .vala import ValaCompiler
-from .mixins.visualstudio import VisualStudioLikeCompiler
-from .mixins.gnu import GnuCompiler
-from .mixins.clang import ClangCompiler
+from ..linkers import guess_win_linker, guess_nix_linker
 
 import subprocess
 import platform
@@ -140,6 +31,12 @@
 import typing as T
 
 if T.TYPE_CHECKING:
+    from .compilers import Compiler
+    from .c import CCompiler
+    from .cpp import CPPCompiler
+    from .fortran import FortranCompiler
+    from .rust import RustCompiler
+    from ..linkers import StaticLinker
     from ..environment import Environment
     from ..programs import ExternalProgram
 
@@ -171,11 +68,11 @@
         defaults'objc' = 'clang'
         defaults'objcpp' = 'clang++'
     else:
-        defaults'c' = 'cc', 'gcc', 'clang', 'nvc', 'pgcc', 'icc'
-        defaults'cpp' = 'c++', 'g++', 'clang++', 'nvc++', 'pgc++', 'icpc'
+        defaults'c' = 'cc', 'gcc', 'clang', 'nvc', 'pgcc', 'icc', 'icx'
+        defaults'cpp' = 'c++', 'g++', 'clang++', 'nvc++', 'pgc++', 'icpc', 'icpx'
         defaults'objc' = 'cc', 'gcc', 'clang'
         defaults'objcpp' = 'c++', 'g++', 'clang++'
-    defaults'fortran' = 'gfortran', 'flang', 'nvfortran', 'pgfortran', 'ifort', 'g95'
+    defaults'fortran' = 'gfortran', 'flang', 'nvfortran', 'pgfortran', 'ifort', 'ifx', 'g95'
     defaults'cs' = 'mcs', 'csc'
 defaults'd' = 'ldc2', 'ldc', 'gdc', 'dmd'
 defaults'java' = 'javac'
@@ -191,6 +88,7 @@
 defaults'cuda_static_linker' = 'nvlink'
 defaults'gcc_static_linker' = 'gcc-ar'
 defaults'clang_static_linker' = 'llvm-ar'
+defaults'nasm' = 'nasm', 'yasm'
 
 
 def compiler_from_language(env: 'Environment', lang: str, for_machine: MachineChoice) -> T.OptionalCompiler:
@@ -208,6 +106,8 @@
         'fortran': detect_fortran_compiler,
         'swift': detect_swift_compiler,
         'cython': detect_cython_compiler,
+        'nasm': detect_nasm_compiler,
+        'masm': detect_masm_compiler,
     }
     return lang_maplang(env, for_machine) if lang in lang_map else None
 
@@ -248,13 +148,12 @@
 def _handle_exceptions(
         exceptions: T.Mappingstr, T.UnionException, str,
         binaries: T.ListT.Liststr,
-        bintype: str = 'compiler'
-    ) -> T.NoReturn:
+        bintype: str = 'compiler') -> T.NoReturn:
     errmsg = f'Unknown {bintype}(s): {binaries}'
     if exceptions:
         errmsg += '\nThe following exception(s) were encountered:'
         for c, e in exceptions.items():
-            errmsg += f'\nRunning "{c}" gave "{e}"'
+            errmsg += f'\nRunning `{c}` gave "{e}"'
     raise EnvironmentException(errmsg)
 
 
@@ -262,81 +161,89 @@
 # ===============
 
 def detect_static_linker(env: 'Environment', compiler: Compiler) -> StaticLinker:
+    from . import d
+    from ..linkers import linkers
     linker = env.lookup_binary_entry(compiler.for_machine, 'ar')
     if linker is not None:
-        linkers = linker
+        trials = linker
     else:
         default_linkers = l for l in defaults'static_linker'
-        if isinstance(compiler, CudaCompiler):
-            linkers = defaults'cuda_static_linker' + default_linkers
-        elif isinstance(compiler, VisualStudioLikeCompiler):
-            linkers = defaults'vs_static_linker', defaults'clang_cl_static_linker'
-        elif isinstance(compiler, GnuCompiler):
+        if compiler.language == 'cuda':
+            trials = defaults'cuda_static_linker' + default_linkers
+        elif compiler.get_argument_syntax() == 'msvc':
+            trials = defaults'vs_static_linker', defaults'clang_cl_static_linker'
+        elif compiler.id == 'gcc':
             # Use gcc-ar if available; needed for LTO
-            linkers = defaults'gcc_static_linker' + default_linkers
-        elif isinstance(compiler, ClangCompiler):
+            trials = defaults'gcc_static_linker' + default_linkers
+        elif compiler.id == 'clang':
             # Use llvm-ar if available; needed for LTO
-            linkers = defaults'clang_static_linker' + default_linkers
-        elif isinstance(compiler, DCompiler):
+            trials = defaults'clang_static_linker' + default_linkers
+        elif compiler.language == 'd':
             # Prefer static linkers over linkers used by D compilers
             if is_windows():
-                linkers = defaults'vs_static_linker', defaults'clang_cl_static_linker', compiler.get_linker_exelist()
+                trials = defaults'vs_static_linker', defaults'clang_cl_static_linker', compiler.get_linker_exelist()
             else:
-                linkers = default_linkers
-        elif isinstance(compiler, IntelClCCompiler):
+                trials = default_linkers
+        elif compiler.id == 'intel-cl' and compiler.language == 'c': # why not cpp? Is this a bug?
             # Intel has it's own linker that acts like microsoft's lib
-            linkers = 'xilib'
-        elif isinstance(compiler, (PGICCompiler, PGIFortranCompiler)) and is_windows():
-            linkers = 'ar'  # For PGI on Windows, "ar" is just a wrapper calling link/lib.
+            trials = 'xilib'
+        elif is_windows() and compiler.id == 'pgi': # this handles cpp / nvidia HPC, in addition to just c/fortran
+            trials = 'ar'  # For PGI on Windows, "ar" is just a wrapper calling link/lib.
         else:
-            linkers = default_linkers
+            trials = default_linkers
     popen_exceptions = {}
-    for linker in linkers:
-        if not {'lib', 'lib.exe', 'llvm-lib', 'llvm-lib.exe', 'xilib', 'xilib.exe'}.isdisjoint(linker):
+    for linker in trials:
+        linker_name = os.path.basename(linker0)
+
+        if any(os.path.basename(x) in {'lib', 'lib.exe', 'llvm-lib', 'llvm-lib.exe', 'xilib', 'xilib.exe'} for x in linker):
             arg = '/?'
-        elif not {'ar2000', 'ar2000.exe'}.isdisjoint(linker):
+        elif linker_name in {'ar2000', 'ar2000.exe', 'ar430', 'ar430.exe', 'armar', 'armar.exe'}:
             arg = '?'
         else:
             arg = '--version'
         try:
             p, out, err = Popen_safe(linker + arg)
         except OSError as e:
-            popen_exceptions' '.join(linker + arg) = e
+            popen_exceptionsjoin_args(linker + arg) = e
             continue
         if "xilib: executing 'lib'" in err:
-            return IntelVisualStudioLinker(linker, getattr(compiler, 'machine', None))
+            return linkers.IntelVisualStudioLinker(linker, getattr(compiler, 'machine', None))
         if '/OUT:' in out.upper() or '/OUT:' in err.upper():
-            return VisualStudioLinker(linker, getattr(compiler, 'machine', None))
+            return linkers.VisualStudioLinker(linker, getattr(compiler, 'machine', None))
         if 'ar-Error-Unknown switch: --version' in err:
-            return PGIStaticLinker(linker)
-        if p.returncode == 0 and ('armar' in linker or 'armar.exe' in linker):
-            return ArmarLinker(linker)
+            return linkers.PGIStaticLinker(linker)
+        if p.returncode == 0 and 'armar' in linker_name:
+            return linkers.ArmarLinker(linker)
         if 'DMD32 D Compiler' in out or 'DMD64 D Compiler' in out:
-            assert isinstance(compiler, DCompiler)
-            return DLinker(linker, compiler.arch)
+            assert isinstance(compiler, d.DCompiler)
+            return linkers.DLinker(linker, compiler.arch)
         if 'LDC - the LLVM D compiler' in out:
-            assert isinstance(compiler, DCompiler)
-            return DLinker(linker, compiler.arch, rsp_syntax=compiler.rsp_file_syntax())
+            assert isinstance(compiler, d.DCompiler)
+            return linkers.DLinker(linker, compiler.arch, rsp_syntax=compiler.rsp_file_syntax())
         if 'GDC' in out and ' based on D ' in out:
-            assert isinstance(compiler, DCompiler)
-            return DLinker(linker, compiler.arch)
-        if err.startswith('Renesas') and ('rlink' in linker or 'rlink.exe' in linker):
-            return CcrxLinker(linker)
-        if out.startswith('GNU ar') and ('xc16-ar' in linker or 'xc16-ar.exe' in linker):
-            return Xc16Linker(linker)
-        if out.startswith('TMS320C2000') and ('ar2000' in linker or 'ar2000.exe' in linker):
-            return C2000Linker(linker)
+            assert isinstance(compiler, d.DCompiler)
+            return linkers.DLinker(linker, compiler.arch)
+        if err.startswith('Renesas') and 'rlink' in linker_name:
+            return linkers.CcrxLinker(linker)
+        if out.startswith('GNU ar') and 'xc16-ar' in linker_name:
+            return linkers.Xc16Linker(linker)
+        if 'Texas Instruments Incorporated' in out:
+            if 'ar2000' in linker_name:
+                return linkers.C2000Linker(linker)
+            else:
+                return linkers.TILinker(linker)
         if out.startswith('The CompCert'):
-            return CompCertLinker(linker)
+            return linkers.CompCertLinker(linker)
         if p.returncode == 0:
-            return ArLinker(linker)
+            return linkers.ArLinker(compiler.for_machine, linker)
         if p.returncode == 1 and err.startswith('usage'): # OSX
-            return ArLinker(linker)
+            return linkers.AppleArLinker(compiler.for_machine, linker)
         if p.returncode == 1 and err.startswith('Usage'): # AIX
-            return AIXArLinker(linker)
+            return linkers.AIXArLinker(linker)
         if p.returncode == 1 and err.startswith('ar: bad option: --'): # Solaris
-            return ArLinker(linker)
-    _handle_exceptions(popen_exceptions, linkers, 'linker')
+            return linkers.ArLinker(compiler.for_machine, linker)
+    _handle_exceptions(popen_exceptions, trials, 'linker')
+    raise EnvironmentException('Unreachable code (exception to make mypy happy)')
 
 
 # Compilers
@@ -350,6 +257,8 @@
     the compiler (GCC or Clang usually) as their shared linker, to find
     the linker they need.
     """
+    from . import c, cpp
+    from ..linkers import linkers
     popen_exceptions: T.Dictstr, T.UnionException, str = {}
     compilers, ccache, exe_wrap = _get_compilers(env, lang, for_machine)
     if override_compiler is not None:
@@ -378,9 +287,9 @@
                     return os.path.normcase(os.path.abspath(p))
 
                 watcom_cls = sanitize(os.path.join(os.environ'WATCOM', 'BINNT', 'cl')),
-                                sanitize(os.path.join(os.environ'WATCOM', 'BINNT', 'cl.exe')),
-                                sanitize(os.path.join(os.environ'WATCOM', 'BINNT64', 'cl')),
-                                sanitize(os.path.join(os.environ'WATCOM', 'BINNT64', 'cl.exe')),
+                              sanitize(os.path.join(os.environ'WATCOM', 'BINNT', 'cl.exe')),
+                              sanitize(os.path.join(os.environ'WATCOM', 'BINNT64', 'cl')),
+                              sanitize(os.path.join(os.environ'WATCOM', 'BINNT64', 'cl.exe'))
                 found_cl = sanitize(shutil.which('cl'))
                 if found_cl in watcom_cls:
                     mlog.debug('Skipping unsupported cl.exe clone at:', found_cl)
@@ -394,7 +303,8 @@
             arg = '--version'
         elif 'ccomp' in compiler_name:
             arg = '-version'
-        elif 'cl2000' in compiler_name:
+        elif compiler_name in {'cl2000', 'cl2000.exe', 'cl430', 'cl430.exe', 'armcl', 'armcl.exe'}:
+            # TI compiler
             arg = '-version'
         elif compiler_name in {'icl', 'icl.exe'}:
             # if you pass anything to icl you get stuck in a pager
@@ -402,10 +312,16 @@
         else:
             arg = '--version'
 
+        cmd = compiler + arg
         try:
-            p, out, err = Popen_safe(compiler + arg)
+            mlog.debug('-----')
+            mlog.debug(f'Detecting compiler via: {join_args(cmd)}')
+            p, out, err = Popen_safe(cmd)
+            mlog.debug(f'compiler returned {p}')
+            mlog.debug(f'compiler stdout:\n{out}')
+            mlog.debug(f'compiler stderr:\n{err}')
         except OSError as e:
-            popen_exceptions' '.join(compiler + arg) = e
+            popen_exceptionsjoin_args(cmd) = e
             continue
 
         if 'ccrx' in compiler_name:
@@ -426,42 +342,53 @@
         if guess_gcc_or_lcc:
             defines = _get_gnu_compiler_defines(compiler)
             if not defines:
-                popen_exceptions' '.join(compiler) = 'no pre-processor defines'
+                popen_exceptionsjoin_args(compiler) = 'no pre-processor defines'
                 continue
 
             if guess_gcc_or_lcc == 'lcc':
                 version = _get_lcc_version_from_defines(defines)
-                cls = ElbrusCCompiler if lang == 'c' else ElbrusCPPCompiler
+                cls = c.ElbrusCCompiler if lang == 'c' else cpp.ElbrusCPPCompiler
             else:
                 version = _get_gnu_version_from_defines(defines)
-                cls = GnuCCompiler if lang == 'c' else GnuCPPCompiler
+                cls = c.GnuCCompiler if lang == 'c' else cpp.GnuCPPCompiler
 
-            linker = guess_nix_linker(env, compiler, cls, for_machine)
+            linker = guess_nix_linker(env, compiler, cls, version, for_machine)
 
             return cls(
-                ccache + compiler, version, for_machine, is_cross,
+                ccache, compiler, version, for_machine, is_cross,
                 info, exe_wrap, defines=defines, full_version=full_version,
                 linker=linker)
 
         if 'Emscripten' in out:
-            cls = EmscriptenCCompiler if lang == 'c' else EmscriptenCPPCompiler
+            cls = c.EmscriptenCCompiler if lang == 'c' else cpp.EmscriptenCPPCompiler
             env.coredata.add_lang_args(cls.language, cls, for_machine, env)
 
             # emcc requires a file input in order to pass arguments to the
             # linker. It'll exit with an error code, but still print the
-            # linker version. Old emcc versions ignore -Wl,--version completely,
-            # however. We'll report "unknown version" in that case.
+            # linker version.
             with tempfile.NamedTemporaryFile(suffix='.c') as f:
                 cmd = compiler + cls.LINKER_PREFIX + "--version", f.name
                 _, o, _ = Popen_safe(cmd)
 
-            linker = WASMDynamicLinker(
+            linker = linkers.WASMDynamicLinker(
                 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, info,
                 exe_wrap, linker=linker, full_version=full_version)
 
+        if 'Arm C/C++/Fortran Compiler' in out:
+            arm_ver_match = re.search(r'version (\d+)\.(\d+)\.?(\d+)? $build number (\d+)$', out)
+            assert arm_ver_match is not None, 'for mypy'  # because mypy *should* be complaning that this could be None
+            version = '.'.join(x for x in arm_ver_match.groups() if x is not None)
+            if lang == 'c':
+                cls = c.ArmLtdClangCCompiler
+            elif lang == 'cpp':
+                cls = cpp.ArmLtdClangCPPCompiler
+            linker = guess_nix_linker(env, compiler, cls, version, for_machine)
+            return cls(
+                ccache, compiler, version, for_machine, is_cross, info,
+                exe_wrap, linker=linker)
         if 'armclang' in out:
             # The compiler version is not present in the first line of output,
             # instead it is present in second line, startswith 'Component:'.
@@ -470,17 +397,17 @@
             # output format in future versions
             arm_ver_match = re.search('.*Component.*', out)
             if arm_ver_match is None:
-                popen_exceptions' '.join(compiler) = 'version string not found'
+                popen_exceptionsjoin_args(compiler) = 'version string not found'
                 continue
             arm_ver_str = arm_ver_match.group(0)
             # Override previous values
             version = search_version(arm_ver_str)
             full_version = arm_ver_str
-            cls = ArmclangCCompiler if lang == 'c' else ArmclangCPPCompiler
-            linker = ArmClangDynamicLinker(for_machine, version=version)
+            cls = c.ArmclangCCompiler if lang == 'c' else cpp.ArmclangCPPCompiler
+            linker = linkers.ArmClangDynamicLinker(for_machine, version=version)
             env.coredata.add_lang_args(cls.language, cls, for_machine, env)
             return cls(
-                ccache + compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, info,
                 exe_wrap, 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
@@ -489,15 +416,15 @@
             try:
                 p, out, err = Popen_safe(compiler + arg)
             except OSError as e:
-                popen_exceptions' '.join(compiler + arg) = e
+                popen_exceptionsjoin_args(compiler + arg) = e
             version = search_version(out)
             match = re.search('^Target: (.*?)-', out, re.MULTILINE)
             if match:
                 target = match.group(1)
             else:
                 target = 'unknown target'
-            cls = ClangClCCompiler if lang == 'c' else ClangClCPPCompiler
-            linker = guess_win_linker(env, 'lld-link', cls, for_machine)
+            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,
                 exe_wrap, linker=linker)
@@ -509,31 +436,40 @@
             # Even if the for_machine is darwin, we could be using vanilla
             # clang.
             if 'Apple' in out:
-                cls = AppleClangCCompiler if lang == 'c' else AppleClangCPPCompiler
+                cls = c.AppleClangCCompiler if lang == 'c' else cpp.AppleClangCPPCompiler
             else:
-                cls = ClangCCompiler if lang == 'c' else ClangCPPCompiler
+                cls = c.ClangCCompiler if lang == 'c' else cpp.ClangCPPCompiler
 
             if 'windows' in out or env.machinesfor_machine.is_windows():
                 # If we're in a MINGW context this actually will use a gnu
                 # style ld, but for clang on "real" windows we'll use
                 # either link.exe or lld-link.exe
                 try:
-                    linker = guess_win_linker(env, compiler, cls, for_machine, invoked_directly=False)
+                    linker = guess_win_linker(env, compiler, cls, version, for_machine, invoked_directly=False)
                 except MesonException:
                     pass
             if linker is None:
-                linker = guess_nix_linker(env, compiler, cls, for_machine)
+                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, info,
                 exe_wrap, defines=defines, full_version=full_version, linker=linker)
 
         if 'Intel(R) C++ Intel(R)' in err:
             version = search_version(err)
             target = 'x86' if 'IA-32' in err else 'x86_64'
-            cls = IntelClCCompiler if lang == 'c' else IntelClCPPCompiler
+            cls = c.IntelClCCompiler if lang == 'c' else cpp.IntelClCPPCompiler
+            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            linker = linkers.XilinkDynamicLinker(for_machine, , version=version)
+            return cls(
+                compiler, version, for_machine, is_cross, info, target,
+                exe_wrap, linker=linker)
+        if 'Intel(R) oneAPI DPC++/C++ Compiler for applications' in err:
+            version = search_version(err)
+            target = 'x86' if 'IA-32' in err else 'x86_64'
+            cls = c.IntelLLVMClCCompiler if lang == 'c' else cpp.IntelLLVMClCPPCompiler
             env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-            linker = XilinkDynamicLinker(for_machine, , version=version)
+            linker = linkers.XilinkDynamicLinker(for_machine, , version=version)
             return cls(
                 compiler, version, for_machine, is_cross, info, target,
                 exe_wrap, linker=linker)
@@ -548,80 +484,90 @@
                     break
             else:
                 raise EnvironmentException(f'Failed to detect MSVC compiler version: stderr was\n{err!r}')
-            cl_signature = lookat.split('\n')0
+            cl_signature = lookat.split('\n', maxsplit=1)0
             match = re.search(r'.*(x86|x64|ARM|ARM64)(^_A-Za-z0-9|$)', cl_signature)
             if match:
                 target = match.group(1)
             else:
                 m = f'Failed to detect MSVC compiler target architecture: \'cl /?\' output is\n{cl_signature}'
                 raise EnvironmentException(m)
-            cls = VisualStudioCCompiler if lang == 'c' else VisualStudioCPPCompiler
-            linker = guess_win_linker(env, 'link', cls, for_machine)
+            cls = c.VisualStudioCCompiler if lang == 'c' else cpp.VisualStudioCPPCompiler
+            linker = guess_win_linker(env, 'link', cls, version, for_machine)
             # As of this writing, CCache does not support MSVC but sccache does.
-            if 'sccache' in ccache:
-                final_compiler = ccache + compiler
-            else:
-                final_compiler = compiler
+            if 'sccache' not in ccache:
+                ccache = 
             return cls(
-                final_compiler, version, for_machine, is_cross, info, target,
+                ccache, compiler, version, for_machine, is_cross, info, target,
                 exe_wrap, full_version=cl_signature, linker=linker)
         if 'PGI Compilers' in out:
-            cls = PGICCompiler if lang == 'c' else PGICPPCompiler
+            cls = c.PGICCompiler if lang == 'c' else cpp.PGICPPCompiler
             env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-            linker = PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, , version=version)
+            linker = linkers.PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, , version=version)
             return cls(
-                ccache + compiler, version, for_machine, is_cross,
+                ccache, compiler, version, for_machine, is_cross,
                 info, exe_wrap, linker=linker)
         if 'NVIDIA Compilers and Tools' in out:
-            cls = NvidiaHPC_CCompiler if lang == 'c' else NvidiaHPC_CPPCompiler
+            cls = c.NvidiaHPC_CCompiler if lang == 'c' else cpp.NvidiaHPC_CPPCompiler
             env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-            linker = NvidiaHPC_DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, , version=version)
+            linker = linkers.NvidiaHPC_DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, , version=version)
             return cls(
-                ccache + compiler, version, for_machine, is_cross,
+                ccache, compiler, version, for_machine, is_cross,
                 info, exe_wrap, linker=linker)
         if '(ICC)' in out:
-            cls = IntelCCompiler if lang == 'c' else IntelCPPCompiler
-            l = guess_nix_linker(env, compiler, cls, for_machine)
+            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, info,
                 exe_wrap, 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,
+                exe_wrap, full_version=full_version, linker=l)
+        if 'TMS320C2000 C/C++' in out or 'MSP430 C/C++' in out or 'TI ARM C/C++ Compiler' in out:
+            lnk: T.UnionT.Typelinkers.C2000DynamicLinker, T.Typelinkers.TIDynamicLinker
+            if 'TMS320C2000 C/C++' in out:
+                cls = c.C2000CCompiler if lang == 'c' else cpp.C2000CPPCompiler
+                lnk = linkers.C2000DynamicLinker
+            else:
+                cls = c.TICCompiler if lang == 'c' else cpp.TICPPCompiler
+                lnk = linkers.TIDynamicLinker
+
+            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            linker = lnk(compiler, for_machine, version=version)
+            return cls(
+                ccache, compiler, version, for_machine, is_cross, info,
+                exe_wrap, full_version=full_version, linker=linker)
         if 'ARM' in out:
-            cls = ArmCCompiler if lang == 'c' else ArmCPPCompiler
+            cls = c.ArmCCompiler if lang == 'c' else cpp.ArmCPPCompiler
             env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-            linker = ArmDynamicLinker(for_machine, version=version)
+            linker = linkers.ArmDynamicLinker(for_machine, version=version)
             return cls(
-                ccache + compiler, version, for_machine, is_cross,
+                ccache, compiler, version, for_machine, is_cross,
                 info, exe_wrap, full_version=full_version, linker=linker)
         if 'RX Family' in out:
-            cls = CcrxCCompiler if lang == 'c' else CcrxCPPCompiler
+            cls = c.CcrxCCompiler if lang == 'c' else cpp.CcrxCPPCompiler
             env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-            linker = CcrxDynamicLinker(for_machine, version=version)
+            linker = linkers.CcrxDynamicLinker(for_machine, version=version)
             return cls(
-                ccache + compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, info,
                 exe_wrap, full_version=full_version, linker=linker)
 
         if 'Microchip Technology' in out:
-            cls = Xc16CCompiler if lang == 'c' else Xc16CCompiler
+            cls = c.Xc16CCompiler
             env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-            linker = Xc16DynamicLinker(for_machine, version=version)
+            linker = linkers.Xc16DynamicLinker(for_machine, version=version)
             return cls(
-                ccache + compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, info,
                 exe_wrap, full_version=full_version, linker=linker)
 
         if 'CompCert' in out:
-            cls = CompCertCCompiler
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-            linker = CompCertDynamicLinker(for_machine, version=version)
-            return cls(
-                ccache + compiler, version, for_machine, is_cross, info,
-                exe_wrap, full_version=full_version, linker=linker)
-
-        if 'TMS320C2000 C/C++' in out:
-            cls = C2000CCompiler if lang == 'c' else C2000CPPCompiler
+            cls = c.CompCertCCompiler
             env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-            linker = C2000DynamicLinker(compiler, for_machine, version=version)
+            linker = linkers.CompCertDynamicLinker(for_machine, version=version)
             return cls(
-                ccache + compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, info,
                 exe_wrap, full_version=full_version, linker=linker)
 
     _handle_exceptions(popen_exceptions, compilers)
@@ -634,6 +580,8 @@
     return _detect_c_or_cpp_compiler(env, 'cpp', for_machine)
 
 def detect_cuda_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
+    from .cuda import CudaCompiler
+    from ..linkers.linkers import CudaLinker
     popen_exceptions = {}
     is_cross = env.is_cross_build(for_machine)
     compilers, ccache, exe_wrap = _get_compilers(env, 'cuda', for_machine)
@@ -643,7 +591,7 @@
         try:
             p, out, err = Popen_safe(compiler + arg)
         except OSError as e:
-            popen_exceptions' '.join(compiler + arg) = e
+            popen_exceptionsjoin_args(compiler + arg) = e
             continue
         # Example nvcc printout:
         #
@@ -660,15 +608,17 @@
         #    - CUDA Toolkit 8.0.61 requires NVIDIA Driver 375.26
         # Luckily, the "V" also makes it very simple to extract
         # the full version:
-        version = out.strip().split('V')-1
+        version = out.strip().rsplit('V', maxsplit=1)-1
         cpp_compiler = detect_cpp_compiler(env, for_machine)
         cls = CudaCompiler
         env.coredata.add_lang_args(cls.language, cls, for_machine, env)
         linker = CudaLinker(compiler, for_machine, CudaCompiler.LINKER_PREFIX, , version=CudaLinker.parse_version())
-        return cls(ccache + compiler, version, for_machine, is_cross, exe_wrap, host_compiler=cpp_compiler, info=info, linker=linker)
+        return cls(ccache, compiler, version, for_machine, is_cross, exe_wrap, host_compiler=cpp_compiler, info=info, 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:
+    from . import fortran
+    from ..linkers import linkers
     popen_exceptions: T.Dictstr, T.UnionException, str = {}
     compilers, ccache, exe_wrap = _get_compilers(env, 'fortran', for_machine)
     is_cross = env.is_cross_build(for_machine)
@@ -679,7 +629,7 @@
             try:
                 p, out, err = Popen_safe(compiler + arg)
             except OSError as e:
-                popen_exceptions' '.join(compiler + arg) = e
+                popen_exceptionsjoin_args(compiler + arg) = e
                 continue
 
             version = search_version(out)
@@ -694,97 +644,126 @@
             if guess_gcc_or_lcc:
                 defines = _get_gnu_compiler_defines(compiler)
                 if not defines:
-                    popen_exceptions' '.join(compiler) = 'no pre-processor defines'
+                    popen_exceptionsjoin_args(compiler) = 'no pre-processor defines'
                     continue
                 if guess_gcc_or_lcc == 'lcc':
                     version = _get_lcc_version_from_defines(defines)
-                    cls = ElbrusFortranCompiler
-                    linker = guess_nix_linker(env, compiler, cls, for_machine)
+                    cls = fortran.ElbrusFortranCompiler
+                    linker = guess_nix_linker(env, compiler, cls, version, for_machine)
                     return cls(
                         compiler, version, for_machine, is_cross, info,
                         exe_wrap, defines, full_version=full_version, linker=linker)
                 else:
                     version = _get_gnu_version_from_defines(defines)
-                    cls = GnuFortranCompiler
-                    linker = guess_nix_linker(env, compiler, cls, for_machine)
+                    cls = fortran.GnuFortranCompiler
+                    linker = guess_nix_linker(env, compiler, cls, version, for_machine)
                     return cls(
                         compiler, version, for_machine, is_cross, info,
                         exe_wrap, defines, full_version=full_version, linker=linker)
 
+            if 'Arm C/C++/Fortran Compiler' in out:
+                cls = fortran.ArmLtdFlangFortranCompiler
+                arm_ver_match = re.search(r'version (\d+)\.(\d+)\.?(\d+)? $build number (\d+)$', out)
+                assert arm_ver_match is not None, 'for mypy'  # because mypy *should* be complaning that this could be None
+                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,
+                    exe_wrap, linker=linker)
             if 'G95' in out:
-                cls = G95FortranCompiler
-                linker = guess_nix_linker(env, compiler, cls, for_machine)
-                return G95FortranCompiler(
+                cls = fortran.G95FortranCompiler
+                linker = guess_nix_linker(env, compiler, cls, version, for_machine)
+                return cls(
                     compiler, version, for_machine, is_cross, info,
                     exe_wrap, full_version=full_version, linker=linker)
 
             if 'Sun Fortran' in err:
                 version = search_version(err)
-                cls = SunFortranCompiler
-                linker = guess_nix_linker(env, compiler, cls, for_machine)
-                return SunFortranCompiler(
+                cls = fortran.SunFortranCompiler
+                linker = guess_nix_linker(env, compiler, cls, version, for_machine)
+                return cls(
                     compiler, version, for_machine, is_cross, info,
                     exe_wrap, full_version=full_version, linker=linker)
 
+            if 'Intel(R) Fortran Compiler for applications' in err:
+                version = search_version(err)
+                target = 'x86' if 'IA-32' in err else 'x86_64'
+                cls = fortran.IntelLLVMClFortranCompiler
+                env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+                linker = linkers.XilinkDynamicLinker(for_machine, , version=version)
+                return cls(
+                    compiler, version, for_machine, is_cross, info,
+                    target, exe_wrap, linker=linker)
+
             if 'Intel(R) Visual Fortran' in err or 'Intel(R) Fortran' in err:
                 version = search_version(err)
                 target = 'x86' if 'IA-32' in err else 'x86_64'
-                cls = IntelClFortranCompiler
+                cls = fortran.IntelClFortranCompiler
                 env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-                linker = XilinkDynamicLinker(for_machine, , version=version)
+                linker = linkers.XilinkDynamicLinker(for_machine, , version=version)
                 return cls(
                     compiler, version, for_machine, is_cross, info,
                     target, exe_wrap, linker=linker)
 
             if 'ifort (IFORT)' in out:
-                linker = guess_nix_linker(env, compiler, IntelFortranCompiler, for_machine)
-                return IntelFortranCompiler(
+                cls = fortran.IntelFortranCompiler
+                linker = guess_nix_linker(env, compiler, cls, version, for_machine)
+                return cls(
+                    compiler, version, for_machine, is_cross, info,
+                    exe_wrap, full_version=full_version, linker=linker)
+
+            if 'ifx (IFORT)' in out:
+                cls = fortran.IntelLLVMFortranCompiler
+                linker = guess_nix_linker(env, compiler, cls, version, for_machine)
+                return cls(
                     compiler, version, for_machine, is_cross, info,
                     exe_wrap, full_version=full_version, linker=linker)
 
             if 'PathScale EKOPath(tm)' in err:
-                return PathScaleFortranCompiler(
+                return fortran.PathScaleFortranCompiler(
                     compiler, version, for_machine, is_cross, info,
                     exe_wrap, full_version=full_version)
 
             if 'PGI Compilers' in out:
-                cls = PGIFortranCompiler
+                cls = fortran.PGIFortranCompiler
                 env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-                linker = PGIDynamicLinker(compiler, for_machine,
-                                            cls.LINKER_PREFIX, , version=version)
+                linker = linkers.PGIDynamicLinker(compiler, for_machine,
+                                                  cls.LINKER_PREFIX, , version=version)
                 return cls(
                     compiler, version, for_machine, is_cross, info, exe_wrap,
                     full_version=full_version, linker=linker)
 
             if 'NVIDIA Compilers and Tools' in out:
-                cls = NvidiaHPC_FortranCompiler
+                cls = fortran.NvidiaHPC_FortranCompiler
                 env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-                linker = PGIDynamicLinker(compiler, for_machine,
-                                            cls.LINKER_PREFIX, , version=version)
+                linker = linkers.PGIDynamicLinker(compiler, for_machine,
+                                                  cls.LINKER_PREFIX, , version=version)
                 return cls(
                     compiler, version, for_machine, is_cross, info, exe_wrap,
                     full_version=full_version, linker=linker)
 
             if 'flang' in out or 'clang' in out:
+                cls = fortran.FlangFortranCompiler
                 linker = guess_nix_linker(env,
-                    compiler, FlangFortranCompiler, for_machine)
-                return FlangFortranCompiler(
+                                          compiler, cls, version, for_machine)
+                return cls(
                     compiler, version, for_machine, is_cross, info,
                     exe_wrap, full_version=full_version, linker=linker)
 
             if 'Open64 Compiler Suite' in err:
+                cls = fortran.Open64FortranCompiler
                 linker = guess_nix_linker(env,
-                    compiler, Open64FortranCompiler, for_machine)
-                return Open64FortranCompiler(
+                                          compiler, cls, version, for_machine)
+                return cls(
                     compiler, version, for_machine, is_cross, info,
                     exe_wrap, full_version=full_version, linker=linker)
 
             if 'NAG Fortran' in err:
                 full_version = err.split('\n', 1)0
                 version = full_version.split()-1
-                cls = NAGFortranCompiler
+                cls = fortran.NAGFortranCompiler
                 env.coredata.add_lang_args(cls.language, cls, for_machine, env)
-                linker = NAGDynamicLinker(
+                linker = linkers.NAGDynamicLinker(
                     compiler, for_machine, cls.LINKER_PREFIX, ,
                     version=version)
                 return cls(
@@ -795,63 +774,65 @@
     raise EnvironmentException('Unreachable code (exception to make mypy happy)')
 
 def detect_objc_compiler(env: 'Environment', for_machine: MachineChoice) -> 'Compiler':
-    return _detect_objc_or_objcpp_compiler(env, for_machine, True)
+    return _detect_objc_or_objcpp_compiler(env, 'objc', for_machine)
 
 def detect_objcpp_compiler(env: 'Environment', for_machine: MachineChoice) -> 'Compiler':
-    return _detect_objc_or_objcpp_compiler(env, for_machine, False)
+    return _detect_objc_or_objcpp_compiler(env, 'objcpp', for_machine)
 
-def _detect_objc_or_objcpp_compiler(env: 'Environment', for_machine: MachineChoice, objc: bool) -> 'Compiler':
+def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine: MachineChoice) -> 'Compiler':
+    from . import objc, objcpp
     popen_exceptions: T.Dictstr, T.UnionException, str = {}
-    compilers, ccache, exe_wrap = _get_compilers(env, 'objc' if objc else 'objcpp', for_machine)
+    compilers, ccache, exe_wrap = _get_compilers(env, lang, for_machine)
     is_cross = env.is_cross_build(for_machine)
     info = env.machinesfor_machine
-    comp: T.UnionT.TypeObjCCompiler, T.TypeObjCPPCompiler
+    comp: T.UnionT.Typeobjc.ObjCCompiler, T.Typeobjcpp.ObjCPPCompiler
 
     for compiler in compilers:
         arg = '--version'
         try:
             p, out, err = Popen_safe(compiler + arg)
         except OSError as e:
-            popen_exceptions' '.join(compiler + arg) = e
+            popen_exceptionsjoin_args(compiler + arg) = e
             continue
         version = search_version(out)
         if 'Free Software Foundation' in out:
             defines = _get_gnu_compiler_defines(compiler)
             if not defines:
-                popen_exceptions' '.join(compiler) = 'no pre-processor defines'
+                popen_exceptionsjoin_args(compiler) = 'no pre-processor defines'
                 continue
             version = _get_gnu_version_from_defines(defines)
-            comp = GnuObjCCompiler if objc else GnuObjCPPCompiler
-            linker = guess_nix_linker(env, compiler, comp, for_machine)
+            comp = objc.GnuObjCCompiler if lang == 'objc' else objcpp.GnuObjCPPCompiler
+            linker = guess_nix_linker(env, compiler, comp, version, for_machine)
             return comp(
-                ccache + compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, info,
                 exe_wrap, defines, linker=linker)
         if 'clang' in out:
             linker = None
             defines = _get_clang_compiler_defines(compiler)
             if not defines:
-                popen_exceptions' '.join(compiler) = 'no pre-processor defines'
+                popen_exceptionsjoin_args(compiler) = 'no pre-processor defines'
                 continue
             if 'Apple' in out:
-                comp = AppleClangObjCCompiler if objc else AppleClangObjCPPCompiler
+                comp = objc.AppleClangObjCCompiler if lang == 'objc' else objcpp.AppleClangObjCPPCompiler
             else:
-                comp = ClangObjCCompiler if objc else ClangObjCPPCompiler
+                comp = objc.ClangObjCCompiler if lang == 'objc' else objcpp.ClangObjCPPCompiler
             if 'windows' in out or env.machinesfor_machine.is_windows():
                 # If we're in a MINGW context this actually will use a gnu style ld
                 try:
-                    linker = guess_win_linker(env, compiler, comp, for_machine)
+                    linker = guess_win_linker(env, compiler, comp, version, for_machine)
                 except MesonException:
                     pass
 
             if not linker:
-                linker = guess_nix_linker(env, compiler, comp, for_machine)
+                linker = guess_nix_linker(env, compiler, comp, version, for_machine)
             return comp(
-                ccache + compiler, version, for_machine,
+                ccache, compiler, version, for_machine,
                 is_cross, info, exe_wrap, 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.machinesfor_machine
     if exelist is None:
@@ -861,7 +842,7 @@
     try:
         p, out, err = Popen_safe(exelist + '-version')
     except OSError:
-        raise EnvironmentException('Could not execute Java compiler "{}"'.format(' '.join(exelist)))
+        raise EnvironmentException('Could not execute Java compiler: {}'.format(join_args(exelist)))
     if 'javac' in out or 'javac' in err:
         version = search_version(err if 'javac' in err else out)
         if not version or version == 'unknown version':
@@ -871,9 +852,10 @@
         comp_class = JavaCompiler
         env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
         return comp_class(exelist, version, for_machine, info)
-    raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
+    raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
 
 def detect_cs_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
+    from . import cs
     compilers, ccache, exe_wrap = _get_compilers(env, 'cs', for_machine)
     popen_exceptions = {}
     info = env.machinesfor_machine
@@ -881,15 +863,15 @@
         try:
             p, out, err = Popen_safe(comp + '--version')
         except OSError as e:
-            popen_exceptions' '.join(comp + '--version') = e
+            popen_exceptionsjoin_args(comp + '--version') = e
             continue
 
         version = search_version(out)
-        cls: T.UnionT.TypeMonoCompiler, T.TypeVisualStudioCsCompiler
+        cls: T.Typecs.CsCompiler
         if 'Mono' in out:
-            cls = MonoCompiler
+            cls = cs.MonoCompiler
         elif "Visual C#" in out:
-            cls = VisualStudioCsCompiler
+            cls = cs.VisualStudioCsCompiler
         else:
             continue
         env.coredata.add_lang_args(cls.language, cls, for_machine, env)
@@ -900,7 +882,8 @@
 
 def detect_cython_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
     """Search for a cython compiler."""
-    compilers, _, _ = _get_compilers(env, 'cython', for_machine)
+    from .cython import CythonCompiler
+    compilers, _, _ = _get_compilers(env, 'cython', MachineChoice.BUILD)
     is_cross = env.is_cross_build(for_machine)
     info = env.machinesfor_machine
 
@@ -909,19 +892,20 @@
         try:
             err = Popen_safe(comp + '-V')2
         except OSError as e:
-            popen_exceptions' '.join(comp + '-V') = e
+            popen_exceptionsjoin_args(comp + '-V') = e
             continue
 
         version = search_version(err)
         if 'Cython' in err:
             comp_class = CythonCompiler
             env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
-            return comp_class(comp, version, for_machine, info, is_cross=is_cross)
+            return comp_class(, comp, version, for_machine, info, is_cross=is_cross)
     _handle_exceptions(popen_exceptions, compilers)
     raise EnvironmentException('Unreachable code (exception to make mypy happy)')
 
 def detect_vala_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
-    exelist = env.lookup_binary_entry(for_machine, 'vala')
+    from .vala import ValaCompiler
+    exelist = env.lookup_binary_entry(MachineChoice.BUILD, 'vala')
     is_cross = env.is_cross_build(for_machine)
     info = env.machinesfor_machine
     if exelist is None:
@@ -931,22 +915,24 @@
     try:
         p, out = Popen_safe(exelist + '--version')0:2
     except OSError:
-        raise EnvironmentException('Could not execute Vala compiler "{}"'.format(' '.join(exelist)))
+        raise EnvironmentException('Could not execute Vala compiler: {}'.format(join_args(exelist)))
     version = search_version(out)
     if 'Vala' in out:
         comp_class = ValaCompiler
         env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
         return comp_class(exelist, version, for_machine, is_cross, info)
-    raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
+    raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
 
 def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> RustCompiler:
+    from . import rust
+    from ..linkers import linkers
     popen_exceptions = {}  # type: T.Dictstr, Exception
     compilers, _, exe_wrap = _get_compilers(env, 'rust', for_machine)
     is_cross = env.is_cross_build(for_machine)
     info = env.machinesfor_machine
 
     cc = detect_c_compiler(env, for_machine)
-    is_link_exe = isinstance(cc.linker, VisualStudioLikeLinkerMixin)
+    is_link_exe = isinstance(cc.linker, linkers.VisualStudioLikeLinkerMixin)
     override = env.lookup_binary_entry(for_machine, 'rust_ld')
 
     for compiler in compilers:
@@ -954,17 +940,17 @@
         try:
             out = Popen_safe(compiler + arg)1
         except OSError as e:
-            popen_exceptions' '.join(compiler + arg) = e
+            popen_exceptionsjoin_args(compiler + arg) = e
             continue
 
         version = search_version(out)
-        cls: T.TypeRustCompiler = RustCompiler
+        cls: T.TypeRustCompiler = rust.RustCompiler
 
         # Clippy is a wrapper around rustc, but it doesn't have rustc in it's
         # output. We can otherwise treat it as rustc.
         if 'clippy' in out:
             out = 'rustc'
-            cls = ClippyRustCompiler
+            cls = rust.ClippyRustCompiler
 
         if 'rustc' in out:
             # On Linux and mac rustc will invoke gcc (clang for mac
@@ -989,7 +975,7 @@
                 extra_args: T.Dictstr, T.Unionstr, bool = {}
                 always_args: T.Liststr = 
                 if is_link_exe:
-                    compiler.extend(cls.use_linker_args(cc.linker.exelist0))
+                    compiler.extend(cls.use_linker_args(cc.linker.exelist0, ''))
                     extra_args'direct' = True
                     extra_args'machine' = cc.linker.machine
                 else:
@@ -997,7 +983,7 @@
                     if 'ccache' in exelist0:
                         del exelist0
                     c = exelist.pop(0)
-                    compiler.extend(cls.use_linker_args(c))
+                    compiler.extend(cls.use_linker_args(c, ''))
 
                     # Also ensure that we pass any extra arguments to the linker
                     for l in exelist:
@@ -1006,21 +992,22 @@
                 # This trickery with type() gets us the class of the linker
                 # so we can initialize a new copy for the Rust Compiler
                 # TODO rewrite this without type: ignore
+                assert cc.linker is not None, 'for mypy'
                 if is_link_exe:
                     linker = type(cc.linker)(for_machine, always_args, exelist=cc.linker.exelist,   # type: ignore
-                                                version=cc.linker.version, **extra_args)            # type: ignore
+                                             version=cc.linker.version, **extra_args)               # type: ignore
                 else:
                     linker = type(cc.linker)(compiler, for_machine, cc.LINKER_PREFIX,
-                                                always_args=always_args, version=cc.linker.version,
-                                                **extra_args)
+                                             always_args=always_args, version=cc.linker.version,
+                                             **extra_args)
             elif 'link' in override0:
                 linker = guess_win_linker(env,
-                    override, cls, for_machine, use_linker_prefix=False)
+                                          override, cls, version, for_machine, use_linker_prefix=False)
                 # rustc takes linker arguments without a prefix, and
                 # inserts the correct prefix itself.
-                assert isinstance(linker, VisualStudioLikeLinkerMixin)
+                assert isinstance(linker, linkers.VisualStudioLikeLinkerMixin)
                 linker.direct = True
-                compiler.extend(cls.use_linker_args(linker.exelist0))
+                compiler.extend(cls.use_linker_args(linker.exelist0, ''))
             else:
                 # On linux and macos rust will invoke the c compiler for
                 # linking, on windows it will use lld-link or link.exe.
@@ -1032,7 +1019,7 @@
                 # Of course, we're not going to use any of that, we just
                 # need it to get the proper arguments to pass to rustc
                 c = linker.exelist1 if linker.exelist0.endswith('ccache') else linker.exelist0
-                compiler.extend(cls.use_linker_args(c))
+                compiler.extend(cls.use_linker_args(c, ''))
 
             env.coredata.add_lang_args(cls.language, cls, for_machine, env)
             return cls(
@@ -1043,12 +1030,13 @@
     raise EnvironmentException('Unreachable code (exception to make mypy happy)')
 
 def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
+    from . import c, d
     info = env.machinesfor_machine
 
     # Detect the target architecture, required for proper architecture handling on Windows.
     # MSVC compiler is required for correct platform detection.
     c_compiler = {'c': detect_c_compiler(env, for_machine)}
-    is_msvc = isinstance(c_compiler'c', VisualStudioCCompiler)
+    is_msvc = isinstance(c_compiler'c', c.VisualStudioCCompiler)
     if not is_msvc:
         c_compiler = {}
 
@@ -1061,6 +1049,7 @@
     popen_exceptions = {}
     is_cross = env.is_cross_build(for_machine)
     compilers, ccache, exe_wrap = _get_compilers(env, 'd', for_machine)
+    cls: T.Typed.DCompiler
     for exelist in compilers:
         # Search for a D compiler.
         # We prefer LDC over GDC unless overridden with the DC
@@ -1073,12 +1062,13 @@
         try:
             p, out = Popen_safe(exelist + '--version')0:2
         except OSError as e:
-            popen_exceptions' '.join(exelist + '--version') = e
+            popen_exceptionsjoin_args(exelist + '--version') = e
             continue
         version = search_version(out)
         full_version = out.split('\n', 1)0
 
         if 'LLVM D compiler' in out:
+            cls = d.LLVMDCompiler
             # LDC seems to require a file
             # We cannot use NamedTemproraryFile on windows, its documented
             # to not work for our uses. So, just use mkstemp and only have
@@ -1090,31 +1080,33 @@
                 if info.is_windows() or info.is_cygwin():
                     objfile = os.path.basename(f):-1 + 'obj'
                     linker = guess_win_linker(env,
-                        exelist,
-                        LLVMDCompiler, for_machine,
-                        use_linker_prefix=True, invoked_directly=False,
-                        extra_args=f)
+                                              exelist,
+                                              cls, full_version, for_machine,
+                                              use_linker_prefix=True, invoked_directly=False,
+                                              extra_args=f)
                 else:
                     # LDC writes an object file to the current working directory.
                     # Clean it up.
                     objfile = os.path.basename(f):-1 + 'o'
                     linker = guess_nix_linker(env,
-                        exelist, LLVMDCompiler, for_machine,
-                        extra_args=f)
+                                              exelist, cls, full_version, for_machine,
+                                              extra_args=f)
             finally:
                 windows_proof_rm(f)
                 windows_proof_rm(objfile)
 
-            return LLVMDCompiler(
+            return cls(
                 exelist, version, for_machine, info, arch,
                 full_version=full_version, linker=linker, version_output=out)
         elif 'gdc' in out:
-            linker = guess_nix_linker(env, exelist, GnuDCompiler, for_machine)
-            return GnuDCompiler(
+            cls = d.GnuDCompiler
+            linker = guess_nix_linker(env, exelist, cls, version, for_machine)
+            return cls(
                 exelist, version, for_machine, info, arch,
                 exe_wrapper=exe_wrap, 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
             # DMD seems to require a file
             # We cannot use NamedTemproraryFile on windows, its documented
             # to not work for our uses. So, just use mkstemp and only have
@@ -1129,26 +1121,27 @@
                 if info.is_windows() or info.is_cygwin():
                     objfile = os.path.basename(f):-1 + 'obj'
                     linker = guess_win_linker(env,
-                        exelist, DmdDCompiler, for_machine,
-                        invoked_directly=False, extra_args=f, arch_arg)
+                                              exelist, cls, full_version, for_machine,
+                                              invoked_directly=False, extra_args=f, arch_arg)
                 else:
                     objfile = os.path.basename(f):-1 + 'o'
                     linker = guess_nix_linker(env,
-                        exelist, DmdDCompiler, for_machine,
-                        extra_args=f, arch_arg)
+                                              exelist, cls, full_version, for_machine,
+                                              extra_args=f, arch_arg)
             finally:
                 windows_proof_rm(f)
                 windows_proof_rm(objfile)
 
-            return DmdDCompiler(
+            return cls(
                 exelist, version, for_machine, info, arch,
                 full_version=full_version, linker=linker)
-        raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
+        raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
 
     _handle_exceptions(popen_exceptions, compilers)
     raise EnvironmentException('Unreachable code (exception to make mypy happy)')
 
 def detect_swift_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
+    from .swift import SwiftCompiler
     exelist = env.lookup_binary_entry(for_machine, 'swift')
     is_cross = env.is_cross_build(for_machine)
     info = env.machinesfor_machine
@@ -1159,19 +1152,98 @@
     try:
         p, _, err = Popen_safe(exelist + '-v')
     except OSError:
-        raise EnvironmentException('Could not execute Swift compiler "{}"'.format(' '.join(exelist)))
+        raise EnvironmentException('Could not execute Swift compiler: {}'.format(join_args(exelist)))
     version = search_version(err)
     if 'Swift' in err:
         # As for 5.0.1 swiftc *requires* a file to check the linker:
         with tempfile.NamedTemporaryFile(suffix='.swift') as f:
+            cls = SwiftCompiler
             linker = guess_nix_linker(env,
-                exelist, SwiftCompiler, for_machine,
-                extra_args=f.name)
-        return SwiftCompiler(
+                                      exelist, cls, version, for_machine,
+                                      extra_args=f.name)
+        return cls(
             exelist, version, for_machine, is_cross, info, linker=linker)
 
-    raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
+    raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
+
+def detect_nasm_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
+    from .asm import NasmCompiler, YasmCompiler
+    compilers, _, _ = _get_compilers(env, 'nasm', for_machine)
+    is_cross = env.is_cross_build(for_machine)
+
+    # We need a C compiler to properly detect the machine info and linker
+    cc = detect_c_compiler(env, for_machine)
+    if not is_cross:
+        from ..environment import detect_machine_info
+        info = detect_machine_info({'c': cc})
+    else:
+        info = env.machinesfor_machine
+
+    popen_exceptions: T.Dictstr, Exception = {}
+    for comp in compilers:
+        if comp == 'nasm' and is_windows() and not shutil.which(comp0):
+            # nasm is not in PATH on Windows by default
+            default_path = os.path.join(os.environ'ProgramFiles', 'NASM')
+            comp0 = shutil.which(comp0, path=default_path) or comp0
+        try:
+            output = Popen_safe(comp + '--version')1
+        except OSError as e:
+            popen_exceptions' '.join(comp + '--version') = e
+            continue
+
+        version = search_version(output)
+        if 'NASM' in output:
+            comp_class = NasmCompiler
+            env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+            return comp_class(, comp, version, for_machine, info, cc.linker, is_cross=is_cross)
+        elif 'yasm' in output:
+            comp_class = YasmCompiler
+            env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+            return comp_class(, comp, version, for_machine, info, cc.linker, is_cross=is_cross)
+    _handle_exceptions(popen_exceptions, compilers)
+    raise EnvironmentException('Unreachable code (exception to make mypy happy)')
+
+def detect_masm_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
+    # We need a C compiler to properly detect the machine info and linker
+    is_cross = env.is_cross_build(for_machine)
+    cc = detect_c_compiler(env, for_machine)
+    if not is_cross:
+        from ..environment import detect_machine_info
+        info = detect_machine_info({'c': cc})
+    else:
+        info = env.machinesfor_machine
+
+    from .asm import MasmCompiler, MasmARMCompiler
+    comp_class: T.TypeCompiler
+    if info.cpu_family == 'x86':
+        comp = 'ml'
+        comp_class = MasmCompiler
+        arg = '/?'
+    elif info.cpu_family == 'x86_64':
+        comp = 'ml64'
+        comp_class = MasmCompiler
+        arg = '/?'
+    elif info.cpu_family == 'arm':
+        comp = 'armasm'
+        comp_class = MasmARMCompiler
+        arg = '-h'
+    elif info.cpu_family == 'aarch64':
+        comp = 'armasm64'
+        comp_class = MasmARMCompiler
+        arg = '-h'
+    else:
+        raise EnvironmentException(f'Platform {info.cpu_family} not supported by MASM')
 
+    popen_exceptions: T.Dictstr, Exception = {}
+    try:
+        output = Popen_safe(comp + arg)2
+        version = search_version(output)
+        env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+        return comp_class(, comp, version, for_machine, info, cc.linker, is_cross=is_cross)
+    except OSError as e:
+        popen_exceptions' '.join(comp + arg) = e
+    _handle_exceptions(popen_exceptions, comp)
+    raise EnvironmentException('Unreachable code (exception to make mypy happy)')
 
 # GNU/Clang defines and version
 # =============================
@@ -1183,9 +1255,12 @@
     # Arguments to output compiler pre-processor defines to stdout
     # gcc, g++, and gfortran all support these arguments
     args = compiler + '-E', '-dM', '-'
+    mlog.debug(f'Running command: {join_args(args)}')
     p, output, error = Popen_safe(args, write='', stdin=subprocess.PIPE)
     if p.returncode != 0:
-        raise EnvironmentException('Unable to detect GNU compiler type:\n' + output + error)
+        raise EnvironmentException('Unable to detect GNU compiler type:\n'
+                                   f'Compiler stdout:\n{output}\n-----\n'
+                                   f'Compiler stderr:\n{error}\n-----\n')
     # Parse several lines of the type:
     # `#define ___SOME_DEF some_value`
     # and extract `___SOME_DEF`
@@ -1207,9 +1282,12 @@
     Get the list of Clang pre-processor defines
     """
     args = compiler + '-E', '-dM', '-'
+    mlog.debug(f'Running command: {join_args(args)}')
     p, output, error = Popen_safe(args, write='', stdin=subprocess.PIPE)
     if p.returncode != 0:
-        raise EnvironmentException('Unable to get clang pre-processor defines:\n' + output + error)
+        raise EnvironmentException('Unable to get clang pre-processor defines:\n'
+                                   f'Compiler stdout:\n{output}\n-----\n'
+                                   f'Compiler stderr:\n{error}\n-----\n')
     defines: T.Dictstr, str = {}
     for line in output.split('\n'):
         if not line:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/fortran.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/fortran.py Changed

@@ -11,10 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
-from pathlib import Path
 import typing as T
-import subprocess, os
+import os
 
 from .. import coredata
 from .compilers import (
@@ -23,7 +23,7 @@
 )
 from .mixins.clike import CLikeCompiler
 from .mixins.gnu import (
-    GnuCompiler, gnulike_buildtype_args, gnu_optimization_args,
+    GnuCompiler, gnulike_buildtype_args, gnu_optimization_args
 )
 from .mixins.intel import IntelGnuLikeCompiler, IntelVisualStudioLikeCompiler
 from .mixins.clang import ClangCompiler
@@ -31,16 +31,17 @@
 from .mixins.pgi import PGICompiler
 
 from mesonbuild.mesonlib import (
-    version_compare, EnvironmentException, MesonException, MachineChoice,
+    version_compare, MesonException,
     LibType, OptionKey,
 )
 
 if T.TYPE_CHECKING:
-    from ..coredata import KeyedOptionDictType
+    from ..coredata import MutableKeyedOptionDictType, KeyedOptionDictType
     from ..dependencies import Dependency
     from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
     from ..programs import ExternalProgram
     from .compilers import CompileCheckMode
 
@@ -53,7 +54,7 @@
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        Compiler.__init__(self, exelist, version, for_machine, info,
+        Compiler.__init__(self, , exelist, version, for_machine, info,
                           is_cross=is_cross, full_version=full_version, linker=linker)
         CLikeCompiler.__init__(self, exe_wrapper)
 
@@ -65,41 +66,15 @@
                              "meson.get_compiler('fortran').links('block; end block; end program')\n\n"
                              'that example is to see if the compiler has Fortran 2008 Block element.')
 
-    def sanity_check(self, work_dir_: str, environment: 'Environment') -> None:
-        work_dir = Path(work_dir_)
-        source_name = work_dir / 'sanitycheckf.f90'
-        binary_name = work_dir / 'sanitycheckf'
-        if binary_name.is_file():
-            binary_name.unlink()
-
-        source_name.write_text('program main; print *, "Fortran compilation is working."; end program', encoding='utf-8')
-
-        extra_flags: T.Liststr = 
-        extra_flags += environment.coredata.get_external_args(self.for_machine, self.language)
-        extra_flags += environment.coredata.get_external_link_args(self.for_machine, self.language)
-        extra_flags += self.get_always_args()
-        # %% build the test executable "sanitycheckf"
-        # cwd=work_dir is necessary on Windows especially for Intel compilers to avoid error: cannot write on sanitycheckf.obj
-        # this is a defect with how Windows handles files and ifort's object file-writing behavior vis concurrent ProcessPoolExecutor.
-        # This simple workaround solves the issue.
-        returncode = subprocess.run(self.exelist + extra_flags + str(source_name), '-o', str(binary_name),
-                                    cwd=work_dir).returncode
-        if returncode != 0:
-            raise EnvironmentException('Compiler %s can not compile programs.' % self.name_string())
-        if self.is_cross:
-            if self.exe_wrapper is None:
-                # Can't check if the binaries run so we have to assume they do
-                return
-            cmdlist = self.exe_wrapper.get_command() + str(binary_name)
-        else:
-            cmdlist = str(binary_name)
-        # %% Run the test executable
-        try:
-            returncode = subprocess.run(cmdlist, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode
-            if returncode != 0:
-                raise EnvironmentException('Executables created by Fortran compiler %s are not runnable.' % self.name_string())
-        except OSError:
-            raise EnvironmentException('Executables created by Fortran compiler %s are not runnable.' % self.name_string())
+    def _get_basic_compiler_args(self, env: 'Environment', mode: CompileCheckMode) -> T.TupleT.Liststr, T.Liststr:
+        cargs = env.coredata.get_external_args(self.for_machine, self.language)
+        largs = env.coredata.get_external_link_args(self.for_machine, self.language)
+        return cargs, largs
+
+    def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+        source_name = 'sanitycheckf.f90'
+        code = 'program main; print *, "Fortran compilation is working."; end program\n'
+        return self._sanity_check_impl(work_dir, environment, source_name, code)
 
     def get_buildtype_args(self, buildtype: str) -> T.Liststr:
         return gnulike_buildtype_argsbuildtype
@@ -130,9 +105,9 @@
     def module_name_to_filename(self, module_name: str) -> str:
         if '_' in module_name:  # submodule
             s = module_name.lower()
-            if self.id in ('gcc', 'intel', 'intel-cl'):
+            if self.id in {'gcc', 'intel', 'intel-cl'}:
                 filename = s.replace('_', '@') + '.smod'
-            elif self.id in ('pgi', 'flang'):
+            elif self.id in {'pgi', 'flang'}:
                 filename = s.replace('_', '-') + '.mod'
             else:
                 filename = s + '.mod'
@@ -152,7 +127,7 @@
     def has_multi_link_arguments(self, args: T.Liststr, env: 'Environment') -> T.Tuplebool, bool:
         return self._has_multi_link_arguments(args, env, 'stop; end program')
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         opts.update({
@@ -180,9 +155,10 @@
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic', '-fimplicit-none'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic', '-fimplicit-none',
+                          'everything': default_warn_args + '-Wextra', '-Wpedantic', '-fimplicit-none'}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = FortranCompiler.get_options(self)
         fortran_stds = 'legacy', 'f95', 'f2003'
         if version_compare(self.version, '>=4.4.0'):
@@ -244,7 +220,7 @@
                                  info, exe_wrapper, linker=linker, full_version=full_version)
         ElbrusCompiler.__init__(self)
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = FortranCompiler.get_options(self)
         fortran_stds = 'f95', 'f2003', 'f2008', 'gnu', 'legacy', 'f2008ts'
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
@@ -258,6 +234,7 @@
 class G95FortranCompiler(FortranCompiler):
 
     LINKER_PREFIX = '-Wl,'
+    id = 'g95'
 
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
@@ -266,12 +243,12 @@
         FortranCompiler.__init__(self, exelist, version, for_machine,
                                  is_cross, info, exe_wrapper, linker=linker,
                                  full_version=full_version)
-        self.id = 'g95'
         default_warn_args = '-Wall'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-pedantic'}
+                          '3': default_warn_args + '-Wextra', '-pedantic',
+                          'everything': default_warn_args + '-Wextra', '-pedantic'}
 
     def get_module_outdir_args(self, path: str) -> T.Liststr:
         return '-fmod=' + path
@@ -284,15 +261,7 @@
 class SunFortranCompiler(FortranCompiler):
 
     LINKER_PREFIX = '-Wl,'
-
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
-                 linker: T.Optional'DynamicLinker' = None,
-                 full_version: T.Optionalstr = None):
-        FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, exe_wrapper, linker=linker,
-                                 full_version=full_version)
-        self.id = 'sun'
+    id = 'sun'
 
     def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.Liststr:
         return '-fpp'
@@ -316,6 +285,7 @@
 class IntelFortranCompiler(IntelGnuLikeCompiler, FortranCompiler):
 
     file_suffixes = ('f90', 'f', 'for', 'ftn', 'fpp', )
+    id = 'intel'
 
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
@@ -327,14 +297,14 @@
         # FIXME: Add support for OS X and Windows in detect_fortran_compiler so
         # we are sent the type of compiler
         IntelGnuLikeCompiler.__init__(self)
-        self.id = 'intel'
         default_warn_args = '-warn', 'general', '-warn', 'truncated_source'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-warn', 'unused',
-                          '3': '-warn', 'all'}
+                          '3': '-warn', 'all',
+                          'everything': '-warn', 'all'}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = FortranCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'legacy', 'f95', 'f2003', 'f2008', 'f2018'
@@ -360,6 +330,11 @@
         return '-gen-dep=' + outtarget, '-gen-depformat=make'
 
 
+class IntelLLVMFortranCompiler(IntelFortranCompiler):
+
+    id = 'intel-llvm'
+
+
 class IntelClFortranCompiler(IntelVisualStudioLikeCompiler, FortranCompiler):
 
     file_suffixes = ('f90', 'f', 'for', 'ftn', 'fpp', )
@@ -379,9 +354,10 @@
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '/warn:unused',
-                          '3': '/warn:all'}
+                          '3': '/warn:all',
+                          'everything': '/warn:all'}
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = FortranCompiler.get_options(self)
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         optskey.choices = 'none', 'legacy', 'f95', 'f2003', 'f2008', 'f2018'
@@ -400,8 +376,14 @@
         return '/module:' + path
 
 
+class IntelLLVMClFortranCompiler(IntelClFortranCompiler):
+
+    id = 'intel-llvm-cl'
+
 class PathScaleFortranCompiler(FortranCompiler):
 
+    id = 'pathscale'
+
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
@@ -409,12 +391,12 @@
         FortranCompiler.__init__(self, exelist, version, for_machine,
                                  is_cross, info, exe_wrapper, linker=linker,
                                  full_version=full_version)
-        self.id = 'pathscale'
         default_warn_args = '-fullwarn'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args,
-                          '3': default_warn_args}
+                          '3': default_warn_args,
+                          'everything': default_warn_args}
 
     def openmp_flags(self) -> T.Liststr:
         return '-mp'
@@ -435,7 +417,8 @@
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args,
-                          '3': default_warn_args + '-Mdclchk'}
+                          '3': default_warn_args + '-Mdclchk',
+                          'everything': default_warn_args + '-Mdclchk'}
 
     def language_stdlib_only_link_flags(self, env: 'Environment') -> T.Liststr:
         # TODO: needs default search path added
@@ -445,6 +428,8 @@
 
 class NvidiaHPC_FortranCompiler(PGICompiler, FortranCompiler):
 
+    id = 'nvidia_hpc'
+
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
@@ -454,16 +439,18 @@
                                  full_version=full_version)
         PGICompiler.__init__(self)
 
-        self.id = 'nvidia_hpc'
         default_warn_args = '-Minform=inform'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args,
-                          '3': default_warn_args + '-Mdclchk'}
+                          '3': default_warn_args + '-Mdclchk',
+                          'everything': default_warn_args + '-Mdclchk'}
 
 
 class FlangFortranCompiler(ClangCompiler, FortranCompiler):
 
+    id = 'flang'
+
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
@@ -472,12 +459,12 @@
                                  is_cross, info, exe_wrapper, linker=linker,
                                  full_version=full_version)
         ClangCompiler.__init__(self, {})
-        self.id = 'flang'
         default_warn_args = '-Minform=inform'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args,
-                          '3': default_warn_args}
+                          '3': default_warn_args,
+                          'everything': default_warn_args}
 
     def language_stdlib_only_link_flags(self, env: 'Environment') -> T.Liststr:
         # We need to apply the search prefix here, as these link arguments may
@@ -490,8 +477,14 @@
             search_dirs.append(f'-L{d}')
         return search_dirs + '-lflang', '-lpgmath'
 
+class ArmLtdFlangFortranCompiler(FlangFortranCompiler):
+
+    id = 'armltdflang'
+
 class Open64FortranCompiler(FortranCompiler):
 
+    id = 'open64'
+
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
@@ -499,12 +492,12 @@
         FortranCompiler.__init__(self, exelist, version, for_machine,
                                  is_cross, info, exe_wrapper, linker=linker,
                                  full_version=full_version)
-        self.id = 'open64'
         default_warn_args = '-fullwarn'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args,
-                          '3': default_warn_args}
+                          '3': default_warn_args,
+                          'everything': default_warn_args}
 
     def openmp_flags(self) -> T.Liststr:
         return '-mp'
@@ -512,6 +505,8 @@
 
 class NAGFortranCompiler(FortranCompiler):
 
+    id = 'nagfor'
+
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice, is_cross: bool,
                  info: 'MachineInfo', exe_wrapper: T.Optional'ExternalProgram' = None,
                  linker: T.Optional'DynamicLinker' = None,
@@ -519,13 +514,13 @@
         FortranCompiler.__init__(self, exelist, version, for_machine,
                                  is_cross, info, exe_wrapper, linker=linker,
                                  full_version=full_version)
-        self.id = 'nagfor'
         # Warnings are on by default; -w disables (by category):
         self.warn_args = {
             '0': '-w=all',
             '1': ,
             '2': ,
             '3': ,
+            'everything': ,
         }
 
     def get_always_args(self) -> T.Liststr:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/java.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/java.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import os
 import os.path
@@ -19,24 +20,35 @@
 import textwrap
 import typing as T
 
-from ..mesonlib import EnvironmentException, MachineChoice
+from ..mesonlib import EnvironmentException
 from .compilers import Compiler, java_buildtype_args
 from .mixins.islinker import BasicLinkerIsCompilerMixin
 
 if T.TYPE_CHECKING:
 from ..envconfig import MachineInfo
 from ..environment import Environment
+ from ..mesonlib import MachineChoice
 
 class JavaCompiler(BasicLinkerIsCompilerMixin, Compiler):
 
 language = 'java'
+ id = 'unknown'
+
+ _WARNING_LEVELS: T.Dictstr, T.Liststr = {
+ '0': '-nowarn',
+ '1': '-Xlint:all',
+ '2': '-Xlint:all', '-Xdoclint:all',
+ '3': '-Xlint:all', '-Xdoclint:all',
+ }
 
 def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
 info: 'MachineInfo', full_version: T.Optionalstr = None):
- super().__init__(exelist, version, for_machine, info, full_version=full_version)
- self.id = 'unknown'
+ super().__init__(, exelist, version, for_machine, info, full_version=full_version)
 self.javarunner = 'java'
 
+ def get_warn_args(self, level: str) -> T.Liststr:
+ return self._WARNING_LEVELSlevel
+
 def get_werror_args(self) -> T.Liststr:
 return '-Werror'
 
@@ -63,7 +75,7 @@
 def compute_parameters_with_absolute_paths(self, parameter_list: T.Liststr,
 build_dir: str) -> T.Liststr:
 for idx, i in enumerate(parameter_list):
- if i in '-cp', '-classpath', '-sourcepath' and idx + 1 < len(parameter_list):
+ if i in {'-cp', '-classpath', '-sourcepath'} and idx + 1 < len(parameter_list):
 path_list = parameter_listidx + 1.split(os.pathsep)
 path_list = os.path.normpath(os.path.join(build_dir, x)) for x in path_list
 parameter_listidx + 1 = os.pathsep.join(path_list)
@@ -85,14 +97,14 @@
 pc = subprocess.Popen(self.exelist + src, cwd=work_dir)
 pc.wait()
 if pc.returncode != 0:
- raise EnvironmentException('Java compiler %s can not compile programs.' % self.name_string())
+ raise EnvironmentException(f'Java compiler {self.name_string()} can not compile programs.')
 runner = shutil.which(self.javarunner)
 if runner:
 cmdlist = runner, obj
 pe = subprocess.Popen(cmdlist, cwd=work_dir)
 pe.wait()
 if pe.returncode != 0:
- raise EnvironmentException('Executables created by Java compiler %s are not runnable.' % self.name_string())
+ raise EnvironmentException(f'Executables created by Java compiler {self.name_string()} are not runnable.')
 else:
 m = "Java Virtual Machine wasn't found, but it's needed by Meson. " \
 "Please install a JRE.\nIf you have specific needs where this " \

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/arm.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/arm.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Representations specific to the arm family of compilers."""
 
@@ -43,6 +44,7 @@
 }  # type: T.Dictstr, T.Liststr
 
 arm_optimization_args = {
+    'plain': ,
     '0': '-O0',
     'g': '-g',
     '1': '-O1',
@@ -61,6 +63,7 @@
 }  # type: T.Dictstr, T.Liststr
 
 armclang_optimization_args = {
+    'plain': ,
     '0': , # Compiler defaults to -O0
     'g': '-g',
     '1': '-O1',
@@ -74,15 +77,17 @@
 
     """Functionality that is common to all ARM family compilers."""
 
+    id = 'arm'
+
     def __init__(self) -> None:
         if not self.is_cross:
             raise mesonlib.EnvironmentException('armcc supports only cross-compilation.')
-        self.id = 'arm'
         default_warn_args =   # type: T.Liststr
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + ,
-                          '3': default_warn_args + }  # type: T.Dictstr, T.Liststr
+                          '3': default_warn_args + ,
+                          'everything': default_warn_args + }  # type: T.Dictstr, T.Liststr
         # Assembly
         self.can_compile_suffixes.add('s')
 
@@ -136,6 +141,11 @@
 
 
 class ArmclangCompiler(Compiler):
+    '''
+    This is the Keil armclang.
+    '''
+
+    id = 'armclang'
 
     def __init__(self) -> None:
         if not self.is_cross:
@@ -145,7 +155,6 @@
             raise mesonlib.EnvironmentException(f'Unsupported Linker {self.linker.exelist}, must be armlink')
         if not mesonlib.version_compare(self.version, '==' + self.linker.version):
             raise mesonlib.EnvironmentException('armlink version does not match with compiler version')
-        self.id = 'armclang'
         self.base_options = {
             OptionKey(o) for o in
             'b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/ccrx.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/ccrx.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Representations specific to the Renesas CC-RX compiler family."""
 
@@ -20,6 +21,7 @@
 from ...mesonlib import EnvironmentException
 
 if T.TYPE_CHECKING:
+    from ...envconfig import MachineInfo
     from ...environment import Environment
     from ...compilers.compilers import Compiler
 else:
@@ -59,17 +61,19 @@
         is_cross = True
         can_compile_suffixes = set()  # type: T.Setstr
 
+    id = 'ccrx'
+
     def __init__(self) -> None:
         if not self.is_cross:
             raise EnvironmentException('ccrx supports only cross-compilation.')
-        self.id = 'ccrx'
         # Assembly
         self.can_compile_suffixes.add('src')
         default_warn_args =   # type: T.Liststr
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + ,
-                          '3': default_warn_args + }  # type: T.Dictstr, T.Liststr
+                          '3': default_warn_args + ,
+                          'everything': default_warn_args + }  # type: T.Dictstr, T.Liststr
 
     def get_pic_args(self) -> T.Liststr:
         # PIC support is not enabled by default for CCRX,
@@ -104,7 +108,7 @@
         return ccrx_debug_argsis_debug
 
     @classmethod
-    def unix_args_to_native(cls, args: T.Liststr) -> T.Liststr:
+    def _unix_args_to_native(cls, args: T.Liststr, info: MachineInfo) -> T.Liststr:
         result = 
         for i in args:
             if i.startswith('-D'):

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/clang.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/clang.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2019 The meson development team
+# Copyright 2019-2022 The meson development team
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Abstractions for the LLVM/Clang compiler family."""
 
@@ -19,7 +20,8 @@
 import typing as T
 
 from ... import mesonlib
-from ...linkers import AppleDynamicLinker, ClangClDynamicLinker, LLVMDynamicLinker, GnuGoldDynamicLinker
+from ...linkers import AppleDynamicLinker, ClangClDynamicLinker, LLVMDynamicLinker, GnuGoldDynamicLinker, \
+    MoldDynamicLinker
 from ...mesonlib import OptionKey
 from ..compilers import CompileCheckMode
 from .gnu import GnuLikeCompiler
@@ -35,6 +37,7 @@
 }  # type: T.Dictstr, T.Liststr
 
 clang_optimization_args = {
+    'plain': ,
     '0': '-O0',
     'g': '-Og',
     '1': '-O1',
@@ -45,12 +48,14 @@
 
 class ClangCompiler(GnuLikeCompiler):
 
+    id = 'clang'
+
     def __init__(self, defines: T.OptionalT.Dictstr, str):
         super().__init__()
-        self.id = 'clang'
         self.defines = defines or {}
         self.base_options.update(
-            {OptionKey('b_colorout'), OptionKey('b_lto_threads'), OptionKey('b_lto_mode')})
+            {OptionKey('b_colorout'), OptionKey('b_lto_threads'), OptionKey('b_lto_mode'), OptionKey('b_thinlto_cache'),
+             OptionKey('b_thinlto_cache_dir')})
 
         # TODO: this really should be part of the linker base_options, but
         # linkers don't have base_options.
@@ -105,7 +110,7 @@
         if isinstance(self.linker, AppleDynamicLinker) and mesonlib.version_compare(self.version, '>=8.0'):
             extra_args.append('-Wl,-no_weak_imports')
         return super().has_function(funcname, prefix, env, extra_args=extra_args,
-                                   dependencies=dependencies)
+                                    dependencies=dependencies)
 
     def openmp_flags(self) -> T.Liststr:
         if mesonlib.version_compare(self.version, '>=3.8.0'):
@@ -117,7 +122,7 @@
             return 
 
     @classmethod
-    def use_linker_args(cls, linker: str) -> T.Liststr:
+    def use_linker_args(cls, linker: str, version: str) -> T.Liststr:
         # Clang additionally can use a linker specified as a path, which GCC
         # (and other gcc-like compilers) cannot. This is because clang (being
         # llvm based) is retargetable, while GCC is not.
@@ -126,13 +131,15 @@
         # qcld: Qualcomm Snapdragon linker, based on LLVM
         if linker == 'qcld':
             return '-fuse-ld=qcld'
+        if linker == 'mold':
+            return '-fuse-ld=mold'
 
         if shutil.which(linker):
             if not shutil.which(linker):
                 raise mesonlib.MesonException(
                     f'Cannot find linker {linker}.')
             return f'-fuse-ld={linker}'
-        return super().use_linker_args(linker)
+        return super().use_linker_args(linker, version)
 
     def get_has_func_attribute_extra_args(self, name: str) -> T.Liststr:
         # Clang only warns about unknown or ignored attributes, so force an
@@ -145,17 +152,26 @@
     def get_lto_compile_args(self, *, threads: int = 0, mode: str = 'default') -> T.Liststr:
         args: T.Liststr = 
         if mode == 'thin':
-            # Thin LTO requires the use of gold, lld, ld64, or lld-link
-            if not isinstance(self.linker, (AppleDynamicLinker, ClangClDynamicLinker, LLVMDynamicLinker, GnuGoldDynamicLinker)):
-                raise mesonlib.MesonException(f"LLVM's thinLTO only works with gnu gold, lld, lld-link, and ld64, not {self.linker.id}")
+            # ThinLTO requires the use of gold, lld, ld64, lld-link or mold 1.1+
+            if isinstance(self.linker, (MoldDynamicLinker)):
+                # https://github.com/rui314/mold/commit/46995bcfc3e3113133620bf16445c5f13cd76a18
+                if not mesonlib.version_compare(self.linker.version, '>=1.1'):
+                    raise mesonlib.MesonException("LLVM's ThinLTO requires mold 1.1+")
+            elif not isinstance(self.linker, (AppleDynamicLinker, ClangClDynamicLinker, LLVMDynamicLinker, GnuGoldDynamicLinker)):
+                raise mesonlib.MesonException(f"LLVM's ThinLTO only works with gold, lld, lld-link, ld64 or mold, not {self.linker.id}")
             args.append(f'-flto={mode}')
         else:
             assert mode == 'default', 'someone forgot to wire something up'
             args.extend(super().get_lto_compile_args(threads=threads))
         return args
 
-    def get_lto_link_args(self, *, threads: int = 0, mode: str = 'default') -> T.Liststr:
+    def get_lto_link_args(self, *, threads: int = 0, mode: str = 'default',
+                          thinlto_cache_dir: T.Optionalstr = None) -> T.Liststr:
         args = self.get_lto_compile_args(threads=threads, mode=mode)
+        if mode == 'thin' and thinlto_cache_dir is not None:
+            # We check for ThinLTO linker support above in get_lto_compile_args, and all of them support
+            # get_thinlto_cache_args as well
+            args.extend(self.linker.get_thinlto_cache_args(thinlto_cache_dir))
         # In clang -flto-jobs=0 means auto, and is the default if unspecified, just like in meson
         if threads > 0:
             if not mesonlib.version_compare(self.version, '>=4.0.0'):

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/clike.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/clike.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2012-2017 The Meson development team
+# Copyright 2012-2022 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 
 """Mixin classes to be shared between C and C++ compilers.
@@ -27,6 +28,7 @@
 import os
 import re
 import subprocess
+import copy
 import typing as T
 from pathlib import Path
 
@@ -100,6 +102,7 @@
 # Remove system/default include paths added with -isystem
 default_dirs = self.compiler.get_default_include_dirs()
 if default_dirs:
+ real_default_dirs = self._cached_realpath(i) for i in default_dirs
 bad_idx_list = # type: T.Listint
 for i, each in enumerate(new):
 if not each.startswith('-isystem'):
@@ -108,16 +111,21 @@
 # Remove the -isystem and the path if the path is a default path
 if (each == '-isystem' and
 i < (len(new) - 1) and
- newi + 1 in default_dirs):
+ self._cached_realpath(newi + 1) in real_default_dirs):
 bad_idx_list += i, i + 1
- elif each.startswith('-isystem=') and each9: in default_dirs:
+ elif each.startswith('-isystem=') and self._cached_realpath(each9:) in real_default_dirs:
 bad_idx_list += i
- elif each8: in default_dirs:
+ elif self._cached_realpath(each8:) in real_default_dirs:
 bad_idx_list += i
 for i in reversed(bad_idx_list):
 new.pop(i)
 return self.compiler.unix_args_to_native(new._container)
 
+ @staticmethod
+ @functools.lru_cache(maxsize=None)
+ def _cached_realpath(arg: str) -> str:
+ return os.path.realpath(arg)
+
 def __repr__(self) -> str:
 self.flush_pre_post()
 return f'CLikeCompilerArgs({self.compiler!r}, {self._container!r})'
@@ -144,6 +152,8 @@
 self.exe_wrapper = None
 else:
 self.exe_wrapper = exe_wrapper
+ # Lazy initialized in get_preprocessor()
+ self.preprocessor: T.OptionalCompiler = None
 
 def compiler_args(self, args: T.OptionalT.Iterablestr = None) -> CLikeCompilerArgs:
 # This is correct, mypy just doesn't understand co-operative inheritance
@@ -175,9 +185,6 @@
 def get_depfile_suffix(self) -> str:
 return 'd'
 
- def get_exelist(self) -> T.Liststr:
- return self.exelist.copy()
-
 def get_preprocess_only_args(self) -> T.Liststr:
 return '-E', '-P'
 
@@ -187,8 +194,8 @@
 def get_no_optimization_args(self) -> T.Liststr:
 return '-O0'
 
- def get_output_args(self, target: str) -> T.Liststr:
- return '-o', target
+ def get_output_args(self, outputname: str) -> T.Liststr:
+ return '-o', outputname
 
 def get_werror_args(self) -> T.Liststr:
 return '-Werror'
@@ -270,8 +277,8 @@
 def get_pch_use_args(self, pch_dir: str, header: str) -> T.Liststr:
 return '-include', os.path.basename(header)
 
- def get_pch_name(self, header_name: str) -> str:
- return os.path.basename(header_name) + '.' + self.get_pch_suffix()
+ def get_pch_name(self, name: str) -> str:
+ return os.path.basename(name) + '.' + self.get_pch_suffix()
 
 def get_default_include_dirs(self) -> T.Liststr:
 return 
@@ -284,7 +291,7 @@
 
 def _sanity_check_impl(self, work_dir: str, environment: 'Environment',
 sname: str, code: str) -> None:
- mlog.debug('Sanity testing ' + self.get_display_language() + ' compiler:', ' '.join(self.exelist))
+ mlog.debug('Sanity testing ' + self.get_display_language() + ' compiler:', mesonlib.join_args(self.exelist))
 mlog.debug(f'Is cross compiler: {self.is_cross!s}.')
 
 source_name = os.path.join(work_dir, sname)
@@ -293,7 +300,7 @@
 if self.is_cross:
 binname += '_cross'
 if self.exe_wrapper is None:
- # Linking cross built apps is painful. You can't really
+ # Linking cross built C/C++ apps is painful. You can't really
 # tell if you should use -nostdlib or not and for example
 # on OSX the compiler binary is the same but you need
 # a ton of compiler flags to differentiate between
@@ -313,7 +320,7 @@
 # after which all further arguments will be passed directly to the linker
 cmdlist = self.exelist + sname + self.get_output_args(binname) + extra_flags
 pc, stdo, stde = mesonlib.Popen_safe(cmdlist, cwd=work_dir)
- mlog.debug('Sanity check compiler command line:', ' '.join(cmdlist))
+ mlog.debug('Sanity check compiler command line:', mesonlib.join_args(cmdlist))
 mlog.debug('Sanity check compile stdout:')
 mlog.debug(stdo)
 mlog.debug('-----\nSanity check compile stderr:')
@@ -329,12 +336,12 @@
 cmdlist = self.exe_wrapper.get_command() + binary_name
 else:
 cmdlist = binary_name
- mlog.debug('Running test binary command: ' + ' '.join(cmdlist))
+ mlog.debug('Running test binary command: ', mesonlib.join_args(cmdlist))
 try:
- pe = subprocess.Popen(cmdlist)
+ # fortran code writes to stdout
+ pe = subprocess.run(cmdlist, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 except Exception as e:
 raise mesonlib.EnvironmentException(f'Could not invoke sanity test executable: {e!s}.')
- pe.wait()
 if pe.returncode != 0:
 raise mesonlib.EnvironmentException(f'Executables created by {self.language} compiler {self.name_string()} are not runnable.')
 
@@ -410,7 +417,7 @@
 if mode is CompileCheckMode.LINK:
 ld_value = env.lookup_binary_entry(self.for_machine, self.language + '_ld')
 if ld_value is not None:
- largs += self.use_linker_args(ld_value0)
+ largs += self.use_linker_args(ld_value0, self.version)
 
 # Add LDFLAGS from the env
 sys_ld_args = env.coredata.get_external_link_args(self.for_machine, self.language)
@@ -516,9 +523,7 @@
 low = cur + 1
 if low > maxint:
 raise mesonlib.EnvironmentException('Cross-compile check overflowed')
- cur = cur * 2 + 1
- if cur > maxint:
- cur = maxint
+ cur = min(cur * 2 + 1, maxint)
 high = cur
 else:
 high = cur = -1
@@ -526,9 +531,7 @@
 high = cur - 1
 if high < minint:
 raise mesonlib.EnvironmentException('Cross-compile check overflowed')
- cur = cur * 2
- if cur < minint:
- cur = minint
+ cur = max(cur * 2, minint)
 low = cur
 else:
 # Sanity check limits given by user
@@ -879,9 +882,7 @@
 if extra_args is None:
 extra_args = 
 # Create code that accesses all members
- members = ''
- for member in membernames:
- members += f'foo.{member};\n'
+ members = ''.join(f'foo.{member};\n' for member in membernames)
 t = f'''{prefix}
 void bar(void) {{
 {typename} foo;
@@ -900,9 +901,10 @@
 return self.compiles(t, env, extra_args=extra_args,
 dependencies=dependencies)
 
- def symbols_have_underscore_prefix(self, env: 'Environment') -> bool:
+ def _symbols_have_underscore_prefix_searchbin(self, env: 'Environment') -> bool:
 '''
- Check if the compiler prefixes an underscore to global C symbols
+ Check if symbols have underscore prefix by compiling a small test binary
+ and then searching the binary for the string,
 '''
 symbol_name = b'meson_uscore_prefix'
 code = '''#ifdef __cplusplus
@@ -914,10 +916,10 @@
 #endif
 '''
 args = self.get_compiler_check_args(CompileCheckMode.COMPILE)
- n = 'symbols_have_underscore_prefix'
+ n = '_symbols_have_underscore_prefix_searchbin'
 with self._build_wrapper(code, env, extra_args=args, mode='compile', want_output=True, temp_dir=env.scratch_dir) as p:
 if p.returncode != 0:
- raise RuntimeError(f'BUG: Unable to compile {n!r} check: {p.stdout}')
+ raise RuntimeError(f'BUG: Unable to compile {n!r} check: {p.stderr}')
 if not os.path.isfile(p.output_name):
 raise RuntimeError(f'BUG: Can\'t find compiled test code for {n!r} check')
 with open(p.output_name, 'rb') as o:
@@ -925,13 +927,77 @@
 # Check if the underscore form of the symbol is somewhere
 # in the output file.
 if b'_' + symbol_name in line:
- mlog.debug("Symbols have underscore prefix: YES")
+ mlog.debug("Underscore prefix check found prefixed function in binary")
 return True
 # Else, check if the non-underscored form is present
 elif symbol_name in line:
- mlog.debug("Symbols have underscore prefix: NO")
+ mlog.debug("Underscore prefix check found non-prefixed function in binary")
 return False
- raise RuntimeError(f'BUG: {n!r} check failed unexpectedly')
+ raise RuntimeError(f'BUG: {n!r} check did not find symbol string in binary')
+
+ def _symbols_have_underscore_prefix_define(self, env: 'Environment') -> T.Optionalbool:
+ '''
+ Check if symbols have underscore prefix by querying the
+ __USER_LABEL_PREFIX__ define that most compilers provide
+ for this. Return if functions have underscore prefix or None
+ if it was not possible to determine, like when the compiler
+ does not set the define or the define has an unexpected value.
+ '''
+ delim = '"MESON_HAVE_UNDERSCORE_DELIMITER" '
+ code = f'''
+ #ifndef __USER_LABEL_PREFIX__
+ #define MESON_UNDERSCORE_PREFIX unsupported
+ #else
+ #define MESON_UNDERSCORE_PREFIX __USER_LABEL_PREFIX__
+ #endif
+ {delim}MESON_UNDERSCORE_PREFIX
+ '''
+ with self._build_wrapper(code, env, mode='preprocess', want_output=False, temp_dir=env.scratch_dir) as p:
+ if p.returncode != 0:
+ raise RuntimeError(f'BUG: Unable to preprocess _symbols_have_underscore_prefix_define check: {p.stdout}')
+ symbol_prefix = p.stdout.partition(delim)-1.rstrip()
+
+ mlog.debug(f'Queried compiler for function prefix: __USER_LABEL_PREFIX__ is "{symbol_prefix!s}"')
+ if symbol_prefix == '_':
+ return True
+ elif symbol_prefix == '':
+ return False
+ else:
+ return None
+
+ def _symbols_have_underscore_prefix_list(self, env: 'Environment') -> T.Optionalbool:
+ '''
+ Check if symbols have underscore prefix by consulting a hardcoded
+ list of cases where we know the results.
+ Return if functions have underscore prefix or None if unknown.
+ '''
+ m = env.machinesself.for_machine
+ # Darwin always uses the underscore prefix, not matter what
+ if m.is_darwin():
+ return True
+ # Windows uses the underscore prefix on x86 (32bit) only
+ if m.is_windows() or m.is_cygwin():
+ return m.cpu_family == 'x86'
+ return None
+
+ def symbols_have_underscore_prefix(self, env: 'Environment') -> bool:
+ '''
+ Check if the compiler prefixes an underscore to global C symbols
+ '''
+ # First, try to query the compiler directly
+ result = self._symbols_have_underscore_prefix_define(env)
+ if result is not None:
+ return result
+
+ # Else, try to consult a hardcoded list of cases we know
+ # absolutely have an underscore prefix
+ result = self._symbols_have_underscore_prefix_list(env)
+ if result is not None:
+ return result
+
+ # As a last resort, try search in a compiled binary, which is the
+ # most unreliable way of checking this, see #5482
+ return self._symbols_have_underscore_prefix_searchbin(env)
 
 def _get_patterns(self, env: 'Environment', prefixes: T.Liststr, suffixes: T.Liststr, shared: bool = False) -> T.Liststr:
 patterns = # type: T.Liststr
@@ -1092,6 +1158,8 @@
 trial = self._get_file_from_list(env, trials)
 if not trial:
 continue
+ if libname.startswith('lib') and trial.name.startswith(libname):
+ mlog.warning(f'find_library({libname!r}) starting in "lib" only works by accident and is not portable')
 return trial.as_posix()
 return None
 
@@ -1127,7 +1195,7 @@
 if self.id != 'clang':
 raise mesonlib.MesonException('Cannot find framework path with non-clang compiler')
 # Construct the compiler command-line
- commands = self.get_exelist() + '-v', '-E', '-'
+ commands = self.get_exelist(ccache=False) + '-v', '-E', '-'
 commands += self.get_always_args()
 # Add CFLAGS/CXXFLAGS/OBJCFLAGS/OBJCXXFLAGS from the env
 commands += env.coredata.get_external_args(self.for_machine, self.language)
@@ -1256,7 +1324,7 @@
 # don't work
 m = env.machinesself.for_machine
 if not (m.is_windows() or m.is_cygwin()):
- if name in 'dllimport', 'dllexport':
+ if name in {'dllimport', 'dllexport'}:
 return False, False
 
 return self.compiles(self.attribute_check_func(name), env,
@@ -1264,3 +1332,18 @@
 
 def get_disable_assert_args(self) -> T.Liststr:
 return '-DNDEBUG'
+
+ @functools.lru_cache(maxsize=None)
+ def can_compile(self, src: 'mesonlib.FileOrString') -> bool:
+ # Files we preprocess can be anything, e.g. .in
+ if self.mode == 'PREPROCESSOR':
+ return True
+ return super().can_compile(src)
+
+ def get_preprocessor(self) -> Compiler:
+ if not self.preprocessor:
+ self.preprocessor = copy.copy(self)
+ self.preprocessor.exelist = self.exelist + self.get_preprocess_to_file_args()
+ self.preprocessor.mode = 'PREPROCESSOR'
+ self.modes.append(self.preprocessor)
+ return self.preprocessor

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/compcert.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/compcert.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Representations specific to the CompCert C compiler family."""
 
@@ -19,6 +20,7 @@
 import typing as T
 
 if T.TYPE_CHECKING:
+    from envconfig import MachineInfo
     from ...environment import Environment
     from ...compilers.compilers import Compiler
 else:
@@ -38,6 +40,7 @@
 }  # type: T.Dictstr, T.Liststr
 
 ccomp_optimization_args = {
+    'plain': ,
     '0': '-O0',
     'g': '-O0',
     '1': '-O1',
@@ -60,15 +63,17 @@
 
 class CompCertCompiler(Compiler):
 
+    id = 'ccomp'
+
     def __init__(self) -> None:
-        self.id = 'ccomp'
         # Assembly
         self.can_compile_suffixes.add('s')
         default_warn_args =   # type: T.Liststr
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + ,
-                          '3': default_warn_args + }  # type: T.Dictstr, T.Liststr
+                          '3': default_warn_args + ,
+                          'everything': default_warn_args + }  # type: T.Dictstr, T.Liststr
 
     def get_always_args(self) -> T.Liststr:
         return 
@@ -86,7 +91,8 @@
     def get_pch_use_args(self, pch_dir: str, header: str) -> T.Liststr:
         return 
 
-    def unix_args_to_native(self, args: T.Liststr) -> T.Liststr:
+    @classmethod
+    def _unix_args_to_native(cls, args: T.Liststr, info: MachineInfo) -> T.Liststr:
         "Always returns a copy that can be independently mutated"
         patched_args =   # type: T.Liststr
         for arg in args:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/elbrus.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/elbrus.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Abstractions for the Elbrus family of compilers."""
 
@@ -32,22 +33,24 @@
     # Elbrus compiler is nearly like GCC, but does not support
     # PCH, LTO, sanitizers and color output as of version 1.21.x.
 
+    id = 'lcc'
+
     def __init__(self) -> None:
         super().__init__()
-        self.id = 'lcc'
         self.base_options = {OptionKey(o) for o in 'b_pgo', 'b_coverage', 'b_ndebug', 'b_staticpic', 'b_lundef', 'b_asneeded'}
         default_warn_args = '-Wall'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': default_warn_args + '-Wextra', '-Wpedantic'}
 
     # FIXME: use _build_wrapper to call this so that linker flags from the env
     # get applied
     def get_library_dirs(self, env: 'Environment', elf_class: T.Optionalint = None) -> T.Liststr:
         os_env = os.environ.copy()
         os_env'LC_ALL' = 'C'
-        stdo = Popen_safe(self.exelist + '--print-search-dirs', env=os_env)1
+        stdo = Popen_safe(self.get_exelist(ccache=False) + '--print-search-dirs', env=os_env)1
         for line in stdo.split('\n'):
             if line.startswith('libraries:'):
                 # lcc does not include '=' in --print-search-dirs output. Also it could show nonexistent dirs.
@@ -58,7 +61,7 @@
     def get_program_dirs(self, env: 'Environment') -> T.Liststr:
         os_env = os.environ.copy()
         os_env'LC_ALL' = 'C'
-        stdo = Popen_safe(self.exelist + '--print-search-dirs', env=os_env)1
+        stdo = Popen_safe(self.get_exelist(ccache=False) + '--print-search-dirs', env=os_env)1
         for line in stdo.split('\n'):
             if line.startswith('programs:'):
                 # lcc does not include '=' in --print-search-dirs output.
@@ -69,7 +72,7 @@
     def get_default_include_dirs(self) -> T.Liststr:
         os_env = os.environ.copy()
         os_env'LC_ALL' = 'C'
-        p = subprocess.Popen(self.exelist + '-xc', '-E', '-v', '-', env=os_env, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        p = subprocess.Popen(self.get_exelist(ccache=False) + '-xc', '-E', '-v', '-', env=os_env, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         stderr = p.stderr.read().decode('utf-8', errors='replace')
         includes = 
         for line in stderr.split('\n'):

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/emscripten.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/emscripten.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Provides a mixin for shared code between C and C++ Emscripten compilers."""
 
@@ -58,17 +59,14 @@
             suffix = 'o'
         return os.path.join(dirname, 'output.' + suffix)
 
-    def thread_flags(self, env: 'Environment') -> T.Liststr:
-        return '-s', 'USE_PTHREADS=1'
-
     def thread_link_flags(self, env: 'Environment') -> T.Liststr:
-        args = '-s', 'USE_PTHREADS=1'
+        args = '-pthread'
         count: int = env.coredata.optionsOptionKey('thread_count', lang=self.language, machine=self.for_machine).value
         if count:
-            args.extend('-s', f'PTHREAD_POOL_SIZE={count}')
+            args.append(f'-sPTHREAD_POOL_SIZE={count}')
         return args
 
-    def get_options(self) -> 'coredata.KeyedOptionDictType':
+    def get_options(self) -> 'coredata.MutableKeyedOptionDictType':
         opts = super().get_options()
         key = OptionKey('thread_count', machine=self.for_machine, lang=self.language)
         opts.update({

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/gnu.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/gnu.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2019 The meson development team
+# Copyright 2019-2022 The meson development team
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Provides mixins for GNU compilers and GNU-like compilers."""
 
@@ -55,7 +56,8 @@
 }  # type: T.Dictstr, T.Liststr
 
 gnu_optimization_args = {
-    '0': ,
+    'plain': ,
+    '0': '-O0',
     'g': '-Og',
     '1': '-O1',
     '2': '-O2',
@@ -91,6 +93,238 @@
     'never': '-fdiagnostics-color=never',
 }  # type: T.Dictstr, T.Liststr
 
+# Warnings collected from the GCC source and documentation.  This is an
+# objective set of all the warnings flags that apply to general projects: the
+# only ones omitted are those that require a project-specific value, or are
+# related to non-standard or legacy language support.  This behaves roughly
+# like -Weverything in clang.  Warnings implied by -Wall, -Wextra, or
+# higher-level warnings already enabled here are not included in these lists to
+# keep them as short as possible.  History goes back to GCC 3.0.0, everything
+# earlier is considered historical and listed under version 0.0.0.
+
+# GCC warnings for all C-family languages
+# Omitted non-general warnings:
+#   -Wabi=
+#   -Waggregate-return
+#   -Walloc-size-larger-than=BYTES
+#   -Walloca-larger-than=BYTES
+#   -Wframe-larger-than=BYTES
+#   -Wlarger-than=BYTES
+#   -Wstack-usage=BYTES
+#   -Wsystem-headers
+#   -Wtrampolines
+#   -Wvla-larger-than=BYTES
+#
+# Omitted warnings enabled elsewhere in meson:
+#   -Winvalid-pch (GCC 3.4.0)
+gnu_common_warning_args = {
+    "0.0.0": 
+        "-Wcast-qual",
+        "-Wconversion",
+        "-Wfloat-equal",
+        "-Wformat=2",
+        "-Winline",
+        "-Wmissing-declarations",
+        "-Wredundant-decls",
+        "-Wshadow",
+        "-Wundef",
+        "-Wuninitialized",
+        "-Wwrite-strings",
+    ,
+    "3.0.0": 
+        "-Wdisabled-optimization",
+        "-Wpacked",
+        "-Wpadded",
+    ,
+    "3.3.0": 
+        "-Wmultichar",
+        "-Wswitch-default",
+        "-Wswitch-enum",
+        "-Wunused-macros",
+    ,
+    "4.0.0": 
+        "-Wmissing-include-dirs",
+    ,
+    "4.1.0": 
+        "-Wunsafe-loop-optimizations",
+        "-Wstack-protector",
+    ,
+    "4.2.0": 
+        "-Wstrict-overflow=5",
+    ,
+    "4.3.0": 
+        "-Warray-bounds=2",
+        "-Wlogical-op",
+        "-Wstrict-aliasing=3",
+        "-Wvla",
+    ,
+    "4.6.0": 
+        "-Wdouble-promotion",
+        "-Wsuggest-attribute=const",
+        "-Wsuggest-attribute=noreturn",
+        "-Wsuggest-attribute=pure",
+        "-Wtrampolines",
+    ,
+    "4.7.0": 
+        "-Wvector-operation-performance",
+    ,
+    "4.8.0": 
+        "-Wsuggest-attribute=format",
+    ,
+    "4.9.0": 
+        "-Wdate-time",
+    ,
+    "5.1.0": 
+        "-Wformat-signedness",
+        "-Wnormalized=nfc",
+    ,
+    "6.1.0": 
+        "-Wduplicated-cond",
+        "-Wnull-dereference",
+        "-Wshift-negative-value",
+        "-Wshift-overflow=2",
+        "-Wunused-const-variable=2",
+    ,
+    "7.1.0": 
+        "-Walloca",
+        "-Walloc-zero",
+        "-Wformat-overflow=2",
+        "-Wformat-truncation=2",
+        "-Wstringop-overflow=3",
+    ,
+    "7.2.0": 
+        "-Wduplicated-branches",
+    ,
+    "8.1.0": 
+        "-Wattribute-alias=2",
+        "-Wcast-align=strict",
+        "-Wsuggest-attribute=cold",
+        "-Wsuggest-attribute=malloc",
+    ,
+    "10.1.0": 
+        "-Wanalyzer-too-complex",
+        "-Warith-conversion",
+    ,
+    "12.1.0": 
+        "-Wbidi-chars=ucn",
+        "-Wopenacc-parallelism",
+        "-Wtrivial-auto-var-init",
+    ,
+}  # type: T.Dictstr, T.Liststr
+
+# GCC warnings for C
+# Omitted non-general or legacy warnings:
+#   -Wc11-c2x-compat
+#   -Wc90-c99-compat
+#   -Wc99-c11-compat
+#   -Wdeclaration-after-statement
+#   -Wtraditional
+#   -Wtraditional-conversion
+gnu_c_warning_args = {
+    "0.0.0": 
+        "-Wbad-function-cast",
+        "-Wmissing-prototypes",
+        "-Wnested-externs",
+        "-Wstrict-prototypes",
+    ,
+    "3.4.0": 
+        "-Wold-style-definition",
+        "-Winit-self",
+    ,
+    "4.1.0": 
+        "-Wc++-compat",
+    ,
+    "4.5.0": 
+        "-Wunsuffixed-float-constants",
+    ,
+}  # type: T.Dictstr, T.Liststr
+
+# GCC warnings for C++
+# Omitted non-general or legacy warnings:
+#   -Wc++0x-compat
+#   -Wc++1z-compat
+#   -Wc++2a-compat
+#   -Wctad-maybe-unsupported
+#   -Wnamespaces
+#   -Wtemplates
+gnu_cpp_warning_args = {
+    "0.0.0": 
+        "-Wctor-dtor-privacy",
+        "-Weffc++",
+        "-Wnon-virtual-dtor",
+        "-Wold-style-cast",
+        "-Woverloaded-virtual",
+        "-Wsign-promo",
+    ,
+    "4.0.1": 
+        "-Wstrict-null-sentinel",
+    ,
+    "4.6.0": 
+        "-Wnoexcept",
+    ,
+    "4.7.0": 
+        "-Wzero-as-null-pointer-constant",
+    ,
+    "4.8.0": 
+        "-Wabi-tag",
+        "-Wuseless-cast",
+    ,
+    "4.9.0": 
+        "-Wconditionally-supported",
+    ,
+    "5.1.0": 
+        "-Wsuggest-final-methods",
+        "-Wsuggest-final-types",
+        "-Wsuggest-override",
+    ,
+    "6.1.0": 
+        "-Wmultiple-inheritance",
+        "-Wplacement-new=2",
+        "-Wvirtual-inheritance",
+    ,
+    "7.1.0": 
+        "-Waligned-new=all",
+        "-Wnoexcept-type",
+        "-Wregister",
+    ,
+    "8.1.0": 
+        "-Wcatch-value=3",
+        "-Wextra-semi",
+    ,
+    "9.1.0": 
+        "-Wdeprecated-copy-dtor",
+        "-Wredundant-move",
+    ,
+    "10.1.0": 
+        "-Wcomma-subscript",
+        "-Wmismatched-tags",
+        "-Wredundant-tags",
+        "-Wvolatile",
+    ,
+    "11.1.0": 
+        "-Wdeprecated-enum-enum-conversion",
+        "-Wdeprecated-enum-float-conversion",
+        "-Winvalid-imported-macros",
+    ,
+}  # type: T.Dictstr, T.Liststr
+
+# GCC warnings for Objective C and Objective C++
+# Omitted non-general or legacy warnings:
+#   -Wtraditional
+#   -Wtraditional-conversion
+gnu_objc_warning_args = {
+    "0.0.0": 
+        "-Wselector",
+    ,
+    "3.3": 
+        "-Wundeclared-selector",
+    ,
+    "4.1.0": 
+        "-Wassign-intercept",
+        "-Wstrict-selector-match",
+    ,
+}  # type: T.Dictstr, T.Liststr
+
 
 @functools.lru_cache(maxsize=None)
 def gnulike_default_include_dirs(compiler: T.Tuplestr, ..., lang: str) -> 'ImmutableListProtocolstr':
@@ -183,13 +417,15 @@
         return gnulike_instruction_set_args.get(instruction_set, None)
 
     def get_default_include_dirs(self) -> T.Liststr:
-        return gnulike_default_include_dirs(tuple(self.exelist), self.language).copy()
+        return gnulike_default_include_dirs(tuple(self.get_exelist(ccache=False)), self.language).copy()
 
     @abc.abstractmethod
     def openmp_flags(self) -> T.Liststr:
         pass
 
     def gnu_symbol_visibility_args(self, vistype: str) -> T.Liststr:
+        if vistype == 'inlineshidden' and self.language not in {'cpp', 'objcpp'}:
+            vistype = 'hidden'
         return gnu_symbol_visibility_argsvistype
 
     def gen_vs_module_defs_args(self, defsfile: str) -> T.Liststr:
@@ -209,7 +445,7 @@
         return '-fprofile-generate'
 
     def get_profile_use_args(self) -> T.Liststr:
-        return '-fprofile-use', '-fprofile-correction'
+        return '-fprofile-use'
 
     def get_gui_app_args(self, value: bool) -> T.Liststr:
         return '-mwindows' if value else '-mconsole'
@@ -306,7 +542,7 @@
         return '-I' + path
 
     @classmethod
-    def use_linker_args(cls, linker: str) -> T.Liststr:
+    def use_linker_args(cls, linker: str, version: str) -> T.Liststr:
         if linker not in {'gold', 'bfd', 'lld'}:
             raise mesonlib.MesonException(
                 f'Unsupported linker, only bfd, gold, and lld are supported, not {linker}.')
@@ -315,16 +551,22 @@
     def get_coverage_args(self) -> T.Liststr:
         return '--coverage'
 
+    def get_preprocess_to_file_args(self) -> T.Liststr:
+        # We want to allow preprocessing files with any extension, such as
+        # foo.c.in. In that case we need to tell GCC/CLANG to treat them as
+        # assembly file.
+        return self.get_preprocess_only_args() + '-x', 'assembler-with-cpp'
+
 
 class GnuCompiler(GnuLikeCompiler):
     """
     GnuCompiler represents an actual GCC in its many incarnations.
     Compilers imitating GCC (Clang/Intel) should use the GnuLikeCompiler ABC.
     """
+    id = 'gcc'
 
     def __init__(self, defines: T.OptionalT.Dictstr, str):
         super().__init__()
-        self.id = 'gcc'
         self.defines = defines or {}
         self.base_options.update({OptionKey('b_colorout'), OptionKey('b_lto_threads')})
 
@@ -342,6 +584,13 @@
             argsargs.index('-Wpedantic') = '-pedantic'
         return args
 
+    def supported_warn_args(self, warn_args_by_version: T.Dictstr, T.Liststr) -> T.Liststr:
+        result = 
+        for version, warn_args in warn_args_by_version.items():
+            if mesonlib.version_compare(self.version, '>=' + version):
+                result += warn_args
+        return result
+
     def has_builtin_define(self, define: str) -> bool:
         return define in self.defines
 
@@ -389,3 +638,12 @@
         elif threads > 0:
             return f'-flto={threads}'
         return super().get_lto_compile_args(threads=threads)
+
+    @classmethod
+    def use_linker_args(cls, linker: str, version: str) -> T.Liststr:
+        if linker == 'mold' and mesonlib.version_compare(version, '>=12.0.1'):
+            return '-fuse-ld=mold'
+        return super().use_linker_args(linker, version)
+
+    def get_profile_use_args(self) -> T.Liststr:
+        return super().get_profile_use_args() + '-fprofile-correction'

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/intel.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/intel.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Abstractions for the Intel Compiler families.
 
@@ -58,7 +59,8 @@
         'custom': ,
     }  # type: T.Dictstr, T.Liststr
 
-    OPTIM_ARGS = {
+    OPTIM_ARGS: T.Dictstr, T.Liststr = {
+        'plain': ,
         '0': '-O0',
         'g': '-O0',
         '1': '-O1',
@@ -66,6 +68,7 @@
         '3': '-O3',
         's': '-Os',
     }
+    id = 'intel'
 
     def __init__(self) -> None:
         super().__init__()
@@ -77,7 +80,6 @@
         self.base_options = {mesonlib.OptionKey(o) for o in 
             'b_pch', 'b_lundef', 'b_asneeded', 'b_pgo', 'b_coverage',
             'b_ndebug', 'b_staticpic', 'b_pie'}
-        self.id = 'intel'
         self.lang_header = 'none'
 
     def get_pch_suffix(self) -> str:
@@ -136,7 +138,8 @@
         'custom': ,
     }  # type: T.Dictstr, T.Liststr
 
-    OPTIM_ARGS = {
+    OPTIM_ARGS: T.Dictstr, T.Liststr = {
+        'plain': ,
         '0': '/Od',
         'g': '/Od',
         '1': '/O1',
@@ -145,9 +148,7 @@
         's': '/Os',
     }
 
-    def __init__(self, target: str) -> None:
-        super().__init__(target)
-        self.id = 'intel-cl'
+    id = 'intel-cl'
 
     def get_compiler_check_args(self, mode: CompileCheckMode) -> T.Liststr:
         args = super().get_compiler_check_args(mode)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/islinker.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/islinker.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Mixins for compilers that *are* linkers.
 
@@ -48,7 +49,8 @@
     def sanitizer_link_args(self, value: str) -> T.Liststr:
         return 
 
-    def get_lto_link_args(self, *, threads: int = 0, mode: str = 'default') -> T.Liststr:
+    def get_lto_link_args(self, *, threads: int = 0, mode: str = 'default',
+                          thinlto_cache_dir: T.Optionalstr = None) -> T.Liststr:
         return 
 
     def can_linker_accept_rsp(self) -> bool:
@@ -57,7 +59,7 @@
     def get_linker_exelist(self) -> T.Liststr:
         return self.exelist.copy()
 
-    def get_linker_output_args(self, output: str) -> T.Liststr:
+    def get_linker_output_args(self, outputname: str) -> T.Liststr:
         return 
 
     def get_linker_always_args(self) -> T.Liststr:
@@ -118,7 +120,7 @@
     def get_buildtype_linker_args(self, buildtype: str) -> T.Liststr:
         return 
 
-    def get_link_debugfile_name(self, target: str) -> str:
+    def get_link_debugfile_name(self, targetfile: str) -> str:
         return ''
 
     def thread_flags(self, env: 'Environment') -> T.Liststr:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/pgi.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/pgi.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Abstractions for the PGI family of compilers."""
 
@@ -43,16 +44,19 @@
 
 class PGICompiler(Compiler):
 
+    id = 'pgi'
+
     def __init__(self) -> None:
         self.base_options = {OptionKey('b_pch')}
-        self.id = 'pgi'
 
         default_warn_args = '-Minform=inform'
-        self.warn_args = {'0': ,
-                          '1': default_warn_args,
-                          '2': default_warn_args,
-                          '3': default_warn_args
-        }  # type: T.Dictstr, T.Liststr
+        self.warn_args: T.Dictstr, T.Liststr = {
+            '0': ,
+            '1': default_warn_args,
+            '2': default_warn_args,
+            '3': default_warn_args,
+            'everything': default_warn_args
+        }
 
     def get_module_incdir_args(self) -> T.Tuplestr:
         return ('-module', )

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/ti.py Added

@@ -0,0 +1,151 @@
+# Copyright 2012-2019 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+"""Representations specific to the Texas Instruments compiler family."""
+
+import os
+import typing as T
+
+from ...mesonlib import EnvironmentException
+
+if T.TYPE_CHECKING:
+    from ...envconfig import MachineInfo
+    from ...environment import Environment
+    from ...compilers.compilers import Compiler
+else:
+    # This is a bit clever, for mypy we pretend that these mixins descend from
+    # Compiler, so we get all of the methods and attributes defined for us, but
+    # for runtime we make them descend from object (which all classes normally
+    # do). This gives up DRYer type checking, with no runtime impact
+    Compiler = object
+
+ti_buildtype_args = {
+    'plain': ,
+    'debug': ,
+    'debugoptimized': ,
+    'release': ,
+    'minsize': ,
+    'custom': ,
+}  # type: T.Dictstr, T.Liststr
+
+ti_optimization_args = {
+    'plain': ,
+    '0': '-O0',
+    'g': '-Ooff',
+    '1': '-O1',
+    '2': '-O2',
+    '3': '-O3',
+    's': '-O4'
+}  # type: T.Dictstr, T.Liststr
+
+ti_debug_args = {
+    False: ,
+    True: '-g'
+}  # type: T.Dictbool, T.Liststr
+
+
+class TICompiler(Compiler):
+
+    id = 'ti'
+
+    def __init__(self) -> None:
+        if not self.is_cross:
+            raise EnvironmentException('TI compilers only support cross-compilation.')
+
+        self.can_compile_suffixes.add('asm')    # Assembly
+        self.can_compile_suffixes.add('cla')    # Control Law Accelerator (CLA) used in C2000
+
+        default_warn_args =   # type: T.Liststr
+        self.warn_args = {'0': ,
+                          '1': default_warn_args,
+                          '2': default_warn_args + ,
+                          '3': default_warn_args + ,
+                          'everything': default_warn_args + }  # type: T.Dictstr, T.Liststr
+
+    def get_pic_args(self) -> T.Liststr:
+        # PIC support is not enabled by default for TI compilers,
+        # if users want to use it, they need to add the required arguments explicitly
+        return 
+
+    def get_buildtype_args(self, buildtype: str) -> T.Liststr:
+        return ti_buildtype_argsbuildtype
+
+    def get_pch_suffix(self) -> str:
+        return 'pch'
+
+    def get_pch_use_args(self, pch_dir: str, header: str) -> T.Liststr:
+        return 
+
+    def thread_flags(self, env: 'Environment') -> T.Liststr:
+        return 
+
+    def get_coverage_args(self) -> T.Liststr:
+        return 
+
+    def get_no_stdinc_args(self) -> T.Liststr:
+        return 
+
+    def get_no_stdlib_link_args(self) -> T.Liststr:
+        return 
+
+    def get_optimization_args(self, optimization_level: str) -> T.Liststr:
+        return ti_optimization_argsoptimization_level
+
+    def get_debug_args(self, is_debug: bool) -> T.Liststr:
+        return ti_debug_argsis_debug
+
+    def get_compile_only_args(self) -> T.Liststr:
+        return 
+
+    def get_no_optimization_args(self) -> T.Liststr:
+        return '-Ooff'
+
+    def get_output_args(self, target: str) -> T.Liststr:
+        return f'--output_file={target}'
+
+    def get_werror_args(self) -> T.Liststr:
+        return '--emit_warnings_as_errors'
+
+    def get_include_args(self, path: str, is_system: bool) -> T.Liststr:
+        if path == '':
+            path = '.'
+        return '-I=' + path
+
+    @classmethod
+    def _unix_args_to_native(cls, args: T.Liststr, info: MachineInfo) -> T.Liststr:
+        result = 
+        for i in args:
+            if i.startswith('-D'):
+                i = '--define=' + i2:
+            if i.startswith('-Wl,-rpath='):
+                continue
+            elif i == '--print-search-dirs':
+                continue
+            elif i.startswith('-L'):
+                continue
+            result.append(i)
+        return result
+
+    def compute_parameters_with_absolute_paths(self, parameter_list: T.Liststr, build_dir: str) -> T.Liststr:
+        for idx, i in enumerate(parameter_list):
+            if i:15 == '--include_path=':
+                parameter_listidx = i:15 + os.path.normpath(os.path.join(build_dir, i15:))
+            if i:2 == '-I':
+                parameter_listidx = i:2 + os.path.normpath(os.path.join(build_dir, i2:))
+
+        return parameter_list
+
+    def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.Liststr:
+        return '--preproc_with_compile', f'--preproc_dependency={outfile}'

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/visualstudio.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/visualstudio.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Abstractions to simplify compilers that implement an MSVC compatible
 interface.
@@ -62,6 +63,7 @@
 } # T.Dicststr, T.OptionalT.Liststr
 
 msvc_optimization_args = {
+ 'plain': ,
 '0': '/Od',
 'g': , # No specific flag to optimize debugging, /Zi or /ZI will create debug information
 '1': '/O1',
@@ -103,12 +105,15 @@
 # See: https://ninja-build.org/manual.html#_deps
 # Assume UTF-8 sources by default, but self.unix_args_to_native() removes it
 # if `/source-charset` is set too.
+ # It is also dropped if Visual Studio 2013 or earlier is used, since it would
+ # not be supported in that case.
 always_args = '/nologo', '/showIncludes', '/utf-8'
 warn_args = {
 '0': ,
 '1': '/W2',
 '2': '/W3',
 '3': '/W4',
+ 'everything': '/Wall',
 } # type: T.Dictstr, T.Liststr
 
 INVOKES_LINKER = False
@@ -130,16 +135,13 @@
 self.machine = target
 if mesonlib.version_compare(self.version, '>=19.28.29910'): # VS 16.9.0 includes cl 19.28.29910
 self.base_options.add(mesonlib.OptionKey('b_sanitize'))
- # Exclude /utf-8 in self.always_args in VS2013 and earlier
- if not isinstance(self, ClangClCompiler):
- if mesonlib.version_compare(self.version, '<19.00'):
- self.always_args.remove('/utf-8')
 assert self.linker is not None
 self.linker.machine = self.machine
 
 # Override CCompiler.get_always_args
 def get_always_args(self) -> T.Liststr:
- return self.always_args
+ # TODO: use ImmutableListProtocolstr here instead
+ return self.always_args.copy()
 
 def get_pch_suffix(self) -> str:
 return 'pch'
@@ -162,6 +164,9 @@
 def get_preprocess_only_args(self) -> T.Liststr:
 return '/EP'
 
+ def get_preprocess_to_file_args(self) -> T.Liststr:
+ return '/EP', '/P'
+
 def get_compile_only_args(self) -> T.Liststr:
 return '/c'
 
@@ -176,6 +181,8 @@
 return '/fsanitize=address'
 
 def get_output_args(self, target: str) -> T.Liststr:
+ if self.mode == 'PREPROCESSOR':
+ return '/Fi' + target
 if target.endswith('.exe'):
 return '/Fe' + target
 return '/Fo' + target
@@ -225,7 +232,7 @@
 for i in args:
 # -mms-bitfields is specific to MinGW-GCC
 # -pthread is only valid for GCC
- if i in ('-mms-bitfields', '-pthread'):
+ if i in {'-mms-bitfields', '-pthread'}:
 continue
 if i.startswith('-LIBPATH:'):
 i = '/LIBPATH:' + i9:
@@ -257,7 +264,9 @@
 continue
 # cl.exe does not allow specifying both, so remove /utf-8 that we
 # added automatically in the case the user overrides it manually.
- elif i.startswith('/source-charset:') or i.startswith('/execution-charset:'):
+ elif (i.startswith('/source-charset:')
+ or i.startswith('/execution-charset:')
+ or i == '/validate-charset-'):
 try:
 result.remove('/utf-8')
 except ValueError:
@@ -303,7 +312,7 @@
 with self._build_wrapper(code, env, extra_args=args, mode=mode) as p:
 if p.returncode != 0:
 return False, p.cached
- return not(warning_text in p.stderr or warning_text in p.stdout), p.cached
+ return not (warning_text in p.stderr or warning_text in p.stdout), p.cached
 
 def get_compile_debugfile_args(self, rel_obj: str, pch: bool = False) -> T.Liststr:
 pdbarr = rel_obj.split('.'):-1
@@ -358,7 +367,7 @@
 def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.Liststr:
 if crt_val in self.crt_args:
 return self.crt_argscrt_val
- assert crt_val in 'from_buildtype', 'static_from_buildtype'
+ assert crt_val in {'from_buildtype', 'static_from_buildtype'}
 dbg = 'mdd'
 rel = 'md'
 if crt_val == 'static_from_buildtype':
@@ -382,19 +391,43 @@
 def has_func_attribute(self, name: str, env: 'Environment') -> T.Tuplebool, bool:
 # MSVC doesn't have __attribute__ like Clang and GCC do, so just return
 # false without compiling anything
- return name in 'dllimport', 'dllexport', False
+ return name in {'dllimport', 'dllexport'}, False
 
 def get_argument_syntax(self) -> str:
 return 'msvc'
 
+ def symbols_have_underscore_prefix(self, env: 'Environment') -> bool:
+ '''
+ Check if the compiler prefixes an underscore to global C symbols.
+
+ This overrides the Clike method, as for MSVC checking the
+ underscore prefix based on the compiler define never works,
+ so do not even try.
+ '''
+ # Try to consult a hardcoded list of cases we know
+ # absolutely have an underscore prefix
+ result = self._symbols_have_underscore_prefix_list(env)
+ if result is not None:
+ return result
+
+ # As a last resort, try search in a compiled binary
+ return self._symbols_have_underscore_prefix_searchbin(env)
+
 
 class MSVCCompiler(VisualStudioLikeCompiler):
 
 """Specific to the Microsoft Compilers."""
 
+ id = 'msvc'
+
 def __init__(self, target: str):
 super().__init__(target)
- self.id = 'msvc'
+
+ # Visual Studio 2013 and erlier don't support the /utf-8 argument.
+ # We want to remove it. We also want to make an explicit copy so we
+ # don't mutate class constant state
+ if mesonlib.version_compare(self.version, '<19.00') and '/utf-8' in self.always_args:
+ self.always_args = r for r in self.always_args if r != '/utf-8'
 
 def get_compile_debugfile_args(self, rel_obj: str, pch: bool = False) -> T.Liststr:
 args = super().get_compile_debugfile_args(rel_obj, pch)
@@ -408,6 +441,11 @@
 args = '/FS' + args
 return args
 
+ # Override CCompiler.get_always_args
+ # We want to drop '/utf-8' for Visual Studio 2013 and earlier
+ def get_always_args(self) -> T.Liststr:
+ return self.always_args
+
 def get_instruction_set_args(self, instruction_set: str) -> T.OptionalT.Liststr:
 if self.version.split('.')0 == '16' and instruction_set == 'avx':
 # VS documentation says that this exists and should work, but
@@ -424,16 +462,17 @@
 
 """Specific to Clang-CL."""
 
+ id = 'clang-cl'
+
 def __init__(self, target: str):
 super().__init__(target)
- self.id = 'clang-cl'
 
 # Assembly
 self.can_compile_suffixes.add('s')
 
 def has_arguments(self, args: T.Liststr, env: 'Environment', code: str, mode: str) -> T.Tuplebool, bool:
 if mode != 'link':
- args = args + '-Werror=unknown-argument'
+ args = args + '-Werror=unknown-argument', '-Werror=unknown-warning-option'
 return super().has_arguments(args, env, code, mode)
 
 def get_toolset_version(self) -> T.Optionalstr:
@@ -458,4 +497,4 @@
 converted += i
 return converted
 else:
- return dep.get_compile_args()
\ No newline at end of file
+ return dep.get_compile_args()

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/mixins/xc16.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/mixins/xc16.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Representations specific to the Microchip XC16 C compiler family."""
 
@@ -20,6 +21,7 @@
 from ...mesonlib import EnvironmentException
 
 if T.TYPE_CHECKING:
+    from ...envconfig import MachineInfo
     from ...environment import Environment
     from ...compilers.compilers import Compiler
 else:
@@ -39,6 +41,7 @@
 }  # type: T.Dictstr, T.Liststr
 
 xc16_optimization_args = {
+    'plain': ,
     '0': '-O0',
     'g': '-O0',
     '1': '-O1',
@@ -55,17 +58,19 @@
 
 class Xc16Compiler(Compiler):
 
+    id = 'xc16'
+
     def __init__(self) -> None:
         if not self.is_cross:
             raise EnvironmentException('xc16 supports only cross-compilation.')
-        self.id = 'xc16'
         # Assembly
         self.can_compile_suffixes.add('s')
         default_warn_args =   # type: T.Liststr
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + ,
-                          '3': default_warn_args + }  # type: T.Dictstr, T.Liststr
+                          '3': default_warn_args + ,
+                          'everything': default_warn_args + }  # type: T.Dictstr, T.Liststr
 
     def get_always_args(self) -> T.Liststr:
         return 
@@ -103,7 +108,7 @@
         return xc16_debug_argsis_debug
 
     @classmethod
-    def unix_args_to_native(cls, args: T.Liststr) -> T.Liststr:
+    def _unix_args_to_native(cls, args: T.Liststr, info: MachineInfo) -> T.Liststr:
         result = 
         for i in args:
             if i.startswith('-D'):

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/objc.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/objc.py Changed

@@ -11,15 +11,16 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import typing as T
 
 from .. import coredata
-from ..mesonlib import MachineChoice, OptionKey
+from ..mesonlib import OptionKey
 
 from .compilers import Compiler
 from .mixins.clike import CLikeCompiler
-from .mixins.gnu import GnuCompiler
+from .mixins.gnu import GnuCompiler, gnu_common_warning_args, gnu_objc_warning_args
 from .mixins.clang import ClangCompiler
 
 if T.TYPE_CHECKING:
@@ -27,18 +28,19 @@
     from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
 
 
 class ObjCCompiler(CLikeCompiler, Compiler):
 
     language = 'objc'
 
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrap: T.Optional'ExternalProgram',
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        Compiler.__init__(self, exelist, version, for_machine, info,
+        Compiler.__init__(self, ccache, exelist, version, for_machine, info,
                           is_cross=is_cross, full_version=full_version,
                           linker=linker)
         CLikeCompiler.__init__(self, exe_wrap)
@@ -53,39 +55,43 @@
 
 
 class GnuObjCCompiler(GnuCompiler, ObjCCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        ObjCCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        ObjCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                               info, exe_wrapper, linker=linker, full_version=full_version)
         GnuCompiler.__init__(self, defines)
         default_warn_args = '-Wall', '-Winvalid-pch'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': (default_warn_args + '-Wextra', '-Wpedantic' +
+                                         self.supported_warn_args(gnu_common_warning_args) +
+                                         self.supported_warn_args(gnu_objc_warning_args))}
 
 
 class ClangObjCCompiler(ClangCompiler, ObjCCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        ObjCCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        ObjCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                               info, exe_wrapper, linker=linker, full_version=full_version)
         ClangCompiler.__init__(self, defines)
         default_warn_args = '-Wall', '-Winvalid-pch'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': '-Weverything'}
 
-    def get_options(self) -> 'coredata.KeyedOptionDictType':
+    def get_options(self) -> 'coredata.MutableKeyedOptionDictType':
         opts = super().get_options()
         opts.update({
             OptionKey('std', machine=self.for_machine, lang='c'): coredata.UserComboOption(

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/objcpp.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/objcpp.py Changed

@@ -11,15 +11,16 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import typing as T
 
 from .. import coredata
-from ..mesonlib import MachineChoice, OptionKey
+from ..mesonlib import OptionKey
 
 from .mixins.clike import CLikeCompiler
 from .compilers import Compiler
-from .mixins.gnu import GnuCompiler
+from .mixins.gnu import GnuCompiler, gnu_common_warning_args, gnu_objc_warning_args
 from .mixins.clang import ClangCompiler
 
 if T.TYPE_CHECKING:
@@ -27,17 +28,18 @@
     from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
 
 class ObjCPPCompiler(CLikeCompiler, Compiler):
 
     language = 'objcpp'
 
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrap: T.Optional'ExternalProgram',
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        Compiler.__init__(self, exelist, version, for_machine, info,
+        Compiler.__init__(self, ccache, exelist, version, for_machine, info,
                           is_cross=is_cross, full_version=full_version,
                           linker=linker)
         CLikeCompiler.__init__(self, exe_wrap)
@@ -52,40 +54,44 @@
 
 
 class GnuObjCPPCompiler(GnuCompiler, ObjCPPCompiler):
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        ObjCPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        ObjCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                                 info, exe_wrapper, linker=linker, full_version=full_version)
         GnuCompiler.__init__(self, defines)
-        default_warn_args = '-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor'
+        default_warn_args = '-Wall', '-Winvalid-pch'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': (default_warn_args + '-Wextra', '-Wpedantic' +
+                                         self.supported_warn_args(gnu_common_warning_args) +
+                                         self.supported_warn_args(gnu_objc_warning_args))}
 
 
 class ClangObjCPPCompiler(ClangCompiler, ObjCPPCompiler):
 
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
+    def __init__(self, ccache: T.Liststr, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  defines: T.OptionalT.Dictstr, str = None,
                  linker: T.Optional'DynamicLinker' = None,
                  full_version: T.Optionalstr = None):
-        ObjCPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+        ObjCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
                                 info, exe_wrapper, linker=linker, full_version=full_version)
         ClangCompiler.__init__(self, defines)
-        default_warn_args = '-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor'
+        default_warn_args = '-Wall', '-Winvalid-pch'
         self.warn_args = {'0': ,
                           '1': default_warn_args,
                           '2': default_warn_args + '-Wextra',
-                          '3': default_warn_args + '-Wextra', '-Wpedantic'}
+                          '3': default_warn_args + '-Wextra', '-Wpedantic',
+                          'everything': '-Weverything'}
 
-    def get_options(self) -> 'coredata.KeyedOptionDictType':
+    def get_options(self) -> 'coredata.MutableKeyedOptionDictType':
         opts = super().get_options()
         opts.update({
             OptionKey('std', machine=self.for_machine, lang='cpp'): coredata.UserComboOption(

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/rust.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/rust.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2012-2017 The Meson development team
+# Copyright 2012-2022 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,27 +11,27 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import subprocess, os.path
 import textwrap
 import typing as T
 
 from .. import coredata
-from ..mesonlib import (
-    EnvironmentException, MachineChoice, MesonException, Popen_safe,
-    OptionKey,
-)
+from ..mesonlib import EnvironmentException, MesonException, Popen_safe, OptionKey
 from .compilers import Compiler, rust_buildtype_args, clike_debug_args
 
 if T.TYPE_CHECKING:
-    from ..coredata import KeyedOptionDictType
+    from ..coredata import MutableKeyedOptionDictType, KeyedOptionDictType
     from ..envconfig import MachineInfo
     from ..environment import Environment  # noqa: F401
     from ..linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
     from ..programs import ExternalProgram
 
 
 rust_optimization_args = {
+    'plain': ,
     '0': ,
     'g': '-C', 'opt-level=0',
     '1': '-C', 'opt-level=1',
@@ -44,6 +44,7 @@
 
     # rustc doesn't invoke the compiler itself, it doesn't need a LINKER_PREFIX
     language = 'rust'
+    id = 'rustc'
 
     _WARNING_LEVELS: T.Dictstr, T.Liststr = {
         '0': '-A', 'warnings',
@@ -57,11 +58,10 @@
                  exe_wrapper: T.Optional'ExternalProgram' = None,
                  full_version: T.Optionalstr = None,
                  linker: T.Optional'DynamicLinker' = None):
-        super().__init__(exelist, version, for_machine, info,
+        super().__init__(, exelist, version, for_machine, info,
                          is_cross=is_cross, full_version=full_version,
                          linker=linker)
         self.exe_wrapper = exe_wrapper
-        self.id = 'rustc'
         self.base_options.add(OptionKey('b_colorout'))
         if 'link' in self.linker.id:
             self.base_options.add(OptionKey('b_vscrt'))
@@ -110,9 +110,9 @@
         return rust_buildtype_argsbuildtype
 
     def get_sysroot(self) -> str:
-        cmd = self.exelist + '--print', 'sysroot'
+        cmd = self.get_exelist(ccache=False) + '--print', 'sysroot'
         p, stdo, stde = Popen_safe(cmd)
-        return stdo.split('\n')0
+        return stdo.split('\n', maxsplit=1)0
 
     def get_debug_args(self, is_debug: bool) -> T.Liststr:
         return clike_debug_argsis_debug
@@ -136,14 +136,14 @@
         return '-o', outputname
 
     @classmethod
-    def use_linker_args(cls, linker: str) -> T.Liststr:
+    def use_linker_args(cls, linker: str, version: str) -> T.Liststr:
         return '-C', f'linker={linker}'
 
     # Rust does not have a use_linker_args because it dispatches to a gcc-like
     # C compiler for dynamic linking, as such we invoke the C compiler's
     # use_linker_args method instead.
 
-    def get_options(self) -> 'KeyedOptionDictType':
+    def get_options(self) -> 'MutableKeyedOptionDictType':
         key = OptionKey('std', machine=self.for_machine, lang=self.language)
         return {
             key: coredata.UserComboOption(
@@ -205,11 +205,4 @@
     This just provides us a different id
     """
 
-    def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
-                 exe_wrapper: T.Optional'ExternalProgram' = None,
-                 full_version: T.Optionalstr = None,
-                 linker: T.Optional'DynamicLinker' = None):
-        super().__init__(exelist, version, for_machine, is_cross, info,
-                         exe_wrapper, full_version, linker)
-        self.id = 'clippy-driver rustc'
+    id = 'clippy-driver rustc'

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/swift.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/swift.py Changed

@@ -11,11 +11,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import subprocess, os.path
 import typing as T
 
-from ..mesonlib import EnvironmentException, MachineChoice
+from ..mesonlib import EnvironmentException
 
 from .compilers import Compiler, swift_buildtype_args, clike_debug_args
 
@@ -23,8 +24,10 @@
     from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers import DynamicLinker
+    from ..mesonlib import MachineChoice
 
 swift_optimization_args = {
+    'plain': ,
     '0': ,
     'g': ,
     '1': '-O',
@@ -37,15 +40,15 @@
 
     LINKER_PREFIX = '-Xlinker'
     language = 'swift'
+    id = 'llvm'
 
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo', full_version: T.Optionalstr = None,
                  linker: T.Optional'DynamicLinker' = None):
-        super().__init__(exelist, version, for_machine, info,
+        super().__init__(, exelist, version, for_machine, info,
                          is_cross=is_cross, full_version=full_version,
                          linker=linker)
         self.version = version
-        self.id = 'llvm'
 
     def needs_static_linker(self) -> bool:
         return True
@@ -56,7 +59,7 @@
     def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.Liststr:
         return '-emit-dependencies'
 
-    def depfile_for_object(self, objfile: str) -> str:
+    def depfile_for_object(self, objfile: str) -> T.Optionalstr:
         return os.path.splitext(objfile)0 + '.' + self.get_depfile_suffix()
 
     def get_depfile_suffix(self) -> str:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/compilers/vala.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/compilers/vala.py Changed

@@ -11,28 +11,30 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import os.path
 import typing as T
 
 from .. import mlog
-from ..mesonlib import EnvironmentException, MachineChoice, version_compare, OptionKey
+from ..mesonlib import EnvironmentException, version_compare, OptionKey
 
 from .compilers import Compiler, LibType
 
 if T.TYPE_CHECKING:
     from ..envconfig import MachineInfo
     from ..environment import Environment
+    from ..mesonlib import MachineChoice
 
 class ValaCompiler(Compiler):
 
     language = 'vala'
+    id = 'valac'
 
     def __init__(self, exelist: T.Liststr, version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo'):
-        super().__init__(exelist, version, for_machine, info, is_cross=is_cross)
+        super().__init__(, exelist, version, for_machine, info, is_cross=is_cross)
         self.version = version
-        self.id = 'valac'
         self.base_options = {OptionKey('b_colorout')}
 
     def needs_static_linker(self) -> bool:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/coredata.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/coredata.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2012-2021 The Meson development team
+# Copyright 2012-2022 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from . import mlog, mparser
 import pickle, os, uuid
@@ -22,7 +23,10 @@
     HoldableObject,
     MesonException, EnvironmentException, MachineChoice, PerMachine,
     PerMachineDefaultable, default_libdir, default_libexecdir,
-    default_prefix, split_args, OptionKey, OptionType, stringlistify,
+    default_prefix, default_datadir, default_includedir, default_infodir,
+    default_localedir, default_mandir, default_sbindir, default_sysconfdir,
+    split_args, OptionKey, OptionType, stringlistify,
+    pickle_load, replace_if_different
 )
 from .wrap import WrapMode
 import ast
@@ -35,12 +39,14 @@
 if T.TYPE_CHECKING:
     from . import dependencies
     from .compilers.compilers import Compiler, CompileResult
+    from .dependencies.detect import TV_DepID
     from .environment import Environment
     from .mesonlib import OptionOverrideProxy, FileOrString
     from .cmake.traceparser import CMakeCacheEntry
 
     OptionDictType = T.UnionT.Dictstr, 'UserOptionT.Any', OptionOverrideProxy
-    KeyedOptionDictType = T.UnionT.Dict'OptionKey', 'UserOptionT.Any', OptionOverrideProxy
+    MutableKeyedOptionDictType = T.Dict'OptionKey', 'UserOptionT.Any'
+    KeyedOptionDictType = T.UnionMutableKeyedOptionDictType, OptionOverrideProxy
     CompilerCheckCacheKey = T.TupleT.Tuplestr, ..., str, FileOrString, T.Tuplestr, ..., str
 
     # typeshed
@@ -50,7 +56,7 @@
 #
 # Pip requires that RCs are named like this: '0.1.0.rc1'
 # But the corresponding Git tag needs to be '0.1.0rc1'
-version = '0.61.5'
+version = '1.0.1'
 
 backendlist = 'ninja', 'vs', 'vs2010', 'vs2012', 'vs2013', 'vs2015', 'vs2017', 'vs2019', 'vs2022', 'xcode'
 
@@ -79,7 +85,7 @@
         if not isinstance(yielding, bool):
             raise MesonException('Value of "yielding" must be a boolean.')
         self.yielding = yielding
-        self.deprecated: T.Unionbool, T.Dictstr, str, T.Liststr = False
+        self.deprecated: T.Unionbool, str, T.Dictstr, str, T.Liststr = False
 
     def listify(self, value: T.Any) -> T.ListT.Any:
         return value
@@ -282,9 +288,6 @@
     def is_auto(self) -> bool:
         return self.value == 'auto'
 
-if T.TYPE_CHECKING:
-    from .dependencies.detect import TV_DepID
-
 
 class DependencyCacheType(enum.Enum):
 
@@ -443,7 +446,7 @@
         self.meson_command = meson_command
         self.target_guids = {}
         self.version = version
-        self.options: 'KeyedOptionDictType' = {}
+        self.options: 'MutableKeyedOptionDictType' = {}
         self.cross_files = self.__load_config_files(options, scratch_dir, 'cross')
         self.compilers = PerMachine(OrderedDict(), OrderedDict())  # type: PerMachineT.Dictstr, Compiler
 
@@ -552,14 +555,13 @@
 
     def sanitize_dir_option_value(self, prefix: str, option: OptionKey, value: T.Any) -> T.Any:
         '''
-        If the option is an installation directory option and the value is an
-        absolute path, check that it resides within prefix and return the value
-        as a path relative to the prefix.
-
-        This way everyone can do f.ex, get_option('libdir') and be sure to get
-        the library directory relative to prefix.
+        If the option is an installation directory option, the value is an
+        absolute path and resides within prefix, return the value
+        as a path relative to the prefix. Otherwise, return it as is.
 
-        .as_posix() keeps the posix-like file separators Meson uses.
+        This way everyone can do f.ex, get_option('libdir') and usually get
+        the library directory relative to prefix, even though it really
+        should not be relied upon.
         '''
         try:
             value = PurePath(value)
@@ -567,21 +569,20 @@
             return value
         if option.name.endswith('dir') and value.is_absolute() and \
            option not in BULITIN_DIR_NOPREFIX_OPTIONS:
-            # Value must be a subdir of the prefix
-            # commonpath will always return a path in the native format, so we
-            # must use pathlib.PurePath to do the same conversion before
-            # comparing.
-            msg = ('The value of the \'{!s}\' option is \'{!s}\' which must be a '
-                   'subdir of the prefix {!r}.\nNote that if you pass a '
-                   'relative path, it is assumed to be a subdir of prefix.')
-            # os.path.commonpath doesn't understand case-insensitive filesystems,
-            # but PurePath().relative_to() does.
             try:
+                # Try to relativize the path.
                 value = value.relative_to(prefix)
             except ValueError:
-                raise MesonException(msg.format(option, value, prefix))
-            if '..' in str(value):
-                raise MesonException(msg.format(option, value, prefix))
+                # Path is not relative, let’s keep it as is.
+                pass
+            if '..' in value.parts:
+                raise MesonException(
+                    f'The value of the \'{option}\' option is \'{value}\' but '
+                    'directory options are not allowed to contain \'..\'.\n'
+                    f'If you need a path outside of the {prefix!r} prefix, '
+                    'please use an absolute path.'
+                )
+        # .as_posix() keeps the posix-like file separators Meson uses.
         return value.as_posix()
 
     def init_builtins(self, subproject: str) -> None:
@@ -593,7 +594,7 @@
                 self.add_builtin_option(self.options, key.evolve(subproject=subproject, machine=for_machine), opt)
 
     @staticmethod
-    def add_builtin_option(opts_map: 'KeyedOptionDictType', key: OptionKey,
+    def add_builtin_option(opts_map: 'MutableKeyedOptionDictType', key: OptionKey,
                            opt: 'BuiltinOption') -> None:
         if key.subproject:
             if opt.yielding:
@@ -615,7 +616,7 @@
                 'Default project to execute in Visual Studio',
                 '')
 
-    def get_option(self, key: OptionKey) -> T.Unionstr, int, bool, WrapMode:
+    def get_option(self, key: OptionKey) -> T.UnionT.Liststr, str, int, bool, WrapMode:
         try:
             v = self.optionskey.value
             if key.name == 'wrap_mode':
@@ -663,6 +664,19 @@
                 return v
             newvalue = replace(v) for v in opt.listify(value)
             value = ','.join(newvalue)
+        elif isinstance(opt.deprecated, str):
+            # Option is deprecated and replaced by another. Note that a project
+            # option could be replaced by a built-in or module option, which is
+            # why we use OptionKey.from_string(newname) instead of
+            # key.evolve(newname). We set the value on both the old and new names,
+            # assuming they accept the same value. That could for example be
+            # achieved by adding the values from old option as deprecated on the
+            # new option, for example in the case of boolean option is replaced
+            # by a feature option with a different name.
+            newname = opt.deprecated
+            newkey = OptionKey.from_string(newname).evolve(subproject=key.subproject)
+            mlog.deprecation(f'Option {key.name!r} is replaced by {newname!r}')
+            self.set_option(newkey, value)
 
         opt.set_value(value)
 
@@ -682,7 +696,7 @@
         result = 
         value = self.optionsOptionKey('buildtype').value
         if value == 'plain':
-            opt = '0'
+            opt = 'plain'
             debug = False
         elif value == 'debug':
             opt = '0'
@@ -709,7 +723,7 @@
 
     def _set_others_from_buildtype(self, value: str) -> None:
         if value == 'plain':
-            opt = '0'
+            opt = 'plain'
             debug = False
         elif value == 'debug':
             opt = '0'
@@ -746,13 +760,13 @@
             raise type(e)(('Validation failed for option %s: ' % option_name) + str(e)) \
                 .with_traceback(sys.exc_info()2)
 
-    def get_external_args(self, for_machine: MachineChoice, lang: str) -> T.Unionstr, T.Liststr:
+    def get_external_args(self, for_machine: MachineChoice, lang: str) -> T.Liststr:
         return self.optionsOptionKey('args', machine=for_machine, lang=lang).value
 
-    def get_external_link_args(self, for_machine: MachineChoice, lang: str) -> T.Unionstr, T.Liststr:
+    def get_external_link_args(self, for_machine: MachineChoice, lang: str) -> T.Liststr:
         return self.optionsOptionKey('link_args', machine=for_machine, lang=lang).value
 
-    def update_project_options(self, options: 'KeyedOptionDictType') -> None:
+    def update_project_options(self, options: 'MutableKeyedOptionDictType') -> None:
         for key, value in options.items():
             if not key.is_project():
                 continue
@@ -810,7 +824,7 @@
                 continue
             elif k in self.options:
                 self.set_option(k, v)
-            elif k.machine != MachineChoice.BUILD:
+            elif k.machine != MachineChoice.BUILD and k.type != OptionType.COMPILER:
                 unknown_options.append(k)
         if unknown_options:
             unknown_options_str = ', '.join(sorted(str(s) for s in unknown_options))
@@ -821,13 +835,16 @@
             self.copy_build_options_from_regular_ones()
 
     def set_default_options(self, default_options: T.MutableMappingOptionKey, str, subproject: str, env: 'Environment') -> None:
+        # Main project can set default options on subprojects, but subprojects
+        # can only set default options on themself.
         # Preserve order: if env.options has 'buildtype' it must come after
         # 'optimization' if it is in default_options.
-        options: T.MutableMappingOptionKey, T.Any
-        if not subproject:
-            options = OrderedDict(default_options)
-            options.update(env.options)
-            env.options = options
+        options: T.MutableMappingOptionKey, T.Any = OrderedDict()
+        for k, v in default_options.items():
+            if not subproject or k.subproject == subproject:
+                optionsk = v
+        options.update(env.options)
+        env.options = options
 
         # Create a subset of options, keeping only project and builtin
         # options for this subproject.
@@ -836,7 +853,7 @@
         # to know which backend we'll use).
         options = OrderedDict()
 
-        for k, v in chain(default_options.items(), env.options.items()):
+        for k, v in env.options.items():
             # If this is a subproject, don't use other subproject options
             if k.subproject and k.subproject != subproject:
                 continue
@@ -855,7 +872,7 @@
 
         self.set_options(options, subproject=subproject)
 
-    def add_compiler_options(self, options: 'KeyedOptionDictType', lang: str, for_machine: MachineChoice,
+    def add_compiler_options(self, options: 'MutableKeyedOptionDictType', lang: str, for_machine: MachineChoice,
                              env: 'Environment') -> None:
         for k, o in options.items():
             value = env.options.get(k)
@@ -900,7 +917,7 @@
         # storing subproject options like "subproject:option=value"
         super().__init__(delimiters='=', interpolation=None)
 
-    def read(self, filenames: T.Union'StrOrBytesPath', T.Iterable'StrOrBytesPath', encoding: str ='utf-8') -> T.Liststr:
+    def read(self, filenames: T.Union'StrOrBytesPath', T.Iterable'StrOrBytesPath', encoding: str = 'utf-8') -> T.Liststr:
         return super().read(filenames, encoding)
 
     def optionxform(self, option: str) -> str:
@@ -1021,9 +1038,9 @@
 def format_cmd_line_options(options: argparse.Namespace) -> str:
     cmdline = '-D{}={}'.format(str(k), v) for k, v in options.cmd_line_options.items()
     if options.cross_file:
-        cmdline += f'--cross-file {f}' for f in options.cross_file
+        cmdline += f'--cross-file={f}' for f in options.cross_file
     if options.native_file:
-        cmdline += f'--native-file {f}' for f in options.native_file
+        cmdline += f'--native-file={f}' for f in options.native_file
     return ' '.join(shlex.quote(x) for x in cmdline)
 
 def major_versions_differ(v1: str, v2: str) -> bool:
@@ -1034,23 +1051,11 @@
 
 def load(build_dir: str) -> CoreData:
     filename = os.path.join(build_dir, 'meson-private', 'coredata.dat')
-    load_fail_msg = f'Coredata file {filename!r} is corrupted. Try with a fresh build tree.'
-    try:
-        with open(filename, 'rb') as f:
-            obj = pickle.load(f)
-    except (pickle.UnpicklingError, EOFError):
-        raise MesonException(load_fail_msg)
-    except (TypeError, ModuleNotFoundError, AttributeError):
-        raise MesonException(
-            f"Coredata file {filename!r} references functions or classes that don't "
-            "exist. This probably means that it was generated with an old "
-            "version of meson.")
-    if not isinstance(obj, CoreData):
-        raise MesonException(load_fail_msg)
-    if major_versions_differ(obj.version, version):
-        raise MesonVersionMismatchException(obj.version, version)
+    obj = pickle_load(filename, 'Coredata', CoreData)
+    assert isinstance(obj, CoreData), 'for mypy'
     return obj
 
+
 def save(obj: CoreData, build_dir: str) -> str:
     filename = os.path.join(build_dir, 'meson-private', 'coredata.dat')
     prev_filename = filename + '.prev'
@@ -1064,7 +1069,7 @@
         pickle.dump(obj, f)
         f.flush()
         os.fsync(f.fileno())
-    os.replace(tempfilename, filename)
+    replace_if_different(filename, tempfilename)
     return filename
 
 
@@ -1188,23 +1193,23 @@
 
 # Update `docs/markdown/Builtin-options.md` after changing the options below
 # Also update mesonlib._BUILTIN_NAMES. See the comment there for why this is required.
-BUILTIN_DIR_OPTIONS: 'KeyedOptionDictType' = OrderedDict(
+BUILTIN_DIR_OPTIONS: 'MutableKeyedOptionDictType' = OrderedDict(
     (OptionKey('prefix'),          BuiltinOption(UserStringOption, 'Installation prefix', default_prefix())),
     (OptionKey('bindir'),          BuiltinOption(UserStringOption, 'Executable directory', 'bin')),
-    (OptionKey('datadir'),         BuiltinOption(UserStringOption, 'Data file directory', 'share')),
-    (OptionKey('includedir'),      BuiltinOption(UserStringOption, 'Header file directory', 'include')),
-    (OptionKey('infodir'),         BuiltinOption(UserStringOption, 'Info page directory', 'share/info')),
+    (OptionKey('datadir'),         BuiltinOption(UserStringOption, 'Data file directory', default_datadir())),
+    (OptionKey('includedir'),      BuiltinOption(UserStringOption, 'Header file directory', default_includedir())),
+    (OptionKey('infodir'),         BuiltinOption(UserStringOption, 'Info page directory', default_infodir())),
     (OptionKey('libdir'),          BuiltinOption(UserStringOption, 'Library directory', default_libdir())),
     (OptionKey('libexecdir'),      BuiltinOption(UserStringOption, 'Library executable directory', default_libexecdir())),
-    (OptionKey('localedir'),       BuiltinOption(UserStringOption, 'Locale data directory', 'share/locale')),
+    (OptionKey('localedir'),       BuiltinOption(UserStringOption, 'Locale data directory', default_localedir())),
     (OptionKey('localstatedir'),   BuiltinOption(UserStringOption, 'Localstate data directory', 'var')),
-    (OptionKey('mandir'),          BuiltinOption(UserStringOption, 'Manual page directory', 'share/man')),
-    (OptionKey('sbindir'),         BuiltinOption(UserStringOption, 'System executable directory', 'sbin')),
+    (OptionKey('mandir'),          BuiltinOption(UserStringOption, 'Manual page directory', default_mandir())),
+    (OptionKey('sbindir'),         BuiltinOption(UserStringOption, 'System executable directory', default_sbindir())),
     (OptionKey('sharedstatedir'),  BuiltinOption(UserStringOption, 'Architecture-independent data directory', 'com')),
-    (OptionKey('sysconfdir'),      BuiltinOption(UserStringOption, 'Sysconf data directory', 'etc')),
+    (OptionKey('sysconfdir'),      BuiltinOption(UserStringOption, 'Sysconf data directory', default_sysconfdir())),
 )
 
-BUILTIN_CORE_OPTIONS: 'KeyedOptionDictType' = OrderedDict(
+BUILTIN_CORE_OPTIONS: 'MutableKeyedOptionDictType' = OrderedDict(
     (OptionKey('auto_features'),   BuiltinOption(UserFeatureOption, "Override value of all 'auto' features", 'auto')),
     (OptionKey('backend'),         BuiltinOption(UserComboOption, 'Backend to use', 'ninja', choices=backendlist)),
     (OptionKey('buildtype'),       BuiltinOption(UserComboOption, 'Build type to use', 'debug',
@@ -1215,17 +1220,24 @@
     (OptionKey('errorlogs'),       BuiltinOption(UserBooleanOption, "Whether to print the logs from failing tests", True)),
     (OptionKey('install_umask'),   BuiltinOption(UserUmaskOption, 'Default umask to apply on permissions of installed files', '022')),
     (OptionKey('layout'),          BuiltinOption(UserComboOption, 'Build directory layout', 'mirror', choices='mirror', 'flat')),
-    (OptionKey('optimization'),    BuiltinOption(UserComboOption, 'Optimization level', '0', choices='0', 'g', '1', '2', '3', 's')),
+    (OptionKey('optimization'),    BuiltinOption(UserComboOption, 'Optimization level', '0', choices='plain', '0', 'g', '1', '2', '3', 's')),
+    (OptionKey('prefer_static'),   BuiltinOption(UserBooleanOption, 'Whether to try static linking before shared linking', False)),
     (OptionKey('stdsplit'),        BuiltinOption(UserBooleanOption, 'Split stdout and stderr in test logs', True)),
     (OptionKey('strip'),           BuiltinOption(UserBooleanOption, 'Strip targets on install', False)),
     (OptionKey('unity'),           BuiltinOption(UserComboOption, 'Unity build', 'off', choices='on', 'off', 'subprojects')),
     (OptionKey('unity_size'),      BuiltinOption(UserIntegerOption, 'Unity block size', (2, None, 4))),
-    (OptionKey('warning_level'),   BuiltinOption(UserComboOption, 'Compiler warning level to use', '1', choices='0', '1', '2', '3', yielding=False)),
+    (OptionKey('warning_level'),   BuiltinOption(UserComboOption, 'Compiler warning level to use', '1', choices='0', '1', '2', '3', 'everything', yielding=False)),
     (OptionKey('werror'),          BuiltinOption(UserBooleanOption, 'Treat warnings as errors', False, yielding=False)),
     (OptionKey('wrap_mode'),       BuiltinOption(UserComboOption, 'Wrap mode', 'default', choices='default', 'nofallback', 'nodownload', 'forcefallback', 'nopromote')),
     (OptionKey('force_fallback_for'), BuiltinOption(UserArrayOption, 'Force fallback for those subprojects', )),
 
+    # Pkgconfig module
+    (OptionKey('relocatable', module='pkgconfig'),
+     BuiltinOption(UserBooleanOption, 'Generate pkgconfig files as relocatable', False)),
+
     # Python module
+    (OptionKey('install_env', module='python'),
+     BuiltinOption(UserComboOption, 'Which python environment to install to', 'prefix', choices='auto', 'prefix', 'system', 'venv')),
     (OptionKey('platlibdir', module='python'),
      BuiltinOption(UserStringOption, 'Directory for site-specific, platform-specific files.', '')),
     (OptionKey('purelibdir', module='python'),
@@ -1234,7 +1246,7 @@
 
 BUILTIN_OPTIONS = OrderedDict(chain(BUILTIN_DIR_OPTIONS.items(), BUILTIN_CORE_OPTIONS.items()))
 
-BUILTIN_OPTIONS_PER_MACHINE: 'KeyedOptionDictType' = OrderedDict(
+BUILTIN_OPTIONS_PER_MACHINE: 'MutableKeyedOptionDictType' = OrderedDict(
     (OptionKey('pkg_config_path'), BuiltinOption(UserArrayOption, 'List of additional paths for pkg-config to search', )),
     (OptionKey('cmake_prefix_path'), BuiltinOption(UserArrayOption, 'List of additional prefixes for cmake to search', )),
 )

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/__init__.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/__init__.py Changed

@@ -15,10 +15,10 @@
 from .boost import BoostDependency
 from .cuda import CudaDependency
 from .hdf5 import hdf5_factory
-from .base import Dependency, InternalDependency, ExternalDependency, NotFoundDependency
+from .base import Dependency, InternalDependency, ExternalDependency, NotFoundDependency, MissingCompiler
 from .base import (
         ExternalLibrary, DependencyException, DependencyMethods,
-        BuiltinDependency, SystemDependency)
+        BuiltinDependency, SystemDependency, get_leaf_external_dependencies)
 from .cmake import CMakeDependency
 from .configtool import ConfigToolDependency
 from .dub import DubDependency
@@ -27,7 +27,7 @@
 from .factory import DependencyFactory
 from .detect import find_external_dependency, get_dep_identifier, packages, _packages_accept_language
 from .dev import (
-    ValgrindDependency, JDKSystemDependency, gmock_factory, gtest_factory,
+    ValgrindDependency, JNISystemDependency, JDKSystemDependency, gmock_factory, gtest_factory,
     llvm_factory, zlib_factory)
 from .coarrays import coarray_factory
 from .mpi import mpi_factory
@@ -36,6 +36,7 @@
     BlocksDependency, OpenMPDependency, cups_factory, curses_factory, gpgme_factory,
     libgcrypt_factory, libwmf_factory, netcdf_factory, pcap_factory, python3_factory,
     shaderc_factory, threads_factory, ThreadDependency, iconv_factory, intl_factory,
+    dl_factory, openssl_factory, libcrypto_factory, libssl_factory,
 )
 from .platform import AppleFrameworks
 from .qt import qt4_factory, qt5_factory, qt6_factory
@@ -51,6 +52,7 @@
     'ExternalLibrary',
     'DependencyException',
     'DependencyMethods',
+    'MissingCompiler',
 
     'CMakeDependency',
     'ConfigToolDependency',
@@ -64,6 +66,7 @@
 
     'find_external_dependency',
     'get_dep_identifier',
+    'get_leaf_external_dependencies',
 
 
 """Dependency representations and discovery logic.
@@ -140,8 +143,8 @@
 don't want to be reading random environment variables at this point. Those
 should actually be added to `envconfig.Properties` and read in
 `environment.Environment._set_default_properties_from_env` (see how
-`BOOST_ROOT` is handled). We can also handle the `static` keyword. So
-now that becomes:
+`BOOST_ROOT` is handled). We can also handle the `static` keyword and the
+`prefer_static` built-in option. So now that becomes:
 
 ```python
 class FooSystemDependency(ExternalDependency):
@@ -154,7 +157,9 @@
             self.is_found = False
             return
 
-        static = Mesonlib.LibType.STATIC if kwargs.get('static', False) else Mesonlib.LibType.SHARED
+        get_option = environment.coredata.get_option
+        static_opt = kwargs.get('static', get_option(Mesonlib.OptionKey('prefer_static'))
+        static = Mesonlib.LibType.STATIC if static_opt else Mesonlib.LibType.SHARED
         lib = self.clib_compiler.find_library(
             'foo', environment, os.path.join(root, 'lib'), libtype=static)
         if lib is None:
@@ -228,6 +233,7 @@
     'llvm': llvm_factory,
     'valgrind': ValgrindDependency,
     'zlib': zlib_factory,
+    'jni': JNISystemDependency,
     'jdk': JDKSystemDependency,
 
     'boost': BoostDependency,
@@ -254,6 +260,10 @@
     'shaderc': shaderc_factory,
     'iconv': iconv_factory,
     'intl': intl_factory,
+    'dl': dl_factory,
+    'openssl': openssl_factory,
+    'libcrypto': libcrypto_factory,
+    'libssl': libssl_factory,
 
     # From platform:
     'appleframeworks': AppleFrameworks,

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/base.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/base.py Changed

@@ -14,22 +14,31 @@
 
 # This file contains the detection logic for external dependencies.
 # Custom logic for several other packages are in separate files.
+
+from __future__ import annotations
 import copy
 import os
+import collections
 import itertools
 import typing as T
 from enum import Enum
 
-from .. import mlog
+from .. import mlog, mesonlib
 from ..compilers import clib_langs
-from ..mesonlib import LibType, MachineChoice, MesonException, HoldableObject
+from ..mesonlib import LibType, MachineChoice, MesonException, HoldableObject, OptionKey
 from ..mesonlib import version_compare_many
-from ..interpreterbase import FeatureDeprecated
+#from ..interpreterbase import FeatureDeprecated, FeatureNew
 
 if T.TYPE_CHECKING:
+ from .._typing import ImmutableListProtocol
+ from ..build import StructuredSources
 from ..compilers.compilers import Compiler
 from ..environment import Environment
- from ..build import BuildTarget, CustomTarget
+ from ..interpreterbase import FeatureCheckBase
+ from ..build import (
+ CustomTarget, IncludeDirs, CustomTargetIndex, LibTypes,
+ StaticLibrary
+ )
 from ..mesonlib import FileOrString
 
 
@@ -37,6 +46,19 @@
 '''Exceptions raised while trying to find dependencies'''
 
 
+class MissingCompiler:
+ """Represent a None Compiler - when no tool chain is found.
+ replacing AttributeError with DependencyException"""
+
+ def __getattr__(self, item: str) -> T.Any:
+ if item.startswith('__'):
+ raise AttributeError()
+ raise DependencyException('no toolchain found')
+
+ def __bool__(self) -> bool:
+ return False
+
+
 class DependencyMethods(Enum):
 # Auto means to use whatever dependency checking mechanisms in whatever order meson thinks is best.
 AUTO = 'auto'
@@ -88,9 +110,12 @@
 # Raw -L and -l arguments without manual library searching
 # If None, self.link_args will be used
 self.raw_link_args: T.OptionalT.Liststr = None
- self.sources: T.ListT.Union'FileOrString', 'CustomTarget' = 
+ self.sources: T.ListT.Union'FileOrString', 'CustomTarget', 'StructuredSources' = 
 self.include_type = self._process_include_type_kw(kwargs)
 self.ext_deps: T.ListDependency = 
+ self.d_features: T.DefaultDictstr, T.ListT.Any = collections.defaultdict(list)
+ self.featurechecks: T.List'FeatureCheckBase' = 
+ self.feature_since: T.OptionalT.Tuplestr, str = None
 
 def __repr__(self) -> str:
 return f'<{self.__class__.__name__} {self.name}: {self.is_found}>'
@@ -142,7 +167,7 @@
 def found(self) -> bool:
 return self.is_found
 
- def get_sources(self) -> T.ListT.Union'FileOrString', 'CustomTarget':
+ def get_sources(self) -> T.ListT.Union'FileOrString', 'CustomTarget', 'StructuredSources':
 """Source files that need to be added to the target.
 As an example, gtest-all.cc when using GTest."""
 return self.sources
@@ -156,13 +181,18 @@
 else:
 return 'unknown'
 
+ def get_include_dirs(self) -> T.List'IncludeDirs':
+ return 
+
 def get_include_type(self) -> str:
 return self.include_type
 
 def get_exe_args(self, compiler: 'Compiler') -> T.Liststr:
 return 
 
- def get_pkgconfig_variable(self, variable_name: str, kwargs: T.Dictstr, T.Any) -> str:
+ def get_pkgconfig_variable(self, variable_name: str,
+ define_variable: 'ImmutableListProtocolstr',
+ default: T.Optionalstr) -> str:
 raise DependencyException(f'{self.name!r} is not a pkgconfig dependency')
 
 def get_configtool_variable(self, variable_name: str) -> str:
@@ -205,7 +235,7 @@
 def get_variable(self, *, cmake: T.Optionalstr = None, pkgconfig: T.Optionalstr = None,
 configtool: T.Optionalstr = None, internal: T.Optionalstr = None,
 default_value: T.Optionalstr = None,
- pkgconfig_define: T.OptionalT.Liststr = None) -> T.Unionstr, T.Liststr:
+ pkgconfig_define: T.OptionalT.Liststr = None) -> str:
 if default_value is not None:
 return default_value
 raise DependencyException(f'No default provided for dependency {self!r}, which is not pkg-config, cmake, or config-tool based.')
@@ -216,11 +246,13 @@
 return new_dep
 
 class InternalDependency(Dependency):
- def __init__(self, version: str, incdirs: T.Liststr, compile_args: T.Liststr,
- link_args: T.Liststr, libraries: T.List'BuildTarget',
- whole_libraries: T.List'BuildTarget',
- sources: T.SequenceT.Union'FileOrString', 'CustomTarget',
- ext_deps: T.ListDependency, variables: T.Dictstr, T.Any):
+ def __init__(self, version: str, incdirs: T.List'IncludeDirs', compile_args: T.Liststr,
+ link_args: T.Liststr,
+ libraries: T.ListLibTypes,
+ whole_libraries: T.ListT.UnionStaticLibrary, CustomTarget, CustomTargetIndex,
+ sources: T.SequenceT.UnionFileOrString, CustomTarget, StructuredSources,
+ ext_deps: T.ListDependency, variables: T.Dictstr, str,
+ d_module_versions: T.ListT.Unionstr, int, d_import_dirs: T.List'IncludeDirs'):
 super().__init__(DependencyTypeName('internal'), {})
 self.version = version
 self.is_found = True
@@ -232,13 +264,17 @@
 self.sources = list(sources)
 self.ext_deps = ext_deps
 self.variables = variables
+ if d_module_versions:
+ self.d_features'versions' = d_module_versions
+ if d_import_dirs:
+ self.d_features'import_dirs' = d_import_dirs
 
 def __deepcopy__(self, memo: T.Dictint, 'InternalDependency') -> 'InternalDependency':
 result = self.__class__.__new__(self.__class__)
 assert isinstance(result, InternalDependency)
 memoid(self) = result
 for k, v in self.__dict__.items():
- if k in 'libraries', 'whole_libraries':
+ if k in {'libraries', 'whole_libraries'}:
 setattr(result, k, copy.copy(v))
 else:
 setattr(result, k, copy.deepcopy(v, memo))
@@ -254,7 +290,9 @@
 return True
 return any(d.is_built() for d in self.ext_deps)
 
- def get_pkgconfig_variable(self, variable_name: str, kwargs: T.Dictstr, T.Any) -> str:
+ def get_pkgconfig_variable(self, variable_name: str,
+ define_variable: 'ImmutableListProtocolstr',
+ default: T.Optionalstr) -> str:
 raise DependencyException('Method "get_pkgconfig_variable()" is '
 'invalid for an internal dependency')
 
@@ -277,26 +315,34 @@
 return InternalDependency(
 self.version, final_includes, final_compile_args,
 final_link_args, final_libraries, final_whole_libraries,
- final_sources, final_deps, self.variables)
+ final_sources, final_deps, self.variables, , )
+
+ def get_include_dirs(self) -> T.List'IncludeDirs':
+ return self.include_directories
 
 def get_variable(self, *, cmake: T.Optionalstr = None, pkgconfig: T.Optionalstr = None,
 configtool: T.Optionalstr = None, internal: T.Optionalstr = None,
 default_value: T.Optionalstr = None,
- pkgconfig_define: T.OptionalT.Liststr = None) -> T.Unionstr, T.Liststr:
+ pkgconfig_define: T.OptionalT.Liststr = None) -> str:
 val = self.variables.get(internal, default_value)
 if val is not None:
- # TODO: Try removing this assert by better typing self.variables
- if isinstance(val, str):
- return val
- if isinstance(val, list):
- for i in val:
- assert isinstance(i, str)
- return val
+ return val
 raise DependencyException(f'Could not get an internal variable and no default provided for {self!r}')
 
 def generate_link_whole_dependency(self) -> Dependency:
+ from ..build import SharedLibrary, CustomTarget, CustomTargetIndex
 new_dep = copy.deepcopy(self)
- new_dep.whole_libraries += new_dep.libraries
+ for x in new_dep.libraries:
+ if isinstance(x, SharedLibrary):
+ raise MesonException('Cannot convert a dependency to link_whole when it contains a '
+ 'SharedLibrary')
+ elif isinstance(x, (CustomTarget, CustomTargetIndex)) and x.links_dynamically():
+ raise MesonException('Cannot convert a dependency to link_whole when it contains a '
+ 'CustomTarget or CustomTargetIndex which is a shared library')
+
+ # Mypy doesn't understand that the above is a TypeGuard
+ new_dep.whole_libraries += T.cast('T.ListT.UnionStaticLibrary, CustomTarget, CustomTargetIndex',
+ new_dep.libraries)
 new_dep.libraries = 
 return new_dep
 
@@ -314,12 +360,13 @@
 self.name = type_name # default
 self.is_found = False
 self.language = language
- self.version_reqs = kwargs.get('version', None)
- if isinstance(self.version_reqs, str):
- self.version_reqs = self.version_reqs
+ version_reqs = kwargs.get('version', None)
+ if isinstance(version_reqs, str):
+ version_reqs = version_reqs
+ self.version_reqs: T.OptionalT.Liststr = version_reqs
 self.required = kwargs.get('required', True)
 self.silent = kwargs.get('silent', False)
- self.static = kwargs.get('static', False)
+ self.static = kwargs.get('static', self.env.coredata.get_option(OptionKey('prefer_static')))
 self.libtype = LibType.STATIC if self.static else LibType.PREFER_SHARED
 if not isinstance(self.static, bool):
 raise DependencyException('Static keyword must be boolean')
@@ -327,7 +374,7 @@
 HasNativeKwarg.__init__(self, kwargs)
 self.clib_compiler = detect_compiler(self.name, environment, self.for_machine, self.language)
 
- def get_compiler(self) -> 'Compiler':
+ def get_compiler(self) -> T.Union'MissingCompiler', 'Compiler':
 return self.clib_compiler
 
 def get_partial_dependency(self, *, compile_args: bool = False,
@@ -353,7 +400,8 @@
 def log_info(self) -> str:
 return ''
 
- def log_tried(self) -> str:
+ @staticmethod
+ def log_tried() -> str:
 return ''
 
 # Check if dependency version meets the requirements
@@ -371,7 +419,7 @@
 mlog.log(*found_msg)
 
 if self.required:
- m = f'Unknown version of dependency {self.name!r}, but need {self.version_reqs!r}.'
+ m = f'Unknown version, but need {self.version_reqs!r}.'
 raise DependencyException(m)
 
 else:
@@ -388,7 +436,7 @@
 mlog.log(*found_msg)
 
 if self.required:
- m = 'Invalid version of dependency, need {!r} {!r} found {!r}.'
+ m = 'Invalid version, need {!r} {!r} found {!r}.'
 raise DependencyException(m.format(self.name, not_found, self.version))
 return
 
@@ -448,6 +496,22 @@
 return new
 
 
+def get_leaf_external_dependencies(deps: T.ListDependency) -> T.ListDependency:
+ if not deps:
+ # Ensure that we always return a new instance
+ return deps.copy()
+ final_deps = 
+ while deps:
+ next_deps = 
+ for d in mesonlib.listify(deps):
+ if not isinstance(d, Dependency) or d.is_built():
+ raise DependencyException('Dependencies must be external dependencies')
+ final_deps.append(d)
+ next_deps.extend(d.ext_deps)
+ deps = next_deps
+ return final_deps
+
+
 def sort_libpaths(libpaths: T.Liststr, refpaths: T.Liststr) -> T.Liststr:
 """Sort <libpaths> according to <refpaths>
 
@@ -490,14 +554,21 @@
 raise DependencyException(f'method {method!r} is invalid')
 method = DependencyMethods(method)
 
+ # Raise FeatureNew where appropriate
+ if method is DependencyMethods.CONFIG_TOOL:
+ # FIXME: needs to get a handle on the subproject
+ # FeatureNew.single_use('Configuration method "config-tool"', '0.44.0')
+ pass
 # This sets per-tool config methods which are deprecated to to the new
 # generic CONFIG_TOOL value.
 if method in DependencyMethods.SDLCONFIG, DependencyMethods.CUPSCONFIG,
 DependencyMethods.PCAPCONFIG, DependencyMethods.LIBWMFCONFIG:
- FeatureDeprecated.single_use(f'Configuration method {method.value}', '0.44', 'Use "config-tool" instead.')
+ # FIXME: needs to get a handle on the subproject
+ #FeatureDeprecated.single_use(f'Configuration method {method.value}', '0.44', 'Use "config-tool" instead.')
 method = DependencyMethods.CONFIG_TOOL
 if method is DependencyMethods.QMAKE:
- FeatureDeprecated.single_use('Configuration method "qmake"', '0.58', 'Use "config-tool" instead.')
+ # FIXME: needs to get a handle on the subproject
+ # FeatureDeprecated.single_use('Configuration method "qmake"', '0.58', 'Use "config-tool" instead.')
 method = DependencyMethods.CONFIG_TOOL
 
 # Set the detection method. If the method is set to auto, use any available method.
@@ -515,7 +586,7 @@
 return methods
 
 def detect_compiler(name: str, env: 'Environment', for_machine: MachineChoice,
- language: T.Optionalstr) -> T.Optional'Compiler':
+ language: T.Optionalstr) -> T.Union'MissingCompiler', 'Compiler':
 """Given a language and environment find the compiler used."""
 compilers = env.coredata.compilersfor_machine
 
@@ -533,7 +604,7 @@
 return compilerslang
 except KeyError:
 continue
- return None
+ return MissingCompiler()
 
 
 class SystemDependency(ExternalDependency):
@@ -545,7 +616,8 @@
 super().__init__(DependencyTypeName('system'), env, kwargs, language=language)
 self.name = name
 
- def log_tried(self) -> str:
+ @staticmethod
+ def log_tried() -> str:
 return 'system'
 
 
@@ -558,5 +630,6 @@
 super().__init__(DependencyTypeName('builtin'), env, kwargs, language=language)
 self.name = name
 
- def log_tried(self) -> str:
+ @staticmethod
+ def log_tried() -> str:
 return 'builtin'

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/boost.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/boost.py Changed

@@ -11,22 +11,23 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import re
+import dataclasses
 import functools
 import typing as T
 from pathlib import Path
 
 from .. import mlog
 from .. import mesonlib
-from ..environment import Environment
 
 from .base import DependencyException, SystemDependency
 from .pkgconfig import PkgConfigDependency
 from .misc import threads_factory
 
 if T.TYPE_CHECKING:
-    from ..environment import Properties
+    from ..environment import Environment, Properties
 
 # On windows 3 directory layouts are supported:
 # * The default layout (versioned) installed:
@@ -83,6 +84,10 @@
 #     2.4 Ensure that all libraries have the same boost tag (and are thus compatible)
 #   3. Select the libraries matching the requested modules
 
+@dataclasses.dataclass(eq=False, order=False)
+class UnknownFileException(Exception):
+    path: Path
+
 @functools.total_ordering
 class BoostIncludeDir():
     def __init__(self, path: Path, version_int: int):
@@ -147,12 +152,12 @@
             self.version_lib = '{}_{}'.format(self.vers_raw0, self.vers_raw1)
 
         # Detecting library type
-        if self.nvsuffix in 'so', 'dll', 'dll.a', 'dll.lib', 'dylib':
+        if self.nvsuffix in {'so', 'dll', 'dll.a', 'dll.lib', 'dylib'}:
             self.static = False
-        elif self.nvsuffix in 'a', 'lib':
+        elif self.nvsuffix in {'a', 'lib'}:
             self.static = True
         else:
-            raise DependencyException(f'Unable to process library extension "{self.nvsuffix}" ({self.path})')
+            raise UnknownFileException(self.path)
 
         # boost_.lib is the dll import library
         if self.basename.startswith('boost_') and self.nvsuffix == 'lib':
@@ -172,7 +177,7 @@
         for i in tags:
             if i == 'mt':
                 self.mt = True
-            elif len(i) == 3 and i1: in '32', '64':
+            elif len(i) == 3 and i1: in {'32', '64'}:
                 self.arch = i
             elif BoostLibraryFile.reg_abi_tag.match(i):
                 self.runtime_static = 's' in i
@@ -232,10 +237,10 @@
         return abitag
 
     def is_boost(self) -> bool:
-        return any(self.name.startswith(x) for x in 'libboost_', 'boost_')
+        return any(self.name.startswith(x) for x in 'libboost_', 'boost_')
 
     def is_python_lib(self) -> bool:
-        return any(self.mod_name.startswith(x) for x in BoostLibraryFile.boost_python_libs)
+        return any(self.mod_name.startswith(x) for x in BoostLibraryFile.boost_python_libs)
 
     def fix_python_name(self, tags: T.Liststr) -> T.Liststr:
         # Handle the boost_python naming madeness.
@@ -311,13 +316,13 @@
         # If no vscrt tag present, assume that it fits  '/MD', '/MDd', '/MT', '/MTd'
         if not vscrt:
             return True
-        if vscrt in '/MD', '-MD':
+        if vscrt in {'/MD', '-MD'}:
             return not self.runtime_static and not self.runtime_debug
-        elif vscrt in '/MDd', '-MDd':
+        elif vscrt in {'/MDd', '-MDd'}:
             return not self.runtime_static and self.runtime_debug
-        elif vscrt in '/MT', '-MT':
+        elif vscrt in {'/MT', '-MT'}:
             return (self.runtime_static or not self.static) and not self.runtime_debug
-        elif vscrt in '/MTd', '-MTd':
+        elif vscrt in {'/MTd', '-MTd'}:
             return (self.runtime_static or not self.static) and self.runtime_debug
 
         mlog.warning(f'Boost: unknown vscrt tag {vscrt}. This may cause the compilation to fail. Please consider reporting this as a bug.', once=True)
@@ -433,7 +438,7 @@
 
         raw_paths = mesonlib.stringlistify(rootdir)
         paths = Path(x) for x in raw_paths
-        if paths and any(not x.is_absolute() for x in paths):
+        if paths and any(not x.is_absolute() for x in paths):
             raise DependencyException('boost_root path given in machine file must be absolute')
 
         self.check_and_set_roots(paths, use_system=False)
@@ -487,8 +492,8 @@
                 comp_args += c_args
                 link_args += l_args
 
-            comp_args = list(set(comp_args))
-            link_args = list(set(link_args))
+            comp_args = list(mesonlib.OrderedSet(comp_args))
+            link_args = list(mesonlib.OrderedSet(link_args))
 
             self.modules_found = x.mod_name for x in selected_modules
             self.modules_found = x6: for x in self.modules_found
@@ -569,13 +574,13 @@
         arch_list_64 = '64'
 
         raw_list = dirs + subdirs
-        no_arch = x for x in raw_list if not any(y in x.name for y in arch_list_32 + arch_list_64)
+        no_arch = x for x in raw_list if not any(y in x.name for y in arch_list_32 + arch_list_64)
 
         matching_arch =   # type: T.ListPath
         if '32' in self.arch:
-            matching_arch = x for x in raw_list if any(y in x.name for y in arch_list_32)
+            matching_arch = x for x in raw_list if any(y in x.name for y in arch_list_32)
         elif '64' in self.arch:
-            matching_arch = x for x in raw_list if any(y in x.name for y in arch_list_64)
+            matching_arch = x for x in raw_list if any(y in x.name for y in arch_list_64)
 
         return sorted(matching_arch) + sorted(no_arch)
 
@@ -621,10 +626,17 @@
         for i in libdir.iterdir():
             if not i.is_file():
                 continue
-            if not any(i.name.startswith(x) for x in 'libboost_', 'boost_'):
+            if not any(i.name.startswith(x) for x in 'libboost_', 'boost_'):
+                continue
+            # Windows binaries from SourceForge ship with PDB files alongside
+            # DLLs (#8325).  Ignore them.
+            if i.name.endswith('.pdb'):
                 continue
 
-            libs.add(BoostLibraryFile(i.resolve()))
+            try:
+                libs.add(BoostLibraryFile(i.resolve()))
+            except UnknownFileException as e:
+                mlog.warning('Boost: ignoring unknown file {} under lib directory'.format(e.path.name))
 
         return x for x in libs if x.is_boost()  # Filter out no boost libraries
 
@@ -648,7 +660,7 @@
         try:
             boost_pc = PkgConfigDependency('boost', self.env, {'required': False})
             if boost_pc.found():
-                boost_root = boost_pc.get_pkgconfig_variable('prefix', {'default': None})
+                boost_root = boost_pc.get_pkgconfig_variable('prefix', , None)
                 if boost_root:
                     roots += Path(boost_root)
         except DependencyException:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/cmake.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/cmake.py Changed

@@ -11,12 +11,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from .base import ExternalDependency, DependencyException, DependencyTypeName
-from ..mesonlib import is_windows, MesonException, OptionKey, PerMachine, stringlistify, extract_as_list
-from ..mesondata import mesondata
-from ..cmake import CMakeExecutor, CMakeTraceParser, CMakeException, CMakeToolchain, CMakeExecScope, check_cmake_args, CMakeTarget, resolve_cmake_trace_targets, cmake_is_debug
+from ..mesonlib import is_windows, MesonException, PerMachine, stringlistify, extract_as_list
+from ..cmake import CMakeExecutor, CMakeTraceParser, CMakeException, CMakeToolchain, CMakeExecScope, check_cmake_args, resolve_cmake_trace_targets, cmake_is_debug
 from .. import mlog
+import importlib.resources
 from pathlib import Path
 import functools
 import re
@@ -26,6 +27,7 @@
 import typing as T
 
 if T.TYPE_CHECKING:
+    from ..cmake import CMakeTarget
     from ..environment import Environment
     from ..envconfig import MachineInfo
 
@@ -104,7 +106,7 @@
         # Store a copy of the CMake path on the object itself so it is
         # stored in the pickled coredata and recovered.
         self.cmakebin:  T.OptionalCMakeExecutor = None
-        self.cmakeinfo: T.OptionalCMakeInfo     = None
+        self.cmakeinfo: T.OptionalCMakeInfo = None
 
         # Where all CMake "build dirs" are located
         self.cmake_root_dir = environment.scratch_dir
@@ -127,7 +129,7 @@
             return
 
         # Setup the trace parser
-        self.traceparser = CMakeTraceParser(self.cmakebin.version(), self._get_build_dir())
+        self.traceparser = CMakeTraceParser(self.cmakebin.version(), self._get_build_dir(), self.env)
 
         cm_args = stringlistify(extract_as_list(kwargs, 'cmake_args'))
         cm_args = check_cmake_args(cm_args)
@@ -166,7 +168,7 @@
             gen_list += CMakeDependency.class_working_generator
         gen_list += CMakeDependency.class_cmake_generators
 
-        temp_parser = CMakeTraceParser(self.cmakebin.version(), self._get_build_dir())
+        temp_parser = CMakeTraceParser(self.cmakebin.version(), self._get_build_dir(), self.env)
         toolchain = CMakeToolchain(self.cmakebin, self.env, self.for_machine, CMakeExecScope.DEPENDENCY, self._get_build_dir())
         toolchain.write()
 
@@ -270,7 +272,7 @@
                 content = self._cached_listdir(i)
                 candidates = 'Find{}.cmake', '{}Config.cmake', '{}-config.cmake'
                 candidates = x.format(name).lower() for x in candidates
-                if any(x1 in candidates for x in content):
+                if any(x1 in candidates for x in content):
                     return True
             return False
 
@@ -482,7 +484,6 @@
                 for tgt in partial_modules:
                     mlog.debug(tgt)
 
-
             incDirs = x for x in self.traceparser.get_cmake_var('PACKAGE_INCLUDE_DIRS') if x
             defs = x for x in self.traceparser.get_cmake_var('PACKAGE_DEFINITIONS') if x
             libs_raw = x for x in self.traceparser.get_cmake_var('PACKAGE_LIBRARIES') if x
@@ -509,7 +510,7 @@
 
             # Try to use old style variables if no module is specified
             if len(libs) > 0:
-                self.compile_args = list(map(lambda x: f'-I{x}', incDirs)) + defs
+                self.compile_args = f'-I{x}' for x in incDirs + defs
                 self.link_args = 
                 for j in libs:
                     rtgt = resolve_cmake_trace_targets(j, self.traceparser, self.env, clib_compiler=self.clib_compiler)
@@ -546,13 +547,14 @@
             if not autodetected_module_list:
                 self.found_modules += i
 
-            rtgt = resolve_cmake_trace_targets(i ,self.traceparser, self.env,
-                clib_compiler=self.clib_compiler,
-                not_found_warning=lambda x: mlog.warning('CMake: Dependency', mlog.bold(x), 'for', mlog.bold(name), 'was not found')
-            )
-            incDirs        += rtgt.include_directories
+            rtgt = resolve_cmake_trace_targets(i, self.traceparser, self.env,
+                                               clib_compiler=self.clib_compiler,
+                                               not_found_warning=lambda x:
+                                                   mlog.warning('CMake: Dependency', mlog.bold(x), 'for', mlog.bold(name), 'was not found')
+                                               )
+            incDirs += rtgt.include_directories
             compileOptions += rtgt.public_compile_opts
-            libraries      += rtgt.libraries + rtgt.link_flags
+            libraries += rtgt.libraries + rtgt.link_flags
 
         # Make sure all elements in the lists are unique and sorted
         incDirs = sorted(set(incDirs))
@@ -583,7 +585,7 @@
         shutil.rmtree(cmake_files.as_posix(), ignore_errors=True)
 
         # Insert language parameters into the CMakeLists.txt and write new CMakeLists.txt
-        cmake_txt = mesondata'dependencies/data/' + cmake_file.data
+        cmake_txt = importlib.resources.read_text('mesonbuild.dependencies.data', cmake_file, encoding = 'utf-8')
 
         # In general, some Fortran CMake find_package() also require C language enabled,
         # even if nothing from C is directly used. An easy Fortran example that fails
@@ -615,8 +617,9 @@
         build_dir = self._setup_cmake_dir(cmake_file)
         return self.cmakebin.call(args, build_dir, env=env)
 
-    def log_tried(self) -> str:
-        return self.type_name
+    @staticmethod
+    def log_tried() -> str:
+        return 'cmake'
 
     def log_details(self) -> str:
         modules = self._original_module_name(x) for x in self.found_modules
@@ -628,17 +631,23 @@
     def get_variable(self, *, cmake: T.Optionalstr = None, pkgconfig: T.Optionalstr = None,
                      configtool: T.Optionalstr = None, internal: T.Optionalstr = None,
                      default_value: T.Optionalstr = None,
-                     pkgconfig_define: T.OptionalT.Liststr = None) -> T.Unionstr, T.Liststr:
+                     pkgconfig_define: T.OptionalT.Liststr = None) -> str:
         if cmake and self.traceparser is not None:
             try:
                 v = self.traceparser.varscmake
             except KeyError:
                 pass
             else:
-                if len(v) == 1:
-                    return v0
-                elif v:
-                    return v
+                # CMake does NOT have a list datatype. We have no idea whether
+                # anything is a string or a string-separated-by-; Internally,
+                # we treat them as the latter and represent everything as a
+                # list, because it is convenient when we are mostly handling
+                # imported targets, which have various properties that are
+                # actually lists.
+                #
+                # As a result we need to convert them back to strings when grabbing
+                # raw variables the user requested.
+                return ';'.join(v)
         if default_value is not None:
             return default_value
         raise DependencyException(f'Could not get cmake variable and no default provided for {self!r}')

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/coarrays.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/coarrays.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/configtool.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/configtool.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from .base import ExternalDependency, DependencyException, DependencyTypeName
 from ..mesonlib import listify, Popen_safe, split_args, version_compare, version_compare_many
@@ -31,6 +32,9 @@
     Takes the following extra keys in kwargs that it uses internally:
     :tools Liststr: A list of tool names to use
     :version_arg str: The argument to pass to the tool to get it's version
+    :skip_version str: The argument to pass to the tool to ignore its version
+        (if ``version_arg`` fails, but it may start accepting it in the future)
+        Because some tools are stupid and don't accept --version
     :returncode_value int: The value of the correct returncode
         Because some tools are stupid and don't return 0
     """
@@ -38,6 +42,7 @@
     tools: T.OptionalT.Liststr = None
     tool_name: T.Optionalstr = None
     version_arg = '--version'
+    skip_version: T.Optionalstr = None
     __strip_version = re.compile(r'^0-90-9.+')
 
     def __init__(self, name: str, environment: 'Environment', kwargs: T.Dictstr, T.Any, language: T.Optionalstr = None):
@@ -89,7 +94,13 @@
             except (FileNotFoundError, PermissionError):
                 continue
             if p.returncode != returncode:
-                continue
+                if self.skip_version:
+                    # maybe the executable is valid even if it doesn't support --version
+                    p = Popen_safe(tool + self.skip_version)0
+                    if p.returncode != returncode:
+                        continue
+                else:
+                    continue
 
             out = self._sanitize_version(out.strip())
             # Some tools, like pcap-config don't supply a version, but also
@@ -149,13 +160,14 @@
         mlog.debug(f'Got config-tool variable {variable_name} : {variable}')
         return variable
 
-    def log_tried(self) -> str:
-        return self.type_name
+    @staticmethod
+    def log_tried() -> str:
+        return 'config-tool'
 
     def get_variable(self, *, cmake: T.Optionalstr = None, pkgconfig: T.Optionalstr = None,
                      configtool: T.Optionalstr = None, internal: T.Optionalstr = None,
                      default_value: T.Optionalstr = None,
-                     pkgconfig_define: T.OptionalT.Liststr = None) -> T.Unionstr, T.Liststr:
+                     pkgconfig_define: T.OptionalT.Liststr = None) -> str:
         if configtool:
             # In the not required case '' (empty string) will be returned if the
             # variable is not found. Since '' is a valid value to return we

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/cuda.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/cuda.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/data/__init__.py Added

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/detect.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/detect.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from .base import ExternalDependency, DependencyException, DependencyMethods, NotFoundDependency
 from .cmake import CMakeDependency
@@ -27,6 +28,9 @@
     from ..environment import Environment
     from .factory import DependencyFactory, WrappedFactoryFunc, DependencyGenerator
 
+    TV_DepIDEntry = T.Unionstr, bool, int, T.Tuplestr, ...
+    TV_DepID = T.TupleT.Tuplestr, TV_DepIDEntry, ...
+
 # These must be defined in this file to avoid cyclical references.
 packages: T.Dict
     str,
@@ -34,11 +38,6 @@
  = {}
 _packages_accept_language: T.Setstr = set()
 
-if T.TYPE_CHECKING:
-    TV_DepIDEntry = T.Unionstr, bool, int, T.Tuplestr, ...
-    TV_DepID = T.TupleT.Tuplestr, TV_DepIDEntry, ...
-
-
 def get_dep_identifier(name: str, kwargs: T.Dictstr, T.Any) -> 'TV_DepID':
     identifier: 'TV_DepID' = (('name', name), )
     from ..interpreter import permitted_dependency_kwargs
@@ -54,8 +53,8 @@
         # 'default_options' is only used in fallback case
         # 'not_found_message' has no impact on the dependency lookup
         # 'include_type' is handled after the dependency lookup
-        if key in ('version', 'native', 'required', 'fallback', 'allow_fallback', 'default_options',
-                   'not_found_message', 'include_type'):
+        if key in {'version', 'native', 'required', 'fallback', 'allow_fallback', 'default_options',
+                   'not_found_message', 'include_type'}:
             continue
         # All keyword arguments are strings, ints, or lists (or lists of lists)
         if isinstance(value, list):
@@ -105,7 +104,7 @@
     candidates = _build_external_dependency_list(name, env, for_machine, kwargs)
 
     pkg_exc: T.ListDependencyException = 
-    pkgdep:  T.ListExternalDependency  = 
+    pkgdep:  T.ListExternalDependency = 
     details = ''
 
     for c in candidates:
@@ -115,8 +114,11 @@
             d._check_version()
             pkgdep.append(d)
         except DependencyException as e:
+            assert isinstance(c, functools.partial), 'for mypy'
+            bettermsg = f'Dependency lookup for {name} with method {c.func.log_tried()!r} failed: {e}'
+            mlog.debug(bettermsg)
+            e.args = (bettermsg,)
             pkg_exc.append(e)
-            mlog.debug(str(e))
         else:
             pkg_exc.append(None)
             details = d.log_details()
@@ -178,13 +180,12 @@
         # class method, if one exists, otherwise the list just consists of the
         # constructor
         if isinstance(packageslname, type):
-            entry1 = T.cast(T.TypeExternalDependency, packageslname)  # mypy doesn't understand isinstance(..., type)
+            entry1 = T.cast('T.TypeExternalDependency', packageslname)  # mypy doesn't understand isinstance(..., type)
             if issubclass(entry1, ExternalDependency):
-                # TODO: somehow make mypy understand that entry1(env, kwargs) is OK...
-                func: T.Callable, 'ExternalDependency' = lambda: entry1(env, kwargs)  # type: ignore
+                func: T.Callable, 'ExternalDependency' = functools.partial(entry1, env, kwargs)
                 dep = func
         else:
-            entry2 = T.cast(T.Union'DependencyFactory', 'WrappedFactoryFunc', packageslname)
+            entry2 = T.cast('T.UnionDependencyFactory, WrappedFactoryFunc', packageslname)
             dep = entry2(env, for_machine, kwargs)
         return dep

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/dev.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/dev.py Changed

@@ -15,18 +15,22 @@
 # This file contains the detection logic for external dependencies useful for
 # development purposes, such as testing, debugging, etc..
 
+from __future__ import annotations
+
 import glob
 import os
 import re
 import pathlib
 import shutil
+import subprocess
 import typing as T
 
+from mesonbuild.interpreterbase.decorators import FeatureDeprecated
+
 from .. import mesonlib, mlog
-from ..compilers import AppleClangCCompiler, AppleClangCPPCompiler, detect_compiler_for
 from ..environment import get_llvm_tool_names
-from ..mesonlib import version_compare, stringlistify, extract_as_list, MachineChoice
-from .base import DependencyException, DependencyMethods, strip_system_libdirs, SystemDependency, ExternalDependency, DependencyTypeName
+from ..mesonlib import version_compare, stringlistify, extract_as_list
+from .base import DependencyException, DependencyMethods, detect_compiler, strip_system_libdirs, SystemDependency, ExternalDependency, DependencyTypeName
 from .cmake import CMakeDependency
 from .configtool import ConfigToolDependency
 from .factory import DependencyFactory
@@ -35,7 +39,15 @@
 
 if T.TYPE_CHECKING:
 from ..envconfig import MachineInfo
- from .. environment import Environment
+ from ..environment import Environment
+ from ..mesonlib import MachineChoice
+ from typing_extensions import TypedDict
+
+ class JNISystemDependencyKW(TypedDict):
+ modules: T.Liststr
+ # FIXME: When dependency() moves to typed Kwargs, this should inherit
+ # from its TypedDict type.
+ version: T.Optionalstr
 
 
 def get_shared_library_suffix(environment: 'Environment', for_machine: MachineChoice) -> str:
@@ -103,9 +115,6 @@
 else:
 return 'building self'
 
- def log_tried(self) -> str:
- return 'system'
-
 
 class GTestDependencyPC(PkgConfigDependency):
 
@@ -174,9 +183,6 @@
 else:
 return 'building self'
 
- def log_tried(self) -> str:
- return 'system'
-
 
 class GMockDependencyPC(PkgConfigDependency):
 
@@ -478,6 +484,8 @@
 
 def __init__(self, name: str, environment: 'Environment', kwargs: T.Dictstr, T.Any):
 super().__init__(name, environment, kwargs)
+ from ..compilers.c import AppleClangCCompiler
+ from ..compilers.cpp import AppleClangCPPCompiler
 
 m = self.env.machinesself.for_machine
 
@@ -492,13 +500,8 @@
 self.is_found = True
 self.link_args = '-lz'
 else:
- # Without a clib_compiler we can't find zlib, so just give up.
- if self.clib_compiler is None:
- self.is_found = False
- return
-
 if self.clib_compiler.get_argument_syntax() == 'msvc':
- libs = 'zlib1' 'zlib'
+ libs = 'zlib1', 'zlib'
 else:
 libs = 'z'
 for lib in libs:
@@ -515,17 +518,27 @@
 self.version = v.strip('"')
 
 
-class JDKSystemDependency(SystemDependency):
- def __init__(self, environment: 'Environment', kwargs: T.Dictstr, T.Any):
- super().__init__('jdk', environment, kwargs)
+class JNISystemDependency(SystemDependency):
+ def __init__(self, environment: 'Environment', kwargs: JNISystemDependencyKW):
+ super().__init__('jni', environment, T.cast('T.Dictstr, T.Any', kwargs))
+
+ self.feature_since = ('0.62.0', '')
 
 m = self.env.machinesself.for_machine
 
 if 'java' not in environment.coredata.compilersself.for_machine:
- detect_compiler_for(environment, 'java', self.for_machine)
+ detect_compiler(self.name, environment, self.for_machine, 'java')
 self.javac = environment.coredata.compilersself.for_machine'java'
 self.version = self.javac.version
 
+ modules: T.Liststr = mesonlib.listify(kwargs.get('modules', ))
+ for module in modules:
+ if module not in {'jvm', 'awt'}:
+ log = mlog.error if self.required else mlog.debug
+ log(f'Unknown JNI module ({module})')
+ self.is_found = False
+ return
+
 if 'version' in kwargs and not version_compare(self.version, kwargs'version'):
 mlog.error(f'Incorrect JDK version found ({self.version}), wanted {kwargs"version"}')
 self.is_found = False
@@ -534,6 +547,17 @@
 self.java_home = environment.propertiesself.for_machine.get_java_home()
 if not self.java_home:
 self.java_home = pathlib.Path(shutil.which(self.javac.exelist0)).resolve().parents1
+ if m.is_darwin():
+ problem_java_prefix = pathlib.Path('/System/Library/Frameworks/JavaVM.framework/Versions')
+ if problem_java_prefix in self.java_home.parents:
+ res = subprocess.run('/usr/libexec/java_home', '--failfast', '--arch', m.cpu_family,
+ stdout=subprocess.PIPE)
+ if res.returncode != 0:
+ log = mlog.error if self.required else mlog.debug
+ log('JAVA_HOME could not be discovered on the system. Please set it explicitly.')
+ self.is_found = False
+ return
+ self.java_home = pathlib.Path(res.stdout.decode().strip())
 
 platform_include_dir = self.__machine_info_to_platform_include_dir(m)
 if platform_include_dir is None:
@@ -544,16 +568,56 @@
 java_home_include = self.java_home / 'include'
 self.compile_args.append(f'-I{java_home_include}')
 self.compile_args.append(f'-I{java_home_include / platform_include_dir}')
+
+ if modules:
+ if m.is_windows():
+ java_home_lib = self.java_home / 'lib'
+ java_home_lib_server = java_home_lib
+ else:
+ if version_compare(self.version, '<= 1.8.0'):
+ java_home_lib = self.java_home / 'jre' / 'lib' / self.__cpu_translate(m.cpu_family)
+ else:
+ java_home_lib = self.java_home / 'lib'
+
+ java_home_lib_server = java_home_lib / 'server'
+
+ if 'jvm' in modules:
+ jvm = self.clib_compiler.find_library('jvm', environment, extra_dirs=str(java_home_lib_server))
+ if jvm is None:
+ mlog.debug('jvm library not found.')
+ self.is_found = False
+ else:
+ self.link_args.extend(jvm)
+ if 'awt' in modules:
+ jawt = self.clib_compiler.find_library('jawt', environment, extra_dirs=str(java_home_lib))
+ if jawt is None:
+ mlog.debug('jawt library not found.')
+ self.is_found = False
+ else:
+ self.link_args.extend(jawt)
+
 self.is_found = True
 
 @staticmethod
+ def __cpu_translate(cpu: str) -> str:
+ '''
+ The JDK and Meson have a disagreement here, so translate it over. In the event more
+ translation needs to be done, add to following dict.
+ '''
+ java_cpus = {
+ 'x86_64': 'amd64',
+ }
+
+ return java_cpus.get(cpu, cpu)
+
+ @staticmethod
 def __machine_info_to_platform_include_dir(m: 'MachineInfo') -> T.Optionalstr:
- """Translates the machine information to the platform-dependent include directory
+ '''Translates the machine information to the platform-dependent include directory
 
 When inspecting a JDK release tarball or $JAVA_HOME, inside the `include/` directory is a
- platform dependent folder that must be on the target's include path in addition to the
+ platform-dependent directory that must be on the target's include path in addition to the
 parent `include/` directory.
- """
+ '''
 if m.is_linux():
 return 'linux'
 elif m.is_windows():
@@ -562,10 +626,30 @@
 return 'darwin'
 elif m.is_sunos():
 return 'solaris'
+ elif m.is_freebsd():
+ return 'freebsd'
+ elif m.is_netbsd():
+ return 'netbsd'
+ elif m.is_openbsd():
+ return 'openbsd'
+ elif m.is_dragonflybsd():
+ return 'dragonfly'
 
 return None
 
 
+class JDKSystemDependency(JNISystemDependency):
+ def __init__(self, environment: 'Environment', kwargs: JNISystemDependencyKW):
+ super().__init__(environment, kwargs)
+
+ self.feature_since = ('0.59.0', '')
+ self.featurechecks.append(FeatureDeprecated(
+ 'jdk system dependency',
+ '0.62.0',
+ 'Use the jni system dependency instead'
+ ))
+
+
 llvm_factory = DependencyFactory(
 'LLVM',
 DependencyMethods.CMAKE, DependencyMethods.CONFIG_TOOL,

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/dub.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/dub.py Changed

@@ -11,18 +11,16 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from .base import ExternalDependency, DependencyException, DependencyTypeName
 from .pkgconfig import PkgConfigDependency
-from ..mesonlib import Popen_safe
+from ..mesonlib import (Popen_safe, OptionKey, join_args)
 from ..programs import ExternalProgram
-from ..compilers import DCompiler
 from .. import mlog
 import re
 import os
-import copy
 import json
-import platform
 import typing as T
 
 if T.TYPE_CHECKING:
@@ -34,7 +32,7 @@
     def __init__(self, name: str, environment: 'Environment', kwargs: T.Dictstr, T.Any):
         super().__init__(DependencyTypeName('dub'), environment, kwargs, language='d')
         self.name = name
-        self.module_path: T.Optionalstr = None
+        from ..compilers.d import DCompiler, d_feature_args
 
         _temp_comp = super().get_compiler()
         assert isinstance(_temp_comp, DCompiler)
@@ -59,158 +57,328 @@
         mlog.debug('Determining dependency {!r} with DUB executable '
                    '{!r}'.format(name, self.dubbin.get_path()))
 
+        # if an explicit version spec was stated, use this when querying Dub
+        main_pack_spec = name
+        if 'version' in kwargs:
+            version_spec = kwargs'version'
+            if isinstance(version_spec, list):
+                version_spec = " ".join(version_spec)
+            main_pack_spec = f'{name}@{version_spec}'
+
         # we need to know the target architecture
-        arch = self.compiler.arch
+        dub_arch = self.compiler.arch
+
+        # we need to know the build type as well
+        dub_buildtype = str(environment.coredata.get_option(OptionKey('buildtype')))
+        # MESON types: choices='plain', 'debug', 'debugoptimized', 'release', 'minsize', 'custom')),
+        # DUB types: debug (default), plain, release, release-debug, release-nobounds, unittest, profile, profile-gc,
+        # docs, ddox, cov, unittest-cov, syntax and custom
+        if dub_buildtype == 'debugoptimized':
+            dub_buildtype = 'release-debug'
+        elif dub_buildtype == 'minsize':
+            dub_buildtype = 'release'
 
         # Ask dub for the package
-        ret, res = self._call_dubbin('describe', name, '--arch=' + arch)
+        describe_cmd = 
+            'describe', main_pack_spec, '--arch=' + dub_arch,
+            '--build=' + dub_buildtype, '--compiler=' + self.compiler.get_exelist()-1
+        
+        ret, res, err = self._call_dubbin(describe_cmd)
 
         if ret != 0:
+            mlog.debug('DUB describe failed: ' + err)
+            if 'locally' in err:
+                fetch_cmd = 'dub', 'fetch', main_pack_spec
+                mlog.error(mlog.bold(main_pack_spec), 'is not present locally. You may try the following command:')
+                mlog.log(mlog.bold(join_args(fetch_cmd)))
             self.is_found = False
             return
 
-        comp = self.compiler.get_id().replace('llvm', 'ldc').replace('gcc', 'gdc')
-        packages = 
+        # A command that might be useful in case of missing DUB package
+        def dub_build_deep_command() -> str:
+            cmd = 
+                'dub', 'run', 'dub-build-deep', '--yes', '--', main_pack_spec,
+                '--arch=' + dub_arch, '--compiler=' + self.compiler.get_exelist()-1,
+                '--build=' + dub_buildtype
+            
+            return join_args(cmd)
+
+        dub_comp_id = self.compiler.get_id().replace('llvm', 'ldc').replace('gcc', 'gdc')
         description = json.loads(res)
-        for package in description'packages':
-            packages.append(package'name')
-            if package'name' == name:
-                self.is_found = True
 
-                not_lib = True
-                if 'targetType' in package:
-                    if package'targetType' in 'library', 'sourceLibrary', 'staticLibrary', 'dynamicLibrary':
-                        not_lib = False
+        self.compile_args = 
+        self.link_args = self.raw_link_args = 
+
+        show_buildtype_warning = False
+
+        def find_package_target(pkg: T.Dictstr, str) -> bool:
+            nonlocal show_buildtype_warning
+            # try to find a static library in a DUB folder corresponding to
+            # version, configuration, compiler, arch and build-type
+            # if can find, add to link_args.
+            # link_args order is meaningful, so this function MUST be called in the right order
+            pack_id = f'{pkg"name"}@{pkg"version"}'
+            (tgt_file, compatibilities) = self._find_compatible_package_target(description, pkg, dub_comp_id)
+            if tgt_file is None:
+                if not compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'not found')
+                elif 'compiler' not in compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'found but not compiled with ', mlog.bold(dub_comp_id))
+                elif dub_comp_id != 'gdc' and 'compiler_version' not in compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'found but not compiled with', mlog.bold(f'{dub_comp_id}-{self.compiler.version}'))
+                elif 'arch' not in compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'found but not compiled for', mlog.bold(dub_arch))
+                elif 'platform' not in compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'found but not compiled for', mlog.bold(description'platform'.join('.')))
+                elif 'configuration' not in compatibilities:
+                    mlog.error(mlog.bold(pack_id), 'found but not compiled for the', mlog.bold(pkg'configuration'), 'configuration')
+                else:
+                    mlog.error(mlog.bold(pack_id), 'not found')
+
+                mlog.log('You may try the following command to install the necessary DUB libraries:')
+                mlog.log(mlog.bold(dub_build_deep_command()))
+
+                return False
+
+            if 'build_type' not in compatibilities:
+                mlog.warning(mlog.bold(pack_id), 'found but not compiled as', mlog.bold(dub_buildtype))
+                show_buildtype_warning = True
+
+            self.link_args.append(tgt_file)
+            return True
+
+        # Main algorithm:
+        # 1. Ensure that the target is a compatible library type (not dynamic)
+        # 2. Find a compatible built library for the main dependency
+        # 3. Do the same for each sub-dependency.
+        #    link_args MUST be in the same order than the "linkDependencies" of the main target
+        # 4. Add other build settings (imports, versions etc.)
+
+        # 1
+        self.is_found = False
+        packages = {}
+        for pkg in description'packages':
+            packagespkg'name' = pkg
+
+            if not pkg'active':
+                continue
+
+            if pkg'targetType' == 'dynamicLibrary':
+                mlog.error('DUB dynamic library dependencies are not supported.')
+                self.is_found = False
+                return
+
+            ## check that the main dependency is indeed a library
+            if pkg'name' == name:
+                self.is_found = True
 
-                if not_lib:
+                if pkg'targetType' not in 'library', 'sourceLibrary', 'staticLibrary':
                     mlog.error(mlog.bold(name), "found but it isn't a library")
                     self.is_found = False
                     return
 
-                self.module_path = self._find_right_lib_path(package'path', comp, description, True, package'targetFileName')
-                if not os.path.exists(self.module_path):
-                    # check if the dependency was built for other archs
-                    archs = 'x86_64', 'x86', 'x86', 'x86_mscoff'
-                    for a in archs:
-                        description_a = copy.deepcopy(description)
-                        description_a'architecture' = a
-                        arch_module_path = self._find_right_lib_path(package'path', comp, description_a, True, package'targetFileName')
-                        if arch_module_path:
-                            mlog.error(mlog.bold(name), "found but it wasn't compiled for", mlog.bold(arch))
-                            self.is_found = False
-                            return
-
-                    mlog.error(mlog.bold(name), "found but it wasn't compiled with", mlog.bold(comp))
-                    self.is_found = False
-                    return
+                self.version = pkg'version'
+                self.pkg = pkg
 
-                self.version = package'version'
-                self.pkg = package
+        # collect all targets
+        targets = {}
+        for tgt in description'targets':
+            targetstgt'rootPackage' = tgt
 
-        if self.pkg'targetFileName'.endswith('.a'):
-            self.static = True
+        if name not in targets:
+            self.is_found = False
+            if self.pkg'targetType' == 'sourceLibrary':
+                # source libraries have no associated targets,
+                # but some build settings like import folders must be found from the package object.
+                # Current algo only get these from "buildSettings" in the target object.
+                # Let's save this for a future PR.
+                # (See openssl DUB package for example of sourceLibrary)
+                mlog.error('DUB targets of type', mlog.bold('sourceLibrary'), 'are not supported.')
+            else:
+                mlog.error('Could not find target description for', mlog.bold(main_pack_spec))
 
-        self.compile_args = 
-        for flag in self.pkg'dflags':
-            self.link_args.append(flag)
-        for path in self.pkg'importPaths':
-            self.compile_args.append('-I' + os.path.join(self.pkg'path', path))
+        if not self.is_found:
+            mlog.error(f'Could not find {name} in DUB description')
+            return
 
-        self.link_args = self.raw_link_args = 
-        for flag in self.pkg'lflags':
-            self.link_args.append(flag)
+        # Current impl only supports static libraries
+        self.static = True
 
-        self.link_args.append(os.path.join(self.module_path, self.pkg'targetFileName'))
-
-        # Handle dependencies
-        libs = 
-
-        def add_lib_args(field_name: str, target: T.Dictstr, T.Dictstr, str) -> None:
-            if field_name in target'buildSettings':
-                for lib in target'buildSettings'field_name:
-                    if lib not in libs:
-                        libs.append(lib)
-                        if os.name != 'nt':
-                            pkgdep = PkgConfigDependency(lib, environment, {'required': 'true', 'silent': 'true'})
-                            for arg in pkgdep.get_compile_args():
-                                self.compile_args.append(arg)
-                            for arg in pkgdep.get_link_args():
-                                self.link_args.append(arg)
-                            for arg in pkgdep.get_link_args(raw=True):
-                                self.raw_link_args.append(arg)
-
-        for target in description'targets':
-            if target'rootPackage' in packages:
-                add_lib_args('libs', target)
-                add_lib_args(f'libs-{platform.machine()}', target)
-                for file in target'buildSettings''linkerFiles':
-                    lib_path = self._find_right_lib_path(file, comp, description)
-                    if lib_path:
-                        self.link_args.append(lib_path)
-                    else:
-                        self.is_found = False
-
-    def _find_right_lib_path(self,
-                             default_path: str,
-                             comp: str,
-                             description: T.Dictstr, str,
-                             folder_only: bool = False,
-                             file_name: str = '') -> T.Optionalstr:
-        module_path = lib_file_name = ''
-        if folder_only:
-            module_path = default_path
-            lib_file_name = file_name
-        else:
-            module_path = os.path.dirname(default_path)
-            lib_file_name = os.path.basename(default_path)
-        module_build_path = os.path.join(module_path, '.dub', 'build')
-
-        # If default_path is a path to lib file and
-        # directory of lib don't have subdir '.dub/build'
-        if not os.path.isdir(module_build_path) and os.path.isfile(default_path):
-            if folder_only:
-                return module_path
-            else:
-                return default_path
+        # 2
+        if not find_package_target(self.pkg):
+            self.is_found = False
+            return
+
+        # 3
+        for link_dep in targetsname'linkDependencies':
+            pkg = packageslink_dep
+            if not find_package_target(pkg):
+                self.is_found = False
+                return
+
+        if show_buildtype_warning:
+            mlog.log('If it is not suitable, try the following command and reconfigure Meson with', mlog.bold('--clearcache'))
+            mlog.log(mlog.bold(dub_build_deep_command()))
+
+        # 4
+        bs = targetsname'buildSettings'
 
-        # Get D version implemented in the compiler
+        for flag in bs'dflags':
+            self.compile_args.append(flag)
+
+        for path in bs'importPaths':
+            self.compile_args.append('-I' + path)
+
+        for path in bs'stringImportPaths':
+            if 'import_dir' not in d_feature_argsself.compiler.id:
+                break
+            flag = d_feature_argsself.compiler.id'import_dir'
+            self.compile_args.append(f'{flag}={path}')
+
+        for ver in bs'versions':
+            if 'version' not in d_feature_argsself.compiler.id:
+                break
+            flag = d_feature_argsself.compiler.id'version'
+            self.compile_args.append(f'{flag}={ver}')
+
+        if bs'mainSourceFile':
+            self.compile_args.append(bs'mainSourceFile')
+
+        # pass static libraries
+        # linkerFiles are added during step 3
+        # for file in bs'linkerFiles':
+        #     self.link_args.append(file)
+
+        for file in bs'sourceFiles':
+            # sourceFiles may contain static libraries
+            if file.endswith('.lib') or file.endswith('.a'):
+                self.link_args.append(file)
+
+        for flag in bs'lflags':
+            self.link_args.append(flag)
+
+        is_windows = self.env.machines.host.is_windows()
+        if is_windows:
+            winlibs = 'kernel32', 'user32', 'gdi32', 'winspool', 'shell32', 'ole32',
+                       'oleaut32', 'uuid', 'comdlg32', 'advapi32', 'ws2_32'
+
+        for lib in bs'libs':
+            if os.name != 'nt':
+                # trying to add system libraries by pkg-config
+                pkgdep = PkgConfigDependency(lib, environment, {'required': 'true', 'silent': 'true'})
+                if pkgdep.is_found:
+                    for arg in pkgdep.get_compile_args():
+                        self.compile_args.append(arg)
+                    for arg in pkgdep.get_link_args():
+                        self.link_args.append(arg)
+                    for arg in pkgdep.get_link_args(raw=True):
+                        self.raw_link_args.append(arg)
+                    continue
+
+            if is_windows and lib in winlibs:
+                self.link_args.append(lib + '.lib')
+                continue
+
+            # fallback
+            self.link_args.append('-l'+lib)
+
+    # This function finds the target of the provided JSON package, built for the right
+    # compiler, architecture, configuration...
+    # It returns (target|None, {compatibilities})
+    # If None is returned for target, compatibilities will list what other targets were found without full compatibility
+    def _find_compatible_package_target(self, jdesc: T.Dictstr, str, jpack: T.Dictstr, str, dub_comp_id: str) -> T.Tuplestr, T.Setstr:
+        dub_build_path = os.path.join(jpack'path', '.dub', 'build')
+
+        if not os.path.exists(dub_build_path):
+            return (None, None)
+
+        # try to find a dir like library-debug-linux.posix-x86_64-ldc_2081-EF934983A3319F8F8FF2F0E107A363BA
+
+        # fields are:
+        #  - configuration
+        #  - build type
+        #  - platform
+        #  - architecture
+        #  - compiler id (dmd, ldc, gdc)
+        #  - compiler version or frontend id or frontend version?
+
+        conf = jpack'configuration'
+        build_type = jdesc'buildType'
+        platforms = jdesc'platform'
+        archs = jdesc'architecture'
+
+        # Get D frontend version implemented in the compiler, or the compiler version itself
         # gdc doesn't support this
-        ret, res = self._call_dubbin('--version')
+        comp_versions = 
 
-        if ret != 0:
-            mlog.error('Failed to run {!r}', mlog.bold(comp))
-            return None
+        if dub_comp_id != 'gdc':
+            comp_versions.append(self.compiler.version)
 
-        d_ver_reg = re.search('v0-9.0-90-90-9.0-9', res) # Ex.: v2.081.2
-        if d_ver_reg is not None:
-            d_ver = d_ver_reg.group().rsplit('.', 1)0.replace('v', '').replace('.', '') # Fix structure. Ex.: 2081
-        else:
-            d_ver = '' # gdc
+            ret, res = self._call_compbin('--version')0:2
+            if ret != 0:
+                mlog.error('Failed to run {!r}', mlog.bold(dub_comp_id))
+                return (None, None)
+            d_ver_reg = re.search('v0-9.0-90-90-9.0-9', res) # Ex.: v2.081.2
+
+            if d_ver_reg is not None:
+                frontend_version = d_ver_reg.group()
+                frontend_id = frontend_version.rsplit('.', 1)0.replace('v', '').replace('.', '') # Fix structure. Ex.: 2081
+                comp_versions.extend(frontend_version, frontend_id)
 
-        if not os.path.isdir(module_build_path):
-            return ''
+        compatibilities: T.Setstr = set()
 
-        # Ex.: library-debug-linux.posix-x86_64-ldc_2081-EF934983A3319F8F8FF2F0E107A363BA
-        build_name = '-{}-{}-{}-{}_{}'.format(description'buildType', '.'.join(description'platform'), '.'.join(description'architecture'), comp, d_ver)
-        for entry in os.listdir(module_build_path):
-            if build_name in entry:
-                for file in os.listdir(os.path.join(module_build_path, entry)):
-                    if file == lib_file_name:
-                        if folder_only:
-                            return os.path.join(module_build_path, entry)
-                        else:
-                            return os.path.join(module_build_path, entry, lib_file_name)
+        # build_type is not in check_list because different build types might be compatible.
+        # We do show a WARNING that the build type is not the same.
+        # It might be critical in release builds, and acceptable otherwise
+        check_list = ('configuration', 'platform', 'arch', 'compiler', 'compiler_version')
+
+        for entry in os.listdir(dub_build_path):
+
+            target = os.path.join(dub_build_path, entry, jpack'targetFileName')
+            if not os.path.exists(target):
+                # unless Dub and Meson are racing, the target file should be present
+                # when the directory is present
+                mlog.debug("WARNING: Could not find a Dub target: " + target)
+                continue
+
+            # we build a new set for each entry, because if this target is returned
+            # we want to return only the compatibilities associated to this target
+            # otherwise we could miss the WARNING about build_type
+            comps = set()
+
+            if conf in entry:
+                comps.add('configuration')
+
+            if build_type in entry:
+                comps.add('build_type')
+
+            if all(platform in entry for platform in platforms):
+                comps.add('platform')
+
+            if all(arch in entry for arch in archs):
+                comps.add('arch')
+
+            if dub_comp_id in entry:
+                comps.add('compiler')
+
+            if dub_comp_id == 'gdc' or any(cv in entry for cv in comp_versions):
+                comps.add('compiler_version')
+
+            if all(key in comps for key in check_list):
+                return (target, comps)
+            else:
+                compatibilities = set.union(compatibilities, comps)
 
-        return ''
+        return (None, compatibilities)
 
-    def _call_dubbin(self, args: T.Liststr, env: T.OptionalT.Dictstr, str = None) -> T.Tupleint, str:
+    def _call_dubbin(self, args: T.Liststr, env: T.OptionalT.Dictstr, str = None) -> T.Tupleint, str, str:
         assert isinstance(self.dubbin, ExternalProgram)
-        p, out = Popen_safe(self.dubbin.get_command() + args, env=env)0:2
-        return p.returncode, out.strip()
+        p, out, err = Popen_safe(self.dubbin.get_command() + args, env=env)
+        return p.returncode, out.strip(), err.strip()
 
-    def _call_copmbin(self, args: T.Liststr, env: T.OptionalT.Dictstr, str = None) -> T.Tupleint, str:
-        p, out = Popen_safe(self.compiler.get_exelist() + args, env=env)0:2
-        return p.returncode, out.strip()
+    def _call_compbin(self, args: T.Liststr, env: T.OptionalT.Dictstr, str = None) -> T.Tupleint, str, str:
+        p, out, err = Popen_safe(self.compiler.get_exelist() + args, env=env)
+        return p.returncode, out.strip(), err.strip()
 
     def _check_dub(self) -> T.Unionbool, ExternalProgram:
         dubbin: T.Unionbool, ExternalProgram = ExternalProgram('dub', silent=True)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/factory.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/factory.py Changed

@@ -12,13 +12,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import functools
 import typing as T
 
-from ..mesonlib import MachineChoice
 from .base import DependencyException, DependencyMethods
-from .base import ExternalDependency
 from .base import process_method_kw
 from .base import BuiltinDependency, SystemDependency
 from .cmake import CMakeDependency
@@ -26,8 +25,10 @@
 from .pkgconfig import PkgConfigDependency
 
 if T.TYPE_CHECKING:
-    from ..environment import Environment
+    from .base import ExternalDependency
     from .configtool import ConfigToolDependency
+    from ..environment import Environment
+    from ..mesonlib import MachineChoice
 
     DependencyGenerator = T.Callable, ExternalDependency
     FactoryFunc = T.Callable
@@ -49,6 +50,10 @@
         T.ListDependencyGenerator
     
 
+    # This should be str, Environment, T.Dictstr, T.Any, T.Optionalstr
+    # But if you try that, you get error: Cannot infer type of lambda
+    CmakeDependencyFunc = T.Callable..., CMakeDependency
+
 class DependencyFactory:
 
     """Factory to get dependencies from multiple sources.
@@ -77,7 +82,7 @@
                  pkgconfig_name: T.Optionalstr = None,
                  pkgconfig_class: 'T.TypePkgConfigDependency' = PkgConfigDependency,
                  cmake_name: T.Optionalstr = None,
-                 cmake_class: 'T.TypeCMakeDependency' = CMakeDependency,
+                 cmake_class: 'T.UnionT.TypeCMakeDependency, CmakeDependencyFunc' = CMakeDependency,
                  configtool_class: 'T.OptionalT.TypeConfigToolDependency' = None,
                  framework_name: T.Optionalstr = None,
                  framework_class: 'T.TypeExtraFrameworkDependency' = ExtraFrameworkDependency,
@@ -95,15 +100,15 @@
          = {
             # Just attach the correct name right now, either the generic name
             # or the method specific name.
-            DependencyMethods.EXTRAFRAMEWORK: lambda env, kwargs: framework_class(framework_name or name, env, kwargs),
-            DependencyMethods.PKGCONFIG:      lambda env, kwargs: pkgconfig_class(pkgconfig_name or name, env, kwargs),
-            DependencyMethods.CMAKE:          lambda env, kwargs: cmake_class(cmake_name or name, env, kwargs),
-            DependencyMethods.SYSTEM:         lambda env, kwargs: system_class(name, env, kwargs),
-            DependencyMethods.BUILTIN:        lambda env, kwargs: builtin_class(name, env, kwargs),
-            DependencyMethods.CONFIG_TOOL:    None,
+            DependencyMethods.EXTRAFRAMEWORK: functools.partial(framework_class, framework_name or name),
+            DependencyMethods.PKGCONFIG: functools.partial(pkgconfig_class, pkgconfig_name or name),
+            DependencyMethods.CMAKE: functools.partial(cmake_class, cmake_name or name),
+            DependencyMethods.SYSTEM: functools.partial(system_class, name),
+            DependencyMethods.BUILTIN: functools.partial(builtin_class, name),
+            DependencyMethods.CONFIG_TOOL: None,
         }
         if configtool_class is not None:
-            self.classesDependencyMethods.CONFIG_TOOL = lambda env, kwargs: configtool_class(name, env, kwargs)
+            self.classesDependencyMethods.CONFIG_TOOL = functools.partial(configtool_class, name)
 
     @staticmethod
     def _process_method(method: DependencyMethods, env: 'Environment', for_machine: MachineChoice) -> bool:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/framework.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/framework.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/hdf5.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/hdf5.py Changed

@@ -13,15 +13,16 @@
 # limitations under the License.
 
 # This file contains the detection logic for miscellaneous external dependencies.
+from __future__ import annotations
 
 import functools
 import os
 import re
-import shutil
 import subprocess
 from pathlib import Path
 
-from ..mesonlib import OrderedSet, join_args
+from ..mesonlib import Popen_safe, OrderedSet, join_args
+from ..programs import ExternalProgram
 from .base import DependencyException, DependencyMethods
 from .configtool import ConfigToolDependency
 from .pkgconfig import PkgConfigDependency
@@ -51,7 +52,7 @@
         newinc =   # type: T.Liststr
         for arg in self.compile_args:
             if arg.startswith('-I'):
-                stem = 'static' if kwargs.get('static', False) else 'shared'
+                stem = 'static' if self.static else 'shared'
                 if (Path(arg2:) / stem).is_dir():
                     newinc.append('-I' + str(Path(arg2:) / stem))
         self.compile_args += newinc
@@ -129,7 +130,7 @@
         # We first need to call the tool with -c to get the compile arguments
         # and then without -c to get the link arguments.
         args = self.get_config_value('-show', '-c', 'args')1:
-        args += self.get_config_value('-show', '-noshlib' if kwargs.get('static', False) else '-shlib', 'args')1:
+        args += self.get_config_value('-show', '-noshlib' if self.static else '-shlib', 'args')1:
         for arg in args:
             if arg.startswith(('-I', '-f', '-D')) or arg == '-pthread':
                 self.compile_args.append(arg)
@@ -159,14 +160,14 @@
     if DependencyMethods.PKGCONFIG in methods:
         # Use an ordered set so that these remain the first tried pkg-config files
         pkgconfig_files = OrderedSet('hdf5', 'hdf5-serial')
-        # FIXME: This won't honor pkg-config paths, and cross-native files
-        PCEXE = shutil.which('pkg-config')
+        PCEXE = PkgConfigDependency._detect_pkgbin(False, env, for_machine)
+        pcenv = PkgConfigDependency.setup_env(os.environ, env, for_machine)
         if PCEXE:
+            assert isinstance(PCEXE, ExternalProgram)
             # some distros put hdf5-1.2.3.pc with version number in .pc filename.
-            ret = subprocess.run(PCEXE, '--list-all', stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
-                                    universal_newlines=True)
+            ret, stdout, _ = Popen_safe(PCEXE.get_command() + '--list-all', stderr=subprocess.DEVNULL, env=pcenv)
             if ret.returncode == 0:
-                for pkg in ret.stdout.split('\n'):
+                for pkg in stdout.split('\n'):
                     if pkg.startswith('hdf5'):
                         pkgconfig_files.add(pkg.split(' ', 1)0)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/misc.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/misc.py Changed

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 # This file contains the detection logic for miscellaneous external dependencies.
+from __future__ import annotations
 
 from pathlib import Path
 import functools
@@ -60,6 +61,27 @@
 return candidates
 
 
+class DlBuiltinDependency(BuiltinDependency):
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dictstr, T.Any):
+ super().__init__(name, env, kwargs)
+ self.feature_since = ('0.62.0', "consider checking for `dlopen` with and without `find_library('dl')`")
+
+ if self.clib_compiler.has_function('dlopen', '#include <dlfcn.h>', env)0:
+ self.is_found = True
+
+
+class DlSystemDependency(SystemDependency):
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dictstr, T.Any):
+ super().__init__(name, env, kwargs)
+ self.feature_since = ('0.62.0', "consider checking for `dlopen` with and without `find_library('dl')`")
+
+ h = self.clib_compiler.has_header('dlfcn.h', '', env)
+ self.link_args = self.clib_compiler.find_library('dl', env, , self.libtype)
+
+ if h0 and self.link_args:
+ self.is_found = True
+
+
 class OpenMPDependency(SystemDependency):
 # Map date of specification release (which is the macro value) to a version.
 VERSIONS = {
@@ -124,7 +146,7 @@
 self.is_found = True
 # Happens if you are using a language with threads
 # concept without C, such as plain Cuda.
- if self.clib_compiler is None:
+ if not self.clib_compiler:
 self.compile_args = 
 self.link_args = 
 else:
@@ -175,7 +197,6 @@
 return
 
 self.name = 'python3'
- self.static = kwargs.get('static', False)
 # We can only be sure that it is Python 3 at this point
 self.version = '3'
 self._find_libpy3_windows(environment)
@@ -194,7 +215,7 @@
 return None
 elif pyplat == 'win32':
 return '32'
- elif pyplat in ('win64', 'win-amd64'):
+ elif pyplat in {'win64', 'win-amd64'}:
 return '64'
 mlog.log(f'Unknown Windows Python platform {pyplat!r}')
 return None
@@ -264,7 +285,8 @@
 self.version = sysconfig.get_config_var('py_version')
 self.is_found = True
 
- def log_tried(self) -> str:
+ @staticmethod
+ def log_tried() -> str:
 return 'sysconfig'
 
 class PcapDependencyConfigTool(ConfigToolDependency):
@@ -272,13 +294,19 @@
 tools = 'pcap-config'
 tool_name = 'pcap-config'
 
+ # version 1.10.2 added error checking for invalid arguments
+ # version 1.10.3 will hopefully add actual support for --version
+ skip_version = '--help'
+
 def __init__(self, name: str, environment: 'Environment', kwargs: T.Dictstr, T.Any):
 super().__init__(name, environment, kwargs)
 if not self.is_found:
 return
 self.compile_args = self.get_config_value('--cflags', 'compile_args')
 self.link_args = self.get_config_value('--libs', 'link_args')
- self.version = self.get_pcap_lib_version()
+ if self.version is None:
+ # older pcap-config versions don't support this
+ self.version = self.get_pcap_lib_version()
 
 def get_pcap_lib_version(self) -> T.Optionalstr:
 # Since we seem to need to run a program to discover the pcap version,
@@ -373,9 +401,6 @@
 
 break
 
- def log_tried(self) -> str:
- return 'system'
-
 
 class CursesConfigToolDependency(ConfigToolDependency):
 
@@ -451,6 +476,7 @@
 class IconvBuiltinDependency(BuiltinDependency):
 def __init__(self, name: str, env: 'Environment', kwargs: T.Dictstr, T.Any):
 super().__init__(name, env, kwargs)
+ self.feature_since = ('0.60.0', "consider checking for `iconv_open` with and without `find_library('iconv')`")
 code = '''#include <iconv.h>\n\nint main() {\n iconv_open("","");\n}''' # ignore encoding this is C, not python, Mr. Lint
 
 if self.clib_compiler.links(code, env)0:
@@ -460,6 +486,7 @@
 class IconvSystemDependency(SystemDependency):
 def __init__(self, name: str, env: 'Environment', kwargs: T.Dictstr, T.Any):
 super().__init__(name, env, kwargs)
+ self.feature_since = ('0.60.0', "consider checking for `iconv_open` with and without find_library('iconv')")
 
 h = self.clib_compiler.has_header('iconv.h', '', env)
 self.link_args = self.clib_compiler.find_library('iconv', env, , self.libtype)
@@ -471,6 +498,7 @@
 class IntlBuiltinDependency(BuiltinDependency):
 def __init__(self, name: str, env: 'Environment', kwargs: T.Dictstr, T.Any):
 super().__init__(name, env, kwargs)
+ self.feature_since = ('0.59.0', "consider checking for `ngettext` with and without `find_library('intl')`")
 code = '''#include <libintl.h>\n\nint main() {\n gettext("Hello world");\n}'''
 
 if self.clib_compiler.links(code, env)0:
@@ -480,6 +508,7 @@
 class IntlSystemDependency(SystemDependency):
 def __init__(self, name: str, env: 'Environment', kwargs: T.Dictstr, T.Any):
 super().__init__(name, env, kwargs)
+ self.feature_since = ('0.59.0', "consider checking for `ngettext` with and without `find_library('intl')`")
 
 h = self.clib_compiler.has_header('libintl.h', '', env)
 self.link_args = self.clib_compiler.find_library('intl', env, , self.libtype)
@@ -493,6 +522,55 @@
 return
 
 
+class OpensslSystemDependency(SystemDependency):
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dictstr, T.Any):
+ super().__init__(name, env, kwargs)
+
+ dependency_kwargs = {
+ 'method': 'system',
+ 'static': self.static,
+ }
+ if not self.clib_compiler.has_header('openssl/ssl.h', '', env)0:
+ return
+
+ # openssl >= 3 only
+ self.version = self.clib_compiler.get_define('OPENSSL_VERSION_STR', '#include <openssl/opensslv.h>', env, , self)0
+ # openssl < 3 only
+ if not self.version:
+ version_hex = self.clib_compiler.get_define('OPENSSL_VERSION_NUMBER', '#include <openssl/opensslv.h>', env, , self)0
+ if not version_hex:
+ return
+ version_hex = version_hex.rstrip('L')
+ version_ints = ((int(version_hex.rstrip('L'), 16) >> 4 + i) & 0xFF) for i in (24, 16, 8, 0)
+ # since this is openssl, the format is 1.2.3a in four parts
+ self.version = '.'.join(str(i) for i in version_ints:3) + chr(ord('a') + version_ints3 - 1)
+
+ if name == 'openssl':
+ if self._add_sub_dependency(libssl_factory(env, self.for_machine, dependency_kwargs)) and \
+ self._add_sub_dependency(libcrypto_factory(env, self.for_machine, dependency_kwargs)):
+ self.is_found = True
+ return
+ else:
+ self.link_args = self.clib_compiler.find_library(name.lstrip('lib'), env, , self.libtype)
+ if not self.link_args:
+ return
+
+ if not self.static:
+ self.is_found = True
+ else:
+ if name == 'libssl':
+ if self._add_sub_dependency(libcrypto_factory(env, self.for_machine, dependency_kwargs)):
+ self.is_found = True
+ elif name == 'libcrypto':
+ use_threads = self.clib_compiler.has_header_symbol('openssl/opensslconf.h', 'OPENSSL_THREADS', '', env, dependencies=self)0
+ if not use_threads or self._add_sub_dependency(threads_factory(env, self.for_machine, {})):
+ self.is_found = True
+ # only relevant on platforms where it is distributed with the libc, in which case it always succeeds
+ sublib = self.clib_compiler.find_library('dl', env, , self.libtype)
+ if sublib:
+ self.link_args.extend(sublib)
+
+
 @factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.SYSTEM})
 def curses_factory(env: 'Environment',
 for_machine: 'MachineChoice',
@@ -539,7 +617,7 @@
 shared_libs = 'shaderc'
 static_libs = 'shaderc_combined', 'shaderc_static'
 
- if kwargs.get('static', False):
+ if kwargs.get('static', env.coredata.get_option(mesonlib.OptionKey('prefer_static'))):
 c = functools.partial(PkgConfigDependency, name, env, kwargs)
 for name in static_libs + shared_libs
 else:
@@ -560,6 +638,13 @@
 cmake_name='Cups',
 )
 
+dl_factory = DependencyFactory(
+ 'dl',
+ DependencyMethods.BUILTIN, DependencyMethods.SYSTEM,
+ builtin_class=DlBuiltinDependency,
+ system_class=DlSystemDependency,
+)
+
 gpgme_factory = DependencyFactory(
 'gpgme',
 DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL,
@@ -616,3 +701,24 @@
 builtin_class=IntlBuiltinDependency,
 system_class=IntlSystemDependency,
 )
+
+openssl_factory = DependencyFactory(
+ 'openssl',
+ DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM, DependencyMethods.CMAKE,
+ system_class=OpensslSystemDependency,
+ cmake_class=lambda name, env, kwargs: CMakeDependency('OpenSSL', env, dict(kwargs, modules='OpenSSL::Crypto', 'OpenSSL::SSL')),
+)
+
+libcrypto_factory = DependencyFactory(
+ 'libcrypto',
+ DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM, DependencyMethods.CMAKE,
+ system_class=OpensslSystemDependency,
+ cmake_class=lambda name, env, kwargs: CMakeDependency('OpenSSL', env, dict(kwargs, modules='OpenSSL::Crypto')),
+)
+
+libssl_factory = DependencyFactory(
+ 'libssl',
+ DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM, DependencyMethods.CMAKE,
+ system_class=OpensslSystemDependency,
+ cmake_class=lambda name, env, kwargs: CMakeDependency('OpenSSL', env, dict(kwargs, modules='OpenSSL::SSL')),
+)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/mpi.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/mpi.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import functools
 import typing as T
@@ -40,7 +41,7 @@
 
     candidates: T.List'DependencyGenerator' = 
     compiler = detect_compiler('mpi', env, for_machine, language)
-    if compiler is None:
+    if not compiler:
         return 
     compiler_is_intel = compiler.get_id() in {'intel', 'intel-cl'}
 
@@ -102,7 +103,7 @@
 
 class _MPIConfigToolDependency(ConfigToolDependency):
 
-    def _filter_compile_args(self, args: T.Sequencestr) -> T.Liststr:
+    def _filter_compile_args(self, args: T.Liststr) -> T.Liststr:
         """
         MPI wrappers return a bunch of garbage args.
         Drop -O2 and everything that is not needed.
@@ -126,7 +127,7 @@
                 result.append(f)
         return result
 
-    def _filter_link_args(self, args: T.Sequencestr) -> T.Liststr:
+    def _filter_link_args(self, args: T.Liststr) -> T.Liststr:
         """
         MPI wrappers return a bunch of garbage args.
         Drop -O2 and everything that is not needed.
@@ -136,7 +137,7 @@
         for f in args:
             if self._is_link_arg(f):
                 result.append(f)
-                if f in ('-L', '-Xlinker'):
+                if f in {'-L', '-Xlinker'}:
                     include_next = True
             elif include_next:
                 include_next = False

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/pkgconfig.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/pkgconfig.py Changed

@@ -11,9 +11,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
+
+from pathlib import Path
 
 from .base import ExternalDependency, DependencyException, sort_libpaths, DependencyTypeName
-from ..mesonlib import MachineChoice, OptionKey, OrderedSet, PerMachine, Popen_safe
+from ..mesonlib import OptionKey, OrderedSet, PerMachine, Popen_safe
 from ..programs import find_external_program, ExternalProgram
 from .. import mlog
 from pathlib import PurePath
@@ -24,6 +27,9 @@
 
 if T.TYPE_CHECKING:
     from ..environment import Environment
+    from ..mesonlib import MachineChoice
+    from .._typing import ImmutableListProtocol
+    from ..build import EnvironmentVariables
 
 class PkgConfigDependency(ExternalDependency):
     # The class's copy of the pkg-config path. Avoids having to search for it
@@ -41,36 +47,7 @@
         self.is_libtool = False
         # Store a copy of the pkg-config path on the object itself so it is
         # stored in the pickled coredata and recovered.
-        self.pkgbin: T.UnionNone, bool, ExternalProgram = None
-
-        # Only search for pkg-config for each machine the first time and store
-        # the result in the class definition
-        if PkgConfigDependency.class_pkgbinself.for_machine is False:
-            mlog.debug(f'Pkg-config binary for {self.for_machine} is cached as not found.')
-        elif PkgConfigDependency.class_pkgbinself.for_machine is not None:
-            mlog.debug(f'Pkg-config binary for {self.for_machine} is cached.')
-        else:
-            assert PkgConfigDependency.class_pkgbinself.for_machine is None
-            mlog.debug(f'Pkg-config binary for {self.for_machine} is not cached.')
-            for potential_pkgbin in find_external_program(
-                    self.env, self.for_machine, 'pkgconfig', 'Pkg-config',
-                    environment.default_pkgconfig, allow_default_for_cross=False):
-                version_if_ok = self.check_pkgconfig(potential_pkgbin)
-                if not version_if_ok:
-                    continue
-                if not self.silent:
-                    mlog.log('Found pkg-config:', mlog.bold(potential_pkgbin.get_path()),
-                             f'({version_if_ok})')
-                PkgConfigDependency.class_pkgbinself.for_machine = potential_pkgbin
-                break
-            else:
-                if not self.silent:
-                    mlog.log('Found Pkg-config:', mlog.red('NO'))
-                # Set to False instead of None to signify that we've already
-                # searched for it and not found it
-                PkgConfigDependency.class_pkgbinself.for_machine = False
-
-        self.pkgbin = PkgConfigDependency.class_pkgbinself.for_machine
+        self.pkgbin = self._detect_pkgbin(self.silent, self.env, self.for_machine)
         if self.pkgbin is False:
             self.pkgbin = None
             msg = f'Pkg-config binary for machine {self.for_machine} not found. Giving up.'
@@ -109,46 +86,86 @@
         return s.format(self.__class__.__name__, self.name, self.is_found,
                         self.version_reqs)
 
+    @classmethod
+    def _detect_pkgbin(cls, silent: bool, env: Environment,
+                       for_machine: MachineChoice) -> T.UnionNone, bool, ExternalProgram:
+        # Only search for pkg-config for each machine the first time and store
+        # the result in the class definition
+        if cls.class_pkgbinfor_machine is False:
+            mlog.debug(f'Pkg-config binary for {for_machine} is cached as not found.')
+        elif cls.class_pkgbinfor_machine is not None:
+            mlog.debug(f'Pkg-config binary for {for_machine} is cached.')
+        else:
+            assert cls.class_pkgbinfor_machine is None, 'for mypy'
+            mlog.debug(f'Pkg-config binary for {for_machine} is not cached.')
+            for potential_pkgbin in find_external_program(
+                    env, for_machine, 'pkgconfig', 'Pkg-config',
+                    env.default_pkgconfig, allow_default_for_cross=False):
+                version_if_ok = cls.check_pkgconfig(env, potential_pkgbin)
+                if not version_if_ok:
+                    continue
+                if not silent:
+                    mlog.log('Found pkg-config:', mlog.bold(potential_pkgbin.get_path()),
+                             f'({version_if_ok})')
+                cls.class_pkgbinfor_machine = potential_pkgbin
+                break
+            else:
+                if not silent:
+                    mlog.log('Found Pkg-config:', mlog.red('NO'))
+                # Set to False instead of None to signify that we've already
+                # searched for it and not found it
+                cls.class_pkgbinfor_machine = False
+
+        return cls.class_pkgbinfor_machine
+
     def _call_pkgbin_real(self, args: T.Liststr, env: T.Dictstr, str) -> T.Tupleint, str, str:
         assert isinstance(self.pkgbin, ExternalProgram)
         cmd = self.pkgbin.get_command() + args
         p, out, err = Popen_safe(cmd, env=env)
         rc, out, err = p.returncode, out.strip(), err.strip()
         call = ' '.join(cmd)
-        mlog.debug(f"Called `{call}` -> {rc}\n{out}")
+        mlog.debug(f"Called `{call}` -> {rc}")
+        if out:
+            mlog.debug(f'stdout:\n{out}\n-----------')
+        if err:
+            mlog.debug(f'stderr:\n{err}\n-----------')
         return rc, out, err
 
     @staticmethod
-    def setup_env(env: T.MutableMappingstr, str, environment: 'Environment', for_machine: MachineChoice,
-                  extra_path: T.Optionalstr = None) -> None:
-        extra_paths: T.Liststr = environment.coredata.optionsOptionKey('pkg_config_path', machine=for_machine).value:
-        if extra_path and extra_path not in extra_paths:
-            extra_paths.append(extra_path)
+    def get_env(environment: 'Environment', for_machine: MachineChoice,
+                uninstalled: bool = False) -> 'EnvironmentVariables':
+        from ..build import EnvironmentVariables
+        env = EnvironmentVariables()
+        key = OptionKey('pkg_config_path', machine=for_machine)
+        extra_paths: T.Liststr = environment.coredata.optionskey.value:
+        if uninstalled:
+            uninstalled_path = Path(environment.get_build_dir(), 'meson-uninstalled').as_posix()
+            if uninstalled_path not in extra_paths:
+                extra_paths.append(uninstalled_path)
+        env.set('PKG_CONFIG_PATH', extra_paths)
         sysroot = environment.propertiesfor_machine.get_sys_root()
         if sysroot:
-            env'PKG_CONFIG_SYSROOT_DIR' = sysroot
-        new_pkg_config_path = ':'.join(p for p in extra_paths)
-        env'PKG_CONFIG_PATH' = new_pkg_config_path
-
+            env.set('PKG_CONFIG_SYSROOT_DIR', sysroot)
         pkg_config_libdir_prop = environment.propertiesfor_machine.get_pkg_config_libdir()
         if pkg_config_libdir_prop:
-            new_pkg_config_libdir = ':'.join(p for p in pkg_config_libdir_prop)
-            env'PKG_CONFIG_LIBDIR' = new_pkg_config_libdir
+            env.set('PKG_CONFIG_LIBDIR', pkg_config_libdir_prop)
+        return env
+
+    @staticmethod
+    def setup_env(env: T.MutableMappingstr, str, environment: 'Environment', for_machine: MachineChoice,
+                  uninstalled: bool = False) -> T.Dictstr, str:
+        envvars = PkgConfigDependency.get_env(environment, for_machine, uninstalled)
+        env = envvars.get_env(env)
         # Dump all PKG_CONFIG environment variables
         for key, value in env.items():
             if key.startswith('PKG_'):
                 mlog.debug(f'env{key}: {value}')
+        return env
 
-    def _call_pkgbin(self, args: T.Liststr, env: T.OptionalT.Dictstr, str = None) -> T.Tupleint, str, str:
-        # Always copy the environment since we're going to modify it
-        # with pkg-config variables
-        if env is None:
-            env = os.environ.copy()
-        else:
-            env = env.copy()
-
+    def _call_pkgbin(self, args: T.Liststr, env: T.OptionalT.MutableMappingstr, str = None) -> T.Tupleint, str, str:
         assert isinstance(self.pkgbin, ExternalProgram)
-        PkgConfigDependency.setup_env(env, self.env, self.for_machine)
+        env = env or os.environ
+        env = PkgConfigDependency.setup_env(env, self.env, self.for_machine)
 
         fenv = frozenset(env.items())
         targs = tuple(args)
@@ -295,7 +312,7 @@
                         continue
                     else:
                         mlog.warning('Library {!r} not found for dependency {!r}, may '
-                                    'not be successfully linked'.format(libfilename, self.name))
+                                     'not be successfully linked'.format(libfilename, self.name))
                     libs_notfound.append(lib)
                 else:
                     lib = foundname
@@ -380,18 +397,13 @@
             raise DependencyException(f'Could not generate libs for {self.name}:\n\n{out_raw}')
         self.link_args, self.raw_link_args = self._search_libs(out, out_raw)
 
-    def get_pkgconfig_variable(self, variable_name: str, kwargs: T.Dictstr, T.Unionstr, T.Liststr) -> str:
+    def get_pkgconfig_variable(self, variable_name: str,
+                               define_variable: 'ImmutableListProtocolstr',
+                               default: T.Optionalstr) -> str:
         options = '--variable=' + variable_name, self.name
 
-        if 'define_variable' in kwargs:
-            definition = kwargs.get('define_variable', )
-            if not isinstance(definition, list):
-                raise DependencyException('define_variable takes a list')
-
-            if len(definition) != 2 or not all(isinstance(i, str) for i in definition):
-                raise DependencyException('define_variable must be made up of 2 strings for VARIABLENAME and VARIABLEVALUE')
-
-            options = '--define-variable=' + '='.join(definition) + options
+        if define_variable:
+            options = '--define-variable=' + '='.join(define_variable) + options
 
         ret, out, err = self._call_pkgbin(options)
         variable = ''
@@ -406,16 +418,16 @@
             if not variable:
                 ret, out, _ = self._call_pkgbin('--print-variables', self.name)
                 if not re.search(r'^' + variable_name + r'$', out, re.MULTILINE):
-                    if 'default' in kwargs:
-                        assert isinstance(kwargs'default', str)
-                        variable = kwargs'default'
+                    if default is not None:
+                        variable = default
                     else:
                         mlog.warning(f"pkgconfig variable '{variable_name}' not defined for dependency {self.name}.")
 
         mlog.debug(f'Got pkgconfig variable {variable_name} : {variable}')
         return variable
 
-    def check_pkgconfig(self, pkgbin: ExternalProgram) -> T.Optionalstr:
+    @staticmethod
+    def check_pkgconfig(env: Environment, pkgbin: ExternalProgram) -> T.Optionalstr:
         if not pkgbin.found():
             mlog.log(f'Did not find pkg-config by name {pkgbin.name!r}')
             return None
@@ -434,7 +446,7 @@
             return None
         except PermissionError:
             msg = f'Found pkg-config {command_as_string!r} but didn\'t have permissions to run it.'
-            if not self.env.machines.build.is_windows():
+            if not env.machines.build.is_windows():
                 msg += '\n\nOn Unix-like systems this is often caused by scripts that are not executable.'
             mlog.warning(msg)
             return None
@@ -475,21 +487,17 @@
         # a path rather than the raw dlname
         return os.path.basename(dlname)
 
-    def log_tried(self) -> str:
-        return self.type_name
+    @staticmethod
+    def log_tried() -> str:
+        return 'pkgconfig'
 
     def get_variable(self, *, cmake: T.Optionalstr = None, pkgconfig: T.Optionalstr = None,
                      configtool: T.Optionalstr = None, internal: T.Optionalstr = None,
                      default_value: T.Optionalstr = None,
-                     pkgconfig_define: T.OptionalT.Liststr = None) -> T.Unionstr, T.Liststr:
+                     pkgconfig_define: T.OptionalT.Liststr = None) -> str:
         if pkgconfig:
-            kwargs: T.Dictstr, T.Unionstr, T.Liststr = {}
-            if default_value is not None:
-                kwargs'default' = default_value
-            if pkgconfig_define is not None:
-                kwargs'define_variable' = pkgconfig_define
             try:
-                return self.get_pkgconfig_variable(pkgconfig, kwargs)
+                return self.get_pkgconfig_variable(pkgconfig, pkgconfig_define or , default_value)
             except DependencyException:
                 pass
         if default_value is not None:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/platform.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/platform.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/qt.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/qt.py Changed

@@ -13,6 +13,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Dependency finders for the Qt framework."""
 
@@ -33,6 +34,7 @@
     from ..compilers import Compiler
     from ..envconfig import MachineInfo
     from ..environment import Environment
+    from ..dependencies import MissingCompiler
 
 
 def _qt_get_private_includes(mod_inc_dir: str, module: str, mod_version: str) -> T.Liststr:
@@ -122,7 +124,7 @@
     """Mixin class for shared components between PkgConfig and Qmake."""
 
     link_args: T.Liststr
-    clib_compiler: 'Compiler'
+    clib_compiler: T.Union'MissingCompiler', 'Compiler'
     env: 'Environment'
     libexecdir: T.Optionalstr = None
 
@@ -135,25 +137,28 @@
         else:
             self.qtpkgname = self.qtname
 
-        self.private_headers = T.cast(bool, kwargs.get('private_headers', False))
+        self.private_headers = T.cast('bool', kwargs.get('private_headers', False))
 
         self.requested_modules = mesonlib.stringlistify(mesonlib.extract_as_list(kwargs, 'modules'))
         if not self.requested_modules:
             raise DependencyException('No ' + self.qtname + '  modules specified.')
 
-        self.qtmain = T.cast(bool, kwargs.get('main', False))
+        self.qtmain = T.cast('bool', kwargs.get('main', False))
         if not isinstance(self.qtmain, bool):
             raise DependencyException('"main" argument must be a boolean')
 
-    def _link_with_qtmain(self, is_debug: bool, libdir: T.Unionstr, T.Liststr) -> bool:
+    def _link_with_qt_winmain(self, is_debug: bool, libdir: T.Unionstr, T.Liststr) -> bool:
         libdir = mesonlib.listify(libdir)  # TODO: shouldn't be necessary
-        base_name = 'qtmaind' if is_debug else 'qtmain'
-        qtmain = self.clib_compiler.find_library(base_name, self.env, libdir)
-        if qtmain:
-            self.link_args.append(qtmain0)
+        base_name = self.get_qt_winmain_base_name(is_debug)
+        qt_winmain = self.clib_compiler.find_library(base_name, self.env, libdir)
+        if qt_winmain:
+            self.link_args.append(qt_winmain0)
             return True
         return False
 
+    def get_qt_winmain_base_name(self, is_debug: bool) -> str:
+        return 'qtmaind' if is_debug else 'qtmain'
+
     def get_exe_args(self, compiler: 'Compiler') -> T.Liststr:
         # Originally this was -fPIE but nowadays the default
         # for upstream and distros seems to be -reduce-relocations
@@ -189,7 +194,7 @@
                 self.is_found = False
                 return
             if self.private_headers:
-                qt_inc_dir = mod.get_pkgconfig_variable('includedir', {})
+                qt_inc_dir = mod.get_pkgconfig_variable('includedir', , None)
                 mod_private_dir = os.path.join(qt_inc_dir, 'Qt' + m)
                 if not os.path.isdir(mod_private_dir):
                     # At least some versions of homebrew don't seem to set this
@@ -211,23 +216,30 @@
                 if arg == f'-l{debug_lib_name}' or arg.endswith(f'{debug_lib_name}.lib') or arg.endswith(f'{debug_lib_name}.a'):
                     is_debug = True
                     break
-            libdir = self.get_pkgconfig_variable('libdir', {})
-            if not self._link_with_qtmain(is_debug, libdir):
+            libdir = self.get_pkgconfig_variable('libdir', , None)
+            if not self._link_with_qt_winmain(is_debug, libdir):
                 self.is_found = False
                 return
 
         self.bindir = self.get_pkgconfig_host_bins(self)
         if not self.bindir:
             # If exec_prefix is not defined, the pkg-config file is broken
-            prefix = self.get_pkgconfig_variable('exec_prefix', {})
+            prefix = self.get_pkgconfig_variable('exec_prefix', , None)
             if prefix:
                 self.bindir = os.path.join(prefix, 'bin')
 
+        self.libexecdir = self.get_pkgconfig_host_libexecs(self)
+
     @staticmethod
     @abc.abstractmethod
     def get_pkgconfig_host_bins(core: PkgConfigDependency) -> T.Optionalstr:
         pass
 
+    @staticmethod
+    @abc.abstractmethod
+    def get_pkgconfig_host_libexecs(core: PkgConfigDependency) -> T.Optionalstr:
+        pass
+
     @abc.abstractmethod
     def get_private_includes(self, mod_inc_dir: str, module: str) -> T.Liststr:
         pass
@@ -325,7 +337,7 @@
             self.link_args.append(libfile)
 
         if self.env.machinesself.for_machine.is_windows() and self.qtmain:
-            if not self._link_with_qtmain(is_debug, libdir):
+            if not self._link_with_qt_winmain(is_debug, libdir):
                 self.is_found = False
 
     def _sanitize_version(self, version: str) -> str:
@@ -368,6 +380,12 @@
         return 'qmake'
 
 
+class Qt6WinMainMixin:
+
+    def get_qt_winmain_base_name(self, is_debug: bool) -> str:
+        return 'Qt6EntryPointd' if is_debug else 'Qt6EntryPoint'
+
+
 class Qt4ConfigToolDependency(QmakeQtDependency):
 
     def get_private_includes(self, mod_inc_dir: str, module: str) -> T.Liststr:
@@ -380,7 +398,7 @@
         return _qt_get_private_includes(mod_inc_dir, module, self.version)
 
 
-class Qt6ConfigToolDependency(QmakeQtDependency):
+class Qt6ConfigToolDependency(Qt6WinMainMixin, QmakeQtDependency):
 
     def get_private_includes(self, mod_inc_dir: str, module: str) -> T.Liststr:
         return _qt_get_private_includes(mod_inc_dir, module, self.version)
@@ -397,7 +415,7 @@
         applications = 'moc', 'uic', 'rcc', 'lupdate', 'lrelease'
         for application in applications:
             try:
-                return os.path.dirname(core.get_pkgconfig_variable(f'{application}_location', {}))
+                return os.path.dirname(core.get_pkgconfig_variable(f'{application}_location', , None))
             except mesonlib.MesonException:
                 pass
         return None
@@ -405,22 +423,42 @@
     def get_private_includes(self, mod_inc_dir: str, module: str) -> T.Liststr:
         return 
 
+    @staticmethod
+    def get_pkgconfig_host_libexecs(core: PkgConfigDependency) -> str:
+        return None
+
 
 class Qt5PkgConfigDependency(QtPkgConfigDependency):
 
     @staticmethod
     def get_pkgconfig_host_bins(core: PkgConfigDependency) -> str:
-        return core.get_pkgconfig_variable('host_bins', {})
+        return core.get_pkgconfig_variable('host_bins', , None)
+
+    @staticmethod
+    def get_pkgconfig_host_libexecs(core: PkgConfigDependency) -> str:
+        return None
 
     def get_private_includes(self, mod_inc_dir: str, module: str) -> T.Liststr:
         return _qt_get_private_includes(mod_inc_dir, module, self.version)
 
 
-class Qt6PkgConfigDependency(QtPkgConfigDependency):
+class Qt6PkgConfigDependency(Qt6WinMainMixin, QtPkgConfigDependency):
+
+    def __init__(self, name: str, env: 'Environment', kwargs: T.Dictstr, T.Any):
+        super().__init__(name, env, kwargs)
+        if not self.libexecdir:
+            mlog.debug(f'detected Qt6 {self.version} pkg-config dependency does not '
+                       'have proper tools support, ignoring')
+            self.is_found = False
 
     @staticmethod
     def get_pkgconfig_host_bins(core: PkgConfigDependency) -> str:
-        return core.get_pkgconfig_variable('host_bins', {})
+        return core.get_pkgconfig_variable('bindir', , None)
+
+    @staticmethod
+    def get_pkgconfig_host_libexecs(core: PkgConfigDependency) -> str:
+        # Qt6 pkg-config for Qt defines libexecdir from 6.3+
+        return core.get_pkgconfig_variable('libexecdir', , None)
 
     def get_private_includes(self, mod_inc_dir: str, module: str) -> T.Liststr:
         return _qt_get_private_includes(mod_inc_dir, module, self.version)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/scalapack.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/scalapack.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/dependencies/ui.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/dependencies/ui.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/depfile.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/depfile.py Changed

@@ -10,13 +10,15 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
-import collections
+import typing as T
 
-def parse(lines):
-    rules = 
-    targets = 
-    deps = 
+
+def parse(lines: T.Iterablestr) -> T.ListT.TupleT.Liststr, T.Liststr:
+    rules: T.ListT.TupleT.Liststr, T.Liststr = 
+    targets: T.Liststr = 
+    deps: T.Liststr = 
     in_deps = False
     out = ''
     for line in lines:
@@ -32,10 +34,10 @@
                 out += c
                 escape = None
                 continue
-            if c == '\\' or c == '$':
+            if c in {'\\', '$'}:
                 escape = c
                 continue
-            elif c in (' ', '\n'):
+            elif c in {' ', '\n'}:
                 if out != '':
                     if in_deps:
                         deps.append(out)
@@ -56,12 +58,15 @@
             out += c
     return rules
 
-Target = collections.namedtuple('Target', 'deps')
+class Target(T.NamedTuple):
+
+    deps: T.Setstr
+
 
 class DepFile:
-    def __init__(self, lines):
+    def __init__(self, lines: T.Iterablestr):
         rules = parse(lines)
-        depfile = {}
+        depfile: T.Dictstr, Target = {}
         for (targets, deps) in rules:
             for target in targets:
                 t = depfile.setdefault(target, Target(deps=set()))
@@ -69,16 +74,17 @@
                     t.deps.add(dep)
         self.depfile = depfile
 
-    def get_all_dependencies(self, target, visited=None):
-        deps = set()
+    def get_all_dependencies(self, name: str, visited: T.OptionalT.Setstr = None) -> T.Liststr:
+        deps: T.Setstr = set()
         if not visited:
             visited = set()
-        if target in visited:
-            return set()
-        visited.add(target)
-        target = self.depfile.get(target)
+        if name in visited:
+            return 
+        visited.add(name)
+
+        target = self.depfile.get(name)
         if not target:
-            return set()
+            return 
         deps.update(target.deps)
         for dep in target.deps:
             deps.update(self.get_all_dependencies(dep, visited))

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/envconfig.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/envconfig.py Changed

@@ -11,7 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
+from dataclasses import dataclass
 import subprocess
 import typing as T
 from enum import Enum
@@ -52,6 +54,7 @@
 'microblaze',
 'mips',
 'mips64',
+ 'msp430',
 'parisc',
 'pic24',
 'ppc',
@@ -88,7 +91,7 @@
 
 
 # Map from language identifiers to environment variables.
-ENV_VAR_PROG_MAP: T.Mappingstr, str = {
+ENV_VAR_COMPILER_MAP: T.Mappingstr, str = {
 # Compilers
 'c': 'CC',
 'cpp': 'CXX',
@@ -99,6 +102,7 @@
 'objcpp': 'OBJCXX',
 'rust': 'RUSTC',
 'vala': 'VALAC',
+ 'nasm': 'NASM',
 
 # Linkers
 'c_ld': 'CC_LD',
@@ -108,20 +112,36 @@
 'objc_ld': 'OBJC_LD',
 'objcpp_ld': 'OBJCXX_LD',
 'rust_ld': 'RUSTC_LD',
+}
 
+# Map from utility names to environment variables.
+ENV_VAR_TOOL_MAP: T.Mappingstr, str = {
 # Binutils
- 'strip': 'STRIP',
 'ar': 'AR',
+ 'as': 'AS',
+ 'ld': 'LD',
+ 'nm': 'NM',
+ 'objcopy': 'OBJCOPY',
+ 'objdump': 'OBJDUMP',
+ 'ranlib': 'RANLIB',
+ 'readelf': 'READELF',
+ 'size': 'SIZE',
+ 'strings': 'STRINGS',
+ 'strip': 'STRIP',
 'windres': 'WINDRES',
 
 # Other tools
 'cmake': 'CMAKE',
 'qmake': 'QMAKE',
 'pkgconfig': 'PKG_CONFIG',
+ 'pkg-config': 'PKG_CONFIG',
 'make': 'MAKE',
 'vapigen': 'VAPIGEN',
+ 'llvm-config': 'LLVM_CONFIG',
 }
 
+ENV_VAR_PROG_MAP = {**ENV_VAR_COMPILER_MAP, **ENV_VAR_TOOL_MAP}
+
 # Deprecated environment variables mapped from the new variable to the old one
 # Deprecated in 0.54.0
 DEPRECATED_ENV_PROG_MAP: T.Mappingstr, str = {
@@ -214,7 +234,7 @@
 return res
 
 def get_java_home(self) -> T.OptionalPath:
- value = T.cast(T.Optionalstr, self.properties.get('java_home'))
+ value = T.cast('T.Optionalstr', self.properties.get('java_home'))
 return Path(value) if value else None
 
 def __eq__(self, other: object) -> bool:
@@ -234,27 +254,15 @@
 def get(self, key: str, default: T.OptionalT.Unionstr, bool, int, T.Liststr = None) -> T.OptionalT.Unionstr, bool, int, T.Liststr:
 return self.properties.get(key, default)
 
+@dataclass(unsafe_hash=True)
 class MachineInfo(HoldableObject):
- def __init__(self, system: str, cpu_family: str, cpu: str, endian: str):
- self.system = system
- self.cpu_family = cpu_family
- self.cpu = cpu
- self.endian = endian
- self.is_64_bit = cpu_family in CPU_FAMILIES_64_BIT # type: bool
+ system: str
+ cpu_family: str
+ cpu: str
+ endian: str
 
- def __eq__(self, other: object) -> bool:
- if not isinstance(other, MachineInfo):
- return NotImplemented
- return \
- self.system == other.system and \
- self.cpu_family == other.cpu_family and \
- self.cpu == other.cpu and \
- self.endian == other.endian
-
- def __ne__(self, other: object) -> bool:
- if not isinstance(other, MachineInfo):
- return NotImplemented
- return not self.__eq__(other)
+ def __post_init__(self) -> None:
+ self.is_64_bit: bool = self.cpu_family in CPU_FAMILIES_64_BIT
 
 def __repr__(self) -> str:
 return f'<MachineInfo: {self.system} {self.cpu_family} ({self.cpu})>'
@@ -439,7 +447,8 @@
 for key, value in variables.items():
 value = mesonlib.listify(value)
 for i in value:
- assert isinstance(i, str)
+ if not isinstance(i, str):
+ raise EnvironmentException(f"Value '{i}' of CMake variable '{key}' defined in a machine file is a {type(i).__name__} and not a str")
 self.variableskey = value
 
 def get_variables(self) -> T.Dictstr, T.Liststr:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/environment.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/environment.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import itertools
 import os, platform, re, sys, shutil
@@ -20,14 +21,12 @@
 from . import coredata
 from . import mesonlib
 from .mesonlib import (
-    MesonException, EnvironmentException, MachineChoice, Popen_safe, PerMachine,
+    MesonException, MachineChoice, Popen_safe, PerMachine,
     PerMachineDefaultable, PerThreeMachineDefaultable, split_args, quote_arg, OptionKey,
     search_version, MesonBugException
 )
 from . import mlog
-from .programs import (
-    ExternalProgram, EmptyExternalProgram
-)
+from .programs import ExternalProgram
 
 from .envconfig import (
     BinaryTable, MachineInfo, Properties, known_cpu_families, CMakeVariables,
@@ -47,16 +46,15 @@
 from mesonbuild import envconfig
 
 if T.TYPE_CHECKING:
+    import argparse
     from configparser import ConfigParser
 
     from .wrap.wrap import Resolver
 
-build_filename = 'meson.build'
+    CompilersDict = T.Dictstr, Compiler
 
-CompilersDict = T.Dictstr, Compiler
 
-if T.TYPE_CHECKING:
-    import argparse
+build_filename = 'meson.build'
 
 
 def _get_env_var(for_machine: MachineChoice, is_cross: bool, var_name: str) -> T.Optionalstr:
@@ -159,6 +157,8 @@
     # unless it becomes a stable release.
     suffixes = 
         '', # base (no suffix)
+        '-14',  '14',
+        '-13',  '13',
         '-12',  '12',
         '-11',  '11',
         '-10',  '10',
@@ -173,7 +173,7 @@
         '-3.7', '37',
         '-3.6', '36',
         '-3.5', '35',
-        '-13',    # Debian development snapshot
+        '-15',    # Debian development snapshot
         '-devel', # FreeBSD development snapshot
     
     names = 
@@ -228,22 +228,6 @@
             return path
     return 
 
-def detect_native_windows_arch():
-    """
-    The architecture of Windows itself: x86, amd64 or arm64
-    """
-    # These env variables are always available. See:
-    # https://msdn.microsoft.com/en-us/library/aa384274(VS.85).aspx
-    # https://blogs.msdn.microsoft.com/david.wang/2006/03/27/howto-detect-process-bitness/
-    arch = os.environ.get('PROCESSOR_ARCHITEW6432', '').lower()
-    if not arch:
-        try:
-            # If this doesn't exist, something is messing with the environment
-            arch = os.environ'PROCESSOR_ARCHITECTURE'.lower()
-        except KeyError:
-            raise EnvironmentException('Unable to detect native OS architecture')
-    return arch
-
 def detect_windows_arch(compilers: CompilersDict) -> str:
     """
     Detecting the 'native' architecture of Windows is not a trivial task. We
@@ -268,7 +252,7 @@
     3. Otherwise, use the actual Windows architecture
 
     """
-    os_arch = detect_native_windows_arch()
+    os_arch = mesonlib.windows_detect_native_arch()
     if os_arch == 'x86':
         return os_arch
     # If we're on 64-bit Windows, 32-bit apps can be compiled without
@@ -276,7 +260,7 @@
     # 32-bit and pretend like we're running under WOW64. Else, return the
     # actual Windows architecture that we deduced above.
     for compiler in compilers.values():
-        if compiler.id == 'msvc' and (compiler.target == 'x86' or compiler.target == '80x86'):
+        if compiler.id == 'msvc' and (compiler.target in {'x86', '80x86'}):
             return 'x86'
         if compiler.id == 'clang-cl' and compiler.target == 'x86':
             return 'x86'
@@ -322,7 +306,7 @@
         trial = 'ppc64'
     elif trial.startswith(('powerpc', 'ppc')) or trial in {'macppc', 'power macintosh'}:
         trial = 'ppc'
-    elif trial in ('amd64', 'x64', 'i86pc'):
+    elif trial in {'amd64', 'x64', 'i86pc'}:
         trial = 'x86_64'
     elif trial in {'sun4u', 'sun4v'}:
         trial = 'sparc64'
@@ -369,13 +353,13 @@
     else:
         trial = platform.machine().lower()
 
-    if trial in ('amd64', 'x64', 'i86pc'):
+    if trial in {'amd64', 'x64', 'i86pc'}:
         trial = 'x86_64'
     if trial == 'x86_64':
         # Same check as above for cpu_family
         if any_compiler_has_define(compilers, '__i386__'):
             trial = 'i686' # All 64 bit cpus have at least this level of x86 support.
-    elif trial.startswith('aarch64'):
+    elif trial.startswith('aarch64') or trial.startswith('arm64'):
         # Same check as above for cpu_family
         if any_compiler_has_define(compilers, '__arm__'):
             trial = 'arm'
@@ -656,7 +640,7 @@
                         _p_env = re.split(r':|;', p_env)
                     p_list = list(mesonlib.OrderedSet(_p_env))
                 elif keyname == 'pkg_config_path':
-                    p_list = list(mesonlib.OrderedSet(p_env.split(':')))
+                    p_list = list(mesonlib.OrderedSet(p_env.split(os.pathsep)))
                 else:
                     p_list = split_args(p_env)
                 p_list = e for e in p_list if e  # filter out any empty elements
@@ -692,7 +676,7 @@
                             # acts as a linker driver, `-Dc_args` will not.
                             #
                             # We still use the original key as the base here, as
-                            # we want to inhert the machine and the compiler
+                            # we want to inherit the machine and the compiler
                             # language
                             key = key.evolve('env_args')
                         env_optskey.extend(p_list)
@@ -814,6 +798,10 @@
             return self.get_bindir()
         return self.get_libdir()
 
+    def get_jar_dir(self) -> str:
+        """Install dir for JAR files"""
+        return f"{self.get_datadir()}/java"
+
     def get_static_lib_dir(self) -> str:
         "Install dir for the static library"
         return self.get_libdir()
@@ -841,10 +829,10 @@
 
     def get_compiler_system_dirs(self, for_machine: MachineChoice):
         for comp in self.coredata.compilersfor_machine.values():
-            if isinstance(comp, compilers.ClangCompiler):
+            if comp.id == 'clang':
                 index = 1
                 break
-            elif isinstance(comp, compilers.GnuCompiler):
+            elif comp.id == 'gcc':
                 index = 2
                 break
         else:
@@ -864,7 +852,7 @@
             return value
         return not machine_info_can_run(self.machinesfor_machine)
 
-    def get_exe_wrapper(self) -> ExternalProgram:
+    def get_exe_wrapper(self) -> T.OptionalExternalProgram:
         if not self.need_exe_wrapper():
-            return EmptyExternalProgram()
+            return None
         return self.exe_wrapper

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/__init__.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/__init__.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/compiler.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/compiler.py Changed

@@ -1,9 +1,11 @@
 # SPDX-Licnese-Identifier: Apache-2.0
 # Copyright 2012-2021 The Meson development team
 # Copyright © 2021 Intel Corporation
+from __future__ import annotations
 
 import enum
 import functools
+import os
 import typing as T
 
 from .. import build
@@ -17,6 +19,7 @@
 FeatureNew, disablerIfNotFound,
 InterpreterException)
 from ..interpreterbase.decorators import ContainerTypeInfo, typed_kwargs, KwargInfo, typed_pos_args
+from ..mesonlib import OptionKey
 from .interpreterobjects import (extract_required_kwarg, extract_search_dirs)
 from .type_checking import REQUIRED_KW, in_set_validator, NoneType
 
@@ -78,6 +81,11 @@
 header_prefix: str
 header_required: T.Unionbool, coredata.UserFeatureOption
 
+ class PreprocessKW(TypedDict):
+ output: str
+ compile_args: T.Liststr
+ include_directories: T.Listbuild.IncludeDirs
+
 
 class _TestMode(enum.Enum):
 
@@ -135,7 +143,13 @@
 default=,
 listify=True,
 )
-_PREFIX_KW = KwargInfo('prefix', str, default='')
+_PREFIX_KW: KwargInfostr = KwargInfo(
+ 'prefix',
+ (str, ContainerTypeInfo(list, str)),
+ default='',
+ since_values={list: '1.0.0'},
+ convertor=lambda x: '\n'.join(x) if isinstance(x, list) else x)
+
 _NO_BUILTIN_ARGS_KW = KwargInfo('no_builtin_args', bool, default=False)
 _NAME_KW = KwargInfo('name', str, default='')
 
@@ -183,19 +197,16 @@
 'first_supported_link_argument': self.first_supported_link_argument_method,
 'symbols_have_underscore_prefix': self.symbols_have_underscore_prefix_method,
 'get_argument_syntax': self.get_argument_syntax_method,
+ 'preprocess': self.preprocess_method,
 })
 
 @property
 def compiler(self) -> 'Compiler':
 return self.held_object
 
- def _dep_msg(self, deps: T.List'dependencies.Dependency', endl: str) -> str:
+ def _dep_msg(self, deps: T.List'dependencies.Dependency', compile_only: bool, endl: str) -> str:
 msg_single = 'with dependency {}'
 msg_many = 'with dependencies {}'
- if not deps:
- return endl
- if endl is None:
- endl = ''
 names = 
 for d in deps:
 if isinstance(d, dependencies.InternalDependency):
@@ -203,13 +214,17 @@
 location=self.current_node)
 continue
 if isinstance(d, dependencies.ExternalLibrary):
+ if compile_only:
+ continue
 name = '-l' + d.name
 else:
 name = d.name
 names.append(name)
 if not names:
- return None
+ return endl
 tpl = msg_many if len(names) > 1 else msg_single
+ if endl is None:
+ endl = ''
 return tpl.format(', '.join(names)) + endl
 
 @noPosargs
@@ -223,9 +238,9 @@
 return self.compiler.exelist
 
 def _determine_args(self, nobuiltins: bool,
- incdirs: T.Listbuild.IncludeDirs,
- extra_args: T.Liststr,
- mode: CompileCheckMode = CompileCheckMode.LINK) -> T.Liststr:
+ incdirs: T.Listbuild.IncludeDirs,
+ extra_args: T.Liststr,
+ mode: CompileCheckMode = CompileCheckMode.LINK) -> T.Liststr:
 args: T.Liststr = 
 for i in incdirs:
 for idir in i.to_string_list(self.environment.get_source_dir()):
@@ -238,22 +253,9 @@
 args.extend(extra_args)
 return args
 
- def _determine_dependencies(self, deps: T.List'dependencies.Dependency', endl: str = ':') -> T.TupleT.List'dependencies.Dependency', str:
- if deps:
- final_deps = 
- while deps:
- next_deps = 
- for d in mesonlib.listify(deps):
- if not isinstance(d, dependencies.Dependency) or d.is_built():
- raise InterpreterException('Dependencies must be external dependencies')
- final_deps.append(d)
- next_deps.extend(d.ext_deps)
- deps = next_deps
- deps = final_deps
- else:
- # Ensure that we always return a new instance
- deps = deps.copy()
- return deps, self._dep_msg(deps, endl)
+ def _determine_dependencies(self, deps: T.List'dependencies.Dependency', compile_only: bool = False, endl: str = ':') -> T.TupleT.List'dependencies.Dependency', str:
+ deps = dependencies.get_leaf_external_dependencies(deps)
+ return deps, self._dep_msg(deps, compile_only, endl)
 
 @typed_pos_args('compiler.alignment', str)
 @typed_kwargs(
@@ -264,7 +266,7 @@
 )
 def alignment_method(self, args: T.Tuplestr, kwargs: 'AlignmentKw') -> int:
 typename = args0
- deps, msg = self._determine_dependencies(kwargs'dependencies')
+ deps, msg = self._determine_dependencies(kwargs'dependencies', compile_only=self.compiler.is_cross)
 result = self.compiler.alignment(typename, kwargs'prefix', self.environment,
 extra_args=kwargs'args',
 dependencies=deps)
@@ -281,7 +283,7 @@
 code.rel_to_builddir(self.environment.source_dir))
 testname = kwargs'name'
 extra_args = functools.partial(self._determine_args, kwargs'no_builtin_args', kwargs'include_directories', kwargs'args')
- deps, msg = self._determine_dependencies(kwargs'dependencies', endl=None)
+ deps, msg = self._determine_dependencies(kwargs'dependencies', compile_only=False, endl=None)
 result = self.compiler.run(code, self.environment, extra_args=extra_args,
 dependencies=deps)
 if testname:
@@ -358,7 +360,7 @@
 def has_function_method(self, args: T.Tuplestr, kwargs: 'CommonKW') -> bool:
 funcname = args0
 extra_args = self._determine_args(kwargs'no_builtin_args', kwargs'include_directories', kwargs'args')
- deps, msg = self._determine_dependencies(kwargs'dependencies')
+ deps, msg = self._determine_dependencies(kwargs'dependencies', compile_only=False)
 had, cached = self.compiler.has_function(funcname, kwargs'prefix', self.environment,
 extra_args=extra_args,
 dependencies=deps)
@@ -398,7 +400,7 @@
 def compute_int_method(self, args: T.Tuplestr, kwargs: 'CompupteIntKW') -> int:
 expression = args0
 extra_args = functools.partial(self._determine_args, kwargs'no_builtin_args', kwargs'include_directories', kwargs'args')
- deps, msg = self._determine_dependencies(kwargs'dependencies')
+ deps, msg = self._determine_dependencies(kwargs'dependencies', compile_only=self.compiler.is_cross)
 res = self.compiler.compute_int(expression, kwargs'low', kwargs'high',
 kwargs'guess', kwargs'prefix',
 self.environment, extra_args=extra_args,
@@ -411,7 +413,7 @@
 def sizeof_method(self, args: T.Tuplestr, kwargs: 'CommonKW') -> int:
 element = args0
 extra_args = functools.partial(self._determine_args, kwargs'no_builtin_args', kwargs'include_directories', kwargs'args')
- deps, msg = self._determine_dependencies(kwargs'dependencies')
+ deps, msg = self._determine_dependencies(kwargs'dependencies', compile_only=self.compiler.is_cross)
 esize = self.compiler.sizeof(element, kwargs'prefix', self.environment,
 extra_args=extra_args, dependencies=deps)
 mlog.log('Checking for size of', mlog.bold(element, True), msg, esize)
@@ -477,7 +479,7 @@
 
 testname = kwargs'name'
 extra_args = functools.partial(self._determine_args, kwargs'no_builtin_args', kwargs'include_directories', kwargs'args')
- deps, msg = self._determine_dependencies(kwargs'dependencies')
+ deps, msg = self._determine_dependencies(kwargs'dependencies', compile_only=False)
 result, cached = self.compiler.links(code, self.environment,
 compiler=compiler,
 extra_args=extra_args,
@@ -545,7 +547,7 @@
 hname, symbol = args
 disabled, required, feature = extract_required_kwarg(kwargs, self.subproject, default=False)
 if disabled:
- mlog.log(f'Header <{hname}> has symbol', mlog.bold(symbol, True), 'skipped: feature', mlog.bold(feature), 'disabled')
+ mlog.log('Header', mlog.bold(hname, True), 'has symbol', mlog.bold(symbol, True), 'skipped: feature', mlog.bold(feature), 'disabled')
 return False
 extra_args = functools.partial(self._determine_args, kwargs'no_builtin_args', kwargs'include_directories', kwargs'args')
 deps, msg = self._determine_dependencies(kwargs'dependencies')
@@ -559,7 +561,7 @@
 else:
 h = mlog.red('NO')
 cached_msg = mlog.blue('(cached)') if cached else ''
- mlog.log(f'Header <{hname}> has symbol', mlog.bold(symbol, True), msg, h, cached_msg)
+ mlog.log('Header', mlog.bold(hname, True), 'has symbol', mlog.bold(symbol, True), msg, h, cached_msg)
 return haz
 
 def notfound_library(self, libname: str) -> 'dependencies.ExternalLibrary':
@@ -605,10 +607,13 @@
 
 search_dirs = extract_search_dirs(kwargs)
 
+ prefer_static = self.environment.coredata.get_option(OptionKey('prefer_static'))
 if kwargs'static' is True:
 libtype = mesonlib.LibType.STATIC
 elif kwargs'static' is False:
 libtype = mesonlib.LibType.SHARED
+ elif prefer_static:
+ libtype = mesonlib.LibType.PREFER_STATIC
 else:
 libtype = mesonlib.LibType.PREFER_SHARED
 linkargs = self.compiler.find_library(libname, self.environment, search_dirs, libtype)
@@ -743,3 +748,34 @@
 @noKwargs
 def get_argument_syntax_method(self, args: T.List'TYPE_var', kwargs: 'TYPE_kwargs') -> str:
 return self.compiler.get_argument_syntax()
+
+ @FeatureNew('compiler.preprocess', '0.64.0')
+ @typed_pos_args('compiler.preprocess', varargs=(mesonlib.File, str), min_varargs=1)
+ @typed_kwargs(
+ 'compiler.preprocess',
+ KwargInfo('output', str, default='@PLAINNAME@.i'),
+ KwargInfo('compile_args', ContainerTypeInfo(list, str), listify=True, default=),
+ _INCLUDE_DIRS_KW,
+ )
+ def preprocess_method(self, args: T.TupleT.List'mesonlib.FileOrString', kwargs: 'PreprocessKW') -> T.Listbuild.CustomTargetIndex:
+ compiler = self.compiler.get_preprocessor()
+ sources = self.interpreter.source_strings_to_files(args0)
+ tg_kwargs = {
+ f'{self.compiler.language}_args': kwargs'compile_args',
+ 'build_by_default': False,
+ 'include_directories': kwargs'include_directories',
+ }
+ tg = build.CompileTarget(
+ 'preprocessor',
+ self.interpreter.subdir,
+ self.subproject,
+ self.environment,
+ sources,
+ kwargs'output',
+ compiler,
+ tg_kwargs)
+ self.interpreter.add_target(tg.name, tg)
+ # Expose this target as list of its outputs, so user can pass them to
+ # other targets, list outputs, etc.
+ private_dir = os.path.relpath(self.interpreter.backend.get_target_private_dir(tg), self.interpreter.subdir)
+ return build.CustomTargetIndex(tg, os.path.join(private_dir, o)) for o in tg.outputs

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/dependencyfallbacks.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/dependencyfallbacks.py Changed

@@ -1,18 +1,20 @@
-from .interpreterobjects import SubprojectHolder, extract_required_kwarg
+from __future__ import annotations
 
+from .interpreterobjects import extract_required_kwarg
 from .. import mlog
 from .. import dependencies
 from .. import build
 from ..wrap import WrapMode
-from ..mesonlib import OptionKey, extract_as_list, stringlistify, version_compare_many
+from ..mesonlib import OptionKey, extract_as_list, stringlistify, version_compare_many, listify
 from ..dependencies import Dependency, DependencyException, NotFoundDependency
 from ..interpreterbase import (MesonInterpreterObject, FeatureNew,
- InterpreterException, InvalidArguments,
- TYPE_nkwargs, TYPE_nvar)
+ InterpreterException, InvalidArguments)
 
 import typing as T
 if T.TYPE_CHECKING:
 from .interpreter import Interpreter
+ from ..interpreterbase import TYPE_nkwargs, TYPE_nvar
+ from .interpreterobjects import SubprojectHolder
 
 
 class DependencyFallbacksHolder(MesonInterpreterObject):
@@ -26,10 +28,12 @@
 self.environment = interpreter.environment
 self.wrap_resolver = interpreter.environment.wrap_resolver
 self.allow_fallback = allow_fallback
- self.subproject_name = None
- self.subproject_varname = None
+ self.subproject_name: T.Optionalstr = None
+ self.subproject_varname: T.Optionalstr = None
 self.subproject_kwargs = {'default_options': default_options or }
 self.names: T.Liststr = 
+ self.forcefallback: bool = False
+ self.nofallback: bool = False
 for name in names:
 if not name:
 raise InterpreterException('dependency_fallbacks empty name \'\' is not allowed')
@@ -37,8 +41,9 @@
 raise InvalidArguments('Characters <, > and = are forbidden in dependency names. To specify'
 'version\n requirements use the \'version\' keyword argument instead.')
 if name in self.names:
- raise InterpreterException('dependency_fallbacks name {name!r} is duplicated')
+ raise InterpreterException(f'dependency_fallbacks name {name!r} is duplicated')
 self.names.append(name)
+ self._display_name = self.names0 if self.names else '(anonymous)'
 
 def set_fallback(self, fbinfo: T.OptionalT.UnionT.Liststr, str) -> None:
 # Legacy: This converts dependency()'s fallback kwargs.
@@ -61,14 +66,6 @@
 self._subproject_impl(subp_name, varname)
 
 def _subproject_impl(self, subp_name: str, varname: str) -> None:
- if not varname:
- # If no variable name is specified, check if the wrap file has one.
- # If the wrap file has a variable name, better use it because the
- # subproject most probably is not using meson.override_dependency().
- for name in self.names:
- varname = self.wrap_resolver.get_varname(subp_name, name)
- if varname:
- break
 assert self.subproject_name is None
 self.subproject_name = subp_name
 self.subproject_varname = varname
@@ -105,14 +102,14 @@
 def _do_subproject(self, kwargs: TYPE_nkwargs, func_args: TYPE_nvar, func_kwargs: TYPE_nkwargs) -> T.OptionalDependency:
 if self.forcefallback:
 mlog.log('Looking for a fallback subproject for the dependency',
- mlog.bold(self.display_name), 'because:\nUse of fallback dependencies is forced.')
+ mlog.bold(self._display_name), 'because:\nUse of fallback dependencies is forced.')
 elif self.nofallback:
 mlog.log('Not looking for a fallback subproject for the dependency',
- mlog.bold(self.display_name), 'because:\nUse of fallback dependencies is disabled.')
+ mlog.bold(self._display_name), 'because:\nUse of fallback dependencies is disabled.')
 return None
 else:
 mlog.log('Looking for a fallback subproject for the dependency',
- mlog.bold(self.display_name))
+ mlog.bold(self._display_name))
 
 # dependency('foo', static: true) should implicitly add
 # default_options: 'default_library=static'
@@ -128,6 +125,9 @@
 # Configure the subproject
 subp_name = self.subproject_name
 varname = self.subproject_varname
+ func_kwargs.setdefault('version', )
+ if 'default_options' in kwargs and isinstance(kwargs'default_options', str):
+ func_kwargs'default_options' = listify(kwargs'default_options')
 self.interpreter.do_subproject(subp_name, 'meson', func_kwargs)
 return self._get_subproject_dep(subp_name, varname, kwargs)
 
@@ -141,7 +141,7 @@
 # Verify the subproject is found
 subproject = self._get_subproject(subp_name)
 if not subproject:
- mlog.log('Dependency', mlog.bold(self.display_name), 'from subproject',
+ mlog.log('Dependency', mlog.bold(self._display_name), 'from subproject',
 mlog.bold(subp_name), 'found:', mlog.red('NO'),
 mlog.blue('(subproject failed to configure)'))
 return None
@@ -167,27 +167,35 @@
 # Legacy: Use the variable name if provided instead of relying on the
 # subproject to override one of our dependency names
 if not varname:
- mlog.warning(f'Subproject {subp_name!r} did not override {self.display_name!r} dependency and no variable name specified')
- mlog.log('Dependency', mlog.bold(self.display_name), 'from subproject',
+ # If no variable name is specified, check if the wrap file has one.
+ # If the wrap file has a variable name, better use it because the
+ # subproject most probably is not using meson.override_dependency().
+ for name in self.names:
+ varname = self.wrap_resolver.get_varname(subp_name, name)
+ if varname:
+ break
+ if not varname:
+ mlog.warning(f'Subproject {subp_name!r} did not override {self._display_name!r} dependency and no variable name specified')
+ mlog.log('Dependency', mlog.bold(self._display_name), 'from subproject',
 mlog.bold(subproject.subdir), 'found:', mlog.red('NO'))
 return self._notfound_dependency()
 
 var_dep = self._get_subproject_variable(subproject, varname) or self._notfound_dependency()
 if not var_dep.found():
- mlog.log('Dependency', mlog.bold(self.display_name), 'from subproject',
+ mlog.log('Dependency', mlog.bold(self._display_name), 'from subproject',
 mlog.bold(subproject.subdir), 'found:', mlog.red('NO'))
 return var_dep
 
 wanted = stringlistify(kwargs.get('version', ))
 found = var_dep.get_version()
 if not self._check_version(wanted, found):
- mlog.log('Dependency', mlog.bold(self.display_name), 'from subproject',
+ mlog.log('Dependency', mlog.bold(self._display_name), 'from subproject',
 mlog.bold(subproject.subdir), 'found:', mlog.red('NO'),
 'found', mlog.normal_cyan(found), 'but need:',
 mlog.bold(', '.join(f"'{e}'" for e in wanted)))
 return self._notfound_dependency()
 
- mlog.log('Dependency', mlog.bold(self.display_name), 'from subproject',
+ mlog.log('Dependency', mlog.bold(self._display_name), 'from subproject',
 mlog.bold(subproject.subdir), 'found:', mlog.green('YES'),
 mlog.normal_cyan(found) if found else None)
 return var_dep
@@ -209,7 +217,7 @@
 # have explicitly called meson.override_dependency() with a not-found
 # dep.
 if not cached_dep.found():
- mlog.log('Dependency', mlog.bold(self.display_name),
+ mlog.log('Dependency', mlog.bold(self._display_name),
 'found:', mlog.red('NO'), *info)
 return cached_dep
 else:
@@ -231,7 +239,7 @@
 return self._notfound_dependency()
 if found_vers:
 info = mlog.normal_cyan(found_vers), *info
- mlog.log('Dependency', mlog.bold(self.display_name),
+ mlog.log('Dependency', mlog.bold(self._display_name),
 'found:', mlog.green('YES'), *info)
 return cached_dep
 return None
@@ -247,7 +255,7 @@
 return None
 return var_dep
 
- def _verify_fallback_consistency(self, cached_dep: Dependency):
+ def _verify_fallback_consistency(self, cached_dep: Dependency) -> None:
 subp_name = self.subproject_name
 varname = self.subproject_varname
 subproject = self._get_subproject(subp_name)
@@ -273,12 +281,10 @@
 return NotFoundDependency(self.names0 if self.names else '', self.environment)
 
 @staticmethod
- def _check_version(wanted: T.Optionalstr, found: str) -> bool:
+ def _check_version(wanted: T.Liststr, found: str) -> bool:
 if not wanted:
 return True
- if found == 'undefined' or not version_compare_many(found, wanted)0:
- return False
- return True
+ return not (found == 'undefined' or not version_compare_many(found, wanted)0)
 
 def _get_candidates(self) -> T.ListT.TupleT.CallableTYPE_nkwargs, TYPE_nvar, TYPE_nkwargs, T.OptionalDependency, TYPE_nvar, TYPE_nkwargs:
 candidates = 
@@ -298,19 +304,20 @@
 return candidates
 
 def lookup(self, kwargs: TYPE_nkwargs, force_fallback: bool = False) -> Dependency:
- self.display_name = self.names0 if self.names else '(anonymous)'
 mods = extract_as_list(kwargs, 'modules')
 if mods:
- self.display_name += ' (modules: {})'.format(', '.join(str(i) for i in mods))
+ self._display_name += ' (modules: {})'.format(', '.join(str(i) for i in mods))
 
 disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
 if disabled:
- mlog.log('Dependency', mlog.bold(self.display_name), 'skipped: feature', mlog.bold(feature), 'disabled')
+ mlog.log('Dependency', mlog.bold(self._display_name), 'skipped: feature', mlog.bold(feature), 'disabled')
 return self._notfound_dependency()
 
 # Check if usage of the subproject fallback is forced
 wrap_mode = self.coredata.get_option(OptionKey('wrap_mode'))
+ assert isinstance(wrap_mode, WrapMode), 'for mypy'
 force_fallback_for = self.coredata.get_option(OptionKey('force_fallback_for'))
+ assert isinstance(force_fallback_for, list), 'for mypy'
 self.nofallback = wrap_mode == WrapMode.nofallback
 self.forcefallback = (force_fallback or
 wrap_mode == WrapMode.forcefallback or
@@ -359,7 +366,7 @@
 # This was the last candidate or the dependency has been cached
 # as not-found, or cached dependency version does not match,
 # otherwise func() would have returned None instead.
- raise DependencyException(f'Dependency {self.display_name!r} is required but not found.')
+ raise DependencyException(f'Dependency {self._display_name!r} is required but not found.')
 elif dep:
 # Same as above, but the dependency is not required.
 return dep

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/interpreter.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/interpreter.py Changed

@@ -10,6 +10,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from .. import mparser
 from .. import environment
@@ -22,7 +23,8 @@
 from .. import envconfig
 from ..wrap import wrap, WrapMode
 from .. import mesonlib
-from ..mesonlib import MesonBugException, HoldableObject, FileMode, MachineChoice, OptionKey, listify, extract_as_list, has_path_sep
+from ..mesonlib import (MesonBugException, HoldableObject, FileMode, MachineChoice, OptionKey,
+ listify, extract_as_list, has_path_sep, PerMachine)
 from ..programs import ExternalProgram, NonExistingExternalProgram
 from ..dependencies import Dependency
 from ..depfile import DepFile
@@ -32,10 +34,9 @@
 from ..interpreterbase import Disabler, disablerIfNotFound
 from ..interpreterbase import FeatureNew, FeatureDeprecated, FeatureNewKwargs, FeatureDeprecatedKwargs
 from ..interpreterbase import ObjectHolder
-from ..interpreterbase.baseobjects import TYPE_var, TYPE_kwargs
 from ..modules import ExtensionModule, ModuleObject, MutableModuleObject, NewExtensionModule, NotFoundExtensionModule
 from ..cmake import CMakeInterpreter
-from ..backend.backends import Backend, ExecutableSerialisation
+from ..backend.backends import ExecutableSerialisation
 
 from . import interpreterobjects as OBJ
 from . import compiler as compilerOBJ
@@ -43,7 +44,6 @@
 from .dependencyfallbacks import DependencyFallbacksHolder
 from .interpreterobjects import (
 SubprojectHolder,
- ConfigurationDataObject,
 Test,
 RunProcess,
 extract_required_kwarg,
@@ -51,29 +51,47 @@
 NullSubprojectInterpreter,
 )
 from .type_checking import (
- COMMAND_KW, CT_BUILD_ALWAYS, CT_BUILD_ALWAYS_STALE,
+ COMMAND_KW,
+ CT_BUILD_ALWAYS,
+ CT_BUILD_ALWAYS_STALE,
 CT_BUILD_BY_DEFAULT,
 CT_INPUT_KW,
 CT_INSTALL_DIR_KW,
- CT_OUTPUT_KW,
+ MULTI_OUTPUT_KW,
+ OUTPUT_KW,
 DEFAULT_OPTIONS,
+ DEPENDENCIES_KW,
 DEPENDS_KW,
 DEPEND_FILES_KW,
 DEPFILE_KW,
 DISABLER_KW,
+ D_MODULE_VERSIONS_KW,
 ENV_KW,
+ ENV_METHOD_KW,
+ ENV_SEPARATOR_KW,
+ INCLUDE_DIRECTORIES,
 INSTALL_KW,
+ INSTALL_DIR_KW,
 INSTALL_MODE_KW,
+ LINK_WITH_KW,
+ LINK_WHOLE_KW,
 CT_INSTALL_TAG_KW,
+ INSTALL_TAG_KW,
 LANGUAGE_KW,
- NATIVE_KW, OVERRIDE_OPTIONS_KW,
+ NATIVE_KW,
+ PRESERVE_PATH_KW,
 REQUIRED_KW,
+ SOURCES_KW,
+ VARIABLES_KW,
+ TEST_KWS,
 NoneType,
 in_set_validator,
+ env_convertor_with_method
 )
 from . import primitives as P_OBJ
 
 from pathlib import Path
+from enum import Enum
 import os
 import shutil
 import uuid
@@ -83,11 +101,16 @@
 import typing as T
 import textwrap
 import importlib
+import copy
 
 if T.TYPE_CHECKING:
 import argparse
 
- from . import kwargs
+ from typing_extensions import Literal
+
+ from . import kwargs as kwtypes
+ from ..backend.backends import Backend
+ from ..interpreterbase.baseobjects import InterpreterObject, TYPE_var, TYPE_kwargs
 from ..programs import OverrideProgram
 
 # Input source types passed to Targets
@@ -97,19 +120,19 @@
 # Input source types passed to the build.Target classes
 SourceOutputs = T.Unionmesonlib.File, build.GeneratedList,
 build.BuildTarget, build.CustomTargetIndex, build.CustomTarget,
- build.ExtractedObjects, build.GeneratedList
+ build.ExtractedObjects, build.GeneratedList, build.StructuredSources
 
 
 def _project_version_validator(value: T.UnionT.List, str, mesonlib.File, None) -> T.Optionalstr:
 if isinstance(value, list):
 if len(value) != 1:
 return 'when passed as array must have a length of 1'
- elif not isinstance(value0, (str, mesonlib.File)):
- return 'when passed as array must contain a string or File'
+ elif not isinstance(value0, mesonlib.File):
+ return 'when passed as array must contain a File'
 return None
 
 
-def stringifyUserArguments(args, quote=False):
+def stringifyUserArguments(args: T.ListT.Any, quote: bool = False) -> str:
 if isinstance(args, list):
 return '%s' % ', '.join(stringifyUserArguments(x, True) for x in args)
 elif isinstance(args, dict):
@@ -143,11 +166,14 @@
 elif isinstance(i, (ExternalProgram, Dependency)):
 FeatureNew.single_use('dependency or external program in summary', '0.57.0', subproject)
 formatted_values.append(i.summary_value())
+ elif isinstance(i, Disabler):
+ FeatureNew.single_use('disabler in summary', '0.64.0', subproject)
+ formatted_values.append(mlog.red('NO'))
 elif isinstance(i, coredata.UserOption):
 FeatureNew.single_use('feature option in summary', '0.58.0', subproject)
 formatted_values.append(i.printable_value())
 else:
- m = 'Summary value in section {!r}, key {!r}, must be string, integer, boolean, dependency or external program'
+ m = 'Summary value in section {!r}, key {!r}, must be string, integer, boolean, dependency, disabler, or external program'
 raise InterpreterException(m.format(section, k))
 self.sectionssectionk = (formatted_values, list_sep)
 self.max_key_len = max(self.max_key_len, len(k))
@@ -198,23 +224,15 @@
 {'target_type'}
 )
 
-TEST_KWARGS: T.ListKwargInfo = 
- KwargInfo('args', ContainerTypeInfo(list, (str, mesonlib.File, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex)),
- listify=True, default=),
- KwargInfo('should_fail', bool, default=False),
- KwargInfo('timeout', int, default=30),
- KwargInfo('workdir', (str, NoneType), default=None,
- validator=lambda x: 'must be an absolute path' if not os.path.isabs(x) else None),
- KwargInfo('protocol', str,
- default='exitcode',
- validator=in_set_validator({'exitcode', 'tap', 'gtest', 'rust'}),
- since_values={'gtest': '0.55.0', 'rust': '0.57.0'}),
- KwargInfo('priority', int, default=0, since='0.52.0'),
- # TODO: env needs reworks of the way the environment variable holder itself works probably
- ENV_KW,
- DEPENDS_KW.evolve(since='0.46.0'),
- KwargInfo('suite', ContainerTypeInfo(list, str), listify=True, default=''), # yes, a list of empty string
-
+class InterpreterRuleRelaxation(Enum):
+ ''' Defines specific relaxations of the Meson rules.
+
+ This is intended to be used for automatically converted
+ projects (CMake subprojects, build system mixing) that
+ generate a Meson AST via introspection, etc.
+ '''
+
+ ALLOW_BUILD_DIR_FILE_REFFERENCES = 1
 
 permitted_dependency_kwargs = {
 'allow_fallback',
@@ -251,10 +269,11 @@
 subproject: str = '',
 subdir: str = '',
 subproject_dir: str = 'subprojects',
- default_project_options: T.OptionalT.Dictstr, str = None,
+ default_project_options: T.OptionalT.DictOptionKey, str = None,
 mock: bool = False,
 ast: T.Optionalmparser.CodeBlockNode = None,
 is_translated: bool = False,
+ relaxations: T.OptionalT.SetInterpreterRuleRelaxation = None,
 user_defined_options: T.Optional'argparse.Namespace' = None,
 ) -> None:
 super().__init__(_build.environment.get_source_dir(), subdir, subproject)
@@ -264,12 +283,13 @@
 self.coredata = self.environment.get_coredata()
 self.backend = backend
 self.summary: T.Dictstr, 'Summary' = {}
- self.modules = {}
+ self.modules: T.Dictstr, NewExtensionModule = {}
 # Subproject directory is usually the name of the subproject, but can
 # be different for dependencies provided by wrap files.
 self.subproject_directory_name = subdir.split(os.path.sep)-1
 self.subproject_dir = subproject_dir
 self.option_file = os.path.join(self.source_root, self.subdir, 'meson_options.txt')
+ self.relaxations = relaxations or set()
 if not mock and ast is None:
 self.load_root_meson_file()
 self.sanity_check_ast()
@@ -282,27 +302,28 @@
 self.project_args_frozen = False
 self.global_args_frozen = False # implies self.project_args_frozen
 self.subprojects: T.Dictstr, SubprojectHolder = {}
- self.subproject_stack = 
- self.configure_file_outputs = {}
+ self.subproject_stack: T.Liststr = 
+ self.configure_file_outputs: T.Dictstr, int = {}
 # Passed from the outside, only used in subprojects.
 if default_project_options:
 self.default_project_options = default_project_options.copy()
 else:
 self.default_project_options = {}
- self.project_default_options = {}
+ self.project_default_options: T.DictOptionKey, str = {}
 self.build_func_dict()
 self.build_holder_map()
 self.user_defined_options = user_defined_options
+ self.compilers: PerMachineT.Dictstr, 'compilers.Compiler' = PerMachine({}, {})
 
 # build_def_files needs to be defined before parse_project is called
 #
 # For non-meson subprojects, we'll be using the ast. Even if it does
 # exist we don't want to add a dependency on it, it's autogenerated
 # from the actual build files, and is just for reference.
- self.build_def_files = 
+ self.build_def_files: mesonlib.OrderedSetstr = mesonlib.OrderedSet()
 build_filename = os.path.join(self.subdir, environment.build_filename)
 if not is_translated:
- self.build_def_files.append(build_filename)
+ self.build_def_files.add(build_filename)
 if not mock:
 self.parse_project()
 self._redetect_machines()
@@ -310,7 +331,7 @@
 def __getnewargs_ex__(self) -> T.TupleT.Tupleobject, T.Dictstr, object:
 raise MesonBugException('This class is unpicklable')
 
- def _redetect_machines(self):
+ def _redetect_machines(self) -> None:
 # Re-initialize machine descriptions. We can do a better job now because we
 # have the compilers needed to gain more knowledge, so wipe out old
 # inference and start over.
@@ -328,11 +349,12 @@
 self.builtin'target_machine' = \
 OBJ.MachineHolder(self.build.environment.machines.target, self)
 
- def build_func_dict(self):
+ def build_func_dict(self) -> None:
 self.funcs.update({'add_global_arguments': self.func_add_global_arguments,
 'add_global_link_arguments': self.func_add_global_link_arguments,
 'add_languages': self.func_add_languages,
 'add_project_arguments': self.func_add_project_arguments,
+ 'add_project_dependencies': self.func_add_project_dependencies,
 'add_project_link_arguments': self.func_add_project_link_arguments,
 'add_test_setup': self.func_add_test_setup,
 'alias_target': self.func_alias_target,
@@ -343,6 +365,7 @@
 'configuration_data': self.func_configuration_data,
 'configure_file': self.func_configure_file,
 'custom_target': self.func_custom_target,
+ 'debug': self.func_debug,
 'declare_dependency': self.func_declare_dependency,
 'dependency': self.func_dependency,
 'disabler': self.func_disabler,
@@ -376,6 +399,7 @@
 'run_command': self.func_run_command,
 'run_target': self.func_run_target,
 'set_variable': self.func_set_variable,
+ 'structured_sources': self.func_structured_sources,
 'subdir': self.func_subdir,
 'shared_library': self.func_shared_lib,
 'shared_module': self.func_shared_module,
@@ -405,6 +429,8 @@
 bool: P_OBJ.BooleanHolder,
 str: P_OBJ.StringHolder,
 P_OBJ.MesonVersionString: P_OBJ.MesonVersionStringHolder,
+ P_OBJ.DependencyVariableString: P_OBJ.DependencyVariableStringHolder,
+ P_OBJ.OptionString: P_OBJ.OptionStringHolder,
 
 # Meson types
 mesonlib.File: OBJ.FileHolder,
@@ -429,10 +455,12 @@
 build.InstallDir: OBJ.InstallDirHolder,
 build.IncludeDirs: OBJ.IncludeDirsHolder,
 build.EnvironmentVariables: OBJ.EnvironmentVariablesHolder,
+ build.StructuredSources: OBJ.StructuredSourcesHolder,
 compilers.RunResult: compilerOBJ.TryRunResultHolder,
 dependencies.ExternalLibrary: OBJ.ExternalLibraryHolder,
 coredata.UserFeatureOption: OBJ.FeatureOptionHolder,
 envconfig.MachineInfo: OBJ.MachineHolder,
+ build.ConfigurationData: OBJ.ConfigurationDataHolder,
 })
 
 '''
@@ -488,12 +516,12 @@
 elif isinstance(v, Test):
 self.build.tests.append(v)
 elif isinstance(v, (int, str, bool, Disabler, ObjectHolder, build.GeneratedList,
- ExternalProgram)):
+ ExternalProgram, build.ConfigurationData)):
 pass
 else:
 raise InterpreterException(f'Module returned a value of unknown type {v!r}.')
 
- def get_build_def_files(self) -> T.Liststr:
+ def get_build_def_files(self) -> mesonlib.OrderedSetstr:
 return self.build_def_files
 
 def add_build_def_file(self, f: mesonlib.FileOrString) -> None:
@@ -509,32 +537,32 @@
 srcdir = Path(self.environment.get_source_dir())
 builddir = Path(self.environment.get_build_dir())
 try:
- f = Path(f).resolve()
+ f_ = Path(f).resolve()
 except OSError:
- f = Path(f)
- s = f.stat()
+ f_ = Path(f)
+ s = f_.stat()
 if (hasattr(s, 'st_file_attributes') and
 s.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT != 0 and
 s.st_reparse_tag == stat.IO_REPARSE_TAG_APPEXECLINK):
 # This is a Windows Store link which we can't
 # resolve, so just do our best otherwise.
- f = f.parent.resolve() / f.name
+ f_ = f_.parent.resolve() / f_.name
 else:
 raise
- if builddir in f.parents:
+ if builddir in f_.parents:
 return
- if srcdir in f.parents:
- f = f.relative_to(srcdir)
- f = str(f)
+ if srcdir in f_.parents:
+ f_ = f_.relative_to(srcdir)
+ f = str(f_)
 else:
 return
 if f not in self.build_def_files:
- self.build_def_files.append(f)
+ self.build_def_files.add(f)
 
- def get_variables(self):
+ def get_variables(self) -> T.Dictstr, InterpreterObject:
 return self.variables
 
- def check_stdlibs(self):
+ def check_stdlibs(self) -> None:
 machine_choices = MachineChoice.HOST
 if self.coredata.is_cross_build():
 machine_choices.append(MachineChoice.BUILD)
@@ -555,22 +583,6 @@
 dep = df.lookup(kwargs, force_fallback=True)
 self.build.stdlibsfor_machinel = dep
 
- def _import_module(self, modname: str, required: bool) -> T.UnionExtensionModule, NewExtensionModule, NotFoundExtensionModule:
- if modname in self.modules:
- return self.modulesmodname
- try:
- module = importlib.import_module('mesonbuild.modules.' + modname)
- except ImportError:
- if required:
- raise InvalidArguments(f'Module "{modname}" does not exist')
- ext_module = NotFoundExtensionModule()
- else:
- ext_module = module.initialize(self)
- assert isinstance(ext_module, (ExtensionModule, NewExtensionModule))
- self.build.modules.append(modname)
- self.modulesmodname = ext_module
- return ext_module
-
 @typed_pos_args('import', str)
 @typed_kwargs(
 'import',
@@ -579,87 +591,119 @@
 )
 @disablerIfNotFound
 def func_import(self, node: mparser.BaseNode, args: T.Tuplestr,
- kwargs: 'kwargs.FuncImportModule') -> T.UnionExtensionModule, NewExtensionModule, NotFoundExtensionModule:
+ kwargs: 'kwtypes.FuncImportModule') -> T.UnionExtensionModule, NewExtensionModule, NotFoundExtensionModule:
 modname = args0
 disabled, required, _ = extract_required_kwarg(kwargs, self.subproject)
 if disabled:
- return NotFoundExtensionModule()
+ return NotFoundExtensionModule(modname)
 
- if modname.startswith('unstable-'):
- plainname = modname.split('-', 1)1
- try:
- # check if stable module exists
- mod = self._import_module(plainname, required)
- # XXX: this is actually not helpful, since it doesn't do a version check
- mlog.warning(f'Module {modname} is now stable, please use the {plainname} module instead.')
- return mod
- except InvalidArguments:
- mlog.warning(f'Module {modname} has no backwards or forwards compatibility and might not exist in future releases.', location=node)
- modname = 'unstable_' + plainname
- return self._import_module(modname, required)
+ expect_unstable = False
+ # Some tests use "unstable_" instead of "unstable-", and that happens to work because
+ # of implementation details
+ if modname.startswith(('unstable-', 'unstable_')):
+ if modname.startswith('unstable_'):
+ mlog.deprecation(f'Importing unstable modules as "{modname}" instead of "{modname.replace("_", "-", 1)}"',
+ location=node)
+ real_modname = modnamelen('unstable') + 1: # + 1 to handle the - or _
+ expect_unstable = True
+ else:
+ real_modname = modname
+
+ if real_modname in self.modules:
+ return self.modulesreal_modname
+ try:
+ module = importlib.import_module(f'mesonbuild.modules.{real_modname}')
+ except ImportError:
+ if required:
+ raise InvalidArguments(f'Module "{modname}" does not exist')
+ ext_module = NotFoundExtensionModule(real_modname)
+ else:
+ ext_module = module.initialize(self)
+ assert isinstance(ext_module, (ExtensionModule, NewExtensionModule))
+ self.build.modules.append(real_modname)
+ if ext_module.INFO.added:
+ FeatureNew.single_use(f'module {ext_module.INFO.name}', ext_module.INFO.added, self.subproject, location=node)
+ if ext_module.INFO.deprecated:
+ FeatureDeprecated.single_use(f'module {ext_module.INFO.name}', ext_module.INFO.deprecated, self.subproject, location=node)
+ if expect_unstable and not ext_module.INFO.unstable and ext_module.INFO.stabilized is None:
+ raise InvalidArguments(f'Module {ext_module.INFO.name} has never been unstable, remove "unstable-" prefix.')
+ if ext_module.INFO.stabilized is not None:
+ if expect_unstable:
+ FeatureDeprecated.single_use(
+ f'module {ext_module.INFO.name} has been stabilized',
+ ext_module.INFO.stabilized, self.subproject,
+ 'drop "unstable-" prefix from the module name',
+ location=node)
+ else:
+ FeatureNew.single_use(
+ f'module {ext_module.INFO.name} as stable module',
+ ext_module.INFO.stabilized, self.subproject,
+ f'Consider either adding "unstable-" to the module name, or updating the meson required version to ">= {ext_module.INFO.stabilized}"',
+ location=node)
+ elif ext_module.INFO.unstable:
+ if not expect_unstable:
+ if required:
+ raise InvalidArguments(f'Module "{ext_module.INFO.name}" has not been stabilized, and must be imported as unstable-{ext_module.INFO.name}')
+ ext_module = NotFoundExtensionModule(real_modname)
+ else:
+ mlog.warning(f'Module {ext_module.INFO.name} has no backwards or forwards compatibility and might not exist in future releases.', location=node, fatal=False)
+
+ self.modulesreal_modname = ext_module
+ return ext_module
 
 @typed_pos_args('files', varargs=str)
 @noKwargs
 def func_files(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'TYPE_kwargs') -> T.Listmesonlib.File:
- return mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, fname) for fname in args0
+ return self.source_strings_to_files(args0)
 
- # Used by declare_dependency() and pkgconfig.generate()
- def extract_variables(self, kwargs, argname='variables', list_new=False, dict_new=False):
- variables = kwargs.get(argname, {})
- if isinstance(variables, dict):
- if dict_new and variables:
- FeatureNew.single_use(f'{argname} as dictionary', '0.56.0', self.subproject, location=self.current_node)
- else:
- varlist = mesonlib.stringlistify(variables)
- if list_new:
- FeatureNew.single_use(f'{argname} as list of strings', '0.56.0', self.subproject, location=self.current_node)
- variables = collections.OrderedDict()
- for v in varlist:
- try:
- (key, value) = v.split('=', 1)
- except ValueError:
- raise InterpreterException(f'Variable {v!r} must have a value separated by equals sign.')
- variableskey.strip() = value.strip()
- for k, v in variables.items():
- if not k or not v:
- raise InterpreterException('Empty variable name or value')
- if any(c.isspace() for c in k):
- raise InterpreterException(f'Invalid whitespace in variable name "{k}"')
- if not isinstance(v, str):
- raise InterpreterException('variables values must be strings.')
- return variables
-
- @FeatureNewKwargs('declare_dependency', '0.46.0', 'link_whole')
- @FeatureNewKwargs('declare_dependency', '0.54.0', 'variables')
- @permittedKwargs({'include_directories', 'link_with', 'sources', 'dependencies',
- 'compile_args', 'link_args', 'link_whole', 'version',
- 'variables'})
 @noPosargs
+ @typed_kwargs(
+ 'declare_dependency',
+ KwargInfo('compile_args', ContainerTypeInfo(list, str), listify=True, default=),
+ INCLUDE_DIRECTORIES.evolve(name='d_import_dirs', since='0.62.0'),
+ D_MODULE_VERSIONS_KW.evolve(since='0.62.0'),
+ KwargInfo('link_args', ContainerTypeInfo(list, str), listify=True, default=),
+ DEPENDENCIES_KW,
+ INCLUDE_DIRECTORIES,
+ LINK_WITH_KW,
+ LINK_WHOLE_KW.evolve(since='0.46.0'),
+ SOURCES_KW,
+ VARIABLES_KW.evolve(since='0.54.0', since_values={list: '0.56.0'}),
+ KwargInfo('version', (str, NoneType)),
+ )
 def func_declare_dependency(self, node, args, kwargs):
- version = kwargs.get('version', self.project_version)
- if not isinstance(version, str):
- raise InterpreterException('Version must be a string.')
+ deps = kwargs'dependencies'
 incs = self.extract_incdirs(kwargs)
- libs = extract_as_list(kwargs, 'link_with')
- libs_whole = extract_as_list(kwargs, 'link_whole')
- sources = extract_as_list(kwargs, 'sources')
- sources = listify(self.source_strings_to_files(sources))
- deps = extract_as_list(kwargs, 'dependencies')
- compile_args = mesonlib.stringlistify(kwargs.get('compile_args', ))
- link_args = mesonlib.stringlistify(kwargs.get('link_args', ))
- variables = self.extract_variables(kwargs, list_new=True)
- final_deps = 
+ libs = kwargs'link_with'
+ libs_whole = kwargs'link_whole'
+ sources = self.source_strings_to_files(kwargs'sources')
+ compile_args = kwargs'compile_args'
+ link_args = kwargs'link_args'
+ variables = kwargs'variables'
+ version = kwargs'version'
+ if version is None:
+ version = self.project_version
+ d_module_versions = kwargs'd_module_versions'
+ d_import_dirs = self.extract_incdirs(kwargs, 'd_import_dirs')
+ srcdir = Path(self.environment.source_dir)
+ # convert variables which refer to an -uninstalled.pc style datadir
+ for k, v in variables.items():
+ try:
+ p = Path(v)
+ except ValueError:
+ continue
+ else:
+ if not self.is_subproject() and srcdir / self.subproject_dir in p.parents:
+ continue
+ if p.is_absolute() and p.is_dir() and srcdir / self.root_subdir in p + list(Path(os.path.abspath(p)).parents):
+ variablesk = P_OBJ.DependencyVariableString(v)
 for d in deps:
- if not isinstance(d, (dependencies.Dependency, dependencies.ExternalLibrary, dependencies.InternalDependency)):
- raise InterpreterException('Dependencies must be external deps')
- final_deps.append(d)
- for l in libs:
- if isinstance(l, dependencies.Dependency):
- raise InterpreterException('''Entries in "link_with" may only be self-built targets,
-external dependencies (including libraries) must go to "dependencies".''')
+ if not isinstance(d, dependencies.Dependency):
+ raise InterpreterException('Invalid dependency')
+
 dep = dependencies.InternalDependency(version, incs, compile_args,
- link_args, libs, libs_whole, sources, final_deps,
- variables)
+ link_args, libs, libs_whole, sources, deps,
+ variables, d_module_versions, d_import_dirs)
 return dep
 
 @typed_pos_args('assert', bool, optargs=str)
@@ -701,15 +745,15 @@
 )
 def func_run_command(self, node: mparser.BaseNode,
 args: T.TupleT.Unionbuild.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str,
- T.ListT.Unionbuild.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str,
- kwargs: 'kwargs.RunCommand') -> RunProcess:
+ T.ListT.Unionbuild.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str,
+ kwargs: 'kwtypes.RunCommand') -> RunProcess:
 return self.run_command_impl(node, args, kwargs)
 
 def run_command_impl(self,
 node: mparser.BaseNode,
 args: T.TupleT.Unionbuild.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str,
- T.ListT.Unionbuild.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str,
- kwargs: 'kwargs.RunCommand',
+ T.ListT.Unionbuild.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str,
+ kwargs: 'kwtypes.RunCommand',
 in_builddir: bool = False) -> RunProcess:
 cmd, cargs = args
 capture = kwargs'capture'
@@ -722,8 +766,6 @@
 mlog.warning(implicit_check_false_warning, once=True)
 check = False
 
- m = 'must be a string, or the output of find_program(), files() '\
- 'or configure_file(), or a compiler object; not {!r}'
 overridden_msg = ('Program {!r} was overridden with the compiled '
 'executable {!r} and therefore cannot be used during '
 'configuration')
@@ -750,9 +792,6 @@
 else:
 if isinstance(cmd, mesonlib.File):
 cmd = cmd.absolute_path(srcdir, builddir)
- # FIXME: This case can only be reached through configure_file, delete once that is typesafe
- elif not isinstance(cmd, str):
- raise InterpreterException('First argument ' + m.format(cmd))
 # Prefer scripts in the current source directory
 search_dir = os.path.join(srcdir, self.subdir)
 prog = ExternalProgram(cmd, silent=True, search_dir=search_dir)
@@ -793,27 +832,37 @@
 def func_option(self, nodes, args, kwargs):
 raise InterpreterException('Tried to call option() in build description file. All options must be in the option file.')
 
- @FeatureNewKwargs('subproject', '0.38.0', 'default_options')
- @permittedKwargs({'version', 'default_options', 'required'})
 @typed_pos_args('subproject', str)
- def func_subproject(self, nodes: mparser.BaseNode, args: T.Tuplestr, kwargs: 'TYPE_kwargs') -> SubprojectHolder:
- return self.do_subproject(args0, 'meson', kwargs)
+ @typed_kwargs(
+ 'subproject',
+ REQUIRED_KW,
+ DEFAULT_OPTIONS.evolve(since='0.38.0'),
+ KwargInfo('version', ContainerTypeInfo(list, str), default=, listify=True),
+ )
+ def func_subproject(self, nodes: mparser.BaseNode, args: T.Tuplestr, kwargs: kwtypes.Subproject) -> SubprojectHolder:
+ kw: kwtypes.DoSubproject = {
+ 'required': kwargs'required',
+ 'default_options': kwargs'default_options',
+ 'version': kwargs'version',
+ 'options': None,
+ 'cmake_options': ,
+ }
+ return self.do_subproject(args0, 'meson', kw)
 
- def disabled_subproject(self, subp_name, disabled_feature=None, exception=None):
+ def disabled_subproject(self, subp_name: str, disabled_feature: T.Optionalstr = None,
+ exception: T.OptionalException = None) -> SubprojectHolder:
 sub = SubprojectHolder(NullSubprojectInterpreter(), os.path.join(self.subproject_dir, subp_name),
 disabled_feature=disabled_feature, exception=exception)
 self.subprojectssubp_name = sub
- self.coredata.initialized_subprojects.add(subp_name)
 return sub
 
- def do_subproject(self, subp_name: str, method: str, kwargs):
+ def do_subproject(self, subp_name: str, method: Literal'meson', 'cmake', kwargs: kwtypes.DoSubproject) -> SubprojectHolder:
 disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
 if disabled:
 mlog.log('Subproject', mlog.bold(subp_name), ':', 'skipped: feature', mlog.bold(feature), 'disabled')
 return self.disabled_subproject(subp_name, disabled_feature=feature)
 
- default_options = mesonlib.stringlistify(kwargs.get('default_options', ))
- default_options = coredata.create_options_dict(default_options, subp_name)
+ default_options = coredata.create_options_dict(kwargs'default_options', subp_name)
 
 if subp_name == '':
 raise InterpreterException('Subproject name must not be empty.')
@@ -834,6 +883,11 @@
 subproject = self.subprojectssubp_name
 if required and not subproject.found():
 raise InterpreterException(f'Subproject "{subproject.subdir}" required but not found.')
+ if kwargs'version':
+ pv = self.build.subprojectssubp_name
+ wanted = kwargs'version'
+ if pv == 'undefined' or not mesonlib.version_compare_many(pv, wanted)0:
+ raise InterpreterException(f'Subproject {subp_name} version is {pv} but {wanted} required.')
 return subproject
 
 r = self.environment.wrap_resolver
@@ -876,14 +930,19 @@
 return self.disabled_subproject(subp_name, exception=e)
 raise e
 
- def _do_subproject_meson(self, subp_name: str, subdir: str, default_options, kwargs,
+ def _do_subproject_meson(self, subp_name: str, subdir: str,
+ default_options: T.DictOptionKey, str,
+ kwargs: kwtypes.DoSubproject,
 ast: T.Optionalmparser.CodeBlockNode = None,
 build_def_files: T.OptionalT.Liststr = None,
- is_translated: bool = False) -> SubprojectHolder:
+ is_translated: bool = False,
+ relaxations: T.OptionalT.SetInterpreterRuleRelaxation = None) -> SubprojectHolder:
 with mlog.nested(subp_name):
 new_build = self.build.copy()
 subi = Interpreter(new_build, self.backend, subp_name, subdir, self.subproject_dir,
- default_options, ast=ast, is_translated=is_translated)
+ default_options, ast=ast, is_translated=is_translated,
+ relaxations=relaxations,
+ user_defined_options=self.user_defined_options)
 # Those lists are shared by all interpreters. That means that
 # even if the subproject fails, any modification that the subproject
 # made to those lists will affect the parent project.
@@ -905,7 +964,7 @@
 
 mlog.log()
 
- if 'version' in kwargs:
+ if kwargs'version':
 pv = subi.project_version
 wanted = kwargs'version'
 if pv == 'undefined' or not mesonlib.version_compare_many(pv, wanted)0:
@@ -915,27 +974,23 @@
 self.subprojectssubp_name = SubprojectHolder(subi, subdir, warnings=subi_warnings)
 # Duplicates are possible when subproject uses files from project root
 if build_def_files:
- self.build_def_files = list(set(self.build_def_files + build_def_files))
+ self.build_def_files.update(build_def_files)
 # We always need the subi.build_def_files, to propgate sub-sub-projects
- self.build_def_files = list(set(self.build_def_files + subi.build_def_files))
+ self.build_def_files.update(subi.build_def_files)
 self.build.merge(subi.build)
 self.build.subprojectssubp_name = subi.project_version
- self.coredata.initialized_subprojects.add(subp_name)
 return self.subprojectssubp_name
 
- def _do_subproject_cmake(self, subp_name, subdir, subdir_abs, default_options, kwargs):
+ def _do_subproject_cmake(self, subp_name: str, subdir: str, subdir_abs: str,
+ default_options: T.DictOptionKey, str,
+ kwargs: kwtypes.DoSubproject) -> SubprojectHolder:
 with mlog.nested(subp_name):
 new_build = self.build.copy()
 prefix = self.coredata.optionsOptionKey('prefix').value
 
 from ..modules.cmake import CMakeSubprojectOptions
- options = kwargs.get('options', CMakeSubprojectOptions())
- if not isinstance(options, CMakeSubprojectOptions):
- raise InterpreterException('"options" kwarg must be CMakeSubprojectOptions'
- ' object (created by cmake.subproject_options())')
-
- cmake_options = mesonlib.stringlistify(kwargs.get('cmake_options', ))
- cmake_options += options.cmake_options
+ options = kwargs'options' or CMakeSubprojectOptions()
+ cmake_options = kwargs'cmake_options' + options.cmake_options
 cm_int = CMakeInterpreter(new_build, Path(subdir), Path(subdir_abs), Path(prefix), new_build.environment, self.backend)
 cm_int.initialise(cmake_options)
 cm_int.analyse()
@@ -949,7 +1004,7 @@
 
 # Debug print the generated meson file
 from ..ast import AstIndentationGenerator, AstPrinter
- printer = AstPrinter()
+ printer = AstPrinter(update_ast_line_nos=True)
 ast.accept(AstIndentationGenerator())
 ast.accept(printer)
 printer.post_process()
@@ -961,13 +1016,21 @@
 mlog.cmd_ci_include(meson_filename)
 mlog.log()
 
- result = self._do_subproject_meson(subp_name, subdir, default_options, kwargs, ast, cm_int.bs_files, is_translated=True)
+ result = self._do_subproject_meson(
+ subp_name, subdir, default_options,
+ kwargs, ast,
+ str(f) for f in cm_int.bs_files,
+ is_translated=True,
+ relaxations={
+ InterpreterRuleRelaxation.ALLOW_BUILD_DIR_FILE_REFFERENCES,
+ }
+ )
 result.cm_interpreter = cm_int
 
 mlog.log()
 return result
 
- def get_option_internal(self, optname: str):
+ def get_option_internal(self, optname: str) -> coredata.UserOption:
 key = OptionKey.from_string(optname).evolve(subproject=self.subproject)
 
 if not key.is_project():
@@ -976,6 +1039,7 @@
 if v is None or v.yielding:
 v = opts.get(key.as_root())
 if v is not None:
+ assert isinstance(v, coredata.UserOption), 'for mypy'
 return v
 
 try:
@@ -1015,20 +1079,25 @@
 opt.name = optname
 return opt
 elif isinstance(opt, coredata.UserOption):
+ if isinstance(opt.value, str):
+ return P_OBJ.OptionString(opt.value, f'{{{optname}}}')
 return opt.value
 return opt
 
 @typed_pos_args('configuration_data', optargs=dict)
 @noKwargs
- def func_configuration_data(self, node: mparser.BaseNode, args: T.Optionaldict, kwargs: 'TYPE_kwargs') -> ConfigurationDataObject:
+ def func_configuration_data(self, node: mparser.BaseNode, args: T.TupleT.OptionalT.Dictstr, T.Any,
+ kwargs: 'TYPE_kwargs') -> build.ConfigurationData:
 initial_values = args0
 if initial_values is not None:
 FeatureNew.single_use('configuration_data dictionary', '0.49.0', self.subproject, location=node)
- else:
- initial_values = {}
- return ConfigurationDataObject(self.subproject, initial_values)
+ for k, v in initial_values.items():
+ if not isinstance(v, (str, int, bool)):
+ raise InvalidArguments(
+ f'"configuration_data": initial value dictionary key "{k!r}"" must be "str | int | bool", not "{v!r}"')
+ return build.ConfigurationData(initial_values)
 
- def set_backend(self):
+ def set_backend(self) -> None:
 # The backend is already set when parsing subprojects
 if self.backend is not None:
 return
@@ -1066,7 +1135,7 @@
 KwargInfo('license', ContainerTypeInfo(list, str), default='unknown', listify=True),
 KwargInfo('subproject_dir', str, default='subprojects'),
 )
- def func_project(self, node: mparser.FunctionNode, args: T.Tuplestr, T.Liststr, kwargs: 'kwargs.Project') -> None:
+ def func_project(self, node: mparser.FunctionNode, args: T.Tuplestr, T.Liststr, kwargs: 'kwtypes.Project') -> None:
 proj_name, proj_langs = args
 if ':' in proj_name:
 raise InvalidArguments(f"Project name {proj_name!r} must not contain ':'")
@@ -1100,6 +1169,7 @@
 default_options = self.project_default_options.copy()
 default_options.update(self.default_project_options)
 self.coredata.init_builtins(self.subproject)
+ self.coredata.initialized_subprojects.add(self.subproject)
 else:
 default_options = {}
 self.coredata.set_default_options(default_options, self.subproject, self.environment)
@@ -1181,7 +1251,7 @@
 
 @typed_kwargs('add_languages', KwargInfo('native', (bool, NoneType), since='0.54.0'), REQUIRED_KW)
 @typed_pos_args('add_languages', varargs=str)
- def func_add_languages(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'kwargs.FuncAddLanguages') -> bool:
+ def func_add_languages(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'kwtypes.FuncAddLanguages') -> bool:
 langs = args0
 disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
 native = kwargs'native'
@@ -1205,7 +1275,7 @@
 
 @noArgsFlattening
 @noKwargs
- def func_message(self, node, args, kwargs):
+ def func_message(self, node: mparser.BaseNode, args, kwargs):
 if len(args) > 1:
 FeatureNew.single_use('message with more than one argument', '0.54.0', self.subproject, location=node)
 args_str = stringifyUserArguments(i) for i in args
@@ -1224,7 +1294,7 @@
 KwargInfo('list_sep', (str, NoneType), since='0.54.0')
 )
 def func_summary(self, node: mparser.BaseNode, args: T.TupleT.Unionstr, T.Dictstr, T.Any, T.OptionalT.Any,
- kwargs: 'kwargs.Summary') -> None:
+ kwargs: 'kwtypes.Summary') -> None:
 if args1 is None:
 if not isinstance(args0, dict):
 raise InterpreterException('Summary first argument must be dictionary.')
@@ -1235,7 +1305,7 @@
 values = {args0: args1}
 self.summary_impl(kwargs'section', values, kwargs)
 
- def summary_impl(self, section: str, values, kwargs: 'kwargs.Summary') -> None:
+ def summary_impl(self, section: str, values, kwargs: 'kwtypes.Summary') -> None:
 if self.subproject not in self.summary:
 self.summaryself.subproject = Summary(self.active_projectname, self.project_version)
 self.summaryself.subproject.add_section(
@@ -1257,7 +1327,7 @@
 self.summary_impl('Subprojects', all_subprojects,
 {'bool_yn': True,
 'list_sep': ' ',
- })
+ })
 # Add automatic section with all user defined options
 if self.user_defined_options:
 values = collections.OrderedDict()
@@ -1295,12 +1365,19 @@
 args_str = stringifyUserArguments(i) for i in args
 raise InterpreterException('Problem encountered: ' + ' '.join(args_str))
 
+ @noArgsFlattening
+ @FeatureNew('debug', '0.63.0')
+ @noKwargs
+ def func_debug(self, node, args, kwargs):
+ args_str = stringifyUserArguments(i) for i in args
+ mlog.debug('Debug:', *args_str)
+
 @noKwargs
 @noPosargs
 def func_exception(self, node, args, kwargs):
- raise Exception()
+ raise RuntimeError('unit test traceback :)')
 
- def add_languages(self, args: T.Sequencestr, required: bool, for_machine: MachineChoice) -> bool:
+ def add_languages(self, args: T.Liststr, required: bool, for_machine: MachineChoice) -> bool:
 success = self.add_languages_for(args, required, for_machine)
 if not self.coredata.is_cross_build():
 self.coredata.copy_build_options_from_regular_ones()
@@ -1317,9 +1394,9 @@
 return False
 return should
 
- def add_languages_for(self, args: T.Liststr, required: bool, for_machine: MachineChoice) -> None:
+ def add_languages_for(self, args: T.Liststr, required: bool, for_machine: MachineChoice) -> bool:
 args = a.lower() for a in args
- langs = set(self.coredata.compilersfor_machine.keys())
+ langs = set(self.compilersfor_machine.keys())
 langs.update(args)
 # We'd really like to add cython's default language here, but it can't
 # actually be done because the cython compiler hasn't been initialized,
@@ -1330,14 +1407,16 @@
 if 'vala' in langs and 'c' not in langs:
 FeatureNew.single_use('Adding Vala language without C', '0.59.0', self.subproject, location=self.current_node)
 args.append('c')
+ if 'nasm' in langs:
+ FeatureNew.single_use('Adding NASM language', '0.64.0', self.subproject, location=self.current_node)
 
 success = True
 for lang in sorted(args, key=compilers.sort_clink):
- clist = self.coredata.compilersfor_machine
+ if lang in self.compilersfor_machine:
+ continue
 machine_name = for_machine.get_lower_case_name()
- if lang in clist:
- comp = clistlang
- else:
+ comp = self.coredata.compilersfor_machine.get(lang)
+ if not comp:
 try:
 comp = compilers.detect_compiler_for(self.environment, lang, for_machine)
 if comp is None:
@@ -1356,6 +1435,15 @@
 else:
 raise
 
+ # Add per-subproject compiler options. They inherit value from main project.
+ if self.subproject:
+ options = {}
+ for k in comp.get_options():
+ v = copy.copy(self.coredata.optionsk)
+ k = k.evolve(subproject=self.subproject)
+ optionsk = v
+ self.coredata.add_compiler_options(options, lang, for_machine, self.environment)
+
 if for_machine == MachineChoice.HOST or self.environment.is_cross_build():
 logger_fun = mlog.log
 else:
@@ -1366,21 +1454,26 @@
 logger_fun(comp.get_display_language(), 'linker for the', machine_name, 'machine:',
 mlog.bold(' '.join(comp.linker.get_exelist())), comp.linker.id, comp.linker.version)
 self.build.ensure_static_linker(comp)
+ self.compilersfor_machinelang = comp
 
 return success
 
- def program_from_file_for(self, for_machine, prognames):
+ def program_from_file_for(self, for_machine: MachineChoice, prognames: T.Listmesonlib.FileOrString
+ ) -> T.OptionalExternalProgram:
 for p in prognames:
 if isinstance(p, mesonlib.File):
 continue # Always points to a local (i.e. self generated) file.
 if not isinstance(p, str):
 raise InterpreterException('Executable name must be a string')
 prog = ExternalProgram.from_bin_list(self.environment, for_machine, p)
- if prog.found():
+ # if the machine file specified something, it may be a regular
+ # not-found program but we still want to return that
+ if not isinstance(prog, NonExistingExternalProgram):
 return prog
 return None
 
- def program_from_system(self, args, search_dirs, extra_info):
+ def program_from_system(self, args: T.Listmesonlib.FileOrString, search_dirs: T.Liststr,
+ extra_info: T.Listmlog.TV_Loggable) -> T.OptionalExternalProgram:
 # Search for scripts relative to current subdir.
 # Do not cache found programs because find_program('foobar')
 # might give different results when run from different source dirs.
@@ -1406,9 +1499,11 @@
 if extprog.found():
 extra_info.append(f"({' '.join(extprog.get_command())})")
 return extprog
+ return None
 
- def program_from_overrides(self, command_names: T.Liststr, extra_info: T.List'mlog.TV_Loggable') -> \
- T.OptionalT.UnionExternalProgram, 'OverrideProgram', 'build.Executable':
+ def program_from_overrides(self, command_names: T.Listmesonlib.FileOrString,
+ extra_info: T.List'mlog.TV_Loggable'
+ ) -> T.OptionalT.UnionExternalProgram, OverrideProgram, build.Executable:
 for name in command_names:
 if not isinstance(name, str):
 continue
@@ -1418,7 +1513,7 @@
 return exe
 return None
 
- def store_name_lookups(self, command_names):
+ def store_name_lookups(self, command_names: T.Listmesonlib.FileOrString) -> None:
 for name in command_names:
 if isinstance(name, str):
 self.build.searched_programs.add(name)
@@ -1430,8 +1525,10 @@
 raise InterpreterException(f'Tried to override executable "{name}" which has already been overridden.')
 self.build.find_overridesname = exe
 
- def notfound_program(self, args):
- return NonExistingExternalProgram(' '.join(args))
+ def notfound_program(self, args: T.Listmesonlib.FileOrString) -> ExternalProgram:
+ return NonExistingExternalProgram(' '.join(
+ a if isinstance(a, str) else a.absolute_path(self.environment.source_dir, self.environment.build_dir)
+ for a in args))
 
 # TODO update modules to always pass `for_machine`. It is bad-form to assume
 # the host machine.
@@ -1444,7 +1541,7 @@
 ) -> T.Union'ExternalProgram', 'build.Executable', 'OverrideProgram':
 args = mesonlib.listify(args)
 
- extra_info = 
+ extra_info: T.Listmlog.TV_Loggable = 
 progobj = self.program_lookup(args, for_machine, required, search_dirs, extra_info)
 if progobj is None:
 progobj = self.notfound_program(args)
@@ -1461,14 +1558,15 @@
 if version_func:
 version = version_func(progobj)
 elif isinstance(progobj, build.Executable):
- interp = self
 if progobj.subproject:
 interp = self.subprojectsprogobj.subproject.held_object
- assert isinstance(interp, Interpreter)
+ else:
+ interp = self
+ assert isinstance(interp, Interpreter)
 version = interp.project_version
 else:
 version = progobj.get_version(self)
- is_found, not_found, found = mesonlib.version_compare_many(version, wanted)
+ is_found, not_found, _ = mesonlib.version_compare_many(version, wanted)
 if not is_found:
 mlog.log('Program', mlog.bold(progobj.name), 'found:', mlog.red('NO'),
 'found', mlog.normal_cyan(version), 'but need:',
@@ -1487,7 +1585,9 @@
 progobj.was_returned_by_find_program = True
 return progobj
 
- def program_lookup(self, args, for_machine, required, search_dirs, extra_info):
+ def program_lookup(self, args: T.Listmesonlib.FileOrString, for_machine: MachineChoice,
+ required: bool, search_dirs: T.Liststr, extra_info: T.Listmlog.TV_Loggable
+ ) -> T.OptionalT.UnionExternalProgram, build.Executable, OverrideProgram:
 progobj = self.program_from_overrides(args, extra_info)
 if progobj:
 return progobj
@@ -1510,10 +1610,18 @@
 
 return progobj
 
- def find_program_fallback(self, fallback, args, required, extra_info):
+ def find_program_fallback(self, fallback: str, args: T.Listmesonlib.FileOrString,
+ required: bool, extra_info: T.Listmlog.TV_Loggable
+ ) -> T.OptionalT.UnionExternalProgram, build.Executable, OverrideProgram:
 mlog.log('Fallback to subproject', mlog.bold(fallback), 'which provides program',
 mlog.bold(' '.join(args)))
- sp_kwargs = {'required': required}
+ sp_kwargs: kwtypes.DoSubproject = {
+ 'required': required,
+ 'default_options': ,
+ 'version': ,
+ 'cmake_options': ,
+ 'options': None,
+ }
 self.do_subproject(fallback, 'meson', sp_kwargs)
 return self.program_from_overrides(args, extra_info)
 
@@ -1528,7 +1636,7 @@
 )
 @disablerIfNotFound
 def func_find_program(self, node: mparser.BaseNode, args: T.TupleT.Listmesonlib.FileOrString,
- kwargs: 'kwargs.FindProgram',
+ kwargs: 'kwtypes.FindProgram',
 ) -> T.Union'build.Executable', ExternalProgram, 'OverrideProgram':
 disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
 if disabled:
@@ -1558,7 +1666,7 @@
 @disablerIfNotFound
 @permittedKwargs(permitted_dependency_kwargs)
 @typed_pos_args('dependency', varargs=str, min_varargs=1)
- def func_dependency(self, node, args, kwargs):
+ def func_dependency(self, node: mparser.BaseNode, args: T.TupleT.Liststr, kwargs) -> Dependency:
 # Replace '' by empty list of names
 names = n for n in args0 if n
 if len(names) > 1:
@@ -1582,7 +1690,6 @@
 assert isinstance(d, Dependency)
 if not d.found() and not_found_message:
 self.message_impl(not_found_message)
- self.message_impl(not_found_message)
 # Ensure the correct include type
 if 'include_type' in kwargs:
 wanted = kwargs'include_type'
@@ -1592,6 +1699,11 @@
 if wanted != actual:
 mlog.debug(f'Current include type of {args0} is {actual}. Converting to requested {wanted}')
 d = d.generate_system_dependency(wanted)
+ if d.feature_since is not None:
+ version, extra_msg = d.feature_since
+ FeatureNew.single_use(f'dep {d.name!r} custom lookup', version, self.subproject, extra_msg, node)
+ for f in d.featurechecks:
+ f.use(self.subproject, node)
 return d
 
 @FeatureNew('disabler', '0.44.0')
@@ -1645,8 +1757,9 @@
 elif target_type == 'shared_library':
 return self.build_target(node, args, kwargs, build.SharedLibrary)
 elif target_type == 'shared_module':
- FeatureNew('build_target(target_type: \'shared_module\')',
- '0.51.0').use(self.subproject)
+ FeatureNew.single_use(
+ 'build_target(target_type: \'shared_module\')',
+ '0.51.0', self.subproject, location=node)
 return self.build_target(node, args, kwargs, build.SharedModule)
 elif target_type == 'static_library':
 return self.build_target(node, args, kwargs, build.StaticLibrary)
@@ -1659,25 +1772,38 @@
 else:
 raise InterpreterException('Unknown target_type.')
 
- @permittedKwargs({'input', 'output', 'fallback', 'command', 'replace_string'})
 @noPosargs
- def func_vcs_tag(self, node, args, kwargs):
- if 'input' not in kwargs or 'output' not in kwargs:
- raise InterpreterException('Keyword arguments input and output must exist')
- if 'fallback' not in kwargs:
+ @typed_kwargs(
+ 'vcs_tag',
+ CT_INPUT_KW.evolve(required=True),
+ MULTI_OUTPUT_KW,
+ # Cannot use the COMMAND_KW because command is allowed to be empty
+ KwargInfo(
+ 'command',
+ ContainerTypeInfo(list, (str, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex, ExternalProgram, mesonlib.File)),
+ listify=True,
+ default=,
+ ),
+ KwargInfo('fallback', (str, NoneType)),
+ KwargInfo('replace_string', str, default='@VCS_TAG@'),
+ )
+ def func_vcs_tag(self, node: mparser.BaseNode, args: T.List'TYPE_var', kwargs: 'kwtypes.VcsTag') -> build.CustomTarget:
+ if kwargs'fallback' is None:
 FeatureNew.single_use('Optional fallback in vcs_tag', '0.41.0', self.subproject, location=node)
- fallback = kwargs.pop('fallback', self.project_version)
- if not isinstance(fallback, str):
- raise InterpreterException('Keyword argument fallback must be a string.')
- replace_string = kwargs.pop('replace_string', '@VCS_TAG@')
+ fallback = kwargs'fallback' or self.project_version
+ replace_string = kwargs'replace_string'
 regex_selector = '(.*)' # default regex selector for custom command: use complete output
- vcs_cmd = kwargs.get('command', None)
- if vcs_cmd and not isinstance(vcs_cmd, list):
- vcs_cmd = vcs_cmd
+ vcs_cmd = kwargs'command'
 source_dir = os.path.normpath(os.path.join(self.environment.get_source_dir(), self.subdir))
 if vcs_cmd:
- # Is the command an executable in path or maybe a script in the source tree?
- vcs_cmd0 = shutil.which(vcs_cmd0) or os.path.join(source_dir, vcs_cmd0)
+ if isinstance(vcs_cmd0, (str, mesonlib.File)):
+ if isinstance(vcs_cmd0, mesonlib.File):
+ FeatureNew.single_use('vcs_tag with file as the first argument', '0.62.0', self.subproject, location=node)
+ maincmd = self.find_program_impl(vcs_cmd0, required=False)
+ if maincmd.found():
+ vcs_cmd0 = maincmd
+ else:
+ FeatureNew.single_use('vcs_tag with custom_tgt, external_program, or exe as the first argument', '0.63.0', self.subproject, location=node)
 else:
 vcs = mesonlib.detect_vcs(source_dir)
 if vcs:
@@ -1687,7 +1813,10 @@
 else:
 vcs_cmd = ' ' # executing this cmd will fail in vcstagger.py and force to use the fallback string
 # vcstagger.py parameters: infile, outfile, fallback, source_dir, replace_string, regex_selector, command...
- kwargs'command' = self.environment.get_build_command() + \
+
+ self._validate_custom_target_outputs(len(kwargs'input') > 1, kwargs'output', "vcs_tag")
+
+ cmd = self.environment.get_build_command() + \
 '--internal',
 'vcstagger',
 '@INPUT0@',
@@ -1696,16 +1825,39 @@
 source_dir,
 replace_string,
 regex_selector + vcs_cmd
- kwargs.setdefault('build_by_default', True)
- kwargs.setdefault('build_always_stale', True)
- return self._func_custom_target_impl(node, kwargs'output', kwargs)
+
+ tg = build.CustomTarget(
+ kwargs'output'0,
+ self.subdir,
+ self.subproject,
+ self.environment,
+ cmd,
+ self.source_strings_to_files(kwargs'input'),
+ kwargs'output',
+ build_by_default=True,
+ build_always_stale=True,
+ )
+ self.add_target(tg.name, tg)
+ return tg
 
 @FeatureNew('subdir_done', '0.46.0')
 @noPosargs
 @noKwargs
- def func_subdir_done(self, node, args, kwargs):
+ def func_subdir_done(self, node: mparser.BaseNode, args: TYPE_var, kwargs: TYPE_kwargs) -> T.NoReturn:
 raise SubdirDoneRequest()
 
+ @staticmethod
+ def _validate_custom_target_outputs(has_multi_in: bool, outputs: T.Iterablestr, name: str) -> None:
+ """Checks for additional invalid values in a custom_target output.
+
+ This cannot be done with typed_kwargs because it requires the number of
+ inputs.
+ """
+ for out in outputs:
+ if has_multi_in and ('@PLAINNAME@' in out or '@BASENAME@' in out):
+ raise InvalidArguments(f'{name}: output cannot contain "@PLAINNAME@" or "@BASENAME@" '
+ 'when there is more than one input (we can\'t know which to use)')
+
 @typed_pos_args('custom_target', optargs=str)
 @typed_kwargs(
 'custom_target',
@@ -1716,69 +1868,107 @@
 CT_INPUT_KW,
 CT_INSTALL_DIR_KW,
 CT_INSTALL_TAG_KW,
- CT_OUTPUT_KW,
+ MULTI_OUTPUT_KW,
 DEPENDS_KW,
 DEPEND_FILES_KW,
 DEPFILE_KW,
 ENV_KW.evolve(since='0.57.0'),
 INSTALL_KW,
 INSTALL_MODE_KW.evolve(since='0.47.0'),
- OVERRIDE_OPTIONS_KW,
 KwargInfo('feed', bool, default=False, since='0.59.0'),
 KwargInfo('capture', bool, default=False),
 KwargInfo('console', bool, default=False, since='0.48.0'),
 )
 def func_custom_target(self, node: mparser.FunctionNode, args: T.Tuplestr,
- kwargs: 'kwargs.CustomTarget') -> build.CustomTarget:
+ kwargs: 'kwtypes.CustomTarget') -> build.CustomTarget:
 if kwargs'depfile' and ('@BASENAME@' in kwargs'depfile' or '@PLAINNAME@' in kwargs'depfile'):
 FeatureNew.single_use('substitutions in custom_target depfile', '0.47.0', self.subproject, location=node)
+ install_mode = self._warn_kwarg_install_mode_sticky(kwargs'install_mode')
 
 # Don't mutate the kwargs
- kwargs = kwargs.copy()
 
+ build_by_default = kwargs'build_by_default'
+ build_always_stale = kwargs'build_always_stale'
 # Remap build_always to build_by_default and build_always_stale
 if kwargs'build_always' is not None and kwargs'build_always_stale' is not None:
 raise InterpreterException('CustomTarget: "build_always" and "build_always_stale" are mutually exclusive')
 
- if kwargs'build_by_default' is None and kwargs'install':
- kwargs'build_by_default' = True
+ if build_by_default is None and kwargs'install':
+ build_by_default = True
 
 elif kwargs'build_always' is not None:
- if kwargs'build_by_default' is None:
- kwargs'build_by_default' = kwargs'build_always'
- kwargs'build_always_stale' = kwargs'build_by_default'
-
- # Set this to None to satisfy process_kwargs
- kwargs'build_always' = None
+ if build_by_default is None:
+ build_by_default = kwargs'build_always'
+ build_always_stale = kwargs'build_by_default'
 
 # These are are nullaable so that we can know whether they're explicitly
 # set or not. If they haven't been overwritten, set them to their true
 # default
- if kwargs'build_by_default' is None:
- kwargs'build_by_default' = False
- if kwargs'build_always_stale' is None:
- kwargs'build_always_stale' = False
+ if build_by_default is None:
+ build_by_default = False
+ if build_always_stale is None:
+ build_always_stale = False
 
- return self._func_custom_target_impl(node, args, kwargs)
-
- def _func_custom_target_impl(self, node, args, kwargs):
- 'Implementation-only, without FeatureNew checks, for internal use'
 name = args0
 if name is None:
 # name will default to first output, but we cannot do that yet because
 # they could need substitutions (e.g. @BASENAME@) first. CustomTarget()
 # will take care of setting a proper default but name must be an empty
 # string in the meantime.
- FeatureNew('custom_target() with no name argument', '0.60.0', location=node).use(self.subproject)
+ FeatureNew.single_use('custom_target() with no name argument', '0.60.0', self.subproject, location=node)
 name = ''
- kwargs'install_mode' = self._get_kwarg_install_mode(kwargs)
- if 'input' in kwargs:
- kwargs'input' = self.source_strings_to_files(extract_as_list(kwargs, 'input'), strict=False)
- kwargs'env' = self.unpack_env_kwarg(kwargs)
- if 'command' in kwargs and isinstance(kwargs'command', list) and kwargs'command':
- if isinstance(kwargs'command'0, str):
- kwargs'command'0 = self.find_program_impl(kwargs'command'0)
- tg = build.CustomTarget(name, self.subdir, self.subproject, kwargs, backend=self.backend)
+ inputs = self.source_strings_to_files(kwargs'input', strict=False)
+ command = kwargs'command'
+ if command and isinstance(command0, str):
+ command0 = self.find_program_impl(command0)
+
+ if len(inputs) > 1 and kwargs'feed':
+ raise InvalidArguments('custom_target: "feed" keyword argument can only be used used with a single input')
+ if len(kwargs'output') > 1 and kwargs'capture':
+ raise InvalidArguments('custom_target: "capture" keyword argument can only be used used with a single output')
+ if kwargs'capture' and kwargs'console':
+ raise InvalidArguments('custom_target: "capture" and "console" keyword arguments are mutually exclusive')
+ for c in command:
+ if kwargs'capture' and isinstance(c, str) and '@OUTPUT@' in c:
+ raise InvalidArguments('custom_target: "capture" keyword argument cannot be used with "@OUTPUT@"')
+ if kwargs'feed' and isinstance(c, str) and '@INPUT@' in c:
+ raise InvalidArguments('custom_target: "feed" keyword argument cannot be used with "@INPUT@"')
+ if kwargs'install' and not kwargs'install_dir':
+ raise InvalidArguments('custom_target: "install_dir" keyword argument must be set when "install" is true.')
+ if len(kwargs'install_dir') > 1:
+ FeatureNew.single_use('multiple install_dir for custom_target', '0.40.0', self.subproject, location=node)
+ if len(kwargs'install_tag') not in {0, 1, len(kwargs'output')}:
+ raise InvalidArguments('custom_target: install_tag argument must have 0 or 1 outputs, '
+ 'or the same number of elements as the output keyword argument. '
+ f'(there are {len(kwargs"install_tag")} install_tags, '
+ f'and {len(kwargs"output")} outputs)')
+
+ for t in kwargs'output':
+ self.validate_forbidden_targets(t)
+ self._validate_custom_target_outputs(len(inputs) > 1, kwargs'output', "custom_target")
+
+ tg = build.CustomTarget(
+ name,
+ self.subdir,
+ self.subproject,
+ self.environment,
+ command,
+ inputs,
+ kwargs'output',
+ build_always_stale=build_always_stale,
+ build_by_default=build_by_default,
+ capture=kwargs'capture',
+ console=kwargs'console',
+ depend_files=kwargs'depend_files',
+ depfile=kwargs'depfile',
+ extra_depends=kwargs'depends',
+ env=kwargs'env',
+ feed=kwargs'feed',
+ install=kwargs'install',
+ install_dir=kwargs'install_dir',
+ install_mode=install_mode,
+ install_tag=kwargs'install_tag',
+ backend=self.backend)
 self.add_target(tg.name, tg)
 return tg
 
@@ -1790,7 +1980,7 @@
 ENV_KW.evolve(since='0.57.0'),
 )
 def func_run_target(self, node: mparser.FunctionNode, args: T.Tuplestr,
- kwargs: 'kwargs.RunTarget') -> build.RunTarget:
+ kwargs: 'kwtypes.RunTarget') -> build.RunTarget:
 all_args = kwargs'command'.copy()
 
 for i in listify(all_args):
@@ -1799,11 +1989,9 @@
 if isinstance(all_args0, str):
 all_args0 = self.find_program_impl(all_args0)
 name = args0
- tg = build.RunTarget(name, all_args, kwargs'depends', self.subdir, self.subproject, kwargs'env')
+ tg = build.RunTarget(name, all_args, kwargs'depends', self.subdir, self.subproject, self.environment,
+ kwargs'env')
 self.add_target(name, tg)
- full_name = (self.subproject, name)
- assert full_name not in self.build.run_target_names
- self.build.run_target_names.add(full_name)
 return tg
 
 @FeatureNew('alias_target', '0.52.0')
@@ -1812,7 +2000,7 @@
 def func_alias_target(self, node: mparser.BaseNode, args: T.Tuplestr, T.Listbuild.Target,
 kwargs: 'TYPE_kwargs') -> build.AliasTarget:
 name, deps = args
- tg = build.AliasTarget(name, deps, self.subdir, self.subproject)
+ tg = build.AliasTarget(name, deps, self.subdir, self.subproject, self.environment)
 self.add_target(name, tg)
 return tg
 
@@ -1827,7 +2015,7 @@
 )
 def func_generator(self, node: mparser.FunctionNode,
 args: T.TupleT.Unionbuild.Executable, ExternalProgram,
- kwargs: 'kwargs.FuncGenerator') -> build.Generator:
+ kwargs: 'kwtypes.FuncGenerator') -> build.Generator:
 for rule in kwargs'output':
 if '@BASENAME@' not in rule and '@PLAINNAME@' not in rule:
 raise InvalidArguments('Every element of "output" must contain @BASENAME@ or @PLAINNAME@.')
@@ -1843,17 +2031,17 @@
 return gen
 
 @typed_pos_args('benchmark', str, (build.Executable, build.Jar, ExternalProgram, mesonlib.File))
- @typed_kwargs('benchmark', *TEST_KWARGS)
+ @typed_kwargs('benchmark', *TEST_KWS)
 def func_benchmark(self, node: mparser.BaseNode,
 args: T.Tuplestr, T.Unionbuild.Executable, build.Jar, ExternalProgram, mesonlib.File,
- kwargs: 'kwargs.FuncBenchmark') -> None:
+ kwargs: 'kwtypes.FuncBenchmark') -> None:
 self.add_test(node, args, kwargs, False)
 
 @typed_pos_args('test', str, (build.Executable, build.Jar, ExternalProgram, mesonlib.File))
- @typed_kwargs('test', *TEST_KWARGS, KwargInfo('is_parallel', bool, default=True))
+ @typed_kwargs('test', *TEST_KWS, KwargInfo('is_parallel', bool, default=True))
 def func_test(self, node: mparser.BaseNode,
 args: T.Tuplestr, T.Unionbuild.Executable, build.Jar, ExternalProgram, mesonlib.File,
- kwargs: 'kwargs.FuncTest') -> None:
+ kwargs: 'kwtypes.FuncTest') -> None:
 self.add_test(node, args, kwargs, True)
 
 def unpack_env_kwarg(self, kwargs: T.Unionbuild.EnvironmentVariables, T.Dictstr, 'TYPE_var', T.List'TYPE_var', str) -> build.EnvironmentVariables:
@@ -1867,14 +2055,17 @@
 
 def make_test(self, node: mparser.BaseNode,
 args: T.Tuplestr, T.Unionbuild.Executable, build.Jar, ExternalProgram, mesonlib.File,
- kwargs: 'kwargs.BaseTest') -> Test:
+ kwargs: 'kwtypes.BaseTest') -> Test:
 name = args0
 if ':' in name:
 mlog.deprecation(f'":" is not allowed in test name "{name}", it has been replaced with "_"',
 location=node)
 name = name.replace(':', '_')
 exe = args1
- if isinstance(exe, mesonlib.File):
+ if isinstance(exe, ExternalProgram):
+ if not exe.found():
+ raise InvalidArguments('Tried to use not-found external program as test exe')
+ elif isinstance(exe, mesonlib.File):
 exe = self.find_program_impl(exe)
 
 env = self.unpack_env_kwarg(kwargs)
@@ -1902,7 +2093,8 @@
 kwargs'timeout',
 kwargs'workdir',
 kwargs'protocol',
- kwargs'priority')
+ kwargs'priority',
+ kwargs'verbose')
 
 def add_test(self, node: mparser.BaseNode, args: T.List, kwargs: T.Dictstr, T.Any, is_base_test: bool):
 t = self.make_test(node, args, kwargs)
@@ -1916,34 +2108,53 @@
 @typed_pos_args('install_headers', varargs=(str, mesonlib.File))
 @typed_kwargs(
 'install_headers',
- KwargInfo('install_dir', (str, NoneType)),
+ PRESERVE_PATH_KW,
 KwargInfo('subdir', (str, NoneType)),
 INSTALL_MODE_KW.evolve(since='0.47.0'),
+ INSTALL_DIR_KW,
 )
 def func_install_headers(self, node: mparser.BaseNode,
 args: T.TupleT.List'mesonlib.FileOrString',
- kwargs: 'kwargs.FuncInstallHeaders') -> build.Headers:
+ kwargs: 'kwtypes.FuncInstallHeaders') -> build.Headers:
+ install_mode = self._warn_kwarg_install_mode_sticky(kwargs'install_mode')
 source_files = self.source_strings_to_files(args0)
 install_subdir = kwargs'subdir'
- if install_subdir is not None and os.path.isabs(install_subdir):
- mlog.deprecation('Subdir keyword must not be an absolute path. This will be a hard error in the next release.')
+ if install_subdir is not None:
+ if kwargs'install_dir' is not None:
+ raise InterpreterException('install_headers: cannot specify both "install_dir" and "subdir". Use only "install_dir".')
+ if os.path.isabs(install_subdir):
+ mlog.deprecation('Subdir keyword must not be an absolute path. This will be a hard error in the next release.')
+ else:
+ install_subdir = ''
+
+ dirs = collections.defaultdict(list)
+ ret_headers = 
+ if kwargs'preserve_path':
+ for file in source_files:
+ dirname = os.path.dirname(file.fname)
+ dirsdirname.append(file)
+ else:
+ dirs''.extend(source_files)
+
+ for childdir in dirs:
+ h = build.Headers(dirschilddir, os.path.join(install_subdir, childdir), kwargs'install_dir',
+ install_mode, self.subproject)
+ ret_headers.append(h)
+ self.build.headers.append(h)
 
- h = build.Headers(source_files, install_subdir, kwargs'install_dir',
- kwargs'install_mode', self.subproject)
- self.build.headers.append(h)
-
- return h
+ return ret_headers
 
 @typed_pos_args('install_man', varargs=(str, mesonlib.File))
 @typed_kwargs(
 'install_man',
- KwargInfo('install_dir', (str, NoneType)),
 KwargInfo('locale', (str, NoneType), since='0.58.0'),
- INSTALL_MODE_KW.evolve(since='0.47.0')
+ INSTALL_MODE_KW.evolve(since='0.47.0'),
+ INSTALL_DIR_KW,
 )
 def func_install_man(self, node: mparser.BaseNode,
 args: T.TupleT.List'mesonlib.FileOrString',
- kwargs: 'kwargs.FuncInstallMan') -> build.Man:
+ kwargs: 'kwtypes.FuncInstallMan') -> build.Man:
+ install_mode = self._warn_kwarg_install_mode_sticky(kwargs'install_mode')
 # We just need to narrow this, because the input is limited to files and
 # Strings as inputs, so only Files will be returned
 sources = self.source_strings_to_files(args0)
@@ -1955,7 +2166,7 @@
 if not 1 <= num <= 9:
 raise InvalidArguments('Man file must have a file extension of a number between 1 and 9')
 
- m = build.Man(sources, kwargs'install_dir', kwargs'install_mode',
+ m = build.Man(sources, kwargs'install_dir', install_mode,
 self.subproject, kwargs'locale')
 self.build.man.append(m)
 
@@ -1964,10 +2175,11 @@
 @FeatureNew('install_emptydir', '0.60.0')
 @typed_kwargs(
 'install_emptydir',
- INSTALL_MODE_KW
+ INSTALL_MODE_KW,
+ KwargInfo('install_tag', (str, NoneType), since='0.62.0')
 )
 def func_install_emptydir(self, node: mparser.BaseNode, args: T.Tuplestr, kwargs) -> None:
- d = build.EmptyDir(args0, kwargs'install_mode', self.subproject)
+ d = build.EmptyDir(args0, kwargs'install_mode', self.subproject, kwargs'install_tag')
 self.build.emptydir.append(d)
 
 return d
@@ -1978,7 +2190,7 @@
 'install_symlink',
 KwargInfo('pointing_to', str, required=True),
 KwargInfo('install_dir', str, required=True),
- KwargInfo('install_tag', (str, NoneType)),
+ INSTALL_TAG_KW,
 )
 def func_install_symlink(self, node: mparser.BaseNode,
 args: T.TupleT.Liststr,
@@ -1990,6 +2202,35 @@
 self.build.symlinks.append(l)
 return l
 
+ @FeatureNew('structured_sources', '0.62.0')
+ @typed_pos_args('structured_sources', object, optargs=dict)
+ @noKwargs
+ @noArgsFlattening
+ def func_structured_sources(
+ self, node: mparser.BaseNode,
+ args: T.Tupleobject, T.OptionalT.Dictstr, object,
+ kwargs: 'TYPE_kwargs') -> build.StructuredSources:
+ valid_types = (str, mesonlib.File, build.GeneratedList, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)
+ sources: T.Dictstr, T.ListT.Unionmesonlib.File, 'build.GeneratedTypes' = collections.defaultdict(list)
+
+ for arg in mesonlib.listify(args0):
+ if not isinstance(arg, valid_types):
+ raise InvalidArguments(f'structured_sources: type "{type(arg)}" is not valid')
+ if isinstance(arg, str):
+ arg = mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, arg)
+ sources''.append(arg)
+ if args1:
+ if '' in args1:
+ raise InvalidArguments('structured_sources: keys to dictionary argument may not be an empty string.')
+ for k, v in args1.items():
+ for arg in mesonlib.listify(v):
+ if not isinstance(arg, valid_types):
+ raise InvalidArguments(f'structured_sources: type "{type(arg)}" is not valid')
+ if isinstance(arg, str):
+ arg = mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, arg)
+ sourcesk.append(arg)
+ return build.StructuredSources(sources)
+
 @typed_pos_args('subdir', str)
 @typed_kwargs(
 'subdir',
@@ -2002,7 +2243,7 @@
 listify=True,
 ),
 )
- def func_subdir(self, node: mparser.BaseNode, args: T.Tuplestr, kwargs: 'kwargs.Subdir') -> None:
+ def func_subdir(self, node: mparser.BaseNode, args: T.Tuplestr, kwargs: 'kwtypes.Subdir') -> None:
 mesonlib.check_direntry_issues(args)
 if '..' in args0:
 raise InvalidArguments('Subdir contains ..')
@@ -2010,6 +2251,8 @@
 raise InvalidArguments('Must not go into subprojects dir with subdir(), use subproject() instead.')
 if self.subdir == '' and args0.startswith('meson-'):
 raise InvalidArguments('The "meson-" prefix is reserved and cannot be used for top-level subdir().')
+ if args0 == '':
+ raise InvalidArguments("The argument given to subdir() is the empty string ''. This is prohibited.")
 for i in kwargs'if_found':
 if not i.found():
 return
@@ -2027,7 +2270,7 @@
 self.subdir = subdir
 os.makedirs(os.path.join(self.environment.build_dir, subdir), exist_ok=True)
 buildfilename = os.path.join(self.subdir, environment.build_filename)
- self.build_def_files.append(buildfilename)
+ self.build_def_files.add(buildfilename)
 absname = os.path.join(self.environment.get_source_dir(), buildfilename)
 if not os.path.isfile(absname):
 self.subdir = prev_subdir
@@ -2067,18 +2310,33 @@
 'permissions arg to be a string or false')
 return FileMode(*install_mode)
 
+ # This is either ignored on basically any OS nowadays, or silently gets
+ # ignored (Solaris) or triggers an "illegal operation" error (FreeBSD).
+ # It was likely added "because it exists", but should never be used. In
+ # theory it is useful for directories, but we never apply modes to
+ # directories other than in install_emptydir.
+ def _warn_kwarg_install_mode_sticky(self, mode: FileMode) -> None:
+ if mode.perms > 0 and mode.perms & stat.S_ISVTX:
+ mlog.deprecation('install_mode with the sticky bit on a file does not do anything and will '
+ 'be ignored since Meson 0.64.0', location=self.current_node)
+ perms = stat.filemode(mode.perms - stat.S_ISVTX)1:
+ return FileMode(perms, mode.owner, mode.group)
+ else:
+ return mode
+
 @typed_pos_args('install_data', varargs=(str, mesonlib.File))
 @typed_kwargs(
 'install_data',
- KwargInfo('install_dir', (str, NoneType)),
 KwargInfo('sources', ContainerTypeInfo(list, (str, mesonlib.File)), listify=True, default=),
 KwargInfo('rename', ContainerTypeInfo(list, str), default=, listify=True, since='0.46.0'),
 INSTALL_MODE_KW.evolve(since='0.38.0'),
- KwargInfo('install_tag', (str, NoneType), since='0.60.0'),
+ INSTALL_TAG_KW.evolve(since='0.60.0'),
+ INSTALL_DIR_KW,
+ PRESERVE_PATH_KW.evolve(since='0.64.0'),
 )
 def func_install_data(self, node: mparser.BaseNode,
 args: T.TupleT.List'mesonlib.FileOrString',
- kwargs: 'kwargs.FuncInstallData') -> build.Data:
+ kwargs: 'kwtypes.FuncInstallData') -> build.Data:
 sources = self.source_strings_to_files(args0 + kwargs'sources')
 rename = kwargs'rename' or None
 if rename:
@@ -2087,32 +2345,44 @@
 '"rename" and "sources" argument lists must be the same length if "rename" is given. '
 f'Rename has {len(rename)} elements and sources has {len(sources)}.')
 
- install_dir_name = kwargs'install_dir'
- if install_dir_name:
- if not os.path.isabs(install_dir_name):
- install_dir_name = os.path.join('{datadir}', install_dir_name)
- else:
- install_dir_name = '{datadir}'
- return self.install_data_impl(sources, kwargs'install_dir', kwargs'install_mode',
- rename, kwargs'install_tag', install_dir_name)
+ install_mode = self._warn_kwarg_install_mode_sticky(kwargs'install_mode')
+ return self.install_data_impl(sources, kwargs'install_dir', install_mode,
+ rename, kwargs'install_tag',
+ preserve_path=kwargs'preserve_path')
 
- def install_data_impl(self, sources: T.Listmesonlib.File, install_dir: str,
+ def install_data_impl(self, sources: T.Listmesonlib.File, install_dir: T.Optionalstr,
 install_mode: FileMode, rename: T.Optionalstr,
 tag: T.Optionalstr,
 install_dir_name: T.Optionalstr = None,
- install_data_type: T.Optionalstr = None) -> build.Data:
+ install_data_type: T.Optionalstr = None,
+ preserve_path: bool = False) -> build.Data:
 
 """Just the implementation with no validation."""
- data = build.Data(sources, install_dir, install_dir_name or install_dir, install_mode,
- self.subproject, rename, tag, install_data_type)
- self.build.data.append(data)
- return data
+ idir = install_dir or ''
+ idir_name = install_dir_name or idir or '{datadir}'
+ if isinstance(idir_name, P_OBJ.OptionString):
+ idir_name = idir_name.optname
+ dirs = collections.defaultdict(list)
+ ret_data = 
+ if preserve_path:
+ for file in sources:
+ dirname = os.path.dirname(file.fname)
+ dirsdirname.append(file)
+ else:
+ dirs''.extend(sources)
+
+ for childdir, files in dirs.items():
+ d = build.Data(files, os.path.join(idir, childdir), os.path.join(idir_name, childdir),
+ install_mode, self.subproject, rename, tag, install_data_type)
+ ret_data.append(d)
+
+ self.build.data.extend(ret_data)
+ return ret_data
 
 @typed_pos_args('install_subdir', str)
 @typed_kwargs(
 'install_subdir',
 KwargInfo('install_dir', str, required=True),
- KwargInfo('install_tag', (str, NoneType), since='0.60.0'),
 KwargInfo('strip_directory', bool, default=False),
 KwargInfo('exclude_files', ContainerTypeInfo(list, str),
 default=, listify=True, since='0.42.0',
@@ -2121,15 +2391,29 @@
 default=, listify=True, since='0.42.0',
 validator=lambda x: 'cannot be absolute' if any(os.path.isabs(d) for d in x) else None),
 INSTALL_MODE_KW.evolve(since='0.38.0'),
+ INSTALL_TAG_KW.evolve(since='0.60.0'),
 )
 def func_install_subdir(self, node: mparser.BaseNode, args: T.Tuplestr,
- kwargs: 'kwargs.FuncInstallSubdir') -> build.InstallDir:
+ kwargs: 'kwtypes.FuncInstallSubdir') -> build.InstallDir:
 exclude = (set(kwargs'exclude_files'), set(kwargs'exclude_directories'))
+
+ srcdir = os.path.join(self.environment.source_dir, self.subdir, args0)
+ if not os.path.isdir(srcdir) or not any(os.scandir(srcdir)):
+ FeatureNew.single_use('install_subdir with empty directory', '0.47.0', self.subproject, location=node)
+ FeatureDeprecated.single_use('install_subdir with empty directory', '0.60.0', self.subproject,
+ 'It worked by accident and is buggy. Use install_emptydir instead.', node)
+ install_mode = self._warn_kwarg_install_mode_sticky(kwargs'install_mode')
+
+ idir_name = kwargs'install_dir'
+ if isinstance(idir_name, P_OBJ.OptionString):
+ idir_name = idir_name.optname
+
 idir = build.InstallDir(
 self.subdir,
 args0,
 kwargs'install_dir',
- kwargs'install_mode',
+ idir_name,
+ install_mode,
 exclude,
 kwargs'strip_directory',
 self.subproject,
@@ -2137,67 +2421,72 @@
 self.build.install_dirs.append(idir)
 return idir
 
- @FeatureNewKwargs('configure_file', '0.47.0', 'copy', 'output_format', 'install_mode', 'encoding')
- @FeatureNewKwargs('configure_file', '0.46.0', 'format')
- @FeatureNewKwargs('configure_file', '0.41.0', 'capture')
- @FeatureNewKwargs('configure_file', '0.50.0', 'install')
- @FeatureNewKwargs('configure_file', '0.52.0', 'depfile')
- @FeatureNewKwargs('configure_file', '0.60.0', 'install_tag')
- @permittedKwargs({'input', 'output', 'configuration', 'command', 'copy', 'depfile',
- 'install_dir', 'install_mode', 'capture', 'install', 'format',
- 'output_format', 'encoding', 'install_tag'})
 @noPosargs
- def func_configure_file(self, node, args, kwargs):
- if 'output' not in kwargs:
- raise InterpreterException('Required keyword argument "output" not defined.')
- actions = {'configuration', 'command', 'copy'}.intersection(kwargs.keys())
- if len(actions) == 0:
+ @typed_kwargs(
+ 'configure_file',
+ DEPFILE_KW.evolve(since='0.52.0'),
+ INSTALL_MODE_KW.evolve(since='0.47.0,'),
+ INSTALL_TAG_KW.evolve(since='0.60.0'),
+ KwargInfo('capture', bool, default=False, since='0.41.0'),
+ KwargInfo(
+ 'command',
+ (ContainerTypeInfo(list, (build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str), allow_empty=False), NoneType),
+ listify=True,
+ ),
+ KwargInfo(
+ 'configuration',
+ (ContainerTypeInfo(dict, (str, int, bool)), build.ConfigurationData, NoneType),
+ ),
+ KwargInfo(
+ 'copy', bool, default=False, since='0.47.0',
+ deprecated='0.64.0', deprecated_message='Use fs.copyfile instead',
+ ),
+ KwargInfo('encoding', str, default='utf-8', since='0.47.0'),
+ KwargInfo('format', str, default='meson', since='0.46.0',
+ validator=in_set_validator({'meson', 'cmake', 'cmake@'})),
+ KwargInfo(
+ 'input',
+ ContainerTypeInfo(list, (mesonlib.File, str)),
+ listify=True,
+ default=,
+ ),
+ # Cannot use shared implementation until None backwards compat is dropped
+ KwargInfo('install', (bool, NoneType), since='0.50.0'),
+ KwargInfo('install_dir', (str, bool), default='',
+ validator=lambda x: 'must be `false` if boolean' if x is True else None),
+ OUTPUT_KW,
+ KwargInfo('output_format', str, default='c', since='0.47.0',
+ validator=in_set_validator({'c', 'nasm'})),
+ )
+ def func_configure_file(self, node: mparser.BaseNode, args: T.ListTYPE_var,
+ kwargs: kwtypes.ConfigureFile):
+ actions = sorted(x for x in 'configuration', 'command', 'copy'
+ if kwargsx not in None, False)
+ num_actions = len(actions)
+ if num_actions == 0:
 raise InterpreterException('Must specify an action with one of these '
 'keyword arguments: \'configuration\', '
 '\'command\', or \'copy\'.')
- elif len(actions) == 2:
+ elif num_actions == 2:
 raise InterpreterException('Must not specify both {!r} and {!r} '
 'keyword arguments since they are '
 'mutually exclusive.'.format(*actions))
- elif len(actions) == 3:
+ elif num_actions == 3:
 raise InterpreterException('Must specify one of {!r}, {!r}, and '
 '{!r} keyword arguments since they are '
 'mutually exclusive.'.format(*actions))
- if 'capture' in kwargs:
- if not isinstance(kwargs'capture', bool):
- raise InterpreterException('"capture" keyword must be a boolean.')
- if 'command' not in kwargs:
- raise InterpreterException('"capture" keyword requires "command" keyword.')
-
- if 'format' in kwargs:
- fmt = kwargs'format'
- if not isinstance(fmt, str):
- raise InterpreterException('"format" keyword must be a string.')
- else:
- fmt = 'meson'
-
- if fmt not in ('meson', 'cmake', 'cmake@'):
- raise InterpreterException('"format" possible values are "meson", "cmake" or "cmake@".')
-
- if 'output_format' in kwargs:
- output_format = kwargs'output_format'
- if not isinstance(output_format, str):
- raise InterpreterException('"output_format" keyword must be a string.')
- else:
- output_format = 'c'
-
- if output_format not in ('c', 'nasm'):
- raise InterpreterException('"format" possible values are "c" or "nasm".')
-
- if 'depfile' in kwargs:
- depfile = kwargs'depfile'
- if not isinstance(depfile, str):
- raise InterpreterException('depfile file name must be a string')
- else:
- depfile = None
+
+ if kwargs'capture' and not kwargs'command':
+ raise InvalidArguments('configure_file: "capture" keyword requires "command" keyword.')
+
+ install_mode = self._warn_kwarg_install_mode_sticky(kwargs'install_mode')
+
+ fmt = kwargs'format'
+ output_format = kwargs'output_format'
+ depfile = kwargs'depfile'
 
 # Validate input
- inputs = self.source_strings_to_files(extract_as_list(kwargs, 'input'))
+ inputs = self.source_strings_to_files(kwargs'input')
 inputs_abs = 
 for f in inputs:
 if isinstance(f, mesonlib.File):
@@ -2206,10 +2495,9 @@
 self.add_build_def_file(f)
 else:
 raise InterpreterException('Inputs can only be strings or file objects')
+
 # Validate output
 output = kwargs'output'
- if not isinstance(output, str):
- raise InterpreterException('Output file name must be a string')
 if inputs_abs:
 values = mesonlib.get_filenames_templates_dict(inputs_abs, None)
 outputs = mesonlib.substitute_values(output, values)
@@ -2224,29 +2512,30 @@
 mlog.warning('Output file', mlog.bold(ofile_rpath, True), 'for configure_file() at', current_call, 'overwrites configure_file() output at', first_call)
 else:
 self.configure_file_outputsofile_rpath = self.current_lineno
- if os.path.dirname(output) != '':
- raise InterpreterException('Output file name must not contain a subdirectory.')
 (ofile_path, ofile_fname) = os.path.split(os.path.join(self.subdir, output))
 ofile_abs = os.path.join(self.environment.build_dir, ofile_path, ofile_fname)
+
 # Perform the appropriate action
- if 'configuration' in kwargs:
+ if kwargs'configuration' is not None:
 conf = kwargs'configuration'
 if isinstance(conf, dict):
 FeatureNew.single_use('configure_file.configuration dictionary', '0.49.0', self.subproject, location=node)
- conf = ConfigurationDataObject(self.subproject, conf)
- elif not isinstance(conf, ConfigurationDataObject):
- raise InterpreterException('Argument "configuration" is not of type configuration_data')
+ for k, v in conf.items():
+ if not isinstance(v, (str, int, bool)):
+ raise InvalidArguments(
+ f'"configuration_data": initial value dictionary key "{k!r}"" must be "str | int | bool", not "{v!r}"')
+ conf = build.ConfigurationData(conf)
 mlog.log('Configuring', mlog.bold(output), 'using configuration')
 if len(inputs) > 1:
 raise InterpreterException('At most one input file can given in configuration mode')
 if inputs:
 os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True)
- file_encoding = kwargs.setdefault('encoding', 'utf-8')
+ file_encoding = kwargs'encoding'
 missing_variables, confdata_useless = \
- mesonlib.do_conf_file(inputs_abs0, ofile_abs, conf.conf_data,
+ mesonlib.do_conf_file(inputs_abs0, ofile_abs, conf,
 fmt, file_encoding)
 if missing_variables:
- var_list = ", ".join(map(repr, sorted(missing_variables)))
+ var_list = ", ".join(repr(m) for m in sorted(missing_variables))
 mlog.warning(
 f"The variable(s) {var_list} in the input file '{inputs0}' are not "
 "present in the given configuration data.", location=node)
@@ -2259,9 +2548,9 @@
 'copy a file to the build dir, use the \'copy:\' keyword '
 'argument added in 0.47.0', location=node)
 else:
- mesonlib.dump_conf_header(ofile_abs, conf.conf_data, output_format)
- conf.mark_used()
- elif 'command' in kwargs:
+ mesonlib.dump_conf_header(ofile_abs, conf, output_format)
+ conf.used = True
+ elif kwargs'command' is not None:
 if len(inputs) > 1:
 FeatureNew.single_use('multiple inputs in configure_file()', '0.52.0', self.subproject, location=node)
 # We use absolute paths for input and output here because the cwd
@@ -2274,13 +2563,13 @@
 # Substitute @INPUT@, @OUTPUT@, etc here.
 _cmd = mesonlib.substitute_values(kwargs'command', values)
 mlog.log('Configuring', mlog.bold(output), 'with command')
- cmd, *args = mesonlib.listify(_cmd)
+ cmd, *args = _cmd
 res = self.run_command_impl(node, (cmd, args),
 {'capture': True, 'check': True, 'env': build.EnvironmentVariables()},
- True)
- if 'capture' in kwargs and kwargs'capture':
+ True)
+ if kwargs'capture':
 dst_tmp = ofile_abs + '~'
- file_encoding = kwargs.setdefault('encoding', 'utf-8')
+ file_encoding = kwargs'encoding'
 with open(dst_tmp, 'w', encoding=file_encoding) as f:
 f.writelines(res.stdout)
 if inputs_abs:
@@ -2294,48 +2583,43 @@
 for dep in deps:
 self.add_build_def_file(dep)
 
- elif 'copy' in kwargs:
+ elif kwargs'copy':
 if len(inputs_abs) != 1:
 raise InterpreterException('Exactly one input file must be given in copy mode')
 os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True)
 shutil.copy2(inputs_abs0, ofile_abs)
- else:
- # Not reachable
- raise AssertionError
+
 # Install file if requested, we check for the empty string
 # for backwards compatibility. That was the behaviour before
 # 0.45.0 so preserve it.
- idir = kwargs.get('install_dir', '')
+ idir = kwargs'install_dir'
 if idir is False:
 idir = ''
 FeatureDeprecated.single_use('configure_file install_dir: false', '0.50.0',
 self.subproject, 'Use the `install:` kwarg instead', location=node)
- if not isinstance(idir, str):
- if isinstance(idir, list) and len(idir) == 0:
- mlog.deprecation('install_dir: kwarg must be a string and not an empty array. '
- 'Please use the install: kwarg to enable or disable installation. '
- 'This will be a hard error in the next release.')
- else:
- raise InterpreterException('"install_dir" must be a string')
- install = kwargs.get('install', idir != '')
- if not isinstance(install, bool):
- raise InterpreterException('"install" must be a boolean')
+ install = kwargs'install' if kwargs'install' is not None else idir != ''
 if install:
 if not idir:
- raise InterpreterException('"install_dir" must be specified '
- 'when "install" in a configure_file '
- 'is true')
+ raise InterpreterException(
+ '"install_dir" must be specified when "install" in a configure_file is true')
+ idir_name = idir
+ if isinstance(idir_name, P_OBJ.OptionString):
+ idir_name = idir_name.optname
 cfile = mesonlib.File.from_built_file(ofile_path, ofile_fname)
- install_mode = self._get_kwarg_install_mode(kwargs)
- install_tag = kwargs.get('install_tag')
- if install_tag is not None and not isinstance(install_tag, str):
- raise InvalidArguments('install_tag keyword argument must be string')
- self.build.data.append(build.Data(cfile, idir, idir, install_mode, self.subproject,
+ install_tag = kwargs'install_tag'
+ self.build.data.append(build.Data(cfile, idir, idir_name, install_mode, self.subproject,
 install_tag=install_tag, data_type='configure'))
 return mesonlib.File.from_built_file(self.subdir, output)
 
- def extract_incdirs(self, kwargs):
- prospectives = extract_as_list(kwargs, 'include_directories')
+ def extract_incdirs(self, kwargs, key: str = 'include_directories'):
+ prospectives = extract_as_list(kwargs, key)
+ if key == 'include_directories':
+ for i in prospectives:
+ if isinstance(i, str):
+ FeatureNew.single_use('include_directories kwarg of type string', '0.50.0', self.subproject,
+ f'Use include_directories({i!r}) instead', location=self.current_node)
+ break
+
 result = 
 for p in prospectives:
 if isinstance(p, build.IncludeDirs):
@@ -2349,7 +2633,7 @@
 @typed_pos_args('include_directories', varargs=str)
 @typed_kwargs('include_directories', KwargInfo('is_system', bool, default=False))
 def func_include_directories(self, node: mparser.BaseNode, args: T.TupleT.Liststr,
- kwargs: 'kwargs.FuncIncludeDirectories') -> build.IncludeDirs:
+ kwargs: 'kwtypes.FuncIncludeDirectories') -> build.IncludeDirs:
 return self.build_incdir_object(args0, kwargs'is_system')
 
 def build_incdir_object(self, incdir_strings: T.Liststr, is_system: bool = False) -> build.IncludeDirs:
@@ -2363,8 +2647,9 @@
 for a in incdir_strings:
 if a.startswith(src_root):
 raise InvalidArguments(textwrap.dedent('''\
- Tried to form an absolute path to a source dir.
- You should not do that but use relative paths instead.
+ Tried to form an absolute path to a dir in the source tree.
+ You should not do that but use relative paths instead, for
+ directories that are part of your project.
 
 To get include path to any directory relative to the current dir do
 
@@ -2379,14 +2664,18 @@
 put in the include directories by default so you only need to do
 include_directories('.') if you intend to use the result in a
 different subdirectory.
+
+ Note that this error message can also be triggered by
+ external dependencies being installed within your source
+ tree - it's not recommended to do this.
 '''))
 else:
 try:
 self.validate_within_subproject(self.subdir, a)
 except InterpreterException:
- mlog.warning('include_directories sandbox violation!')
+ mlog.warning('include_directories sandbox violation!', location=self.current_node)
 print(textwrap.dedent(f'''\
- The project is trying to access the directory {a} which belongs to a different
+ The project is trying to access the directory {a!r} which belongs to a different
 subproject. This is a problem as it hardcodes the relative paths of these two projects.
 This makes it impossible to compile the project in any other directory layout and also
 prevents the subproject from changing its own directory layout.
@@ -2424,7 +2713,7 @@
 KwargInfo('is_default', bool, default=False, since='0.49.0'),
 ENV_KW,
 )
- def func_add_test_setup(self, node: mparser.BaseNode, args: T.Tuplestr, kwargs: 'kwargs.AddTestSetup') -> None:
+ def func_add_test_setup(self, node: mparser.BaseNode, args: T.Tuplestr, kwargs: 'kwtypes.AddTestSetup') -> None:
 setup_name = args0
 if re.fullmatch('(_a-zA-Z_0-9a-zA-Z*:)?_a-zA-Z_0-9a-zA-Z*', setup_name) is None:
 raise InterpreterException('Setup name may only contain alphanumeric characters.')
@@ -2454,24 +2743,45 @@
 
 @typed_pos_args('add_global_arguments', varargs=str)
 @typed_kwargs('add_global_arguments', NATIVE_KW, LANGUAGE_KW)
- def func_add_global_arguments(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ def func_add_global_arguments(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
 self._add_global_arguments(node, self.build.global_argskwargs'native', args0, kwargs)
 
 @typed_pos_args('add_global_link_arguments', varargs=str)
 @typed_kwargs('add_global_arguments', NATIVE_KW, LANGUAGE_KW)
- def func_add_global_link_arguments(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ def func_add_global_link_arguments(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
 self._add_global_arguments(node, self.build.global_link_argskwargs'native', args0, kwargs)
 
 @typed_pos_args('add_project_arguments', varargs=str)
 @typed_kwargs('add_project_arguments', NATIVE_KW, LANGUAGE_KW)
- def func_add_project_arguments(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ def func_add_project_arguments(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
 self._add_project_arguments(node, self.build.projects_argskwargs'native', args0, kwargs)
 
 @typed_pos_args('add_project_link_arguments', varargs=str)
 @typed_kwargs('add_global_arguments', NATIVE_KW, LANGUAGE_KW)
- def func_add_project_link_arguments(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ def func_add_project_link_arguments(self, node: mparser.FunctionNode, args: T.TupleT.Liststr, kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
 self._add_project_arguments(node, self.build.projects_link_argskwargs'native', args0, kwargs)
 
+ @FeatureNew('add_project_dependencies', '0.63.0')
+ @typed_pos_args('add_project_dependencies', varargs=dependencies.Dependency)
+ @typed_kwargs('add_project_dependencies', NATIVE_KW, LANGUAGE_KW)
+ def func_add_project_dependencies(self, node: mparser.FunctionNode, args: T.TupleT.Listdependencies.Dependency, kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
+ for_machine = kwargs'native'
+ for lang in kwargs'language':
+ if lang not in self.compilersfor_machine:
+ raise InvalidCode(f'add_project_dependencies() called before add_language() for language "{lang}"')
+
+ for d in dependencies.get_leaf_external_dependencies(args0):
+ compile_args = list(d.get_compile_args())
+ system_incdir = d.get_include_type() == 'system'
+ for i in d.get_include_dirs():
+ for lang in kwargs'language':
+ comp = self.coredata.compilersfor_machinelang
+ for idir in i.to_string_list(self.environment.get_source_dir(), self.environment.get_build_dir()):
+ compile_args.extend(comp.get_include_args(idir, system_incdir))
+
+ self._add_project_arguments(node, self.build.projects_argsfor_machine, compile_args, kwargs)
+ self._add_project_arguments(node, self.build.projects_link_argsfor_machine, d.get_link_args(), kwargs)
+
 def _warn_about_builtin_args(self, args: T.Liststr) -> None:
 # -Wpedantic is deliberately not included, since some people want to use it but not use -Wextra
 # see e.g.
@@ -2500,7 +2810,7 @@
 location=self.current_node)
 
 def _add_global_arguments(self, node: mparser.FunctionNode, argsdict: T.Dictstr, T.Liststr,
- args: T.Liststr, kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ args: T.Liststr, kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
 if self.is_subproject():
 msg = f'Function \'{node.func_name}\' cannot be used in subprojects because ' \
 'there is no way to make that reliable.\nPlease only call ' \
@@ -2513,14 +2823,14 @@
 self._add_arguments(node, argsdict, frozen, args, kwargs)
 
 def _add_project_arguments(self, node: mparser.FunctionNode, argsdict: T.Dictstr, T.Dictstr, T.Liststr,
- args: T.Liststr, kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ args: T.Liststr, kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
 if self.subproject not in argsdict:
 argsdictself.subproject = {}
 self._add_arguments(node, argsdictself.subproject,
 self.project_args_frozen, args, kwargs)
 
 def _add_arguments(self, node: mparser.FunctionNode, argsdict: T.Dictstr, T.Liststr,
- args_frozen: bool, args: T.Liststr, kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ args_frozen: bool, args: T.Liststr, kwargs: 'kwtypes.FuncAddProjectArgs') -> None:
 if args_frozen:
 msg = f'Tried to use \'{node.func_name}\' after a build target has been declared.\n' \
 'This is not permitted. Please declare all arguments before your targets.'
@@ -2531,9 +2841,9 @@
 for lang in kwargs'language':
 argsdictlang = argsdict.get(lang, ) + args
 
- @noKwargs
 @noArgsFlattening
 @typed_pos_args('environment', optargs=(str, list, dict))
+ @typed_kwargs('environment', ENV_METHOD_KW, ENV_SEPARATOR_KW.evolve(since='0.62.0'))
 def func_environment(self, node: mparser.FunctionNode, args: T.TupleT.UnionNone, str, T.List'TYPE_var', T.Dictstr, 'TYPE_var',
 kwargs: 'TYPE_kwargs') -> build.EnvironmentVariables:
 init = args0
@@ -2542,13 +2852,24 @@
 msg = ENV_KW.validator(init)
 if msg:
 raise InvalidArguments(f'"environment": {msg}')
- return ENV_KW.convertor(init)
+ if isinstance(init, dict) and any(i for i in init.values() if isinstance(i, list)):
+ FeatureNew.single_use('List of string in dictionary value', '0.62.0', self.subproject, location=node)
+ return env_convertor_with_method(init, kwargs'method', kwargs'separator')
 return build.EnvironmentVariables()
 
 @typed_pos_args('join_paths', varargs=str, min_varargs=1)
 @noKwargs
 def func_join_paths(self, node: mparser.BaseNode, args: T.TupleT.Liststr, kwargs: 'TYPE_kwargs') -> str:
- return os.path.join(*args0).replace('\\', '/')
+ parts = args0
+ other = os.path.join('', *parts1:).replace('\\', '/')
+ ret = os.path.join(*parts).replace('\\', '/')
+ if isinstance(parts0, P_OBJ.DependencyVariableString) and '..' not in other:
+ return P_OBJ.DependencyVariableString(ret)
+ elif isinstance(parts0, P_OBJ.OptionString):
+ name = os.path.join(parts0.optname, other)
+ return P_OBJ.OptionString(ret, name)
+ else:
+ return ret
 
 def run(self) -> None:
 super().run()
@@ -2557,7 +2878,6 @@
 FeatureDeprecated.report(self.subproject)
 if not self.is_subproject():
 self.print_extra_warnings()
- if self.subproject == '':
 self._print_summary()
 
 def print_extra_warnings(self) -> None:
@@ -2591,11 +2911,33 @@
 # declare_dependency).
 def validate_within_subproject(self, subdir, fname):
 srcdir = Path(self.environment.source_dir)
+ builddir = Path(self.environment.build_dir)
+ if isinstance(fname, P_OBJ.DependencyVariableString):
+ def validate_installable_file(fpath: Path) -> bool:
+ installablefiles: T.SetPath = set()
+ for d in self.build.data:
+ for s in d.sources:
+ installablefiles.add(Path(s.absolute_path(srcdir, builddir)))
+ installabledirs = str(Path(srcdir, s.source_subdir)) for s in self.build.install_dirs
+ if fpath in installablefiles:
+ return True
+ for d in installabledirs:
+ if str(fpath).startswith(d):
+ return True
+ return False
+
+ norm = Path(fname)
+ # variables built from a dep.get_variable are allowed to refer to
+ # subproject files, as long as they are scheduled to be installed.
+ if validate_installable_file(norm):
+ return
 norm = Path(os.path.abspath(Path(srcdir, subdir, fname)))
 if os.path.isdir(norm):
 inputtype = 'directory'
 else:
 inputtype = 'file'
+ if InterpreterRuleRelaxation.ALLOW_BUILD_DIR_FILE_REFFERENCES in self.relaxations and builddir in norm.parents:
+ return
 if srcdir not in norm.parents:
 # Grabbing files outside the source tree is ok.
 # This is for vendor stuff like:
@@ -2603,11 +2945,12 @@
 # /opt/vendorsdk/src/file_with_license_restrictions.c
 return
 project_root = Path(srcdir, self.root_subdir)
+ subproject_dir = project_root / self.subproject_dir
 if norm == project_root:
 return
 if project_root not in norm.parents:
 raise InterpreterException(f'Sandbox violation: Tried to grab {inputtype} {norm.name} outside current (sub)project.')
- if project_root / self.subproject_dir in norm.parents:
+ if subproject_dir == norm or subproject_dir in norm.parents:
 raise InterpreterException(f'Sandbox violation: Tried to grab {inputtype} {norm.name} from a nested subproject.')
 
 @T.overload
@@ -2617,6 +2960,9 @@
 def source_strings_to_files(self, sources: T.List'mesonlib.FileOrString', strict: bool = False) -> T.List'mesonlib.FileOrString': ... # noqa: F811
 
 @T.overload
+ def source_strings_to_files(self, sources: T.Listmesonlib.FileOrString, build.GeneratedTypes) -> T.ListT.Unionmesonlib.File, build.GeneratedTypes: ... # noqa: F811
+
+ @T.overload
 def source_strings_to_files(self, sources: T.List'SourceInputs', strict: bool = True) -> T.List'SourceOutputs': ... # noqa: F811
 
 def source_strings_to_files(self, sources: T.List'SourceInputs', strict: bool = True) -> T.List'SourceOutputs': # noqa: F811
@@ -2644,14 +2990,26 @@
 results.append(s)
 elif isinstance(s, (build.GeneratedList, build.BuildTarget,
 build.CustomTargetIndex, build.CustomTarget,
- build.ExtractedObjects)):
+ build.ExtractedObjects, build.StructuredSources)):
 results.append(s)
 else:
 raise InterpreterException(f'Source item is {s!r} instead of '
 'string or File-type object')
 return results
 
- def add_target(self, name, tobj):
+ @staticmethod
+ def validate_forbidden_targets(name: str) -> None:
+ if name.startswith('meson-internal__'):
+ raise InvalidArguments("Target names starting with 'meson-internal__' are reserved "
+ "for Meson's internal use. Please rename.")
+ if name.startswith('meson-') and '.' not in name:
+ raise InvalidArguments("Target names starting with 'meson-' and without a file extension "
+ "are reserved for Meson's internal use. Please rename.")
+ if name in coredata.FORBIDDEN_TARGET_NAMES:
+ raise InvalidArguments(f"Target name '{name}' is reserved for Meson's "
+ "internal use. Please rename.")
+
+ def add_target(self, name: str, tobj: build.Target) -> None:
 if name == '':
 raise InterpreterException('Target name must not be empty.')
 if name.strip() == '':
@@ -2664,17 +3022,19 @@
 To define a target that builds in that directory you must define it
 in the meson.build file in that directory.
 '''))
- if name.startswith('meson-'):
- raise InvalidArguments("Target names starting with 'meson-' are reserved "
- "for Meson's internal use. Please rename.")
- if name in coredata.FORBIDDEN_TARGET_NAMES:
- raise InvalidArguments(f"Target name '{name}' is reserved for Meson's "
- "internal use. Please rename.")
+ self.validate_forbidden_targets(name)
 # To permit an executable and a shared library to have the
 # same name, such as "foo.exe" and "libfoo.a".
 idname = tobj.get_id()
 if idname in self.build.targets:
 raise InvalidCode(f'Tried to create target "{name}", but a target of that name already exists.')
+
+ if isinstance(tobj, build.BuildTarget):
+ missing_languages = tobj.process_compilers()
+ self.add_languages(missing_languages, True, tobj.for_machine)
+ tobj.process_compilers_late(missing_languages)
+ self.add_stdlib_info(tobj)
+
 self.build.targetsidname = tobj
 if idname not in self.coredata.target_guids:
 self.coredata.target_guidsidname = str(uuid.uuid4()).upper()
@@ -2682,6 +3042,7 @@
 @FeatureNew('both_libraries', '0.46.0')
 def build_both_libraries(self, node, args, kwargs):
 shared_lib = self.build_target(node, args, kwargs, build.SharedLibrary)
+ static_lib = self.build_target(node, args, kwargs, build.StaticLibrary)
 
 # Check if user forces non-PIC static library.
 pic = True
@@ -2703,16 +3064,16 @@
 reuse_object_files = pic
 
 if reuse_object_files:
- # Exclude sources from args and kwargs to avoid building them twice
- static_args = args0
- static_kwargs = kwargs.copy()
- static_kwargs'sources' = 
- static_kwargs'objects' = shared_lib.extract_all_objects()
- else:
- static_args = args
- static_kwargs = kwargs
-
- static_lib = self.build_target(node, static_args, static_kwargs, build.StaticLibrary)
+ # Replace sources with objects from the shared library to avoid
+ # building them twice. We post-process the static library instead of
+ # removing sources from args because sources could also come from
+ # any InternalDependency, see BuildTarget.add_deps().
+ static_lib.objects.append(build.ExtractedObjects(shared_lib, shared_lib.sources, shared_lib.generated, ))
+ static_lib.sources = 
+ static_lib.generated = 
+ # Compilers with no corresponding sources confuses the backend.
+ # Keep only compilers used for linking
+ static_lib.compilers = {k: v for k, v in static_lib.compilers.items() if k in compilers.clink_langs}
 
 return build.BothLibraries(shared_lib, static_lib)
 
@@ -2727,10 +3088,10 @@
 else:
 raise InterpreterException(f'Unknown default_library value: {default_library}.')
 
- def build_target(self, node, args, kwargs, targetclass):
+ def build_target(self, node: mparser.BaseNode, args, kwargs, targetclass):
 @FeatureNewKwargs('build target', '0.42.0', 'rust_crate_type', 'build_rpath', 'implicit_include_directories')
 @FeatureNewKwargs('build target', '0.41.0', 'rust_args')
- @FeatureNewKwargs('build target', '0.40.0', 'build_by_default')
+ @FeatureNewKwargs('build target', '0.38.0', 'build_by_default')
 @FeatureNewKwargs('build target', '0.48.0', 'gnu_symbol_visibility')
 def build_target_decorator_caller(self, node, args, kwargs):
 return True
@@ -2760,11 +3121,42 @@
 # passed to library() when default_library == 'static'.
 kwargs = {k: v for k, v in kwargs.items() if k in targetclass.known_kwargs}
 
+ srcs: T.List'SourceInputs' = 
+ struct: T.Optionalbuild.StructuredSources = build.StructuredSources()
+ for s in sources:
+ if isinstance(s, build.StructuredSources):
+ struct = struct + s
+ else:
+ srcs.append(s)
+
+ if not struct:
+ struct = None
+ else:
+ # Validate that we won't end up with two outputs with the same name.
+ # i.e, don't allow:
+ # structured_sources('foo/bar.rs'), structured_sources('bar/bar.rs')
+ for v in struct.sources.values():
+ outputs: T.Setstr = set()
+ for f in v:
+ o: T.Liststr
+ if isinstance(f, str):
+ o = os.path.basename(f)
+ elif isinstance(f, mesonlib.File):
+ o = f.fname
+ else:
+ o = f.get_outputs()
+ conflicts = outputs.intersection(o)
+ if conflicts:
+ raise InvalidArguments.from_node(
+ f"Conflicting sources in structured sources: {', '.join(sorted(conflicts))}",
+ node=node)
+ outputs.update(o)
+
 kwargs'include_directories' = self.extract_incdirs(kwargs)
- target = targetclass(name, self.subdir, self.subproject, for_machine, sources, objs, self.environment, kwargs)
+ target = targetclass(name, self.subdir, self.subproject, for_machine, srcs, struct, objs,
+ self.environment, self.compilersfor_machine, kwargs)
 target.project_version = self.project_version
 
- self.add_stdlib_info(target)
 self.add_target(name, target)
 self.project_args_frozen = True
 return target
@@ -2786,17 +3178,8 @@
 cleaned_items.append(i)
 kwargs'd_import_dirs' = cleaned_items
 
- def get_used_languages(self, target):
- result = set()
- for i in target.sources:
- for lang, c in self.coredata.compilerstarget.for_machine.items():
- if c.can_compile(i):
- result.add(lang)
- break
- return result
-
 def add_stdlib_info(self, target):
- for l in self.get_used_languages(target):
+ for l in target.compilers.keys():
 dep = self.build.stdlibstarget.for_machine.get(l, None)
 if dep:
 target.add_deps(dep)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/interpreterobjects.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/interpreterobjects.py Changed

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import shlex
 import subprocess
@@ -15,22 +16,24 @@
 from ..backend.backends import TestProtocol
 from ..interpreterbase import (
 ContainerTypeInfo, KwargInfo, MesonOperator,
- InterpreterObject, MesonInterpreterObject, ObjectHolder, MutableInterpreterObject,
- FeatureCheckBase, FeatureNewKwargs, FeatureNew, FeatureDeprecated,
- typed_pos_args, typed_kwargs, typed_operator, permittedKwargs,
- noArgsFlattening, noPosargs, noKwargs, unholder_return, TYPE_var, TYPE_kwargs, TYPE_nvar, TYPE_nkwargs,
+ MesonInterpreterObject, ObjectHolder, MutableInterpreterObject,
+ FeatureNew, FeatureDeprecated,
+ typed_pos_args, typed_kwargs, typed_operator,
+ noArgsFlattening, noPosargs, noKwargs, unholder_return,
 flatten, resolve_second_level_holders, InterpreterException, InvalidArguments, InvalidCode)
-from ..interpreter.type_checking import NoneType
+from ..interpreter.type_checking import NoneType, ENV_SEPARATOR_KW
 from ..dependencies import Dependency, ExternalLibrary, InternalDependency
 from ..programs import ExternalProgram
-from ..mesonlib import HoldableObject, MesonException, OptionKey, listify, Popen_safe
+from ..mesonlib import HoldableObject, OptionKey, listify, Popen_safe
 
 import typing as T
 
 if T.TYPE_CHECKING:
 from . import kwargs
- from .interpreter import Interpreter
+ from ..cmake.interpreter import CMakeInterpreter
 from ..envconfig import MachineInfo
+ from ..interpreterbase import FeatureCheckBase, InterpreterObject, SubProject, TYPE_var, TYPE_kwargs, TYPE_nvar, TYPE_nkwargs
+ from .interpreter import Interpreter
 
 from typing_extensions import TypedDict
 
@@ -40,7 +43,7 @@
 
 
 def extract_required_kwarg(kwargs: 'kwargs.ExtractRequired',
- subproject: str,
+ subproject: 'SubProject',
 feature_check: T.OptionalFeatureCheckBase = None,
 default: bool = True) -> T.Tuplebool, bool, T.Optionalstr:
 val = kwargs.get('required', default)
@@ -78,14 +81,14 @@
 continue
 if not d.is_absolute():
 raise InvalidCode(f'Search directory {d} is not an absolute path.')
- return list(map(str, search_dirs))
+ return str(s) for s in search_dirs
 
 class FeatureOptionHolder(ObjectHoldercoredata.UserFeatureOption):
 def __init__(self, option: coredata.UserFeatureOption, interpreter: 'Interpreter'):
 super().__init__(option, interpreter)
 if option and option.is_auto():
- # TODO: we need to case here because options is not a TypedDict
- auto = T.cast(coredata.UserFeatureOption, self.env.coredata.optionsOptionKey('auto_features'))
+ # TODO: we need to cast here because options is not a TypedDict
+ auto = T.cast('coredata.UserFeatureOption', self.env.coredata.optionsOptionKey('auto_features'))
 self.held_object = copy.copy(auto)
 self.held_object.name = option.name
 self.methods.update({'enabled': self.enabled_method,
@@ -127,33 +130,26 @@
 return self.value == 'auto'
 
 @FeatureNew('feature_option.require()', '0.59.0')
- @permittedKwargs({'error_message'})
- def require_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> coredata.UserFeatureOption:
- if len(args) != 1:
- raise InvalidArguments(f'Expected 1 argument, got {len(args)}.')
- if not isinstance(args0, bool):
- raise InvalidArguments('boolean argument expected.')
- error_message = kwargs.pop('error_message', '')
- if error_message and not isinstance(error_message, str):
- raise InterpreterException("Error message must be a string.")
+ @typed_pos_args('feature_option.require', bool)
+ @typed_kwargs(
+ 'feature_option.require',
+ KwargInfo('error_message', (str, NoneType))
+ )
+ def require_method(self, args: T.Tuplebool, kwargs: 'kwargs.FeatureOptionRequire') -> coredata.UserFeatureOption:
 if args0:
 return copy.deepcopy(self.held_object)
 
- assert isinstance(error_message, str)
 if self.value == 'enabled':
- prefix = f'Feature {self.held_object.name} cannot be enabled'
- if error_message:
- prefix += ': '
- raise InterpreterException(prefix + error_message)
+ err_msg = f'Feature {self.held_object.name} cannot be enabled'
+ if kwargs'error_message':
+ err_msg += f': {kwargs"error_message"}'
+ raise InterpreterException(err_msg)
 return self.as_disabled()
 
 @FeatureNew('feature_option.disable_auto_if()', '0.59.0')
 @noKwargs
- def disable_auto_if_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> coredata.UserFeatureOption:
- if len(args) != 1:
- raise InvalidArguments(f'Expected 1 argument, got {len(args)}.')
- if not isinstance(args0, bool):
- raise InvalidArguments('boolean argument expected.')
+ @typed_pos_args('feature_option.disable_auto_if', bool)
+ def disable_auto_if_method(self, args: T.Tuplebool, kwargs: TYPE_kwargs) -> coredata.UserFeatureOption:
 return copy.deepcopy(self.held_object) if self.value != 'auto' or not args0 else self.as_disabled()
 
 
@@ -204,7 +200,7 @@
 child_env.update(menv)
 child_env = env.get_env(child_env)
 stdout = subprocess.PIPE if self.capture else subprocess.DEVNULL
- mlog.debug('Running command:', ' '.join(command_array))
+ mlog.debug('Running command:', mesonlib.join_args(command_array))
 try:
 p, o, e = Popen_safe(command_array, stdout=stdout, env=child_env, cwd=cwd)
 if self.capture:
@@ -218,11 +214,11 @@
 mlog.debug('')
 
 if check and p.returncode != 0:
- raise InterpreterException('Command "{}" failed with status {}.'.format(' '.join(command_array), p.returncode))
+ raise InterpreterException('Command `{}` failed with status {}.'.format(mesonlib.join_args(command_array), p.returncode))
 
 return p.returncode, o, e
 except FileNotFoundError:
- raise InterpreterException('Could not execute command "%s".' % ' '.join(command_array))
+ raise InterpreterException('Could not execute command `%s`.' % mesonlib.join_args(command_array))
 
 @noPosargs
 @noKwargs
@@ -239,10 +235,6 @@
 def stderr_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> str:
 return self.stderr
 
-
-_ENV_SEPARATOR_KW = KwargInfo('separator', str, default=os.pathsep)
-
-
 class EnvironmentVariablesHolder(ObjectHolderbuild.EnvironmentVariables, MutableInterpreterObject):
 
 def __init__(self, obj: build.EnvironmentVariables, interpreter: 'Interpreter'):
@@ -264,34 +256,36 @@
 # Multiple append/prepend operations was not supported until 0.58.0.
 if self.held_object.has_name(name):
 m = f'Overriding previous value of environment variable {name!r} with a new one'
- FeatureNew(m, '0.58.0', location=self.current_node).use(self.subproject)
+ FeatureNew(m, '0.58.0').use(self.subproject, self.current_node)
 
 @typed_pos_args('environment.set', str, varargs=str, min_varargs=1)
- @typed_kwargs('environment.set', _ENV_SEPARATOR_KW)
+ @typed_kwargs('environment.set', ENV_SEPARATOR_KW)
 def set_method(self, args: T.Tuplestr, T.Liststr, kwargs: 'EnvironmentSeparatorKW') -> None:
 name, values = args
 self.held_object.set(name, values, kwargs'separator')
 
 @typed_pos_args('environment.append', str, varargs=str, min_varargs=1)
- @typed_kwargs('environment.append', _ENV_SEPARATOR_KW)
+ @typed_kwargs('environment.append', ENV_SEPARATOR_KW)
 def append_method(self, args: T.Tuplestr, T.Liststr, kwargs: 'EnvironmentSeparatorKW') -> None:
 name, values = args
 self.warn_if_has_name(name)
 self.held_object.append(name, values, kwargs'separator')
 
 @typed_pos_args('environment.prepend', str, varargs=str, min_varargs=1)
- @typed_kwargs('environment.prepend', _ENV_SEPARATOR_KW)
+ @typed_kwargs('environment.prepend', ENV_SEPARATOR_KW)
 def prepend_method(self, args: T.Tuplestr, T.Liststr, kwargs: 'EnvironmentSeparatorKW') -> None:
 name, values = args
 self.warn_if_has_name(name)
 self.held_object.prepend(name, values, kwargs'separator')
 
 
-class ConfigurationDataObject(MutableInterpreterObject, MesonInterpreterObject):
- def __init__(self, subproject: str, initial_values: T.OptionalT.Dictstr, T.Any = None) -> None:
- self.used = False # These objects become immutable after use in configure_file.
- super().__init__(subproject=subproject)
- self.conf_data = build.ConfigurationData()
+_CONF_DATA_SET_KWS: KwargInfoT.Optionalstr = KwargInfo('description', (str, NoneType))
+
+
+class ConfigurationDataHolder(ObjectHolderbuild.ConfigurationData, MutableInterpreterObject):
+
+ def __init__(self, obj: build.ConfigurationData, interpreter: 'Interpreter'):
+ super().__init__(obj, interpreter)
 self.methods.update({'set': self.set_method,
 'set10': self.set10_method,
 'set_quoted': self.set_quoted_method,
@@ -301,97 +295,73 @@
 'get_unquoted': self.get_unquoted_method,
 'merge_from': self.merge_from_method,
 })
- if isinstance(initial_values, dict):
- for k, v in initial_values.items():
- self.set_method(k, v, {})
- elif initial_values:
- raise AssertionError('Unsupported ConfigurationDataObject initial_values')
+
+ def __deepcopy__(self, memo: T.Dict) -> 'ConfigurationDataHolder':
+ return ConfigurationDataHolder(copy.deepcopy(self.held_object), self.interpreter)
 
 def is_used(self) -> bool:
- return self.used
-
- def mark_used(self) -> None:
- self.used = True
-
- def validate_args(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> T.Tuplestr, T.Unionstr, int, bool, T.Optionalstr:
- if len(args) == 1 and isinstance(args0, list) and len(args0) == 2:
- mlog.deprecation('Passing a list as the single argument to '
- 'configuration_data.set is deprecated. This will '
- 'become a hard error in the future.',
- location=self.current_node)
- args = args0
-
- if len(args) != 2:
- raise InterpreterException("Configuration set requires 2 arguments.")
- if self.used:
- raise InterpreterException("Can not set values on configuration object that has been used.")
- name, val = args
- if not isinstance(val, (int, str)):
- msg = f'Setting a configuration data value to {val!r} is invalid, ' \
- 'and will fail at configure_file(). If you are using it ' \
- 'just to store some values, please use a dict instead.'
- mlog.deprecation(msg, location=self.current_node)
- desc = kwargs.get('description', None)
- if not isinstance(name, str):
- raise InterpreterException("First argument to set must be a string.")
- if desc is not None and not isinstance(desc, str):
- raise InterpreterException('Description must be a string.')
-
- # TODO: Remove the cast once we get rid of the deprecation
- return name, T.cast(T.Unionstr, bool, int, val), desc
+ return self.held_object.used
 
- @noArgsFlattening
- def set_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> None:
- (name, val, desc) = self.validate_args(args, kwargs)
- self.conf_data.valuesname = (val, desc)
-
- def set_quoted_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> None:
- (name, val, desc) = self.validate_args(args, kwargs)
- if not isinstance(val, str):
- raise InterpreterException("Second argument to set_quoted must be a string.")
- escaped_val = '\\"'.join(val.split('"'))
- self.conf_data.valuesname = ('"' + escaped_val + '"', desc)
-
- def set10_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> None:
- (name, val, desc) = self.validate_args(args, kwargs)
- if val:
- self.conf_data.valuesname = (1, desc)
- else:
- self.conf_data.valuesname = (0, desc)
+ def __check_used(self) -> None:
+ if self.is_used():
+ raise InterpreterException("Can not set values on configuration object that has been used.")
 
- def has_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> bool:
- return args0 in self.conf_data.values
+ @typed_pos_args('configuration_data.set', str, (str, int, bool))
+ @typed_kwargs('configuration_data.set', _CONF_DATA_SET_KWS)
+ def set_method(self, args: T.Tuplestr, T.Unionstr, int, bool, kwargs: 'kwargs.ConfigurationDataSet') -> None:
+ self.__check_used()
+ self.held_object.valuesargs0 = (args1, kwargs'description')
+
+ @typed_pos_args('configuration_data.set_quoted', str, str)
+ @typed_kwargs('configuration_data.set_quoted', _CONF_DATA_SET_KWS)
+ def set_quoted_method(self, args: T.Tuplestr, str, kwargs: 'kwargs.ConfigurationDataSet') -> None:
+ self.__check_used()
+ escaped_val = '\\"'.join(args1.split('"'))
+ self.held_object.valuesargs0 = (f'"{escaped_val}"', kwargs'description')
+
+ @typed_pos_args('configuration_data.set10', str, (int, bool))
+ @typed_kwargs('configuration_data.set10', _CONF_DATA_SET_KWS)
+ def set10_method(self, args: T.Tuplestr, T.Unionint, bool, kwargs: 'kwargs.ConfigurationDataSet') -> None:
+ self.__check_used()
+ # bool is a subclass of int, so we need to check for bool explicitly.
+ # We already have typed_pos_args checking that this is either a bool or
+ # an int.
+ if not isinstance(args1, bool):
+ mlog.deprecation('configuration_data.set10 with number. the `set10` '
+ 'method should only be used with booleans',
+ location=self.interpreter.current_node)
+ if args1 < 0:
+ mlog.warning('Passing a number that is less than 0 may not have the intended result, '
+ 'as meson will treat all non-zero values as true.',
+ location=self.interpreter.current_node)
+ self.held_object.valuesargs0 = (int(args1), kwargs'description')
+
+ @typed_pos_args('configuration_data.has', (str, int, bool))
+ @noKwargs
+ def has_method(self, args: T.TupleT.Unionstr, int, bool, kwargs: TYPE_kwargs) -> bool:
+ return args0 in self.held_object.values
 
 @FeatureNew('configuration_data.get()', '0.38.0')
- @noArgsFlattening
- def get_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> T.Unionstr, int, bool:
- if len(args) < 1 or len(args) > 2:
- raise InterpreterException('Get method takes one or two arguments.')
- if not isinstance(args0, str):
- raise InterpreterException('The variable name must be a string.')
+ @typed_pos_args('configuration_data.get', str, optargs=(str, int, bool))
+ @noKwargs
+ def get_method(self, args: T.Tuplestr, T.OptionalT.Unionstr, int, bool,
+ kwargs: TYPE_kwargs) -> T.Unionstr, int, bool:
 name = args0
- if name in self.conf_data:
- return self.conf_data.get(name)0
- if len(args) > 1:
- # Assertion does not work because setting other values is still
- # supported, but deprecated. Use T.cast in the meantime (even though
- # this is a lie).
- # TODO: Fix this once the deprecation is removed
- # assert isinstance(args1, (int, str, bool))
- return T.cast(T.Unionstr, int, bool, args1)
+ if name in self.held_object:
+ return self.held_object.get(name)0
+ elif args1 is not None:
+ return args1
 raise InterpreterException(f'Entry {name} not in configuration data.')
 
 @FeatureNew('configuration_data.get_unquoted()', '0.44.0')
- def get_unquoted_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> T.Unionstr, int, bool:
- if len(args) < 1 or len(args) > 2:
- raise InterpreterException('Get method takes one or two arguments.')
- if not isinstance(args0, str):
- raise InterpreterException('The variable name must be a string.')
+ @typed_pos_args('configuration_data.get_unquoted', str, optargs=(str, int, bool))
+ @noKwargs
+ def get_unquoted_method(self, args: T.Tuplestr, T.OptionalT.Unionstr, int, bool,
+ kwargs: TYPE_kwargs) -> T.Unionstr, int, bool:
 name = args0
- if name in self.conf_data:
- val = self.conf_data.get(name)0
- elif len(args) > 1:
- assert isinstance(args1, (str, int, bool))
+ if name in self.held_object:
+ val = self.held_object.get(name)0
+ elif args1 is not None:
 val = args1
 else:
 raise InterpreterException(f'Entry {name} not in configuration data.')
@@ -400,25 +370,22 @@
 return val
 
 def get(self, name: str) -> T.TupleT.Unionstr, int, bool, T.Optionalstr:
- return self.conf_data.valuesname
+ return self.held_object.valuesname
 
 @FeatureNew('configuration_data.keys()', '0.57.0')
 @noPosargs
+ @noKwargs
 def keys_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> T.Liststr:
 return sorted(self.keys())
 
 def keys(self) -> T.Liststr:
- return list(self.conf_data.values.keys())
+ return list(self.held_object.values.keys())
 
- def merge_from_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> None:
- if len(args) != 1:
- raise InterpreterException('Merge_from takes one positional argument.')
- from_object_holder = args0
- if not isinstance(from_object_holder, ConfigurationDataObject):
- raise InterpreterException('Merge_from argument must be a configuration data object.')
- from_object = from_object_holder.conf_data
- for k, v in from_object.values.items():
- self.conf_data.valuesk = v
+ @typed_pos_args('configuration_data.merge_from', build.ConfigurationData)
+ @noKwargs
+ def merge_from_method(self, args: T.Tuplebuild.ConfigurationData, kwargs: TYPE_kwargs) -> None:
+ from_object = args0
+ self.held_object.values.update(from_object.values)
 
 
 _PARTIAL_DEP_KWARGS = 
@@ -470,71 +437,75 @@
 def name_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> str:
 return self.held_object.get_name()
 
- @FeatureDeprecated('Dependency.get_pkgconfig_variable', '0.56.0',
- 'use Dependency.get_variable(pkgconfig : ...) instead')
- @permittedKwargs({'define_variable', 'default'})
- def pkgconfig_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> str:
- args = listify(args)
- if len(args) != 1:
- raise InterpreterException('get_pkgconfig_variable takes exactly one argument.')
- varname = args0
- if not isinstance(varname, str):
- raise InterpreterException('Variable name must be a string.')
- return self.held_object.get_pkgconfig_variable(varname, kwargs)
+ @FeatureDeprecated('dependency.get_pkgconfig_variable', '0.56.0',
+ 'use dependency.get_variable(pkgconfig : ...) instead')
+ @typed_pos_args('dependency.get_pkgconfig_variable', str)
+ @typed_kwargs(
+ 'dependency.get_pkgconfig_variable',
+ KwargInfo('default', (str, NoneType)),
+ KwargInfo(
+ 'define_variable',
+ ContainerTypeInfo(list, str, pairs=True),
+ default=,
+ listify=True,
+ validator=lambda x: 'must be of length 2 or empty' if len(x) not in {0, 2} else None,
+ ),
+ )
+ def pkgconfig_method(self, args: T.Tuplestr, kwargs: 'kwargs.DependencyPkgConfigVar') -> str:
+ return self.held_object.get_pkgconfig_variable(args0, **kwargs)
 
- @FeatureNew('dep.get_configtool_variable', '0.44.0')
- @FeatureDeprecated('Dependency.get_configtool_variable', '0.56.0',
- 'use Dependency.get_variable(configtool : ...) instead')
+ @FeatureNew('dependency.get_configtool_variable', '0.44.0')
+ @FeatureDeprecated('dependency.get_configtool_variable', '0.56.0',
+ 'use dependency.get_variable(configtool : ...) instead')
 @noKwargs
- def configtool_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> str:
- args = listify(args)
- if len(args) != 1:
- raise InterpreterException('get_configtool_variable takes exactly one argument.')
- varname = args0
- if not isinstance(varname, str):
- raise InterpreterException('Variable name must be a string.')
- return self.held_object.get_configtool_variable(varname)
+ @typed_pos_args('dependency.get_config_tool_variable', str)
+ def configtool_method(self, args: T.Tuplestr, kwargs: TYPE_kwargs) -> str:
+ return self.held_object.get_configtool_variable(args0)
 
- @FeatureNew('dep.partial_dependency', '0.46.0')
+ @FeatureNew('dependency.partial_dependency', '0.46.0')
 @noPosargs
- @typed_kwargs('dep.partial_dependency', *_PARTIAL_DEP_KWARGS)
+ @typed_kwargs('dependency.partial_dependency', *_PARTIAL_DEP_KWARGS)
 def partial_dependency_method(self, args: T.ListTYPE_nvar, kwargs: 'kwargs.DependencyMethodPartialDependency') -> Dependency:
 pdep = self.held_object.get_partial_dependency(**kwargs)
 return pdep
 
- @FeatureNew('dep.get_variable', '0.51.0')
- @typed_pos_args('dep.get_variable', optargs=str)
- @permittedKwargs({'cmake', 'pkgconfig', 'configtool', 'internal', 'default_value', 'pkgconfig_define'})
- @FeatureNewKwargs('dep.get_variable', '0.54.0', 'internal')
- def variable_method(self, args: T.TupleT.Optionalstr, kwargs: T.Dictstr, T.Any) -> T.Unionstr, T.Liststr:
+ @FeatureNew('dependency.get_variable', '0.51.0')
+ @typed_pos_args('dependency.get_variable', optargs=str)
+ @typed_kwargs(
+ 'dependency.get_variable',
+ KwargInfo('cmake', (str, NoneType)),
+ KwargInfo('pkgconfig', (str, NoneType)),
+ KwargInfo('configtool', (str, NoneType)),
+ KwargInfo('internal', (str, NoneType), since='0.54.0'),
+ KwargInfo('default_value', (str, NoneType)),
+ KwargInfo('pkgconfig_define', ContainerTypeInfo(list, str, pairs=True), default=, listify=True),
+ )
+ def variable_method(self, args: T.TupleT.Optionalstr, kwargs: 'kwargs.DependencyGetVariable') -> str:
 default_varname = args0
 if default_varname is not None:
- FeatureNew('Positional argument to dep.get_variable()', '0.58.0', location=self.current_node).use(self.subproject)
- for k in 'cmake', 'pkgconfig', 'configtool', 'internal':
- kwargs.setdefault(k, default_varname)
- return self.held_object.get_variable(**kwargs)
+ FeatureNew('Positional argument to dependency.get_variable()', '0.58.0').use(self.subproject, self.current_node)
+ return self.held_object.get_variable(
+ cmake=kwargs'cmake' or default_varname,
+ pkgconfig=kwargs'pkgconfig' or default_varname,
+ configtool=kwargs'configtool' or default_varname,
+ internal=kwargs'internal' or default_varname,
+ default_value=kwargs'default_value',
+ pkgconfig_define=kwargs'pkgconfig_define',
+ )
 
- @FeatureNew('dep.include_type', '0.52.0')
+ @FeatureNew('dependency.include_type', '0.52.0')
 @noPosargs
 @noKwargs
 def include_type_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> str:
 return self.held_object.get_include_type()
 
- @FeatureNew('dep.as_system', '0.52.0')
- @noKwargs
- def as_system_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> Dependency:
- args = listify(args)
- new_is_system = 'system'
- if len(args) > 1:
- raise InterpreterException('as_system takes only one optional value')
- if len(args) == 1:
- if not isinstance(args0, str):
- raise InterpreterException('as_system takes exactly one string parameter')
- new_is_system = args0
- new_dep = self.held_object.generate_system_dependency(new_is_system)
- return new_dep
+ @FeatureNew('dependency.as_system', '0.52.0')
+ @noKwargs
+ @typed_pos_args('dependency.as_system', optargs=str)
+ def as_system_method(self, args: T.TupleT.Optionalstr, kwargs: TYPE_kwargs) -> Dependency:
+ return self.held_object.generate_system_dependency(args0 or 'system')
 
- @FeatureNew('dep.as_link_whole', '0.56.0')
+ @FeatureNew('dependency.as_link_whole', '0.56.0')
 @noKwargs
 @noPosargs
 def as_link_whole_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> Dependency:
@@ -548,6 +519,7 @@
 super().__init__(ep, interpreter)
 self.methods.update({'found': self.found_method,
 'path': self.path_method,
+ 'version': self.version_method,
 'full_path': self.full_path_method})
 
 @noPosargs
@@ -575,6 +547,17 @@
 assert path is not None
 return path
 
+ @noPosargs
+ @noKwargs
+ @FeatureNew('ExternalProgram.version', '0.62.0')
+ def version_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> str:
+ if not self.found():
+ raise InterpreterException('Unable to get the version of a not-found external program')
+ try:
+ return self.held_object.get_version(self.interpreter)
+ except mesonlib.MesonException:
+ return 'unknown'
+
 def found(self) -> bool:
 return self.held_object.found()
 
@@ -596,9 +579,9 @@
 def found_method(self, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> bool:
 return self.held_object.found()
 
- @FeatureNew('dep.partial_dependency', '0.46.0')
+ @FeatureNew('dependency.partial_dependency', '0.46.0')
 @noPosargs
- @typed_kwargs('dep.partial_dependency', *_PARTIAL_DEP_KWARGS)
+ @typed_kwargs('dependency.partial_dependency', *_PARTIAL_DEP_KWARGS)
 def partial_dependency_method(self, args: T.ListTYPE_nvar, kwargs: 'kwargs.DependencyMethodPartialDependency') -> Dependency:
 pdep = self.held_object.get_partial_dependency(**kwargs)
 return pdep
@@ -668,7 +651,7 @@
 cmd_args: T.ListT.Unionstr, mesonlib.File, build.Target,
 env: build.EnvironmentVariables,
 should_fail: bool, timeout: int, workdir: T.Optionalstr, protocol: str,
- priority: int):
+ priority: int, verbose: bool):
 super().__init__()
 self.name = name
 self.suite = listify(suite)
@@ -683,6 +666,7 @@
 self.workdir = workdir
 self.protocol = TestProtocol.from_str(protocol)
 self.priority = priority
+ self.verbose = verbose
 
 def get_exe(self) -> T.UnionExternalProgram, build.Executable, build.CustomTarget:
 return self.exe
@@ -702,13 +686,14 @@
 subdir: str,
 warnings: int = 0,
 disabled_feature: T.Optionalstr = None,
- exception: T.OptionalMesonException = None) -> None:
+ exception: T.OptionalException = None) -> None:
 super().__init__()
 self.held_object = subinterpreter
 self.warnings = warnings
 self.disabled_feature = disabled_feature
 self.exception = exception
 self.subdir = PurePath(subdir).as_posix()
+ self.cm_interpreter: T.OptionalCMakeInterpreter = None
 self.methods.update({'get_variable': self.get_variable_method,
 'found': self.found_method,
 })
@@ -994,3 +979,9 @@
 preserve_path_from, extra_args=kwargs'extra_args')
 
 return gl
+
+
+class StructuredSourcesHolder(ObjectHolderbuild.StructuredSources):
+
+ def __init__(self, sources: build.StructuredSources, interp: 'Interpreter'):
+ super().__init__(sources, interp)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/kwargs.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/kwargs.py Changed

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright © 2021 The Meson Developers
 # Copyright © 2021 Intel Corporation
+from __future__ import annotations
 
 """Keyword Argument type annotations."""
 
@@ -10,7 +11,9 @@
 
 from .. import build
 from .. import coredata
-from ..mesonlib import MachineChoice, File, FileMode, FileOrString, OptionKey
+from ..compilers import Compiler
+from ..mesonlib import MachineChoice, File, FileMode, FileOrString
+from ..modules.cmake import CMakeSubprojectOptions
 from ..programs import ExternalProgram
 
 
@@ -167,12 +170,12 @@
 class CustomTarget(TypedDict):
 
     build_always: bool
-    build_always_stale: bool
-    build_by_default: bool
+    build_always_stale: T.Optionalbool
+    build_by_default: T.Optionalbool
     capture: bool
     command: T.ListT.Unionstr, build.BuildTarget, build.CustomTarget,
                             build.CustomTargetIndex, ExternalProgram, File
-    consonle: bool
+    console: bool
     depend_files: T.ListFileOrString
     depends: T.ListT.Unionbuild.BuildTarget, build.CustomTarget
     depfile: T.Optionalstr
@@ -181,11 +184,10 @@
     input: T.ListT.Unionstr, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex,
                           build.ExtractedObjects, build.GeneratedList, ExternalProgram, File
     install: bool
-    install_dir: T.ListT.Unionstr, bool
+    install_dir: T.ListT.Unionstr, T.LiteralFalse
     install_mode: FileMode
-    install_tag: T.ListT.Unionstr, bool
+    install_tag: T.ListT.Optionalstr
     output: T.Liststr
-    override_options: T.DictOptionKey, str
 
 class AddTestSetup(TypedDict):
 
@@ -210,7 +212,7 @@
 
     """Protocol for subdir arguments.
 
-    This allows us to define any objec that has a found(self) -> bool method
+    This allows us to define any object that has a found(self) -> bool method
     """
 
     def found(self) -> bool: ...
@@ -239,3 +241,70 @@
     check: bool
     capture: T.Optionalbool
     env: build.EnvironmentVariables
+
+
+class FeatureOptionRequire(TypedDict):
+
+    error_message: T.Optionalstr
+
+
+class DependencyPkgConfigVar(TypedDict):
+
+    default: T.Optionalstr
+    define_variable: T.Liststr
+
+
+class DependencyGetVariable(TypedDict):
+
+    cmake: T.Optionalstr
+    pkgconfig: T.Optionalstr
+    configtool: T.Optionalstr
+    internal: T.Optionalstr
+    default_value: T.Optionalstr
+    pkgconfig_define: T.Liststr
+
+
+class ConfigurationDataSet(TypedDict):
+
+    description: T.Optionalstr
+
+class VcsTag(TypedDict):
+
+    command: T.ListT.Unionstr, build.BuildTarget, build.CustomTarget,
+                            build.CustomTargetIndex, ExternalProgram, File
+    fallback: T.Optionalstr
+    input: T.ListT.Unionstr, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex,
+                          build.ExtractedObjects, build.GeneratedList, ExternalProgram, File
+    output: T.Liststr
+    replace_string: str
+
+
+class ConfigureFile(TypedDict):
+
+    output: str
+    capture: bool
+    format: T.Literal'meson', 'cmake', 'cmake@'
+    output_format: T.Literal'c', 'nasm'
+    depfile: T.Optionalstr
+    install: T.Optionalbool
+    install_dir: T.Unionstr, T.LiteralFalse
+    install_mode: FileMode
+    install_tag: T.Optionalstr
+    encoding: str
+    command: T.OptionalT.ListT.Unionbuild.Executable, ExternalProgram, Compiler, File, str
+    input: T.ListFileOrString
+    configuration: T.OptionalT.UnionT.Dictstr, T.Unionstr, int, bool, build.ConfigurationData
+
+
+class Subproject(ExtractRequired):
+
+    default_options: T.Liststr
+    version: T.Liststr
+
+
+class DoSubproject(ExtractRequired):
+
+    default_options: T.Liststr
+    version: T.Liststr
+    cmake_options: T.Liststr
+    options: T.OptionalCMakeSubprojectOptions

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/mesonmain.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/mesonmain.py Changed

@@ -12,7 +12,7 @@
 
 from ..mesonlib import MachineChoice, OptionKey
 from ..programs import OverrideProgram, ExternalProgram
-from ..interpreter.type_checking import ENV_KW
+from ..interpreter.type_checking import ENV_KW, ENV_METHOD_KW, ENV_SEPARATOR_KW, env_convertor_with_method
 from ..interpreterbase import (MesonInterpreterObject, FeatureNew, FeatureDeprecated,
                                typed_pos_args,  noArgsFlattening, noPosargs, noKwargs,
                                typed_kwargs, KwargInfo, InterpreterException)
@@ -20,6 +20,7 @@
 from .type_checking import NATIVE_KW, NoneType
 
 if T.TYPE_CHECKING:
+    from typing_extensions import Literal
     from ..backend.backends import ExecutableSerialisation
     from ..compilers import Compiler
     from ..interpreterbase import TYPE_kwargs, TYPE_var
@@ -41,6 +42,10 @@
 
         native: mesonlib.MachineChoice
 
+    class AddDevenvKW(TypedDict):
+        method: Literal'set', 'prepend', 'append'
+        separator: str
+
 
 class MesonMain(MesonInterpreterObject):
     def __init__(self, build: 'build.Build', interpreter: 'Interpreter'):
@@ -367,7 +372,7 @@
                                   static: T.Optionalbool, permissive: bool = False) -> None:
         # We need the cast here as get_dep_identifier works on such a dict,
         # which FuncOverrideDependency is, but mypy can't fgure that out
-        nkwargs = T.cast(T.Dictstr, T.Any, kwargs.copy())
+        nkwargs = T.cast('T.Dictstr, T.Any', kwargs.copy())
         if static is None:
             del nkwargs'static'
         else:
@@ -438,13 +443,14 @@
         return prop_name in self.interpreter.environment.propertieskwargs'native'
 
     @FeatureNew('add_devenv', '0.58.0')
-    @noKwargs
+    @typed_kwargs('environment', ENV_METHOD_KW, ENV_SEPARATOR_KW.evolve(since='0.62.0'))
     @typed_pos_args('add_devenv', (str, list, dict, build.EnvironmentVariables))
-    def add_devenv_method(self, args: T.TupleT.Unionstr, list, dict, build.EnvironmentVariables, kwargs: 'TYPE_kwargs') -> None:
+    def add_devenv_method(self, args: T.TupleT.Unionstr, list, dict, build.EnvironmentVariables,
+                          kwargs: 'AddDevenvKW') -> None:
         env = args0
         msg = ENV_KW.validator(env)
         if msg:
             raise build.InvalidArguments(f'"add_devenv": {msg}')
-        converted = ENV_KW.convertor(env)
+        converted = env_convertor_with_method(env, kwargs'method', kwargs'separator')
         assert isinstance(converted, build.EnvironmentVariables)
         self.build.devenv.append(converted)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/primitives/__init__.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/primitives/__init__.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/primitives/array.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/primitives/array.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/primitives/boolean.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/primitives/boolean.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/primitives/dict.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/primitives/dict.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/primitives/integer.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/primitives/integer.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/primitives/range.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/primitives/range.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/primitives/string.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/primitives/string.py Changed

@@ -1,9 +1,9 @@
 # Copyright 2021 The Meson development team
 # SPDX-license-identifier: Apache-2.0
+from __future__ import annotations
 
 import re
 import os
-from pathlib import PurePath
 
 import typing as T
 
@@ -18,9 +18,6 @@
     noPosargs,
     typed_pos_args,
 
-    TYPE_var,
-    TYPE_kwargs,
-
     InvalidArguments,
 )
 
@@ -28,6 +25,7 @@
 if T.TYPE_CHECKING:
     # Object holders need the actual interpreter
     from ...interpreter import Interpreter
+    from ...interpreterbase import TYPE_var, TYPE_kwargs
 
 class StringHolder(ObjectHolderstr):
     def __init__(self, obj: str, interpreter: 'Interpreter') -> None:
@@ -66,6 +64,8 @@
         self.operators.update({
             MesonOperator.DIV: self.op_div,
             MesonOperator.INDEX: self.op_index,
+            MesonOperator.IN: self.op_in,
+            MesonOperator.NOT_IN: self.op_notin,
         })
 
     def display_name(self) -> str:
@@ -128,7 +128,7 @@
     @typed_pos_args('str.substring', optargs=int, int)
     def substring_method(self, args: T.TupleT.Optionalint, T.Optionalint, kwargs: TYPE_kwargs) -> str:
         start = args0 if args0 is not None else 0
-        end   = args1 if args1 is not None else len(self.held_object)
+        end = args1 if args1 is not None else len(self.held_object)
         return self.held_objectstart:end
 
     @noKwargs
@@ -159,10 +159,14 @@
     def version_compare_method(self, args: T.Tuplestr, kwargs: TYPE_kwargs) -> bool:
         return version_compare(self.held_object, args0)
 
+    @staticmethod
+    def _op_div(this: str, other: str) -> str:
+        return os.path.join(this, other).replace('\\', '/')
+
     @FeatureNew('/ with string arguments', '0.49.0')
     @typed_operator(MesonOperator.DIV, str)
     def op_div(self, other: str) -> str:
-        return os.path.join(self.held_object, other).replace('\\', '/')
+        return self._op_div(self.held_object, other)
 
     @typed_operator(MesonOperator.INDEX, int)
     def op_index(self, other: int) -> str:
@@ -171,6 +175,16 @@
         except IndexError:
             raise InvalidArguments(f'Index {other} out of bounds of string of size {len(self.held_object)}.')
 
+    @FeatureNew('"in" string operator', '1.0.0')
+    @typed_operator(MesonOperator.IN, str)
+    def op_in(self, other: str) -> bool:
+        return other in self.held_object
+
+    @FeatureNew('"not in" string operator', '1.0.0')
+    @typed_operator(MesonOperator.NOT_IN, str)
+    def op_notin(self, other: str) -> bool:
+        return other not in self.held_object
+
 
 class MesonVersionString(str):
     pass
@@ -181,3 +195,39 @@
     def version_compare_method(self, args: T.Tuplestr, kwargs: TYPE_kwargs) -> bool:
         self.interpreter.tmp_meson_version = args0
         return version_compare(self.held_object, args0)
+
+# These special subclasses of string exist to cover the case where a dependency
+# exports a string variable interchangeable with a system dependency. This
+# matters because a dependency can only have string-type get_variable() return
+# values. If at any time dependencies start supporting additional variable
+# types, this class could be deprecated.
+class DependencyVariableString(str):
+    pass
+
+class DependencyVariableStringHolder(StringHolder):
+    def op_div(self, other: str) -> T.Unionstr, DependencyVariableString:
+        ret = super().op_div(other)
+        if '..' in other:
+            return ret
+        return DependencyVariableString(ret)
+
+
+class OptionString(str):
+    optname: str
+
+    def __new__(cls, value: str, name: str) -> 'OptionString':
+        obj = str.__new__(cls, value)
+        obj.optname = name
+        return obj
+
+    def __getnewargs__(self) -> T.Tuplestr, str: # type: ignore # because the entire point of this is to diverge
+        return (str(self), self.optname)
+
+
+class OptionStringHolder(StringHolder):
+    held_object: OptionString
+
+    def op_div(self, other: str) -> T.Unionstr, OptionString:
+        ret = super().op_div(other)
+        name = self._op_div(self.held_object.optname, other)
+        return OptionString(ret, name)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreter/type_checking.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreter/type_checking.py Changed

@@ -3,19 +3,34 @@
 
 """Helpers for strict type checking."""
 
+from __future__ import annotations
+import os
 import typing as T
 
 from .. import compilers
-from ..build import EnvironmentVariables, CustomTarget, BuildTarget, CustomTargetIndex, ExtractedObjects, GeneratedList, IncludeDirs
+from ..build import (CustomTarget, BuildTarget,
+                     CustomTargetIndex, ExtractedObjects, GeneratedList, IncludeDirs,
+                     BothLibraries, SharedLibrary, StaticLibrary, Jar, Executable)
 from ..coredata import UserFeatureOption
-from ..interpreterbase import TYPE_var
+from ..dependencies import Dependency, InternalDependency
+from ..interpreterbase import FeatureNew
 from ..interpreterbase.decorators import KwargInfo, ContainerTypeInfo
-from ..mesonlib import File, FileMode, MachineChoice, listify, has_path_sep, OptionKey
+from ..mesonlib import (File, FileMode, MachineChoice, listify, has_path_sep,
+                        OptionKey, EnvironmentVariables)
 from ..programs import ExternalProgram
 
 # Helper definition for type checks that are `OptionalT`
 NoneType: T.TypeNone = type(None)
 
+if T.TYPE_CHECKING:
+    from typing_extensions import Literal
+
+    from ..interpreterbase import TYPE_var
+    from ..interpreterbase.decorators import FeatureCheckBase
+    from ..mesonlib import EnvInitValueType
+
+    _FullEnvInitValueType = T.UnionEnvironmentVariables, T.Liststr, T.ListT.Liststr, EnvInitValueType, str, None
+
 
 def in_set_validator(choices: T.Setstr) -> T.Callablestr, T.Optionalstr:
     """Check that the choice given was one of the given set."""
@@ -101,6 +116,41 @@
     return i.lower() for i in input
 
 
+def variables_validator(contents: T.Unionstr, T.Liststr, T.Dictstr, str) -> T.Optionalstr:
+    if isinstance(contents, str):
+        contents = contents
+    if isinstance(contents, dict):
+        variables = contents
+    else:
+        variables = {}
+        for v in contents:
+            try:
+                key, val = v.split('=', 1)
+            except ValueError:
+                return f'variable {v!r} must have a value separated by equals sign.'
+            variableskey.strip() = val.strip()
+    for k, v in variables.items():
+        if not k:
+            return 'empty variable name'
+        if not v:
+            return 'empty variable value'
+        if any(c.isspace() for c in k):
+            return f'invalid whitespace in variable name {k!r}'
+    return None
+
+
+def variables_convertor(contents: T.Unionstr, T.Liststr, T.Dictstr, str) -> T.Dictstr, str:
+    if isinstance(contents, str):
+        contents = contents
+    if isinstance(contents, dict):
+        return contents
+    variables = {}
+    for v in contents:
+        key, val = v.split('=', 1)
+        variableskey.strip() = val.strip()
+    return variables
+
+
 NATIVE_KW = KwargInfo(
     'native', bool,
     default=False,
@@ -131,7 +181,8 @@
 
 DISABLER_KW: KwargInfobool = KwargInfo('disabler', bool, default=False)
 
-def _env_validator(value: T.UnionEnvironmentVariables, T.List'TYPE_var', T.Dictstr, 'TYPE_var', str, None) -> T.Optionalstr:
+def _env_validator(value: T.UnionEnvironmentVariables, T.List'TYPE_var', T.Dictstr, 'TYPE_var', str, None,
+                   allow_dict_list: bool = True) -> T.Optionalstr:
     def _splitter(v: str) -> T.Optionalstr:
         split = v.split('=', 1)
         if len(split) == 1:
@@ -152,12 +203,18 @@
     elif isinstance(value, dict):
         # We don't need to spilt here, just do the type checking
         for k, dv in value.items():
-            if not isinstance(dv, str):
+            if allow_dict_list:
+                if any(i for i in listify(dv) if not isinstance(i, str)):
+                    return f"Dictionary element {k} must be a string or list of strings not {dv!r}"
+            elif not isinstance(dv, str):
                 return f"Dictionary element {k} must be a string not {dv!r}"
     # We know that otherwise we have an EnvironmentVariables object or None, and
     # we're okay at this point
     return None
 
+def _options_validator(value: T.UnionEnvironmentVariables, T.List'TYPE_var', T.Dictstr, 'TYPE_var', str, None) -> T.Optionalstr:
+    # Reusing the env validator is a littl overkill, but nicer than duplicating the code
+    return _env_validator(value, allow_dict_list=False)
 
 def split_equal_string(input: str) -> T.Tuplestr, str:
     """Split a string in the form `x=y`
@@ -167,18 +224,23 @@
     a, b = input.split('=', 1)
     return (a, b)
 
-
-def _env_convertor(value: T.UnionEnvironmentVariables, T.Liststr, T.ListT.Liststr, T.Dictstr, str, str, None) -> EnvironmentVariables:
+# Split _env_convertor() and env_convertor_with_method() to make mypy happy.
+# It does not want extra arguments in KwargInfo convertor callable.
+def env_convertor_with_method(value: _FullEnvInitValueType,
+                              init_method: Literal'set', 'prepend', 'append' = 'set',
+                              separator: str = os.pathsep) -> EnvironmentVariables:
     if isinstance(value, str):
-        return EnvironmentVariables(dict(split_equal_string(value)))
+        return EnvironmentVariables(dict(split_equal_string(value)), init_method, separator)
     elif isinstance(value, list):
-        return EnvironmentVariables(dict(split_equal_string(v) for v in listify(value)))
+        return EnvironmentVariables(dict(split_equal_string(v) for v in listify(value)), init_method, separator)
     elif isinstance(value, dict):
-        return EnvironmentVariables(value)
+        return EnvironmentVariables(value, init_method, separator)
     elif value is None:
         return EnvironmentVariables()
     return value
 
+def _env_convertor(value: _FullEnvInitValueType) -> EnvironmentVariables:
+    return env_convertor_with_method(value)
 
 ENV_KW: KwargInfoT.UnionEnvironmentVariables, T.List, T.Dict, str, None = KwargInfo(
     'env',
@@ -230,8 +292,7 @@
     ContainerTypeInfo(list, str),
     listify=True,
     default=,
-    # Reusing the env validator is a littl overkill, but nicer than duplicating the code
-    validator=_env_validator,
+    validator=_options_validator,
     convertor=_override_options_convertor,
 )
 
@@ -244,10 +305,12 @@
             return 'Output must not consist only of whitespace.'
         elif has_path_sep(i):
             return f'Output {i!r} must not contain a path segment.'
+        elif '@INPUT' in i:
+            return f'output {i!r} contains "@INPUT", which is invalid. Did you mean "@PLAINNAME@" or "@BASENAME@?'
 
     return None
 
-CT_OUTPUT_KW: KwargInfoT.Liststr = KwargInfo(
+MULTI_OUTPUT_KW: KwargInfoT.Liststr = KwargInfo(
     'output',
     ContainerTypeInfo(list, str, allow_empty=False),
     listify=True,
@@ -256,6 +319,13 @@
     validator=_output_validator,
 )
 
+OUTPUT_KW: KwargInfostr = KwargInfo(
+    'output',
+    str,
+    required=True,
+    validator=lambda x: _output_validator(x)
+)
+
 CT_INPUT_KW: KwargInfoT.ListT.Unionstr, File, ExternalProgram, BuildTarget, CustomTarget, CustomTargetIndex, ExtractedObjects, GeneratedList = KwargInfo(
     'input',
     ContainerTypeInfo(list, (str, File, ExternalProgram, BuildTarget, CustomTarget, CustomTargetIndex, ExtractedObjects, GeneratedList)),
@@ -269,23 +339,27 @@
     listify=True,
     default=,
     since='0.60.0',
+    convertor=lambda x: y if isinstance(y, str) else None for y in x,
 )
 
+INSTALL_TAG_KW: KwargInfoT.Optionalstr = KwargInfo('install_tag', (str, NoneType))
+
 INSTALL_KW = KwargInfo('install', bool, default=False)
 
-CT_INSTALL_DIR_KW: KwargInfoT.ListT.Unionstr, bool = KwargInfo(
+CT_INSTALL_DIR_KW: KwargInfoT.ListT.Unionstr, LiteralFalse = KwargInfo(
     'install_dir',
     ContainerTypeInfo(list, (str, bool)),
     listify=True,
     default=,
+    validator=lambda x: 'must be `false` if boolean' if True in x else None,
 )
 
 CT_BUILD_BY_DEFAULT: KwargInfoT.Optionalbool = KwargInfo('build_by_default', (bool, type(None)), since='0.40.0')
 
 CT_BUILD_ALWAYS: KwargInfoT.Optionalbool = KwargInfo(
     'build_always', (bool, NoneType),
-     deprecated='0.47.0',
-     deprecated_message='combine build_by_default and build_always_stale instead.',
+    deprecated='0.47.0',
+    deprecated_message='combine build_by_default and build_always_stale instead.',
 )
 
 CT_BUILD_ALWAYS_STALE: KwargInfoT.Optionalbool = KwargInfo(
@@ -293,18 +367,113 @@
     since='0.47.0',
 )
 
+INSTALL_DIR_KW: KwargInfoT.Optionalstr = KwargInfo('install_dir', (str, NoneType))
+
 INCLUDE_DIRECTORIES: KwargInfoT.ListT.Unionstr, IncludeDirs = KwargInfo(
-    'include_dirs',
+    'include_directories',
     ContainerTypeInfo(list, (str, IncludeDirs)),
     listify=True,
     default=,
 )
 
+def include_dir_string_new(val: T.ListT.Unionstr, IncludeDirs) -> T.IterableFeatureCheckBase:
+    strs = v for v in val if isinstance(v, str)
+    if strs:
+        str_msg = ", ".join(f"'{s}'" for s in strs)
+        yield FeatureNew('include_directories kwarg of type string', '1.0.0',
+                         f'Use include_directories({str_msg}) instead')
+
 # for cases like default_options and override_options
 DEFAULT_OPTIONS: KwargInfoT.Liststr = KwargInfo(
     'default_options',
-    ContainerTypeInfo(list, (str, IncludeDirs)),
+    ContainerTypeInfo(list, str),
+    listify=True,
+    default=,
+    validator=_options_validator,
+)
+
+ENV_METHOD_KW = KwargInfo('method', str, default='set', since='0.62.0',
+                          validator=in_set_validator({'set', 'prepend', 'append'}))
+
+ENV_SEPARATOR_KW = KwargInfo('separator', str, default=os.pathsep)
+
+DEPENDENCIES_KW: KwargInfoT.ListDependency = KwargInfo(
+    'dependencies',
+    # InternalDependency is a subclass of Dependency, but we want to
+    # print it in error messages
+    ContainerTypeInfo(list, (Dependency, InternalDependency)),
+    listify=True,
+    default=,
+)
+
+D_MODULE_VERSIONS_KW: KwargInfoT.ListT.Unionstr, int = KwargInfo(
+    'd_module_versions',
+    ContainerTypeInfo(list, (str, int)),
     listify=True,
     default=,
-    validator=_env_validator,
 )
+
+_link_with_error = '''can only be self-built targets, external dependencies (including libraries) must go in "dependencies".'''
+
+# Allow Dependency for the better error message? But then in other cases it will list this as one of the allowed types!
+LINK_WITH_KW: KwargInfoT.ListT.UnionBothLibraries, SharedLibrary, StaticLibrary, CustomTarget, CustomTargetIndex, Jar, Executable = KwargInfo(
+    'link_with',
+    ContainerTypeInfo(list, (BothLibraries, SharedLibrary, StaticLibrary, CustomTarget, CustomTargetIndex, Jar, Executable, Dependency)),
+    listify=True,
+    default=,
+    validator=lambda x: _link_with_error if any(isinstance(i, Dependency) for i in x) else None,
+)
+
+def link_whole_validator(values: T.ListT.UnionStaticLibrary, CustomTarget, CustomTargetIndex, Dependency) -> T.Optionalstr:
+    for l in values:
+        if isinstance(l, (CustomTarget, CustomTargetIndex)) and l.links_dynamically():
+            return f'{type(l).__name__} returning a shared library is not allowed'
+        if isinstance(l, Dependency):
+            return _link_with_error
+    return None
+
+LINK_WHOLE_KW: KwargInfoT.ListT.UnionBothLibraries, StaticLibrary, CustomTarget, CustomTargetIndex = KwargInfo(
+    'link_whole',
+    ContainerTypeInfo(list, (BothLibraries, StaticLibrary, CustomTarget, CustomTargetIndex, Dependency)),
+    listify=True,
+    default=,
+    validator=link_whole_validator,
+)
+
+SOURCES_KW: KwargInfoT.ListT.Unionstr, File, CustomTarget, CustomTargetIndex, GeneratedList = KwargInfo(
+    'sources',
+    ContainerTypeInfo(list, (str, File, CustomTarget, CustomTargetIndex, GeneratedList)),
+    listify=True,
+    default=,
+)
+
+VARIABLES_KW: KwargInfoT.Dictstr, str = KwargInfo(
+    'variables',
+    # str is listified by validator/convertor, cannot use listify=True here because
+    # that would listify dict too.
+    (str, ContainerTypeInfo(list, str), ContainerTypeInfo(dict, str)), # type: ignore
+    validator=variables_validator,
+    convertor=variables_convertor,
+    default={},
+)
+
+PRESERVE_PATH_KW: KwargInfobool = KwargInfo('preserve_path', bool, default=False, since='0.63.0')
+
+TEST_KWS: T.ListKwargInfo = 
+    KwargInfo('args', ContainerTypeInfo(list, (str, File, BuildTarget, CustomTarget, CustomTargetIndex)),
+              listify=True, default=),
+    KwargInfo('should_fail', bool, default=False),
+    KwargInfo('timeout', int, default=30),
+    KwargInfo('workdir', (str, NoneType), default=None,
+              validator=lambda x: 'must be an absolute path' if not os.path.isabs(x) else None),
+    KwargInfo('protocol', str,
+              default='exitcode',
+              validator=in_set_validator({'exitcode', 'tap', 'gtest', 'rust'}),
+              since_values={'gtest': '0.55.0', 'rust': '0.57.0'}),
+    KwargInfo('priority', int, default=0, since='0.52.0'),
+    # TODO: env needs reworks of the way the environment variable holder itself works probably
+    ENV_KW,
+    DEPENDS_KW.evolve(since='0.46.0'),
+    KwargInfo('suite', ContainerTypeInfo(list, str), listify=True, default=''),  # yes, a list of empty string
+    KwargInfo('verbose', bool, default=False, since='0.62.0'),
+

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreterbase/__init__.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreterbase/__init__.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreterbase/_unholder.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreterbase/_unholder.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreterbase/baseobjects.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreterbase/baseobjects.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from .. import mparser
 from .exceptions import InvalidCode, InvalidArguments
@@ -23,9 +24,16 @@
 from abc import ABCMeta
 
 if T.TYPE_CHECKING:
+    from typing_extensions import Protocol
+
     # Object holders need the actual interpreter
     from ..interpreter import Interpreter
 
+    __T = T.TypeVar('__T', bound='TYPE_var', contravariant=True)
+
+    class OperatorCall(Protocol__T):
+        def __call__(self, other: __T) -> 'TYPE_var': ...
+
 TV_fw_var = T.Unionstr, int, bool, list, dict, 'InterpreterObject'
 TV_fw_args = T.ListT.Unionmparser.BaseNode, TV_fw_var
 TV_fw_kwargs = T.Dictstr, T.Unionmparser.BaseNode, TV_fw_var
@@ -39,15 +47,10 @@
 TYPE_nkwargs = T.Dictstr, TYPE_nvar
 TYPE_key_resolver = T.Callablemparser.BaseNode, str
 
-if T.TYPE_CHECKING:
-    from typing_extensions import Protocol
-    __T = T.TypeVar('__T', bound=TYPE_var, contravariant=True)
-
-    class OperatorCall(Protocol__T):
-        def __call__(self, other: __T) -> TYPE_var: ...
+SubProject = T.NewType('SubProject', str)
 
 class InterpreterObject:
-    def __init__(self, *, subproject: T.Optionalstr = None) -> None:
+    def __init__(self, *, subproject: T.Optional'SubProject' = None) -> None:
         self.methods: T.Dict
             str,
             T.CallableT.ListTYPE_var, TYPE_kwargs, TYPE_var
@@ -63,7 +66,7 @@
         # Current node set during a method call. This can be used as location
         # when printing a warning message during a method call.
         self.current_node:  mparser.BaseNode = None
-        self.subproject: str = subproject or ''
+        self.subproject = subproject or SubProject('')
 
         # Some default operators supported by all objects
         self.operators.update({

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreterbase/decorators.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreterbase/decorators.py Changed

@@ -11,23 +11,36 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from .. import mesonlib, mlog
-from .baseobjects import TV_func, TYPE_var, TYPE_kwargs
 from .disabler import Disabler
 from .exceptions import InterpreterException, InvalidArguments
-from .operator import MesonOperator
 from ._unholder import _unholder
 
+from dataclasses import dataclass
 from functools import wraps
 import abc
 import itertools
 import copy
 import typing as T
+
 if T.TYPE_CHECKING:
+    from typing_extensions import Protocol
+
     from .. import mparser
+    from .baseobjects import InterpreterObject, TV_func, TYPE_var, TYPE_kwargs
+    from .interpreterbase import SubProject
+    from .operator import MesonOperator
 
-def get_callee_args(wrapped_args: T.SequenceT.Any) -> T.Tuple'mparser.BaseNode', T.List'TYPE_var', 'TYPE_kwargs', str:
+    _TV_IntegerObject = T.TypeVar('_TV_IntegerObject', bound=InterpreterObject, contravariant=True)
+    _TV_ARG1 = T.TypeVar('_TV_ARG1', bound=TYPE_var, contravariant=True)
+
+    class FN_Operator(Protocol_TV_IntegerObject, _TV_ARG1):
+        def __call__(s, self: _TV_IntegerObject, other: _TV_ARG1) -> TYPE_var: ...
+    _TV_FN_Operator = T.TypeVar('_TV_FN_Operator', bound=FN_Operator)
+
+def get_callee_args(wrapped_args: T.SequenceT.Any) -> T.Tuple'mparser.BaseNode', T.List'TYPE_var', 'TYPE_kwargs', 'SubProject':
     # First argument could be InterpreterBase, InterpreterObject or ModuleObject.
     # In the case of a ModuleObject it is the 2nd argument (ModuleState) that
     # contains the needed information.
@@ -49,7 +62,7 @@
         if args:
             raise InvalidArguments('Function does not take positional arguments.')
         return f(*wrapped_args, **wrapped_kwargs)
-    return T.cast(TV_func, wrapped)
+    return T.cast('TV_func', wrapped)
 
 def noKwargs(f: TV_func) -> TV_func:
     @wraps(f)
@@ -58,7 +71,7 @@
         if kwargs:
             raise InvalidArguments('Function does not take keyword arguments.')
         return f(*wrapped_args, **wrapped_kwargs)
-    return T.cast(TV_func, wrapped)
+    return T.cast('TV_func', wrapped)
 
 def stringArgs(f: TV_func) -> TV_func:
     @wraps(f)
@@ -71,7 +84,7 @@
             mlog.debug('Element not a string:', str(args))
             raise InvalidArguments('Arguments must be strings.')
         return f(*wrapped_args, **wrapped_kwargs)
-    return T.cast(TV_func, wrapped)
+    return T.cast('TV_func', wrapped)
 
 def noArgsFlattening(f: TV_func) -> TV_func:
     setattr(f, 'no-args-flattening', True)  # noqa: B010
@@ -86,7 +99,7 @@
     def wrapped(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
         res = f(*wrapped_args, **wrapped_kwargs)
         return _unholder(res)
-    return T.cast(T.Callable..., TYPE_var, wrapped)
+    return T.cast('T.Callable..., TYPE_var', wrapped)
 
 def disablerIfNotFound(f: TV_func) -> TV_func:
     @wraps(f)
@@ -97,12 +110,11 @@
         if disabler and not ret.found():
             return Disabler()
         return ret
-    return T.cast(TV_func, wrapped)
+    return T.cast('TV_func', wrapped)
 
+@dataclass(repr=False, eq=False)
 class permittedKwargs:
-
-    def __init__(self, permitted: T.Setstr):
-        self.permitted = permitted  # type: T.Setstr
+    permitted: T.Setstr
 
     def __call__(self, f: TV_func) -> TV_func:
         @wraps(f)
@@ -113,18 +125,7 @@
                 ustr = ', '.join(f'"{u}"' for u in sorted(unknowns))
                 raise InvalidArguments(f'Got unknown keyword arguments {ustr}')
             return f(*wrapped_args, **wrapped_kwargs)
-        return T.cast(TV_func, wrapped)
-
-if T.TYPE_CHECKING:
-    from .baseobjects import InterpreterObject
-    from typing_extensions import Protocol
-
-    _TV_IntegerObject = T.TypeVar('_TV_IntegerObject', bound=InterpreterObject, contravariant=True)
-    _TV_ARG1 = T.TypeVar('_TV_ARG1', bound=TYPE_var, contravariant=True)
-
-    class FN_Operator(Protocol_TV_IntegerObject, _TV_ARG1):
-        def __call__(s, self: _TV_IntegerObject, other: _TV_ARG1) -> TYPE_var: ...
-    _TV_FN_Operator = T.TypeVar('_TV_FN_Operator', bound=FN_Operator)
+        return T.cast('TV_func', wrapped)
 
 def typed_operator(operator: MesonOperator,
                    types: T.UnionT.Type, T.TupleT.Type, ...) -> T.Callable'_TV_FN_Operator', '_TV_FN_Operator':
@@ -275,7 +276,7 @@
                 nargsi = tuple(args)
             return f(*nargs, **wrapped_kwargs)
 
-        return T.cast(TV_func, wrapper)
+        return T.cast('TV_func', wrapper)
     return inner
 
 
@@ -381,6 +382,7 @@
         added in.
     :param not_set_warning: A warning message that is logged if the kwarg is not
         set by the user.
+    :param feature_validator: A callable returning an iterable of FeatureNew | FeatureDeprecated objects.
     """
     def __init__(self, name: str,
                  types: T.UnionT.Type_T, T.TupleT.UnionT.Type_T, ContainerTypeInfo, ..., ContainerTypeInfo,
@@ -388,10 +390,11 @@
                  default: T.Optional_T = None,
                  since: T.Optionalstr = None,
                  since_message: T.Optionalstr = None,
-                 since_values: T.OptionalT.Dict_T, T.Unionstr, T.Tuplestr, str = None,
+                 since_values: T.OptionalT.DictT.Union_T, T.TypeT.List, T.TypeT.Dict, T.Unionstr, T.Tuplestr, str = None,
                  deprecated: T.Optionalstr = None,
                  deprecated_message: T.Optionalstr = None,
-                 deprecated_values: T.OptionalT.Dict_T, T.Unionstr, T.Tuplestr, str = None,
+                 deprecated_values: T.OptionalT.DictT.Union_T, T.TypeT.List, T.TypeT.Dict, T.Unionstr, T.Tuplestr, str = None,
+                 feature_validator: T.OptionalT.Callable_T, T.IterableFeatureCheckBase = None,
                  validator: T.OptionalT.CallableT.Any, T.Optionalstr = None,
                  convertor: T.OptionalT.Callable_T, object = None,
                  not_set_warning: T.Optionalstr = None):
@@ -403,6 +406,7 @@
         self.since = since
         self.since_message = since_message
         self.since_values = since_values
+        self.feature_validator = feature_validator
         self.deprecated = deprecated
         self.deprecated_message = deprecated_message
         self.deprecated_values = deprecated_values
@@ -417,10 +421,11 @@
                default: T.Union_T, None, _NULL_T = _NULL,
                since: T.Unionstr, None, _NULL_T = _NULL,
                since_message: T.Unionstr, None, _NULL_T = _NULL,
-               since_values: T.UnionT.Dict_T, T.Unionstr, T.Tuplestr, str, None, _NULL_T = _NULL,
+               since_values: T.UnionT.DictT.Union_T, T.TypeT.List, T.TypeT.Dict, T.Unionstr, T.Tuplestr, str, None, _NULL_T = _NULL,
                deprecated: T.Unionstr, None, _NULL_T = _NULL,
                deprecated_message: T.Unionstr, None, _NULL_T = _NULL,
-               deprecated_values: T.UnionT.Dict_T, T.Unionstr, T.Tuplestr, str, None, _NULL_T = _NULL,
+               deprecated_values: T.UnionT.DictT.Union_T, T.TypeT.List, T.TypeT.Dict, T.Unionstr, T.Tuplestr, str, None, _NULL_T = _NULL,
+               feature_validator: T.UnionT.Callable_T, T.IterableFeatureCheckBase, None, _NULL_T = _NULL,
                validator: T.UnionT.Callable_T, T.Optionalstr, None, _NULL_T = _NULL,
                convertor: T.UnionT.Callable_T, TYPE_var, None, _NULL_T = _NULL) -> 'KwargInfo':
         """Create a shallow copy of this KwargInfo, with modifications.
@@ -446,12 +451,13 @@
             deprecated=deprecated if not isinstance(deprecated, _NULL_T) else self.deprecated,
             deprecated_message=deprecated_message if not isinstance(deprecated_message, _NULL_T) else self.deprecated_message,
             deprecated_values=deprecated_values if not isinstance(deprecated_values, _NULL_T) else self.deprecated_values,
+            feature_validator=feature_validator if not isinstance(feature_validator, _NULL_T) else self.feature_validator,
             validator=validator if not isinstance(validator, _NULL_T) else self.validator,
             convertor=convertor if not isinstance(convertor, _NULL_T) else self.convertor,
         )
 
 
-def typed_kwargs(name: str, *types: KwargInfo) -> T.Callable..., T.Any:
+def typed_kwargs(name: str, *types: KwargInfo, allow_unknown: bool = False) -> T.Callable..., T.Any:
     """Decorator for type checking keyword arguments.
 
     Used to wrap a meson DSL implementation function, where it checks various
@@ -504,29 +510,36 @@
         @wraps(f)
         def wrapper(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
 
-            def emit_feature_change(values: T.Dictstr, T.Unionstr, T.Tuplestr, str, feature: T.UnionT.Type'FeatureDeprecated', T.Type'FeatureNew') -> None:
+            def emit_feature_change(values: T.Dict_T, T.Unionstr, T.Tuplestr, str, feature: T.UnionT.Type'FeatureDeprecated', T.Type'FeatureNew') -> None:
                 for n, version in values.items():
-                    if isinstance(value, (dict, list)):
+                    warn = False
+                    if isinstance(version, tuple):
+                        version, msg = version
+                    else:
+                        msg = None
+
+                    if n in {dict, list}:
+                        assert isinstance(n, type), 'for mypy'
+                        if isinstance(value, n):
+                            feature.single_use(f'"{name}" keyword argument "{info.name}" of type {n.__name__}', version, subproject, msg, location=node)
+                    elif isinstance(value, (dict, list)):
                         warn = n in value
                     else:
                         warn = n == value
 
                     if warn:
-                        if isinstance(version, tuple):
-                            version, msg = version
-                        else:
-                            msg = None
                         feature.single_use(f'"{name}" keyword argument "{info.name}" value "{n}"', version, subproject, msg, location=node)
 
             node, _, _kwargs, subproject = get_callee_args(wrapped_args)
             # Cast here, as the convertor function may place something other than a TYPE_var in the kwargs
-            kwargs = T.cast(T.Dictstr, object, _kwargs)
+            kwargs = T.cast('T.Dictstr, object', _kwargs)
 
-            all_names = {t.name for t in types}
-            unknowns = set(kwargs).difference(all_names)
-            if unknowns:
-                ustr = ', '.join(f'"{u}"' for u in sorted(unknowns))
-                raise InvalidArguments(f'{name} got unknown keyword arguments {ustr}')
+            if not allow_unknown:
+                all_names = {t.name for t in types}
+                unknowns = set(kwargs).difference(all_names)
+                if unknowns:
+                    ustr = ', '.join(f'"{u}"' for u in sorted(unknowns))
+                    raise InvalidArguments(f'{name} got unknown keyword arguments {ustr}')
 
             for info in types:
                 types_tuple = info.types if isinstance(info.types, tuple) else (info.types,)
@@ -549,6 +562,10 @@
                         if msg is not None:
                             raise InvalidArguments(f'{name} keyword argument "{info.name}" {msg}')
 
+                    if info.feature_validator is not None:
+                        for each in info.feature_validator(value):
+                            each.use(subproject, node)
+
                     if info.deprecated_values is not None:
                         emit_feature_change(info.deprecated_values, FeatureDeprecated)
 
@@ -571,21 +588,21 @@
                     kwargsinfo.name = info.convertor(kwargsinfo.name)
 
             return f(*wrapped_args, **wrapped_kwargs)
-        return T.cast(TV_func, wrapper)
+        return T.cast('TV_func', wrapper)
     return inner
 
 
+# This cannot be a dataclass due to https://github.com/python/mypy/issues/5374
 class FeatureCheckBase(metaclass=abc.ABCMeta):
     "Base class for feature version checks"
 
     feature_registry: T.ClassVarT.Dictstr, T.Dictstr, T.SetT.Tuplestr, T.Optional'mparser.BaseNode'
     emit_notice = False
 
-    def __init__(self, feature_name: str, feature_version: str, extra_message: str = '', location: T.Optional'mparser.BaseNode' = None):
+    def __init__(self, feature_name: str, feature_version: str, extra_message: str = ''):
         self.feature_name = feature_name  # type: str
         self.feature_version = feature_version    # type: str
         self.extra_message = extra_message  # type: str
-        self.location = location
 
     @staticmethod
     def get_target_version(subproject: str) -> str:
@@ -599,7 +616,7 @@
     def check_version(target_version: str, feature_version: str) -> bool:
         pass
 
-    def use(self, subproject: str) -> None:
+    def use(self, subproject: 'SubProject', location: T.Optional'mparser.BaseNode' = None) -> None:
         tv = self.get_target_version(subproject)
         # No target version
         if tv == '':
@@ -614,7 +631,7 @@
         if self.feature_version not in register:
             registerself.feature_version = set()
 
-        feature_key = (self.feature_name, self.location)
+        feature_key = (self.feature_name, location)
         if feature_key in registerself.feature_version:
             # Don't warn about the same feature multiple times
             # FIXME: This is needed to prevent duplicate warnings, but also
@@ -624,7 +641,7 @@
         # Target version is new enough, don't warn even if it is registered for notice
         if self.check_version(tv, self.feature_version):
             return
-        self.log_usage_warning(tv)
+        self.log_usage_warning(tv, location)
 
     @classmethod
     def report(cls, subproject: str) -> None:
@@ -644,7 +661,7 @@
         if '\n' in warning_str:
             mlog.warning(warning_str)
 
-    def log_usage_warning(self, tv: str) -> None:
+    def log_usage_warning(self, tv: str, location: T.Optional'mparser.BaseNode') -> None:
         raise InterpreterException('log_usage_warning not implemented')
 
     @staticmethod
@@ -661,16 +678,15 @@
             node, _, _, subproject = get_callee_args(wrapped_args)
             if subproject is None:
                 raise AssertionError(f'{wrapped_args!r}')
-            self.location = node
-            self.use(subproject)
+            self.use(subproject, node)
             return f(*wrapped_args, **wrapped_kwargs)
-        return T.cast(TV_func, wrapped)
+        return T.cast('TV_func', wrapped)
 
     @classmethod
-    def single_use(cls, feature_name: str, version: str, subproject: str,
+    def single_use(cls, feature_name: str, version: str, subproject: 'SubProject',
                    extra_message: str = '', location: T.Optional'mparser.BaseNode' = None) -> None:
         """Oneline version that instantiates and calls use()."""
-        cls(feature_name, version, extra_message, location).use(subproject)
+        cls(feature_name, version, extra_message).use(subproject, location)
 
 
 class FeatureNew(FeatureCheckBase):
@@ -693,16 +709,16 @@
     def get_notice_str_prefix(tv: str) -> str:
         return ''
 
-    def log_usage_warning(self, tv: str) -> None:
+    def log_usage_warning(self, tv: str, location: T.Optional'mparser.BaseNode') -> None:
         args = 
-            'Project targeting', f"'{tv}'",
-            'but tried to use feature introduced in',
+            'Project targets', f"'{tv}'",
+            'but uses feature introduced in',
             f"'{self.feature_version}':",
             f'{self.feature_name}.',
         
         if self.extra_message:
             args.append(self.extra_message)
-        mlog.warning(*args, location=self.location)
+        mlog.warning(*args, location=location)
 
 class FeatureDeprecated(FeatureCheckBase):
     """Checks for deprecated features"""
@@ -726,18 +742,19 @@
     def get_notice_str_prefix(tv: str) -> str:
         return 'Future-deprecated features used:'
 
-    def log_usage_warning(self, tv: str) -> None:
+    def log_usage_warning(self, tv: str, location: T.Optional'mparser.BaseNode') -> None:
         args = 
-            'Project targeting', f"'{tv}'",
-            'but tried to use feature deprecated since',
+            'Project targets', f"'{tv}'",
+            'but uses feature deprecated since',
             f"'{self.feature_version}':",
             f'{self.feature_name}.',
         
         if self.extra_message:
             args.append(self.extra_message)
-        mlog.warning(*args, location=self.location)
+        mlog.warning(*args, location=location)
 
 
+# This cannot be a dataclass due to https://github.com/python/mypy/issues/5374
 class FeatureCheckKwargsBase(metaclass=abc.ABCMeta):
 
     @property
@@ -746,12 +763,11 @@
         pass
 
     def __init__(self, feature_name: str, feature_version: str,
-                 kwargs: T.Liststr, extra_message: T.Optionalstr = None, location: T.Optional'mparser.BaseNode' = None):
+                 kwargs: T.Liststr, extra_message: T.Optionalstr = None):
         self.feature_name = feature_name
         self.feature_version = feature_version
         self.kwargs = kwargs
         self.extra_message = extra_message
-        self.location = location
 
     def __call__(self, f: TV_func) -> TV_func:
         @wraps(f)
@@ -766,7 +782,7 @@
                 self.feature_check_class.single_use(
                         name, self.feature_version, subproject, self.extra_message, node)
             return f(*wrapped_args, **wrapped_kwargs)
-        return T.cast(TV_func, wrapped)
+        return T.cast('TV_func', wrapped)
 
 class FeatureNewKwargs(FeatureCheckKwargsBase):
     feature_check_class = FeatureNew

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreterbase/disabler.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreterbase/disabler.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreterbase/helpers.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreterbase/helpers.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/interpreterbase/interpreterbase.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/interpreterbase/interpreterbase.py Changed

@@ -14,6 +14,7 @@
 
 # This class contains the basic functionality needed to run any interpreter
 # or an interpreter-based tool.
+from __future__ import annotations
 
 from .. import mparser, mesonlib
 from .. import environment
@@ -26,9 +27,6 @@
     ObjectHolder,
     IterableObject,
 
-    TYPE_var,
-    TYPE_kwargs,
-
     HoldableTypes,
 )
 
@@ -52,28 +50,29 @@
 import textwrap
 
 if T.TYPE_CHECKING:
+    from .baseobjects import SubProject, TYPE_kwargs, TYPE_var
     from ..interpreter import Interpreter
 
-HolderMapType = T.Dict
-    T.Union
-        T.Typemesonlib.HoldableObject,
-        T.Typeint,
-        T.Typebool,
-        T.Typestr,
-        T.Typelist,
-        T.Typedict,
-    ,
-    # For some reason, this has to be a callable and can't just be ObjectHolderInterpreterObjectTypeVar
-    T.CallableInterpreterObjectTypeVar, 'Interpreter', ObjectHolderInterpreterObjectTypeVar
-
-
-FunctionType = T.Dict
-    str,
-    T.Callablemparser.BaseNode, T.ListTYPE_var, T.Dictstr, TYPE_var, TYPE_var
-
+    HolderMapType = T.Dict
+        T.Union
+            T.Typemesonlib.HoldableObject,
+            T.Typeint,
+            T.Typebool,
+            T.Typestr,
+            T.Typelist,
+            T.Typedict,
+        ,
+        # For some reason, this has to be a callable and can't just be ObjectHolderInterpreterObjectTypeVar
+        T.CallableInterpreterObjectTypeVar, 'Interpreter', ObjectHolderInterpreterObjectTypeVar
+    
+
+    FunctionType = T.Dict
+        str,
+        T.Callablemparser.BaseNode, T.ListTYPE_var, T.Dictstr, TYPE_var, TYPE_var
+    
 
 class InterpreterBase:
-    def __init__(self, source_root: str, subdir: str, subproject: str):
+    def __init__(self, source_root: str, subdir: str, subproject: 'SubProject'):
         self.source_root = source_root
         self.funcs: FunctionType = {}
         self.builtin: T.Dictstr, InterpreterObject = {}
@@ -216,7 +215,10 @@
         elif isinstance(cur, mparser.TernaryNode):
             return self.evaluate_ternary(cur)
         elif isinstance(cur, mparser.FormatStringNode):
-            return self.evaluate_fstring(cur)
+            if isinstance(cur, mparser.MultilineFormatStringNode):
+                return self.evaluate_multiline_fstring(cur)
+            else:
+                return self.evaluate_fstring(cur)
         elif isinstance(cur, mparser.ContinueNode):
             raise ContinueRequest()
         elif isinstance(cur, mparser.BreakNode):
@@ -366,6 +368,10 @@
         else:
             return self.evaluate_statement(node.falseblock)
 
+    @FeatureNew('multiline format strings', '0.63.0')
+    def evaluate_multiline_fstring(self, node: mparser.MultilineFormatStringNode) -> InterpreterObject:
+        return self.evaluate_fstring(node)
+
     @FeatureNew('format strings', '0.58.0')
     def evaluate_fstring(self, node: mparser.FormatStringNode) -> InterpreterObject:
         assert isinstance(node, mparser.FormatStringNode)
@@ -376,7 +382,7 @@
                 val = _unholder(self.variablesvar)
                 if not isinstance(val, (str, int, float, bool)):
                     raise InvalidCode(f'Identifier "{var}" does not name a formattable variable ' +
-                        '(has to be an integer, a string, a floating point number or a boolean).')
+                                      '(has to be an integer, a string, a floating point number or a boolean).')
 
                 return str(val)
             except KeyError:
@@ -461,9 +467,10 @@
         invokable = node.source_object
         obj: T.OptionalInterpreterObject
         if isinstance(invokable, mparser.IdNode):
-            object_name = invokable.value
-            obj = self.get_variable(object_name)
+            object_display_name = f'variable "{invokable.value}"'
+            obj = self.get_variable(invokable.value)
         else:
+            object_display_name = invokable.__class__.__name__
             obj = self.evaluate_statement(invokable)
         method_name = node.name
         (h_args, h_kwargs) = self.reduce_arguments(node.args)
@@ -471,13 +478,13 @@
         if is_disabled(args, kwargs):
             return Disabler()
         if not isinstance(obj, InterpreterObject):
-            raise InvalidArguments(f'Variable "{object_name}" is not callable.')
+            raise InvalidArguments(f'{object_display_name} is not callable.')
         # TODO: InterpreterBase **really** shouldn't be in charge of checking this
         if method_name == 'extract_objects':
             if isinstance(obj, ObjectHolder):
                 self.validate_extraction(obj.held_object)
             elif not isinstance(obj, Disabler):
-                raise InvalidArguments(f'Invalid operation "extract_objects" on variable "{object_name}" of type {type(obj).__name__}')
+                raise InvalidArguments(f'Invalid operation "extract_objects" on {object_display_name} of type {type(obj).__name__}')
         obj.current_node = node
         res = obj.method_call(method_name, args, kwargs)
         return self._holderify(res) if res is not None else None
@@ -524,7 +531,7 @@
         self.argument_depth += 1
         reduced_pos = self.evaluate_statement(arg) for arg in args.arguments
         if any(x is None for x in reduced_pos):
-            raise InvalidArguments(f'At least one value in the arguments is void.')
+            raise InvalidArguments('At least one value in the arguments is void.')
         reduced_kw: T.Dictstr, InterpreterObject = {}
         for key, val in args.kwargs.items():
             reduced_key = key_resolver(key)
@@ -568,7 +575,6 @@
         if isinstance(value, MutableInterpreterObject):
             value = copy.deepcopy(value)
         self.set_variable(var_name, value)
-        return None
 
     def set_variable(self, varname: str, variable: T.UnionTYPE_var, InterpreterObject, *, holderify: bool = False) -> None:
         if variable is None:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/linkers/__init__.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/linkers/__init__.py Changed

@@ -24,6 +24,7 @@
     VisualStudioLikeLinker,
     VisualStudioLinker,
     IntelVisualStudioLinker,
+    AppleArLinker,
     ArLinker,
     ArmarLinker,
     DLinker,
@@ -31,6 +32,7 @@
     Xc16Linker,
     CompCertLinker,
     C2000Linker,
+    TILinker,
     AIXArLinker,
     PGIStaticLinker,
     NvidiaHPC_StaticLinker,
@@ -43,11 +45,13 @@
     GnuGoldDynamicLinker,
     GnuBFDDynamicLinker,
     LLVMDynamicLinker,
+    MoldDynamicLinker,
     WASMDynamicLinker,
     CcrxDynamicLinker,
     Xc16DynamicLinker,
     CompCertDynamicLinker,
     C2000DynamicLinker,
+    TIDynamicLinker,
     ArmDynamicLinker,
     ArmClangDynamicLinker,
     QualcommLLVMDynamicLinker,
@@ -89,7 +93,9 @@
     'Xc16Linker',
     'CompCertLinker',
     'C2000Linker',
+    'TILinker',
     'AIXArLinker',
+    'AppleArLinker',
     'PGIStaticLinker',
     'NvidiaHPC_StaticLinker',
 
@@ -101,11 +107,13 @@
     'GnuGoldDynamicLinker',
     'GnuBFDDynamicLinker',
     'LLVMDynamicLinker',
+    'MoldDynamicLinker',
     'WASMDynamicLinker',
     'CcrxDynamicLinker',
     'Xc16DynamicLinker',
     'CompCertDynamicLinker',
     'C2000DynamicLinker',
+    'TIDynamicLinker',
     'ArmDynamicLinker',
     'ArmClangDynamicLinker',
     'QualcommLLVMDynamicLinker',

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/linkers/detect.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/linkers/detect.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2012-2021 The Meson development team
+# Copyright 2012-2022 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,16 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
+from .. import mlog
 from ..mesonlib import (
-    EnvironmentException, MachineChoice, OptionKey,
-    Popen_safe, search_version
+    EnvironmentException,
+    Popen_safe, join_args, search_version
 )
 from .linkers import (
-    DynamicLinker,
     AppleDynamicLinker,
-    GnuDynamicLinker,
+    LLVMLD64DynamicLinker,
     GnuGoldDynamicLinker,
     GnuBFDDynamicLinker,
+    MoldDynamicLinker,
     LLVMDynamicLinker,
     QualcommLLVMDynamicLinker,
     MSVCDynamicLinker,
@@ -36,8 +39,10 @@
 import typing as T
 
 if T.TYPE_CHECKING:
+    from .linkers import DynamicLinker, GnuDynamicLinker
     from ..environment import Environment
     from ..compilers import Compiler
+    from ..mesonlib import MachineChoice
 
 defaults: T.Dictstr, T.Liststr = {}
 defaults'static_linker' = 'ar', 'gar'
@@ -48,13 +53,13 @@
 defaults'clang_static_linker' = 'llvm-ar'
 
 def __failed_to_detect_linker(compiler: T.Liststr, args: T.Liststr, stdout: str, stderr: str) -> 'T.NoReturn':
-    msg = 'Unable to detect linker for compiler "{} {}"\nstdout: {}\nstderr: {}'.format(
-        ' '.join(compiler), ' '.join(args), stdout, stderr)
+    msg = 'Unable to detect linker for compiler `{}`\nstdout: {}\nstderr: {}'.format(
+        join_args(compiler + args), stdout, stderr)
     raise EnvironmentException(msg)
 
 
 def guess_win_linker(env: 'Environment', compiler: T.Liststr, comp_class: T.Type'Compiler',
-                     for_machine: MachineChoice, *,
+                     comp_version: str, for_machine: MachineChoice, *,
                      use_linker_prefix: bool = True, invoked_directly: bool = True,
                      extra_args: T.OptionalT.Liststr = None) -> 'DynamicLinker':
     env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
@@ -67,19 +72,19 @@
     elif isinstance(comp_class.LINKER_PREFIX, list):
         check_args = comp_class.LINKER_PREFIX + '/logo' + comp_class.LINKER_PREFIX + '--version'
 
-    check_args += env.coredata.optionsOptionKey('args', lang=comp_class.language, machine=for_machine).value
+    check_args += env.coredata.get_external_link_args(for_machine, comp_class.language)
 
     override =   # type: T.Liststr
     value = env.lookup_binary_entry(for_machine, comp_class.language + '_ld')
     if value is not None:
-        override = comp_class.use_linker_args(value0)
+        override = comp_class.use_linker_args(value0, comp_version)
         check_args += override
 
     if extra_args is not None:
         check_args.extend(extra_args)
 
     p, o, _ = Popen_safe(compiler + check_args)
-    if 'LLD' in o.split('\n')0:
+    if 'LLD' in o.split('\n', maxsplit=1)0:
         if '(compatible with GNU linkers)' in o:
             return LLVMDynamicLinker(
                 compiler, for_machine, comp_class.LINKER_PREFIX,
@@ -94,13 +99,13 @@
         # We've already hanedled the non-direct case above
 
     p, o, e = Popen_safe(compiler + check_args)
-    if 'LLD' in o.split('\n')0:
+    if 'LLD' in o.split('\n', maxsplit=1)0:
         return ClangClDynamicLinker(
             for_machine, ,
             prefix=comp_class.LINKER_PREFIX if use_linker_prefix else ,
             exelist=compiler, version=search_version(o), direct=invoked_directly)
     elif 'OPTLINK' in o:
-        # Opltink's stdout *may* beging with a \r character.
+        # Optlink's stdout *may* begin with a \r character.
         return OptlinkDynamicLinker(compiler, for_machine, version=search_version(o))
     elif o.startswith('Microsoft') or e.startswith('Microsoft'):
         out = o or e
@@ -124,18 +129,21 @@
     __failed_to_detect_linker(compiler, check_args, o, e)
 
 def guess_nix_linker(env: 'Environment', compiler: T.Liststr, comp_class: T.Type'Compiler',
-                     for_machine: MachineChoice, *,
+                     comp_version: str, for_machine: MachineChoice, *,
                      extra_args: T.OptionalT.Liststr = None) -> 'DynamicLinker':
     """Helper for guessing what linker to use on Unix-Like OSes.
 
     :compiler: Invocation to use to get linker
     :comp_class: The Compiler Type (uninstantiated)
+    :comp_version: The compiler version string
     :for_machine: which machine this linker targets
     :extra_args: Any additional arguments required (such as a source file)
     """
     env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
     extra_args = extra_args or 
-    extra_args += env.coredata.optionsOptionKey('args', lang=comp_class.language, machine=for_machine).value
+
+    ldflags = env.coredata.get_external_link_args(for_machine, comp_class.language)
+    extra_args += comp_class._unix_args_to_native(ldflags, env.machinesfor_machine)
 
     if isinstance(comp_class.LINKER_PREFIX, str):
         check_args = comp_class.LINKER_PREFIX + '--version' + extra_args
@@ -145,14 +153,36 @@
     override =   # type: T.Liststr
     value = env.lookup_binary_entry(for_machine, comp_class.language + '_ld')
     if value is not None:
-        override = comp_class.use_linker_args(value0)
+        override = comp_class.use_linker_args(value0, comp_version)
         check_args += override
 
-    _, o, e = Popen_safe(compiler + check_args)
+    mlog.debug('-----')
+    mlog.debug(f'Detecting linker via: {join_args(compiler + check_args)}')
+    p, o, e = Popen_safe(compiler + check_args)
+    mlog.debug(f'linker returned {p}')
+    mlog.debug(f'linker stdout:\n{o}')
+    mlog.debug(f'linker stderr:\n{e}')
+
     v = search_version(o + e)
     linker: DynamicLinker
-    if 'LLD' in o.split('\n')0:
-        linker = LLVMDynamicLinker(
+    if 'LLD' in o.split('\n', maxsplit=1)0:
+        if isinstance(comp_class.LINKER_PREFIX, str):
+            cmd = compiler + override + comp_class.LINKER_PREFIX + '-v' + extra_args
+        else:
+            cmd = compiler + override + comp_class.LINKER_PREFIX + '-v' + extra_args
+        mlog.debug('-----')
+        mlog.debug(f'Detecting LLD linker via: {join_args(cmd)}')
+        _, newo, newerr = Popen_safe(cmd)
+        mlog.debug(f'linker stdout:\n{newo}')
+        mlog.debug(f'linker stderr:\n{newerr}')
+
+        lld_cls: T.TypeDynamicLinker
+        if 'ld64.lld' in newerr:
+            lld_cls = LLVMLD64DynamicLinker
+        else:
+            lld_cls = LLVMDynamicLinker
+
+        linker = lld_cls(
             compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
     elif 'Snapdragon' in e and 'LLVM' in e:
         linker = QualcommLLVMDynamicLinker(
@@ -175,26 +205,36 @@
             v = search_version(o)
 
         linker = LLVMDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
-    # first is for apple clang, second is for real gcc, the third is icc
+    # first might be apple clang, second is for real gcc, the third is icc
     elif e.endswith('(use -v to see invocation)\n') or 'macosx_version' in e or 'ld: unknown option:' in e:
         if isinstance(comp_class.LINKER_PREFIX, str):
-            _, _, e = Popen_safe(compiler + comp_class.LINKER_PREFIX + '-v' + extra_args)
+            cmd = compiler + comp_class.LINKER_PREFIX + '-v' + extra_args
         else:
-            _, _, e = Popen_safe(compiler + comp_class.LINKER_PREFIX + '-v' + extra_args)
-        for line in e.split('\n'):
+            cmd = compiler + comp_class.LINKER_PREFIX + '-v' + extra_args
+        mlog.debug('-----')
+        mlog.debug(f'Detecting Apple linker via: {join_args(cmd)}')
+        _, newo, newerr = Popen_safe(cmd)
+        mlog.debug(f'linker stdout:\n{newo}')
+        mlog.debug(f'linker stderr:\n{newerr}')
+
+        for line in newerr.split('\n'):
             if 'PROJECT:ld' in line:
                 v = line.split('-')1
                 break
         else:
-            v = 'unknown version'
+            __failed_to_detect_linker(compiler, check_args, o, e)
         linker = AppleDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
     elif 'GNU' in o or 'GNU' in e:
-        cls: T.TypeGnuDynamicLinker
-        if 'gold' in o or 'gold' in e:
-            cls = GnuGoldDynamicLinker
+        gnu_cls: T.TypeGnuDynamicLinker
+        # this is always the only thing on stdout, except for swift
+        # which may or may not redirect the linker stdout to stderr
+        if o.startswith('GNU gold') or e.startswith('GNU gold'):
+            gnu_cls = GnuGoldDynamicLinker
+        elif o.startswith('mold') or e.startswith('mold'):
+            gnu_cls = MoldDynamicLinker
         else:
-            cls = GnuBFDDynamicLinker
-        linker = cls(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+            gnu_cls = GnuBFDDynamicLinker
+        linker = gnu_cls(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
     elif 'Solaris' in e or 'Solaris' in o:
         for line in (o+e).split('\n'):
             if 'ld: Software Generation Utilities' in line:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/linkers/linkers.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/linkers/linkers.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2012-2017 The Meson development team
+# Copyright 2012-2022 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import abc
 import enum
@@ -59,14 +60,14 @@
 def get_exelist(self) -> T.Liststr:
 return self.exelist.copy()
 
- def get_std_link_args(self, is_thin: bool) -> T.Liststr:
+ def get_std_link_args(self, env: 'Environment', is_thin: bool) -> T.Liststr:
 return 
 
 def get_buildtype_linker_args(self, buildtype: str) -> T.Liststr:
 return 
 
 def get_output_args(self, target: str) -> T.Liststr:
- return
+ return 
 
 def get_coverage_link_args(self) -> T.Liststr:
 return 
@@ -137,12 +138,12 @@
 
 @classmethod
 def unix_args_to_native(cls, args: T.Liststr) -> T.Liststr:
- from ..compilers import VisualStudioCCompiler
+ from ..compilers.c import VisualStudioCCompiler
 return VisualStudioCCompiler.unix_args_to_native(args)
 
 @classmethod
 def native_args_to_unix(cls, args: T.Liststr) -> T.Liststr:
- from ..compilers import VisualStudioCCompiler
+ from ..compilers.c import VisualStudioCCompiler
 return VisualStudioCCompiler.native_args_to_unix(args)
 
 def rsp_file_syntax(self) -> RSPFileSyntax:
@@ -176,7 +177,7 @@
 # in fact, only the 'ar' id can
 return False
 
- def get_std_link_args(self, is_thin: bool) -> T.Liststr:
+ def get_std_link_args(self, env: 'Environment', is_thin: bool) -> T.Liststr:
 return self.std_args
 
 def get_output_args(self, target: str) -> T.Liststr:
@@ -189,7 +190,7 @@
 class ArLinker(ArLikeLinker):
 id = 'ar'
 
- def __init__(self, exelist: T.Liststr):
+ def __init__(self, for_machine: mesonlib.MachineChoice, exelist: T.Liststr):
 super().__init__(exelist)
 stdo = mesonlib.Popen_safe(self.exelist + '-h')1
 # Enable deterministic builds if they are available.
@@ -202,18 +203,30 @@
 self.std_args = stdargs
 self.std_thin_args = stdargs + thinargs
 self.can_rsp = '@<' in stdo
+ self.for_machine = for_machine
 
 def can_linker_accept_rsp(self) -> bool:
 return self.can_rsp
 
- def get_std_link_args(self, is_thin: bool) -> T.Liststr:
- # FIXME: osx ld rejects this: "file built for unknown-unsupported file format"
- if is_thin and not mesonlib.is_osx():
+ def get_std_link_args(self, env: 'Environment', is_thin: bool) -> T.Liststr:
+ # Thin archives are a GNU extension not supported by the system linkers
+ # on Mac OS X, Solaris, or illumos, so don't build them on those OSes.
+ # OS X ld rejects with: "file built for unknown-unsupported file format"
+ # illumos/Solaris ld rejects with: "unknown file type"
+ if is_thin and not env.machinesself.for_machine.is_darwin() \
+ and not env.machinesself.for_machine.is_sunos():
 return self.std_thin_args
 else:
 return self.std_args
 
 
+class AppleArLinker(ArLinker):
+
+ # mostly this is used to determine that we need to call ranlib
+
+ id = 'applear'
+
+
 class ArmarLinker(ArLikeLinker):
 id = 'armar'
 
@@ -225,7 +238,7 @@
 self.arch = arch
 self.__rsp_syntax = rsp_syntax
 
- def get_std_link_args(self, is_thin: bool) -> T.Liststr:
+ def get_std_link_args(self, env: 'Environment', is_thin: bool) -> T.Liststr:
 return '-lib'
 
 def get_output_args(self, target: str) -> T.Liststr:
@@ -288,11 +301,11 @@
 return f'-o{target}'
 
 
-class C2000Linker(StaticLinker):
+class TILinker(StaticLinker):
 
 def __init__(self, exelist: T.Liststr):
 super().__init__(exelist)
- self.id = 'ar2000'
+ self.id = 'ti-ar'
 
 def can_linker_accept_rsp(self) -> bool:
 return False
@@ -304,6 +317,11 @@
 return '-r'
 
 
+class C2000Linker(TILinker):
+ # Required for backwards compat with projects created before ti-cgt support existed
+ id = 'ar2000'
+
+
 class AIXArLinker(ArLikeLinker):
 id = 'aixar'
 std_args = '-csr', '-Xany'
@@ -443,6 +461,9 @@
 def get_lto_args(self) -> T.Liststr:
 return 
 
+ def get_thinlto_cache_args(self, path: str) -> T.Liststr:
+ return 
+
 def sanitizer_args(self, value: str) -> T.Liststr:
 return 
 
@@ -567,6 +588,18 @@
 'custom': ,
 } # type: T.Dictstr, T.Liststr
 
+ _SUBSYSTEMS = {
+ "native": "1",
+ "windows": "windows",
+ "console": "console",
+ "posix": "7",
+ "efi_application": "10",
+ "efi_boot_service_driver": "11",
+ "efi_runtime_driver": "12",
+ "efi_rom": "13",
+ "boot_application": "16",
+ } # type: T.Dictstr, str
+
 def get_buildtype_args(self, buildtype: str) -> T.Liststr:
 # We can override these in children by just overriding the
 # _BUILDTYPE_ARGS value.
@@ -695,14 +728,21 @@
 return (args, rpath_dirs_to_remove)
 
 def get_win_subsystem_args(self, value: str) -> T.Liststr:
- if 'windows' in value:
- args = '--subsystem,windows'
- elif 'console' in value:
- args = '--subsystem,console'
- else:
- raise MesonException(f'Only "windows" and "console" are supported for win_subsystem with MinGW, not "{value}".')
+ # MinGW only directly supports a couple of the possible
+ # PE application types. The raw integer works as an argument
+ # as well, and is always accepted, so we manually map the
+ # other types here. List of all types:
+ # https://github.com/wine-mirror/wine/blob/3ded60bd1654dc689d24a23305f4a93acce3a6f2/include/winnt.h#L2492-L2507
+ versionsuffix = None
 if ',' in value:
- args-1 = args-1 + ':' + value.split(',')1
+ value, versionsuffix = value.split(',', 1)
+ newvalue = self._SUBSYSTEMS.get(value)
+ if newvalue is not None:
+ if versionsuffix is not None:
+ newvalue += f':{versionsuffix}'
+ args = f'--subsystem,{newvalue}'
+ else:
+ raise mesonlib.MesonBugException(f'win_subsystem: {value!r} not handled in MinGW linker. This should not be possible.')
 
 return self._apply_prefix(args)
 
@@ -782,6 +822,14 @@
 
 return (args, set())
 
+ def get_thinlto_cache_args(self, path: str) -> T.Liststr:
+ return "-Wl,-cache_path_lto," + path
+
+
+class LLVMLD64DynamicLinker(AppleDynamicLinker):
+
+ id = 'ld64.lld'
+
 
 class GnuDynamicLinker(GnuLikeDynamicLinkerMixin, PosixDynamicLinkerMixin, DynamicLinker):
 
@@ -795,12 +843,23 @@
 
 id = 'ld.gold'
 
+ def get_thinlto_cache_args(self, path: str) -> T.Liststr:
+ return '-Wl,-plugin-opt,cache-dir=' + path
+
 
 class GnuBFDDynamicLinker(GnuDynamicLinker):
 
 id = 'ld.bfd'
 
 
+class MoldDynamicLinker(GnuDynamicLinker):
+
+ id = 'ld.mold'
+
+ def get_thinlto_cache_args(self, path: str) -> T.Liststr:
+ return '-Wl,--thinlto-cache-dir=' + path
+
+
 class LLVMDynamicLinker(GnuLikeDynamicLinkerMixin, PosixDynamicLinkerMixin, DynamicLinker):
 
 """Representation of LLVM's ld.lld linker.
@@ -817,7 +876,7 @@
 super().__init__(exelist, for_machine, prefix_arg, always_args, version=version)
 
 # Some targets don't seem to support this argument (windows, wasm, ...)
- _, _, e = mesonlib.Popen_safe(self.exelist + self._apply_prefix('--allow-shlib-undefined'))
+ _, _, e = mesonlib.Popen_safe(self.exelist + always_args + self._apply_prefix('--allow-shlib-undefined'))
 # Versions < 9 do not have a quoted argument
 self.has_allow_shlib_undefined = ('unknown argument: --allow-shlib-undefined' not in e) and ("unknown argument: '--allow-shlib-undefined'" not in e)
 
@@ -826,6 +885,21 @@
 return self._apply_prefix('--allow-shlib-undefined')
 return 
 
+ def get_thinlto_cache_args(self, path: str) -> T.Liststr:
+ return '-Wl,--thinlto-cache-dir=' + path
+
+ def get_win_subsystem_args(self, value: str) -> T.Liststr:
+ # lld does not support a numeric subsystem value
+ version = None
+ if ',' in value:
+ value, version = value.split(',', 1)
+ if value in self._SUBSYSTEMS:
+ if version is not None:
+ value += f':{version}'
+ return self._apply_prefix(f'--subsystem,{value}')
+ else:
+ raise mesonlib.MesonBugException(f'win_subsystem: {value} not handled in lld linker. This should not be possible.')
+
 
 class WASMDynamicLinker(GnuLikeDynamicLinkerMixin, PosixDynamicLinkerMixin, DynamicLinker):
 
@@ -834,10 +908,10 @@
 id = 'ld.wasm'
 
 def get_allow_undefined_args(self) -> T.Liststr:
- return '-s', 'ERROR_ON_UNDEFINED_SYMBOLS=0'
+ return '-sERROR_ON_UNDEFINED_SYMBOLS=0'
 
 def no_undefined_args(self) -> T.Liststr:
- return '-s', 'ERROR_ON_UNDEFINED_SYMBOLS=1'
+ return '-sERROR_ON_UNDEFINED_SYMBOLS=1'
 
 def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
 suffix: str, soversion: str, darwin_versions: T.Tuplestr, str) -> T.Liststr:
@@ -972,15 +1046,15 @@
 install_rpath: str) -> T.TupleT.Liststr, T.Setbytes:
 return (, set())
 
-class C2000DynamicLinker(DynamicLinker):
+class TIDynamicLinker(DynamicLinker):
 
- """Linker for Texas Instruments C2000 compiler."""
+ """Linker for Texas Instruments compiler family."""
 
- id = 'cl2000'
+ id = 'ti'
 
 def __init__(self, exelist: T.Liststr, for_machine: mesonlib.MachineChoice,
 *, version: str = 'unknown version'):
- super().__init__(exelist or 'cl2000.exe', for_machine, '', ,
+ super().__init__(exelist, for_machine, '', ,
 version=version)
 
 def get_link_whole_for(self, args: T.Liststr) -> T.Liststr:
@@ -1001,7 +1075,7 @@
 return '-z', f'--output_file={outputname}'
 
 def get_search_args(self, dirname: str) -> 'T.NoReturn':
- raise OSError('cl2000.exe does not have a search dir argument')
+ raise OSError('TI compilers do not have a search dir argument')
 
 def get_allow_undefined_args(self) -> T.Liststr:
 return 
@@ -1010,6 +1084,11 @@
 return 
 
 
+class C2000DynamicLinker(TIDynamicLinker):
+ # Required for backwards compat with projects created before ti-cgt support existed
+ id = 'cl2000'
+
+
 class ArmDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
 
 """Linker for the ARM compiler."""
@@ -1085,7 +1164,7 @@
 return 
 
 def get_std_shared_lib_args(self) -> T.Liststr:
- from ..compilers import NAGFortranCompiler
+ from ..compilers.fortran import NAGFortranCompiler
 return NAGFortranCompiler.get_nagfor_quiet(self.version) + '-Wl,-shared'
 
 
@@ -1126,7 +1205,7 @@
 self.id = 'ar'
 self.std_args = '-r'
 
- def get_std_link_args(self, is_thin: bool) -> T.Liststr:
+ def get_std_link_args(self, env: 'Environment', is_thin: bool) -> T.Liststr:
 return self.std_args
 
 def get_output_args(self, target: str) -> T.Liststr:
@@ -1173,7 +1252,7 @@
 
 def get_always_args(self) -> T.Liststr:
 parent = super().get_always_args() # type: ignore
- return self._apply_prefix('/nologo') + T.cast(T.Liststr, parent)
+ return self._apply_prefix('/nologo') + T.cast('T.Liststr', parent)
 
 def get_search_args(self, dirname: str) -> T.Liststr:
 return self._apply_prefix('/LIBPATH:' + dirname)
@@ -1263,6 +1342,9 @@
 def get_win_subsystem_args(self, value: str) -> T.Liststr:
 return self._apply_prefix(f'/SUBSYSTEM:{value.upper()}')
 
+ def get_thinlto_cache_args(self, path: str) -> T.Liststr:
+ return "/lldltocache:" + path
+
 
 class XilinkDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
 
@@ -1364,6 +1446,12 @@
 def get_allow_undefined_args(self) -> T.Liststr:
 return self._apply_prefix('-berok')
 
+ def get_link_whole_for(self, args: T.Liststr) -> T.Liststr:
+ # AIX's linker always links the whole archive: "The ld command
+ # processes all input files in the same manner, whether they are
+ # archives or not."
+ return args
+
 def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
 rpath_paths: T.Tuplestr, ..., build_rpath: str,
 install_rpath: str) -> T.TupleT.Liststr, T.Setbytes:
@@ -1401,7 +1489,7 @@
 
 def __init__(self, exelist: T.Liststr, for_machine: mesonlib.MachineChoice,
 *, version: str = 'unknown version'):
- # Use optlink instead of link so we don't interfer with other link.exe
+ # Use optlink instead of link so we don't interfere with other link.exe
 # implementations.
 super().__init__(exelist, for_machine, '', , version=version)
 
@@ -1434,7 +1522,7 @@
 # Built on Sun_Sep_30_21:09:22_CDT_2018
 # Cuda compilation tools, release 10.0, V10.0.166
 # we need the most verbose version output. Luckily starting with V
- return out.strip().split('V')-1
+ return out.strip().rsplit('V', maxsplit=1)-1
 
 def get_accepts_rsp(self) -> bool:
 # nvcc does not support response files
@@ -1454,7 +1542,7 @@
 #
 # nvcc fatal : Don't know what to do with 'subprojects/foo/libbar.so.0.1.2'
 #
- from ..compilers import CudaCompiler
+ from ..compilers.cuda import CudaCompiler
 return CudaCompiler.LINKER_PREFIX
 
 def fatal_warnings(self) -> T.Liststr:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mcompile.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mcompile.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Entrypoint script for backend agnostic compile."""
 
@@ -26,7 +27,7 @@
 from . import mlog
 from . import mesonlib
 from . import coredata
-from .mesonlib import MesonException, RealPathAction, setup_vsenv
+from .mesonlib import MesonException, RealPathAction, join_args, setup_vsenv
 from mesonbuild.environment import detect_ninja
 from mesonbuild.coredata import UserArrayOption
 from mesonbuild import build
@@ -118,7 +119,14 @@
     if not found_targets:
         raise MesonException(f'Can\'t invoke target `{target.full_name}`: target not found')
     elif len(found_targets) > 1:
-        raise MesonException(f'Can\'t invoke target `{target.full_name}`: ambiguous name. Add target type and/or path: `PATH/NAME:TYPE`')
+        suggestions: T.Liststr = 
+        for i in found_targets:
+            p = Path(i'filename'0).relative_to(resolved_bdir)
+            t = i'type'.replace(' ', '_')
+            suggestions.append(f'- ./{p}:{t}')
+        suggestions_str = '\n'.join(suggestions)
+        raise MesonException(f'Can\'t invoke target `{target.full_name}`: ambiguous name.'
+                             f'Add target type and/or path:\n{suggestions_str}')
 
     return found_targets0
 
@@ -183,11 +191,9 @@
 
     if options.targets:
         intro_data = parse_introspect_data(builddir)
-        has_run_target = any(map(
-            lambda t:
-                get_target_from_intro_data(ParsedTargetName(t), builddir, intro_data)'type' == 'run',
-            options.targets
-        ))
+        has_run_target = any(
+            get_target_from_intro_data(ParsedTargetName(t), builddir, intro_data)'type' == 'run'
+            for t in options.targets)
 
         if has_run_target:
             # `run` target can't be used the same way as other targets on `vs` backend.
@@ -329,13 +335,16 @@
 
     cdata = coredata.load(options.wd)
     b = build.load(options.wd)
-    setup_vsenv(b.need_vsenv)
+    vsenv_active = setup_vsenv(b.need_vsenv)
+    if vsenv_active:
+        mlog.log(mlog.green('INFO:'), 'automatically activated MSVC compiler environment')
 
     cmd =     # type: T.Liststr
     env = None  # type: T.OptionalT.Dictstr, str
 
     backend = cdata.get_option(mesonlib.OptionKey('backend'))
     assert isinstance(backend, str)
+    mlog.log(mlog.green('INFO:'), 'autodetecting backend as', backend)
     if backend == 'ninja':
         cmd, env = get_parsed_args_ninja(options, bdir)
     elif backend.startswith('vs'):
@@ -346,6 +355,7 @@
         raise MesonException(
             f'Backend `{backend}` is not yet supported by `compile`. Use generated project files directly instead.')
 
+    mlog.log(mlog.green('INFO:'), 'calculating backend command to run:', join_args(cmd))
     p, *_ = mesonlib.Popen_safe(cmd, stdout=sys.stdout.buffer, stderr=sys.stderr.buffer, env=env)
 
     return p.returncode

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mconf.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mconf.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import itertools
 import shutil
@@ -30,19 +31,23 @@
 
 if T.TYPE_CHECKING:
 import argparse
- from .coredata import UserOption
 
 def add_arguments(parser: 'argparse.ArgumentParser') -> None:
 coredata.register_builtin_arguments(parser)
 parser.add_argument('builddir', nargs='?', default='.')
 parser.add_argument('--clearcache', action='store_true', default=False,
 help='Clear cached state (e.g. found dependencies)')
+ parser.add_argument('--no-pager', action='store_false', dest='pager',
+ help='Do not redirect output to a pager')
 
-def make_lower_case(val: T.Any) -> T.Unionstr, T.ListT.Any: # T.Any because of recursion...
+def stringify(val: T.Any) -> T.Unionstr, T.ListT.Any: # T.Any because of recursion...
 if isinstance(val, bool):
 return str(val).lower()
 elif isinstance(val, list):
- return make_lower_case(i) for i in val
+ s = ', '.join(stringify(i) for i in val)
+ return f'{s}'
+ elif val is None:
+ return ''
 else:
 return str(val)
 
@@ -62,8 +67,6 @@
 self.value_col = 
 self.choices_col = 
 self.descr_col = 
- # XXX: is there a case where this can actually remain false?
- self.has_choices = False
 self.all_subprojects: T.Setstr = set()
 
 if os.path.isdir(os.path.join(self.build_dir, 'meson-private')):
@@ -94,7 +97,6 @@
 # Do nothing when using introspection
 if self.default_values_only:
 return
- # Only called if something has changed so overwrite unconditionally.
 coredata.save(self.coredata, self.build_dir)
 # We don't write the build file because any changes to it
 # are erased when Meson is executed the next time, i.e. when
@@ -113,41 +115,41 @@
 """
 total_width = shutil.get_terminal_size(fallback=(160, 0))0
 _col = max(total_width // 5, 20)
- four_column = (_col, _col, _col, total_width - (3 * _col))
- # In this case we don't have the choices field, so we can redistribute
- # the extra 40 characters to val and desc
- three_column = (_col, _col * 2, total_width // 2)
+ last_column = total_width - (3 * _col) - 3
+ four_column = (_col, _col, _col, last_column if last_column > 1 else _col)
 
 for line in zip(self.name_col, self.value_col, self.choices_col, self.descr_col):
 if not any(line):
- print('')
+ mlog.log('')
 continue
 
 # This is a header, like `Subproject foo:`,
 # We just want to print that and get on with it
 if line0 and not any(line1:):
- print(line0)
+ mlog.log(line0)
 continue
 
+ def wrap_text(text, width):
+ raw = text.text if isinstance(text, mlog.AnsiDecorator) else text
+ indent = ' ' if raw.startswith('') else ''
+ wrapped = textwrap.wrap(raw, width, subsequent_indent=indent)
+ if isinstance(text, mlog.AnsiDecorator):
+ wrapped = mlog.AnsiDecorator(i, text.code) for i in wrapped
+ # Add padding here to get even rows, as `textwrap.wrap()` will
+ # only shorten, not lengthen each item
+ return str(i) + ' ' * (width - len(i)) for i in wrapped
+
 # wrap will take a long string, and create a list of strings no
 # longer than the size given. Then that list can be zipped into, to
 # print each line of the output, such the that columns are printed
 # to the right width, row by row.
- if self.has_choices:
- name = textwrap.wrap(line0, four_column0)
- val = textwrap.wrap(line1, four_column1)
- choice = textwrap.wrap(line2, four_column2)
- desc = textwrap.wrap(line3, four_column3)
- for l in itertools.zip_longest(name, val, choice, desc, fillvalue=''):
- # We must use the length modifier here to get even rows, as
- # `textwrap.wrap` will only shorten, not lengthen each item
- print('{:{widths0}} {:{widths1}} {:{widths2}} {}'.format(*l, widths=four_column))
- else:
- name = textwrap.wrap(line0, three_column0)
- val = textwrap.wrap(line1, three_column1)
- desc = textwrap.wrap(line3, three_column2)
- for l in itertools.zip_longest(name, val, desc, fillvalue=''):
- print('{:{widths0}} {:{widths1}} {}'.format(*l, widths=three_column))
+ name = wrap_text(line0, four_column0)
+ val = wrap_text(line1, four_column1)
+ choice = wrap_text(line2, four_column2)
+ desc = wrap_text(line3, four_column3)
+ for l in itertools.zip_longest(name, val, choice, desc, fillvalue=''):
+ items = li if li else ' ' * four_columni for i in range(4)
+ mlog.log(*items)
 
 def split_options_per_subproject(self, options: 'coredata.KeyedOptionDictType') -> T.Dictstr, 'coredata.KeyedOptionDictType':
 result: T.Dictstr, 'coredata.KeyedOptionDictType' = {}
@@ -157,54 +159,34 @@
 result.setdefault(k.subproject, {})k = o
 return result
 
- def _add_line(self, name: OptionKey, value, choices, descr) -> None:
- self.name_col.append(' ' * self.print_margin + str(name))
+ def _add_line(self, name, value, choices, descr) -> None:
+ if isinstance(name, mlog.AnsiDecorator):
+ name.text = ' ' * self.print_margin + name.text
+ else:
+ name = ' ' * self.print_margin + name
+ self.name_col.append(name)
 self.value_col.append(value)
 self.choices_col.append(choices)
 self.descr_col.append(descr)
 
 def add_option(self, name, descr, value, choices):
- if isinstance(value, list):
- value = '{}'.format(', '.join(make_lower_case(value)))
- else:
- value = make_lower_case(value)
-
- if choices:
- self.has_choices = True
- if isinstance(choices, list):
- choices_list = make_lower_case(choices)
- current = ''
- while choices_list:
- i = choices_list.pop(0)
- if len(current) + len(i) >= self.max_choices_line_length:
- self._add_line(name, value, current + ',', descr)
- name = ''
- value = ''
- descr = ''
- current = ' '
- if len(current) > 1:
- current += ', '
- current += i
- choices = current + ''
- else:
- choices = make_lower_case(choices)
- else:
- choices = ''
-
- self._add_line(name, value, choices, descr)
+ value = stringify(value)
+ choices = stringify(choices)
+ self._add_line(mlog.green(name), mlog.yellow(value), mlog.blue(choices), descr)
 
 def add_title(self, title):
- titles = {'descr': 'Description', 'value': 'Current Value', 'choices': 'Possible Values'}
- if self.default_values_only:
- titles'value' = 'Default Value'
+ title = mlog.cyan(title)
+ descr = mlog.cyan('Description')
+ value = mlog.cyan('Default Value' if self.default_values_only else 'Current Value')
+ choices = mlog.cyan('Possible Values')
 self._add_line('', '', '', '')
- self._add_line(title, titles'value', titles'choices', titles'descr')
- self._add_line('-' * len(title), '-' * len(titles'value'), '-' * len(titles'choices'), '-' * len(titles'descr'))
+ self._add_line(title, value, choices, descr)
+ self._add_line('-' * len(title), '-' * len(value), '-' * len(choices), '-' * len(descr))
 
 def add_section(self, section):
 self.print_margin = 0
 self._add_line('', '', '', '')
- self._add_line(section + ':', '', '', '')
+ self._add_line(mlog.normal_yellow(section + ':'), '', '', '')
 self.print_margin = 2
 
 def print_options(self, title: str, options: 'coredata.KeyedOptionDictType') -> None:
@@ -212,26 +194,32 @@
 return
 if title:
 self.add_title(title)
+ auto = T.cast('coredata.UserFeatureOption', self.coredata.optionsOptionKey('auto_features'))
 for k, o in sorted(options.items()):
 printable_value = o.printable_value()
 root = k.as_root()
 if o.yielding and k.subproject and root in self.coredata.options:
 printable_value = '<inherited from main project>'
+ if isinstance(o, coredata.UserFeatureOption) and o.is_auto():
+ printable_value = auto.printable_value()
 self.add_option(str(root), o.description, printable_value, o.choices)
 
- def print_conf(self):
+ def print_conf(self, pager: bool):
+ if pager:
+ mlog.start_pager()
+
 def print_default_values_warning():
 mlog.warning('The source directory instead of the build directory was specified.')
 mlog.warning('Only the default values for the project are printed, and all command line parameters are ignored.')
 
 if self.default_values_only:
 print_default_values_warning()
- print('')
+ mlog.log('')
 
- print('Core properties:')
- print(' Source dir', self.source_dir)
+ mlog.log('Core properties:')
+ mlog.log(' Source dir', self.source_dir)
 if not self.default_values_only:
- print(' Build dir ', self.build_dir)
+ mlog.log(' Build dir ', self.build_dir)
 
 dir_option_names = set(coredata.BUILTIN_DIR_OPTIONS)
 test_option_names = {OptionKey('errorlogs'),
@@ -294,7 +282,7 @@
 
 # Print the warning twice so that the user shouldn't be able to miss it
 if self.default_values_only:
- print('')
+ mlog.log('')
 print_default_values_warning()
 
 self.print_nondefault_buildtype_options()
@@ -303,10 +291,10 @@
 mismatching = self.coredata.get_nondefault_buildtype_args()
 if not mismatching:
 return
- print("\nThe following option(s) have a different value than the build type default\n")
- print(' current default')
+ mlog.log("\nThe following option(s) have a different value than the build type default\n")
+ mlog.log(' current default')
 for m in mismatching:
- print(f'{m0:21}{m1:10}{m2:10}')
+ mlog.log(f'{m0:21}{m1:10}{m2:10}')
 
 def run(options):
 coredata.parse_cmd_line_options(options)
@@ -315,7 +303,7 @@
 try:
 c = Conf(builddir)
 if c.default_values_only:
- c.print_conf()
+ c.print_conf(options.pager)
 return 0
 
 save = False
@@ -327,14 +315,17 @@
 c.clear_cache()
 save = True
 else:
- c.print_conf()
+ c.print_conf(options.pager)
 if save:
 c.save()
 mintro.update_build_options(c.coredata, c.build.environment.info_dir)
 mintro.write_meson_info_file(c.build, )
 except ConfException as e:
- print('Meson configurator encountered an error:')
+ mlog.log('Meson configurator encountered an error:')
 if c is not None and c.build is not None:
 mintro.write_meson_info_file(c.build, e)
 raise e
+ except BrokenPipeError:
+ # Pager quit before we wrote everything.
+ pass
 return 0

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mdevenv.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mdevenv.py Changed

@@ -1,58 +1,187 @@
+from __future__ import annotations
+
 import os, subprocess
 import argparse
 import tempfile
+import shutil
+import itertools
 
 from pathlib import Path
-from . import build
-from .mesonlib import MesonException, RealPathAction, is_windows, setup_vsenv
+from . import build, minstall, dependencies
+from .mesonlib import (MesonException, is_windows, setup_vsenv, OptionKey,
+                       get_wine_shortpath, MachineChoice)
+from . import mlog
 
 import typing as T
+if T.TYPE_CHECKING:
+    from .backends import InstallData
+
+POWERSHELL_EXES = {'pwsh.exe', 'powershell.exe'}
 
 def add_arguments(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument('-C', dest='wd', action=RealPathAction,
-                        help='directory to cd into before running')
-    parser.add_argument('command', nargs=argparse.REMAINDER,
+    parser.add_argument('-C', dest='builddir', type=Path, default='.',
+                        help='Path to build directory')
+    parser.add_argument('--workdir', '-w', type=Path, default=None,
+                        help='Directory to cd into before running (default: builddir, Since 1.0.0)')
+    parser.add_argument('--dump', action='store_true',
+                        help='Only print required environment (Since 0.62.0)')
+    parser.add_argument('devcmd', nargs=argparse.REMAINDER, metavar='command',
                         help='Command to run in developer environment (default: interactive shell)')
 
-def get_windows_shell() -> str:
+def get_windows_shell() -> T.Optionalstr:
     mesonbuild = Path(__file__).parent
     script = mesonbuild / 'scripts' / 'cmd_or_ps.ps1'
-    command = 'powershell.exe', '-noprofile', '-executionpolicy', 'bypass', '-file', str(script)
-    result = subprocess.check_output(command)
-    return result.decode().strip()
+    for shell in POWERSHELL_EXES:
+        try:
+            command = shell, '-noprofile', '-executionpolicy', 'bypass', '-file', str(script)
+            result = subprocess.check_output(command)
+            return result.decode().strip()
+        except (subprocess.CalledProcessError, OSError):
+            pass
+    return None
 
-def get_env(b: build.Build, build_dir: str) -> T.Dictstr, str:
-    env = os.environ.copy()
-    for i in b.devenv:
-        env = i.get_env(env)
+def reduce_winepath(env: T.Dictstr, str) -> None:
+    winepath = env.get('WINEPATH')
+    if not winepath:
+        return
+    winecmd = shutil.which('wine64') or shutil.which('wine')
+    if not winecmd:
+        return
+    env'WINEPATH' = get_wine_shortpath(winecmd, winepath.split(';'))
+    mlog.log('Meson detected wine and has set WINEPATH accordingly')
 
+def get_env(b: build.Build, dump: bool) -> T.TupleT.Dictstr, str, T.Setstr:
     extra_env = build.EnvironmentVariables()
     extra_env.set('MESON_DEVENV', '1')
     extra_env.set('MESON_PROJECT_NAME', b.project_name)
 
-    meson_uninstalled = Path(build_dir) / 'meson-uninstalled'
-    if meson_uninstalled.is_dir():
-        extra_env.prepend('PKG_CONFIG_PATH', str(meson_uninstalled))
+    sysroot = b.environment.propertiesMachineChoice.HOST.get_sys_root()
+    if sysroot:
+        extra_env.set('QEMU_LD_PREFIX', sysroot)
+
+    env = {} if dump else os.environ.copy()
+    varnames = set()
+    for i in itertools.chain(b.devenv, {extra_env}):
+        env = i.get_env(env, dump)
+        varnames |= i.get_names()
+
+    reduce_winepath(env)
 
-    return extra_env.get_env(env)
+    return env, varnames
+
+def bash_completion_files(b: build.Build, install_data: 'InstallData') -> T.Liststr:
+    result = 
+    dep = dependencies.PkgConfigDependency('bash-completion', b.environment,
+                                           {'required': False, 'silent': True, 'version': '>=2.10'})
+    if dep.found():
+        prefix = b.environment.coredata.get_option(OptionKey('prefix'))
+        assert isinstance(prefix, str), 'for mypy'
+        datadir = b.environment.coredata.get_option(OptionKey('datadir'))
+        assert isinstance(datadir, str), 'for mypy'
+        datadir_abs = os.path.join(prefix, datadir)
+        completionsdir = dep.get_variable(pkgconfig='completionsdir', pkgconfig_define='datadir', datadir_abs)
+        assert isinstance(completionsdir, str), 'for mypy'
+        completionsdir_path = Path(completionsdir)
+        for f in install_data.data:
+            if completionsdir_path in Path(f.install_path).parents:
+                result.append(f.path)
+    return result
+
+def add_gdb_auto_load(autoload_path: Path, gdb_helper: str, fname: Path) -> None:
+    # Copy or symlink the GDB helper into our private directory tree
+    destdir = autoload_path / fname.parent
+    destdir.mkdir(parents=True, exist_ok=True)
+    try:
+        if is_windows():
+            shutil.copy(gdb_helper, str(destdir / os.path.basename(gdb_helper)))
+        else:
+            os.symlink(gdb_helper, str(destdir / os.path.basename(gdb_helper)))
+    except (FileExistsError, shutil.SameFileError):
+        pass
+
+def write_gdb_script(privatedir: Path, install_data: 'InstallData', workdir: Path) -> None:
+    if not shutil.which('gdb'):
+        return
+    bdir = privatedir.parent
+    autoload_basedir = privatedir / 'gdb-auto-load'
+    autoload_path = Path(autoload_basedir, *bdir.parts1:)
+    have_gdb_helpers = False
+    for d in install_data.data:
+        if d.path.endswith('-gdb.py') or d.path.endswith('-gdb.gdb') or d.path.endswith('-gdb.scm'):
+            # This GDB helper is made for a specific shared library, search if
+            # we have it in our builddir.
+            libname = Path(d.path).name.rsplit('-', 1)0
+            for t in install_data.targets:
+                path = Path(t.fname)
+                if path.name == libname:
+                    add_gdb_auto_load(autoload_path, d.path, path)
+                    have_gdb_helpers = True
+    if have_gdb_helpers:
+        gdbinit_line = f'add-auto-load-scripts-directory {autoload_basedir}\n'
+        gdbinit_path = bdir / '.gdbinit'
+        first_time = False
+        try:
+            with gdbinit_path.open('r+', encoding='utf-8') as f:
+                if gdbinit_line not in f.readlines():
+                    f.write(gdbinit_line)
+                    first_time = True
+        except FileNotFoundError:
+            gdbinit_path.write_text(gdbinit_line, encoding='utf-8')
+            first_time = True
+        if first_time:
+            gdbinit_path = gdbinit_path.resolve()
+            workdir_path = workdir.resolve()
+            rel_path = gdbinit_path.relative_to(workdir_path)
+            mlog.log('Meson detected GDB helpers and added config in', mlog.bold(str(rel_path)))
+            mlog.log('To load it automatically you might need to:')
+            mlog.log(' - Add', mlog.bold(f'add-auto-load-safe-path {gdbinit_path.parent}'),
+                     'in', mlog.bold('~/.gdbinit'))
+            if gdbinit_path.parent != workdir_path:
+                mlog.log(' - Change current workdir to', mlog.bold(str(rel_path.parent)),
+                         'or use', mlog.bold(f'--init-command {rel_path}'))
 
 def run(options: argparse.Namespace) -> int:
-    buildfile = Path(options.wd) / 'meson-private' / 'build.dat'
+    privatedir = Path(options.builddir) / 'meson-private'
+    buildfile = privatedir / 'build.dat'
     if not buildfile.is_file():
-        raise MesonException(f'Directory {options.wd!r} does not seem to be a Meson build directory.')
-    b = build.load(options.wd)
-    setup_vsenv(b.need_vsenv)
+        raise MesonException(f'Directory {options.builddir!r} does not seem to be a Meson build directory.')
+    b = build.load(options.builddir)
+    workdir = options.workdir or options.builddir
+
+    setup_vsenv(b.need_vsenv)  # Call it before get_env to get vsenv vars as well
+    devenv, varnames = get_env(b, options.dump)
+    if options.dump:
+        if options.devcmd:
+            raise MesonException('--dump option does not allow running other command.')
+        for name in varnames:
+            print(f'{name}="{devenvname}"')
+            print(f'export {name}')
+        return 0
+
+    if b.environment.need_exe_wrapper():
+        m = 'An executable wrapper could be required'
+        exe_wrapper = b.environment.get_exe_wrapper()
+        if exe_wrapper:
+            cmd = ' '.join(exe_wrapper.get_command())
+            m += f': {cmd}'
+        mlog.log(m)
 
-    devenv = get_env(b, options.wd)
+    install_data = minstall.load_install_data(str(privatedir / 'install.dat'))
+    write_gdb_script(privatedir, install_data, workdir)
 
-    args = options.command
+    args = options.devcmd
     if not args:
         prompt_prefix = f'{b.project_name}'
-        if is_windows():
+        shell_env = os.environ.get("SHELL")
+        # Prefer $SHELL in a MSYS2 bash despite it being Windows
+        if shell_env and os.path.exists(shell_env):
+            args = shell_env
+        elif is_windows():
             shell = get_windows_shell()
-            if shell == 'powershell.exe':
-                args = 'powershell.exe'
-                args += '-NoLogo', '-NoExit'
+            if not shell:
+                mlog.warning('Failed to determine Windows shell, fallback to cmd.exe')
+            if shell in POWERSHELL_EXES:
+                args = shell, '-NoLogo', '-NoExit'
                 prompt = f'function global:prompt {{  "{prompt_prefix} PS " + $PWD + "> "}}'
                 args += '-Command', prompt
             else:
@@ -60,20 +189,27 @@
                 args += '/k', f'prompt {prompt_prefix} $P$G'
         else:
             args = os.environ.get("SHELL", os.path.realpath("/bin/sh"))
-        if "bash" in args0 and not os.environ.get("MESON_DISABLE_PS1_OVERRIDE"):
+        if "bash" in args0:
+            # Let the GC remove the tmp file
             tmprc = tempfile.NamedTemporaryFile(mode='w')
-            bashrc = os.path.expanduser('~/.bashrc')
-            if os.path.exists(bashrc):
-                tmprc.write(f'. {bashrc}\n')
-            tmprc.write(f'export PS1="{prompt_prefix} $PS1"')
+            tmprc.write(' -e ~/.bashrc  && . ~/.bashrc\n')
+            if not os.environ.get("MESON_DISABLE_PS1_OVERRIDE"):
+                tmprc.write(f'export PS1="{prompt_prefix} $PS1"\n')
+            for f in bash_completion_files(b, install_data):
+                tmprc.write(f'. "{f}"\n')
             tmprc.flush()
-            # Let the GC remove the tmp file
             args.append("--rcfile")
             args.append(tmprc.name)
+    else:
+        # Try to resolve executable using devenv's PATH
+        abs_path = shutil.which(args0, path=devenv.get('PATH', None))
+        args0 = abs_path or args0
 
     try:
         return subprocess.call(args, close_fds=False,
                                env=devenv,
-                               cwd=options.wd)
+                               cwd=workdir)
     except subprocess.CalledProcessError as e:
         return e.returncode
+    except FileNotFoundError:
+        raise MesonException(f'Command not found: {args0}')

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mdist.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mdist.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 
 import argparse
@@ -23,7 +24,6 @@
 import tarfile
 import tempfile
 import hashlib
-import json
 from glob import glob
 from pathlib import Path
 from mesonbuild.environment import detect_ninja
@@ -43,6 +43,8 @@
 def add_arguments(parser):
     parser.add_argument('-C', dest='wd', action=RealPathAction,
                         help='directory to cd into before running')
+    parser.add_argument('--allow-dirty', action='store_true',
+                        help='Allow even when repository contains uncommitted changes.')
     parser.add_argument('--formats', default='xztar',
                         help='Comma separated list of archive types to create. Supports xztar (default), gztar, and zip.')
     parser.add_argument('--include-subprojects', action='store_true',
@@ -73,7 +75,16 @@
         t = tarfile.open(fileobj=f) # ignore encoding
         t.extractall(path=distdir)
 
-def process_submodules(src, distdir):
+msg_uncommitted_changes = 'Repository has uncommitted changes that will not be included in the dist tarball'
+
+def handle_dirty_opt(msg, allow_dirty: bool):
+    if allow_dirty:
+        mlog.warning(msg)
+    else:
+        mlog.error(msg + '\n' + 'Use --allow-dirty to ignore the warning and proceed anyway')
+        sys.exit(1)
+
+def process_submodules(src, distdir, options):
     module_file = os.path.join(src, '.gitmodules')
     if not os.path.exists(module_file):
         return
@@ -88,7 +99,7 @@
             mlog.warning(f'Submodule {subpath!r} is not checked out and cannot be added to the dist')
             continue
         elif status in {'+', 'U'}:
-            mlog.warning(f'Submodule {subpath!r} has uncommitted changes that will not be included in the dist tarball')
+            handle_dirty_opt(f'Submodule {subpath!r} has uncommitted changes that will not be included in the dist tarball', options.allow_dirty)
 
         copy_git(os.path.join(src, subpath), distdir, revision=sha1, prefix=subpath)
 
@@ -137,9 +148,9 @@
     ret = subprocess.call('git', '-C', src_root, 'diff-index', '--quiet', 'HEAD')
     return ret == 1
 
-def process_git_project(src_root, distdir):
+def process_git_project(src_root, distdir, options):
     if git_have_dirty_index(src_root):
-        mlog.warning('Repository has uncommitted changes that will not be included in the dist tarball')
+        handle_dirty_opt(msg_uncommitted_changes, options.allow_dirty)
     if os.path.exists(distdir):
         windows_proof_rmtree(distdir)
     repo_root = git_root(src_root)
@@ -155,18 +166,18 @@
         copy_git(repo_root, tmp_distdir, subdir=str(subdir))
         Path(tmp_distdir, subdir).rename(distdir)
         windows_proof_rmtree(tmp_distdir)
-    process_submodules(src_root, distdir)
+    process_submodules(src_root, distdir, options)
 
-def create_dist_git(dist_name, archives, src_root, bld_root, dist_sub, dist_scripts, subprojects):
+def create_dist_git(dist_name, archives, src_root, bld_root, dist_sub, dist_scripts, subprojects, options):
     distdir = os.path.join(dist_sub, dist_name)
-    process_git_project(src_root, distdir)
+    process_git_project(src_root, distdir, options)
     for path in subprojects.values():
         sub_src_root = os.path.join(src_root, path)
         sub_distdir = os.path.join(distdir, path)
         if os.path.exists(sub_distdir):
             continue
         if is_git(sub_src_root):
-            process_git_project(sub_src_root, sub_distdir)
+            process_git_project(sub_src_root, sub_distdir, options)
         else:
             shutil.copytree(sub_src_root, sub_distdir)
     run_dist_scripts(src_root, bld_root, distdir, dist_scripts, subprojects)
@@ -186,9 +197,9 @@
     out = subprocess.check_output('hg', '-R', src_root, 'summary')
     return b'commit: (clean)' not in out
 
-def create_dist_hg(dist_name, archives, src_root, bld_root, dist_sub, dist_scripts):
+def create_dist_hg(dist_name, archives, src_root, bld_root, dist_sub, dist_scripts, options):
     if hg_have_dirty_index(src_root):
-        mlog.warning('Repository has uncommitted changes that will not be included in the dist tarball')
+        handle_dirty_opt(msg_uncommitted_changes, options.allow_dirty)
     if dist_scripts:
         mlog.warning('dist scripts are not supported in Mercurial projects')
 
@@ -314,12 +325,12 @@
         extra_meson_args.append('-Dwrap_mode=nodownload')
 
     if is_git(src_root):
-        names = create_dist_git(dist_name, archives, src_root, bld_root, dist_sub, b.dist_scripts, subprojects)
+        names = create_dist_git(dist_name, archives, src_root, bld_root, dist_sub, b.dist_scripts, subprojects, options)
     elif is_hg(src_root):
         if subprojects:
             print('--include-subprojects option currently not supported with Mercurial')
             return 1
-        names = create_dist_hg(dist_name, archives, src_root, bld_root, dist_sub, b.dist_scripts)
+        names = create_dist_hg(dist_name, archives, src_root, bld_root, dist_sub, b.dist_scripts, options)
     else:
         print('Dist currently only works with Git or Mercurial repos')
         return 1

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mesondata.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mesondata.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2022 The Meson development team
+# Copyright 2021 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,383 +11,38 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 
-####
-####  WARNING: This is an automatically generated file! Do not edit!
-####           Generated by tools/gen_data.py
-####
-
-
-# TODO: Remember to remove this also from tools/gen_data.py
-from pathlib import Path
+import importlib.resources
+from pathlib import PurePosixPath, Path
 import typing as T
 
 if T.TYPE_CHECKING:
     from .environment import Environment
 
-######################
-# BEGIN Data section #
-######################
-
-file_0_data_preload_cmake = '''\
-if(MESON_PS_LOADED)
-  return()
-endif()
-
-set(MESON_PS_LOADED ON)
-
-cmake_policy(PUSH)
-cmake_policy(SET CMP0054 NEW) # https://cmake.org/cmake/help/latest/policy/CMP0054.html
-
-# Dummy macros that have a special meaning in the meson code
-macro(meson_ps_execute_delayed_calls)
-endmacro()
-
-macro(meson_ps_reload_vars)
-endmacro()
-
-macro(meson_ps_disabled_function)
-  message(WARNING "The function '${ARGV0}' is disabled in the context of CMake subprojects.\n"
-                  "This should not be an issue but may lead to compilation errors.")
-endmacro()
-
-# Helper macro to inspect the current CMake state
-macro(meson_ps_inspect_vars)
-  set(MESON_PS_CMAKE_CURRENT_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-  set(MESON_PS_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-  meson_ps_execute_delayed_calls()
-endmacro()
-
-
-# Override some system functions with custom code and forward the args
-# to the original function
-macro(add_custom_command)
-  meson_ps_inspect_vars()
-  _add_custom_command(${ARGV})
-endmacro()
-
-macro(add_custom_target)
-  meson_ps_inspect_vars()
-  _add_custom_target(${ARGV})
-endmacro()
-
-macro(set_property)
-  meson_ps_inspect_vars()
-  _set_property(${ARGV})
-endmacro()
-
-function(set_source_files_properties)
-  set(FILES)
-  set(I 0)
-  set(PROPERTIES OFF)
-
-  while(I LESS ARGC)
-    if(NOT PROPERTIES)
-      if("${ARGV${I}}" STREQUAL "PROPERTIES")
-        set(PROPERTIES ON)
-      else()
-        list(APPEND FILES "${ARGV${I}}")
-      endif()
-
-      math(EXPR I "${I} + 1")
-    else()
-      set(ID_IDX ${I})
-      math(EXPR PROP_IDX "${ID_IDX} + 1")
-
-      set(ID   "${ARGV${ID_IDX}}")
-      set(PROP "${ARGV${PROP_IDX}}")
-
-      set_property(SOURCE ${FILES} PROPERTY "${ID}" "${PROP}")
-      math(EXPR I "${I} + 2")
-    endif()
-  endwhile()
-endfunction()
-
-# Disable some functions that would mess up the CMake meson integration
-macro(target_precompile_headers)
-  meson_ps_disabled_function(target_precompile_headers)
-endmacro()
-
-set(MESON_PS_DELAYED_CALLS add_custom_command;add_custom_target;set_property)
-meson_ps_reload_vars()
-
-cmake_policy(POP)
-'''
-
-file_1_data_CMakeLists_txt = '''\
-# fail noisily if attempt to use this file without setting:
-# cmake_minimum_required(VERSION ${CMAKE_VERSION})
-# project(... LANGUAGES ...)
-
-cmake_policy(SET CMP0000 NEW)
-
-set(PACKAGE_FOUND FALSE)
-set(_packageName "${NAME}")
-string(TOUPPER "${_packageName}" PACKAGE_NAME)
-
-while(TRUE)
-  if ("${VERSION}" STREQUAL "")
-    find_package("${NAME}" QUIET COMPONENTS ${COMPS})
-  else()
-    find_package("${NAME}" "${VERSION}" QUIET COMPONENTS ${COMPS})
-  endif()
-
-  # ARCHS has to be set via the CMD interface
-  if(${_packageName}_FOUND OR ${PACKAGE_NAME}_FOUND OR "${ARCHS}" STREQUAL "")
-    break()
-  endif()
-
-  list(GET       ARCHS 0 CMAKE_LIBRARY_ARCHITECTURE)
-  list(REMOVE_AT ARCHS 0)
-endwhile()
-
-if(${_packageName}_FOUND  OR  ${PACKAGE_NAME}_FOUND)
-  set(PACKAGE_FOUND TRUE)
-
-  # Check the following variables:
-  # FOO_VERSION
-  # Foo_VERSION
-  # FOO_VERSION_STRING
-  # Foo_VERSION_STRING
-  if(NOT DEFINED PACKAGE_VERSION)
-    if(DEFINED ${_packageName}_VERSION)
-      set(PACKAGE_VERSION "${${_packageName}_VERSION}")
-    elseif(DEFINED ${PACKAGE_NAME}_VERSION)
-      set(PACKAGE_VERSION "${${PACKAGE_NAME}_VERSION}")
-    elseif(DEFINED ${_packageName}_VERSION_STRING)
-      set(PACKAGE_VERSION "${${_packageName}_VERSION_STRING}")
-    elseif(DEFINED ${PACKAGE_NAME}_VERSION_STRING)
-      set(PACKAGE_VERSION "${${PACKAGE_NAME}_VERSION_STRING}")
-    endif()
-  endif()
-
-  # Check the following variables:
-  # FOO_LIBRARIES
-  # Foo_LIBRARIES
-  # FOO_LIBS
-  # Foo_LIBS
-  set(libs)
-  if(DEFINED ${_packageName}_LIBRARIES)
-    set(libs ${_packageName}_LIBRARIES)
-  elseif(DEFINED ${PACKAGE_NAME}_LIBRARIES)
-    set(libs ${PACKAGE_NAME}_LIBRARIES)
-  elseif(DEFINED ${_packageName}_LIBS)
-    set(libs ${_packageName}_LIBS)
-  elseif(DEFINED ${PACKAGE_NAME}_LIBS)
-    set(libs ${PACKAGE_NAME}_LIBS)
-  endif()
-
-  # Check the following variables:
-  # FOO_INCLUDE_DIRS
-  # Foo_INCLUDE_DIRS
-  # FOO_INCLUDES
-  # Foo_INCLUDES
-  # FOO_INCLUDE_DIR
-  # Foo_INCLUDE_DIR
-  set(includes)
-  if(DEFINED ${_packageName}_INCLUDE_DIRS)
-    set(includes ${_packageName}_INCLUDE_DIRS)
-  elseif(DEFINED ${PACKAGE_NAME}_INCLUDE_DIRS)
-    set(includes ${PACKAGE_NAME}_INCLUDE_DIRS)
-  elseif(DEFINED ${_packageName}_INCLUDES)
-    set(includes ${_packageName}_INCLUDES)
-  elseif(DEFINED ${PACKAGE_NAME}_INCLUDES)
-    set(includes ${PACKAGE_NAME}_INCLUDES)
-  elseif(DEFINED ${_packageName}_INCLUDE_DIR)
-    set(includes ${_packageName}_INCLUDE_DIR)
-  elseif(DEFINED ${PACKAGE_NAME}_INCLUDE_DIR)
-    set(includes ${PACKAGE_NAME}_INCLUDE_DIR)
-  endif()
-
-  # Check the following variables:
-  # FOO_DEFINITIONS
-  # Foo_DEFINITIONS
-  set(definitions)
-  if(DEFINED ${_packageName}_DEFINITIONS)
-    set(definitions ${_packageName}_DEFINITIONS)
-  elseif(DEFINED ${PACKAGE_NAME}_DEFINITIONS)
-    set(definitions ${PACKAGE_NAME}_DEFINITIONS)
-  endif()
-
-  set(PACKAGE_INCLUDE_DIRS "${${includes}}")
-  set(PACKAGE_DEFINITIONS  "${${definitions}}")
-  set(PACKAGE_LIBRARIES    "${${libs}}")
-endif()
-'''
-
-file_2_data_CMakeListsLLVM_txt = '''\
-
-set(PACKAGE_FOUND FALSE)
-
-while(TRUE)
-  find_package(LLVM REQUIRED CONFIG QUIET)
-
-  # ARCHS has to be set via the CMD interface
-  if(LLVM_FOUND OR "${ARCHS}" STREQUAL "")
-    break()
-  endif()
-
-  list(GET       ARCHS 0 CMAKE_LIBRARY_ARCHITECTURE)
-  list(REMOVE_AT ARCHS 0)
-endwhile()
-
-if(LLVM_FOUND)
-  set(PACKAGE_FOUND TRUE)
-
-  foreach(mod IN LISTS LLVM_MESON_MODULES)
-    # Reset variables
-    set(out_mods)
-    set(real_mods)
-
-    # Generate a lower and upper case version
-    string(TOLOWER "${mod}" mod_L)
-    string(TOUPPER "${mod}" mod_U)
-
-    # Get the mapped components
-    llvm_map_components_to_libnames(out_mods ${mod} ${mod_L} ${mod_U})
-    list(SORT              out_mods)
-    list(REMOVE_DUPLICATES out_mods)
-
-    # Make sure that the modules exist
-    foreach(i IN LISTS out_mods)
-      if(TARGET ${i})
-        list(APPEND real_mods ${i})
-      endif()
-    endforeach()
-
-    # Set the output variables
-    set(MESON_LLVM_TARGETS_${mod} ${real_mods})
-    foreach(i IN LISTS real_mods)
-      set(MESON_TARGET_TO_LLVM_${i} ${mod})
-    endforeach()
-  endforeach()
-
-  # Check the following variables:
-  # LLVM_PACKAGE_VERSION
-  # LLVM_VERSION
-  # LLVM_VERSION_STRING
-  if(NOT DEFINED PACKAGE_VERSION)
-    if(DEFINED LLVM_PACKAGE_VERSION)
-      set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
-    elseif(DEFINED LLVM_VERSION)
-      set(PACKAGE_VERSION "${LLVM_VERSION}")
-    elseif(DEFINED LLVM_VERSION_STRING)
-      set(PACKAGE_VERSION "${LLVM_VERSION_STRING}")
-    endif()
-  endif()
-
-  # Check the following variables:
-  # LLVM_LIBRARIES
-  # LLVM_LIBS
-  set(libs)
-  if(DEFINED LLVM_LIBRARIES)
-    set(libs LLVM_LIBRARIES)
-  elseif(DEFINED LLVM_LIBS)
-    set(libs LLVM_LIBS)
-  endif()
-
-  # Check the following variables:
-  # LLVM_INCLUDE_DIRS
-  # LLVM_INCLUDES
-  # LLVM_INCLUDE_DIR
-  set(includes)
-  if(DEFINED LLVM_INCLUDE_DIRS)
-    set(includes LLVM_INCLUDE_DIRS)
-  elseif(DEFINED LLVM_INCLUDES)
-    set(includes LLVM_INCLUDES)
-  elseif(DEFINED LLVM_INCLUDE_DIR)
-    set(includes LLVM_INCLUDE_DIR)
-  endif()
-
-  # Check the following variables:
-  # LLVM_DEFINITIONS
-  set(definitions)
-  if(DEFINED LLVM_DEFINITIONS)
-    set(definitions LLVM_DEFINITIONS)
-  endif()
-
-  set(PACKAGE_INCLUDE_DIRS "${${includes}}")
-  set(PACKAGE_DEFINITIONS  "${${definitions}}")
-  set(PACKAGE_LIBRARIES    "${${libs}}")
-endif()
-'''
-
-file_3_data_CMakePathInfo_txt = '''\
-cmake_minimum_required(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION})
-
-set(TMP_PATHS_LIST)
-list(APPEND TMP_PATHS_LIST ${CMAKE_PREFIX_PATH})
-list(APPEND TMP_PATHS_LIST ${CMAKE_FRAMEWORK_PATH})
-list(APPEND TMP_PATHS_LIST ${CMAKE_APPBUNDLE_PATH})
-list(APPEND TMP_PATHS_LIST $ENV{CMAKE_PREFIX_PATH})
-list(APPEND TMP_PATHS_LIST $ENV{CMAKE_FRAMEWORK_PATH})
-list(APPEND TMP_PATHS_LIST $ENV{CMAKE_APPBUNDLE_PATH})
-list(APPEND TMP_PATHS_LIST ${CMAKE_SYSTEM_PREFIX_PATH})
-list(APPEND TMP_PATHS_LIST ${CMAKE_SYSTEM_FRAMEWORK_PATH})
-list(APPEND TMP_PATHS_LIST ${CMAKE_SYSTEM_APPBUNDLE_PATH})
-
-set(LIB_ARCH_LIST)
-if(CMAKE_LIBRARY_ARCHITECTURE_REGEX)
-  file(GLOB implicit_dirs RELATIVE /lib /lib/*-linux-gnu* )
-  foreach(dir ${implicit_dirs})
-    if("${dir}" MATCHES "${CMAKE_LIBRARY_ARCHITECTURE_REGEX}")
-      list(APPEND LIB_ARCH_LIST "${dir}")
-    endif()
-  endforeach()
-endif()
-
-# "Export" these variables:
-set(MESON_ARCH_LIST ${LIB_ARCH_LIST})
-set(MESON_PATHS_LIST ${TMP_PATHS_LIST})
-set(MESON_CMAKE_ROOT ${CMAKE_ROOT})
-set(MESON_CMAKE_SYSROOT ${CMAKE_SYSROOT})
-set(MESON_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH})
-
-message(STATUS ${TMP_PATHS_LIST})
-'''
-
-
-####################
-# END Data section #
-####################
-
 class DataFile:
-    def __init__(self, path: Path, sha256sum: str, data: str) -> None:
-        self.path = path
-        self.sha256sum = sha256sum
-        self.data = data
+    def __init__(self, path: str) -> None:
+        self.path = PurePosixPath(path)
 
     def write_once(self, path: Path) -> None:
         if not path.exists():
-            path.write_text(self.data, encoding='utf-8')
+            data = importlib.resources.read_text( # ignore encoding it's on the next lines, Mr. Lint
+                    ('mesonbuild' / self.path.parent).as_posix().replace('/', '.'),
+                    self.path.name,
+                    encoding='utf-8')
+            path.write_text(data, encoding='utf-8')
 
     def write_to_private(self, env: 'Environment') -> Path:
+        try:
+            resource = importlib.resources.files('mesonbuild') / self.path
+            if isinstance(resource, Path):
+                return resource
+        except AttributeError:
+            # fall through to python 3.7 compatible code
+            pass
+
         out_file = Path(env.scratch_dir) / 'data' / self.path.name
         out_file.parent.mkdir(exist_ok=True)
         self.write_once(out_file)
         return out_file
-
-
-mesondata = {
-    'cmake/data/preload.cmake': DataFile(
-        Path('cmake/data/preload.cmake'),
-        'ce8f30159aab25b92c26c58a219a427d47838bfa0739475221d6c8993b4946e5',
-        file_0_data_preload_cmake,
-    ),
-    'dependencies/data/CMakeLists.txt': DataFile(
-        Path('dependencies/data/CMakeLists.txt'),
-        '4dca24afa13e9311f0598a6ac29690490819bd7d82cfdaa0a2fe5eea3c0fa0d5',
-        file_1_data_CMakeLists_txt,
-    ),
-    'dependencies/data/CMakeListsLLVM.txt': DataFile(
-        Path('dependencies/data/CMakeListsLLVM.txt'),
-        'a824db0251c77482993534230f33c521275047a37189ae0ac80d9078e4d7006e',
-        file_2_data_CMakeListsLLVM_txt,
-    ),
-    'dependencies/data/CMakePathInfo.txt': DataFile(
-        Path('dependencies/data/CMakePathInfo.txt'),
-        '90da8b443982d9c87139b7dc84228eb58cab4315764949637208f25e2bda7db2',
-        file_3_data_CMakePathInfo_txt,
-    ),
-}

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mesonlib.py Added

@@ -0,0 +1,35 @@
+# SPDX-license-identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# pylint: skip-file
+
+"""Helper functions and classes."""
+
+import os
+
+from .utils.core import *
+from .utils.vsenv import *
+
+from .utils.universal import *
+
+# Here we import either the posix implementations, the windows implementations,
+# or a generic no-op implementation
+if os.name == 'posix':
+    from .utils.posix import *
+elif os.name == 'nt':
+    from .utils.win32 import *
+else:
+    from .utils.platform import *

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mesonmain.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mesonmain.py Changed

@@ -11,32 +11,70 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 # Work around some pathlib bugs...
+
 from . import _pathlib
 import sys
 sys.modules'pathlib' = _pathlib
 
+# This file is an entry point for all commands, including scripts. Include the
+# strict minimum python modules for performance reasons.
 import os.path
 import platform
 import importlib
-import traceback
 import argparse
-import codecs
-import shutil
 
-from . import mesonlib
+from .utils.core import MesonException, MesonBugException
 from . import mlog
-from . import mconf, mdist, minit, minstall, mintro, msetup, mtest, rewriter, msubprojects, munstable_coredata, mcompile, mdevenv
-from .mesonlib import MesonException, MesonBugException
-from .environment import detect_msys2_arch
-from .wrap import wraptool
 
+def errorhandler(e, command):
+ import traceback
+ if isinstance(e, MesonException):
+ mlog.exception(e)
+ logfile = mlog.shutdown()
+ if logfile is not None:
+ mlog.log("\nA full log can be found at", mlog.bold(logfile))
+ if os.environ.get('MESON_FORCE_BACKTRACE'):
+ raise e
+ return 1
+ else:
+ # We assume many types of traceback are Meson logic bugs, but most
+ # particularly anything coming from the interpreter during `setup`.
+ # Some things definitely aren't:
+ # - PermissionError is always a problem in the user environment
+ # - runpython doesn't run Meson's own code, even though it is
+ # dispatched by our run()
+ if os.environ.get('MESON_FORCE_BACKTRACE'):
+ raise e
+ traceback.print_exc()
+
+ if command == 'runpython':
+ return 2
+ elif isinstance(e, OSError):
+ mlog.exception("Unhandled python OSError. This is probably not a Meson bug, "
+ "but an issue with your build environment.")
+ return e.errno
+ else: # Exception
+ msg = 'Unhandled python exception'
+ if all(getattr(e, a, None) is not None for a in 'file', 'lineno', 'colno'):
+ e = MesonBugException(msg, e.file, e.lineno, e.colno) # type: ignore
+ else:
+ e = MesonBugException(msg)
+ mlog.exception(e)
+ return 2
 
 # Note: when adding arguments, please also add them to the completion
 # scripts in $MESONSRC/data/shell-completions/
 class CommandLineParser:
 def __init__(self):
+ # only import these once we do full argparse processing
+ from . import mconf, mdist, minit, minstall, mintro, msetup, mtest, rewriter, msubprojects, munstable_coredata, mcompile, mdevenv
+ from .scripts import env2mfile
+ from .wrap import wraptool
+ import shutil
+
 self.term_width = shutil.get_terminal_size().columns
 self.formatter = lambda prog: argparse.HelpFormatter(prog, max_help_position=int(self.term_width / 2), width=self.term_width)
 
@@ -63,14 +101,17 @@
 help_msg='Wrap tools')
 self.add_command('subprojects', msubprojects.add_arguments, msubprojects.run,
 help_msg='Manage subprojects')
- self.add_command('help', self.add_help_arguments, self.run_help_command,
- help_msg='Print help of a subcommand')
 self.add_command('rewrite', lambda parser: rewriter.add_arguments(parser, self.formatter), rewriter.run,
 help_msg='Modify the project definition')
 self.add_command('compile', mcompile.add_arguments, mcompile.run,
 help_msg='Build the project')
 self.add_command('devenv', mdevenv.add_arguments, mdevenv.run,
 help_msg='Run commands in developer environment')
+ self.add_command('env2mfile', env2mfile.add_arguments, env2mfile.run,
+ help_msg='Convert current environment to a cross or native file')
+ # Add new commands above this line to list them in help command
+ self.add_command('help', self.add_help_arguments, self.run_help_command,
+ help_msg='Print help of a subcommand')
 
 # Hidden commands
 self.add_command('runpython', self.add_runpython_arguments, self.run_runpython_command,
@@ -99,17 +140,17 @@
 parser.add_argument('script_args', nargs=argparse.REMAINDER)
 
 def run_runpython_command(self, options):
- import runpy
+ sys.argv1: = options.script_args
 if options.eval_arg:
 exec(options.script_file)
 else:
- sys.argv1: = options.script_args
+ import runpy
 sys.path.insert(0, os.path.dirname(options.script_file))
 runpy.run_path(options.script_file, run_name='__main__')
 return 0
 
 def add_help_arguments(self, parser):
- parser.add_argument('command', nargs='?')
+ parser.add_argument('command', nargs='?', choices=list(self.commands.keys()))
 
 def run_help_command(self, options):
 if options.command:
@@ -119,11 +160,12 @@
 return 0
 
 def run(self, args):
- pending_python_deprecation_notice = False
+ implicit_setup_command_notice = False
 # If first arg is not a known command, assume user wants to run the setup
 # command.
 known_commands = list(self.commands.keys()) + '-h', '--help'
 if not args or args0 not in known_commands:
+ implicit_setup_command_notice = True
 args = 'setup' + args
 
 # Hidden commands have their own parser instead of using the global one
@@ -135,42 +177,27 @@
 parser = self.parser
 command = None
 
+ from . import mesonlib
 args = mesonlib.expand_arguments(args)
 options = parser.parse_args(args)
 
 if command is None:
 command = options.command
 
- if command in ('setup', 'compile', 'test', 'install') and sys.version_info < (3, 7):
- pending_python_deprecation_notice = True
+ # Bump the version here in order to add a pre-exit warning that we are phasing out
+ # support for old python. If this is already the oldest supported version, then
+ # this can never be true and does nothing.
+ pending_python_deprecation_notice = \
+ command in {'setup', 'compile', 'test', 'install'} and sys.version_info < (3, 7)
 
 try:
 return options.run_func(options)
- except MesonException as e:
- mlog.exception(e)
- logfile = mlog.shutdown()
- if logfile is not None:
- mlog.log("\nA full log can be found at", mlog.bold(logfile))
- if os.environ.get('MESON_FORCE_BACKTRACE'):
- raise
- return 1
- except PermissionError:
- if os.environ.get('MESON_FORCE_BACKTRACE'):
- raise
- traceback.print_exc()
- return 2
 except Exception as e:
- if os.environ.get('MESON_FORCE_BACKTRACE'):
- raise
- traceback.print_exc()
- msg = 'Unhandled python exception'
- if all(getattr(e, a, None) is not None for a in 'file', 'lineno', 'colno'):
- e = MesonBugException(msg, e.file, e.lineno, e.colno) # type: ignore
- else:
- e = MesonBugException(msg)
- mlog.exception(e)
- return 2
+ return errorhandler(e, command)
 finally:
+ if implicit_setup_command_notice:
+ mlog.warning('Running the setup command as `meson options` instead of '
+ '`meson setup options` is ambiguous and deprecated.', fatal=False)
 if pending_python_deprecation_notice:
 mlog.notice('You are using Python 3.6 which is EOL. Starting with v0.62.0, '
 'Meson will require Python 3.7 or newer', fatal=False)
@@ -201,26 +228,25 @@
 
 def ensure_stdout_accepts_unicode():
 if sys.stdout.encoding and not sys.stdout.encoding.upper().startswith('UTF-'):
- if sys.version_info >= (3, 7):
- sys.stdout.reconfigure(errors='surrogateescape')
- else:
- sys.stdout = codecs.getwriter('utf-8')(sys.stdout.detach(),
- errors='surrogateescape')
- sys.stdout.encoding = 'UTF-8'
- if not hasattr(sys.stdout, 'buffer'):
- sys.stdout.buffer = sys.stdout.raw if hasattr(sys.stdout, 'raw') else sys.stdout
+ sys.stdout.reconfigure(errors='surrogateescape')
 
-def run(original_args, mainfile):
- if sys.version_info < (3, 6):
- print('Meson works correctly only with python 3.6+.')
- print(f'You have python {sys.version}.')
- print('Please update your environment')
- return 1
+def set_meson_command(mainfile):
+ # Set the meson command that will be used to run scripts and so on
+ from . import mesonlib
+ mesonlib.set_meson_command(mainfile)
 
+def run(original_args, mainfile):
 if sys.version_info >= (3, 10) and os.environ.get('MESON_RUNNING_IN_PROJECT_TESTS'):
 # workaround for https://bugs.python.org/issue34624
 import warnings
 warnings.filterwarnings('error', category=EncodingWarning, module='mesonbuild')
+ # python 3.11 adds a warning that in 3.15, UTF-8 mode will be default.
+ # This is fantastic news, we'd love that. Less fantastic: this warning is silly,
+ # we *want* these checks to be affected. Plus, the recommended alternative API
+ # would (in addition to warning people when UTF-8 mode removed the problem) also
+ # require using a minimum python version of 3.11 (in which the warning was added)
+ # or add verbose if/else soup.
+ warnings.filterwarnings('ignore', message="UTF-8 Mode affects .*getpreferredencoding", category=EncodingWarning)
 
 # Meson gets confused if stdout can't output Unicode, if the
 # locale isn't Unicode, just force stdout to accept it. This tries
@@ -228,30 +254,27 @@
 ensure_stdout_accepts_unicode()
 
 # https://github.com/mesonbuild/meson/issues/3653
- if sys.platform.lower() == 'msys':
- mlog.error('This python3 seems to be msys/python on MSYS2 Windows, which is known to have path semantics incompatible with Meson')
- msys2_arch = detect_msys2_arch()
- if msys2_arch:
- mlog.error('Please install and use mingw-w64-i686-python3 and/or mingw-w64-x86_64-python3 with Pacman')
- else:
- mlog.error('Please download and use Python as detailed at: https://mesonbuild.com/Getting-meson.html')
+ if sys.platform == 'cygwin' and os.environ.get('MSYSTEM', '') not in 'MSYS', '':
+ mlog.error('This python3 seems to be msys/python on MSYS2 Windows, but you are in a MinGW environment')
+ mlog.error('Please install and use mingw-w64-x86_64-python3 and/or mingw-w64-x86_64-meson with Pacman')
 return 2
 
- # Set the meson command that will be used to run scripts and so on
- mesonlib.set_meson_command(mainfile)
-
 args = original_args:
 
 # Special handling of internal commands called from backends, they don't
 # need to go through argparse.
 if len(args) >= 2 and args0 == '--internal':
 if args1 == 'regenerate':
- # Rewrite "meson --internal regenerate" command line to
- # "meson --reconfigure"
- args = '--reconfigure' + args2:
+ set_meson_command(mainfile)
+ from . import msetup
+ try:
+ return msetup.run('--reconfigure' + args2:)
+ except Exception as e:
+ return errorhandler(e, 'setup')
 else:
 return run_script_command(args1, args2:)
 
+ set_meson_command(mainfile)
 return CommandLineParser().run(args)
 
 def main():

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/minit.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/minit.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Code that creates simple startup projects."""
 
@@ -23,6 +24,7 @@
 import re
 from glob import glob
 from mesonbuild import mesonlib
+from mesonbuild.coredata import FORBIDDEN_TARGET_NAMES
 from mesonbuild.environment import detect_ninja
 from mesonbuild.templates.samplefactory import sameple_generator
 import typing as T
@@ -81,6 +83,9 @@
     if not options.executable:
         options.executable = options.name
         print(f'Using "{options.executable}" (project name) as name of executable to build.')
+    if options.executable in FORBIDDEN_TARGET_NAMES:
+        raise mesonlib.MesonException(f'Executable name {options.executable!r} is reserved for Meson internal use. '
+                                      'Refusing to init an invalid project.')
     if sample:
         # The rest of the autodetection is not applicable to generating sample projects.
         return
@@ -93,14 +98,14 @@
             raise SystemExit('No recognizable source files found.\n'
                              'Run meson init in an empty directory to create a sample project.')
         options.srcfiles = srcfiles
-        print("Detected source files: " + ' '.join(map(str, srcfiles)))
+        print("Detected source files: " + ' '.join(str(s) for s in srcfiles))
     options.srcfiles = Path(f) for f in options.srcfiles
     if not options.language:
         for f in options.srcfiles:
             if f.suffix == '.c':
                 options.language = 'c'
                 break
-            if f.suffix in ('.cc', '.cpp'):
+            if f.suffix in {'.cc', '.cpp'}:
                 options.language = 'cpp'
                 break
             if f.suffix == '.cs':

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/minstall.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/minstall.py Changed

@@ -11,14 +11,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from glob import glob
 from pathlib import Path
 import argparse
 import errno
 import os
-import pickle
-import platform
 import shlex
 import shutil
 import subprocess
@@ -27,13 +26,8 @@
 
 from . import build
 from . import environment
-from .backend.backends import (
- InstallData, InstallDataBase, InstallEmptyDir, InstallSymlinkData,
- TargetInstallData, ExecutableSerialisation
-)
-from .coredata import major_versions_differ, MesonVersionMismatchException
-from .coredata import version as coredata_version
-from .mesonlib import MesonException, Popen_safe, RealPathAction, is_windows, setup_vsenv
+from .backend.backends import InstallData
+from .mesonlib import MesonException, Popen_safe, RealPathAction, is_windows, setup_vsenv, pickle_load, is_osx
 from .scripts import depfixer, destdir_join
 from .scripts.meson_exe import run_exe
 try:
@@ -44,6 +38,10 @@
 main_file = None
 
 if T.TYPE_CHECKING:
+ from .backend.backends import (
+ ExecutableSerialisation, InstallDataBase, InstallEmptyDir,
+ InstallSymlinkData, TargetInstallData
+ )
 from .mesonlib import FileMode
 
 try:
@@ -62,6 +60,7 @@
 dry_run: bool
 skip_subprojects: str
 tags: str
+ strip: bool
 
 
 symlink_warning = '''Warning: trying to copy a symlink that points to a file. This will copy the file,
@@ -89,6 +88,8 @@
 help='Do not install files from given subprojects. (Since 0.58.0)')
 parser.add_argument('--tags', default=None,
 help='Install only targets having one of the given tags. (Since 0.60.0)')
+ parser.add_argument('--strip', action='store_true',
+ help='Strip targets even if strip option was not set during configure. (Since 0.62.0)')
 
 class DirMaker:
 def __init__(self, lf: T.TextIO, makedirs: T.Callable..., None):
@@ -128,6 +129,11 @@
 append_to_log(self.lf, d)
 
 
+def load_install_data(fname: str) -> InstallData:
+ obj = pickle_load(fname, 'InstallData', InstallData)
+ assert isinstance(obj, InstallData), 'fo mypy'
+ return obj
+
 def is_executable(path: str, follow_symlinks: bool = False) -> bool:
 '''Checks whether any of the "x" bits are set in the source file mode.'''
 return bool(os.stat(path, follow_symlinks=follow_symlinks).st_mode & 0o111)
@@ -216,7 +222,7 @@
 try:
 set_chmod(path, mode.perms, follow_symlinks=False)
 except PermissionError as e:
- print('{path!r}: Unable to set permissions {mode.perms_s!r}: {e.strerror}, ignoring...')
+ print(f'{path!r}: Unable to set permissions {mode.perms_s!r}: {e.strerror}, ignoring...')
 else:
 sanitize_permissions(path, default_umask)
 
@@ -229,7 +235,7 @@
 '''
 try:
 subprocess.check_call('selinuxenabled')
- except (FileNotFoundError, NotADirectoryError, PermissionError, subprocess.CalledProcessError):
+ except (FileNotFoundError, NotADirectoryError, OSError, PermissionError, subprocess.CalledProcessError):
 # If we don't have selinux or selinuxenabled returned 1, failure
 # is ignored quietly.
 return
@@ -248,41 +254,6 @@
 'Standard output:', out,
 'Standard error:', err, sep='\n')
 
-def apply_ldconfig(dm: DirMaker, libdir: str) -> None:
- '''
- Apply ldconfig to update the ld.so.cache.
- '''
- if not shutil.which('ldconfig'):
- # If we don't have ldconfig, failure is ignored quietly.
- return
-
- platlower = platform.system().lower()
- if platlower == 'dragonfly' or 'bsd' in platlower:
- if libdir in dm.all_dirs:
- proc, out, err = Popen_safe('ldconfig', '-m', libdir)
- if proc.returncode != 0:
- print('Failed to apply ldconfig ...',
- 'Standard output:', out,
- 'Standard error:', err, sep='\n')
- return
-
- # Try to update ld cache, it could fail if we don't have permission.
- proc, out, err = Popen_safe('ldconfig', '-v')
- if proc.returncode == 0:
- return
-
- # ldconfig failed, print the error only if we actually installed files in
- # any of the directories it lookup for libraries. Otherwise quietly ignore
- # the error.
- for l in out.splitlines():
- # Lines that start with a \t are libraries, not directories.
- if not l or l0.isspace():
- continue
- # Example: `/usr/lib/i386-linux-gnu/i686: (hwcap: 0x0002000000000000)`
- if l:l.find(':') in dm.all_dirs:
- print(f'Failed to apply ldconfig:\n{err}')
- break
-
 def get_destdir_path(destdir: str, fullprefix: str, path: str) -> str:
 if os.path.isabs(path):
 output = destdir_join(destdir, path)
@@ -384,11 +355,6 @@
 if not self.dry_run and not destdir:
 restore_selinux_contexts()
 
- def apply_ldconfig(self, dm: DirMaker, destdir: str, is_cross_build: bool, libdir: str) -> None:
- if any(self.dry_run, destdir, is_cross_build):
- return
- apply_ldconfig(dm, libdir)
-
 def Popen_safe(self, *args: T.Any, **kwargs: T.Any) -> T.Tupleint, str, str:
 if not self.dry_run:
 p, o, e = Popen_safe(*args, **kwargs)
@@ -460,13 +426,13 @@
 append_to_log(self.lf, to_file)
 return True
 
- def do_symlink(self, target: str, link: str, destdir: str, full_dst_dir: str) -> bool:
+ def do_symlink(self, target: str, link: str, destdir: str, full_dst_dir: str, allow_missing: bool) -> bool:
 abs_target = target
 if not os.path.isabs(target):
 abs_target = os.path.join(full_dst_dir, target)
- elif not os.path.exists(abs_target):
+ elif not os.path.exists(abs_target) and not allow_missing:
 abs_target = destdir_join(destdir, abs_target)
- if not os.path.exists(abs_target):
+ if not os.path.exists(abs_target) and not allow_missing:
 raise MesonException(f'Tried to install symlink to missing file {abs_target}')
 if os.path.exists(link):
 if not os.path.islink(link):
@@ -553,17 +519,8 @@
 self.do_copyfile(abs_src, abs_dst)
 self.set_mode(abs_dst, install_mode, data.install_umask)
 
- @staticmethod
- def check_installdata(obj: InstallData) -> InstallData:
- if not isinstance(obj, InstallData) or not hasattr(obj, 'version'):
- raise MesonVersionMismatchException('<unknown>', coredata_version)
- if major_versions_differ(obj.version, coredata_version):
- raise MesonVersionMismatchException(obj.version, coredata_version)
- return obj
-
 def do_install(self, datafilename: str) -> None:
- with open(datafilename, 'rb') as ifile:
- d = self.check_installdata(pickle.load(ifile))
+ d = load_install_data(datafilename)
 
 destdir = self.options.destdir
 if destdir is None:
@@ -576,7 +533,6 @@
 os.environ'DESTDIR' = destdir
 destdir = destdir or ''
 fullprefix = destdir_join(destdir, d.prefix)
- libdir = os.path.join(d.prefix, d.libdir)
 
 if d.install_umask != 'preserve':
 assert isinstance(d.install_umask, int)
@@ -593,7 +549,6 @@
 self.install_data(d, dm, destdir, fullprefix)
 self.install_symlinks(d, dm, destdir, fullprefix)
 self.restore_selinux_contexts(destdir)
- self.apply_ldconfig(dm, destdir, d.is_cross_build, libdir)
 self.run_install_script(d, destdir, fullprefix)
 if not self.did_install_something:
 self.log('Nothing to install.')
@@ -609,6 +564,21 @@
 else:
 raise
 
+ def do_strip(self, strip_bin: T.Liststr, fname: str, outname: str) -> None:
+ self.log(f'Stripping target {fname!r}.')
+ if is_osx():
+ # macOS expects dynamic objects to be stripped with -x maximum.
+ # To also strip the debug info, -S must be added.
+ # See: https://www.unix.com/man-page/osx/1/strip/
+ returncode, stdo, stde = self.Popen_safe(strip_bin + '-S', '-x', outname)
+ else:
+ returncode, stdo, stde = self.Popen_safe(strip_bin + outname)
+ if returncode != 0:
+ print('Could not strip file.\n')
+ print(f'Stdout:\n{stdo}\n')
+ print(f'Stderr:\n{stde}\n')
+ sys.exit(1)
+
 def install_subdirs(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:
 for i in d.install_subdirs:
 if not self.should_install(i):
@@ -637,7 +607,7 @@
 full_dst_dir = get_destdir_path(destdir, fullprefix, s.install_path)
 full_link_name = get_destdir_path(destdir, fullprefix, s.name)
 dm.makedirs(full_dst_dir, exist_ok=True)
- if self.do_symlink(s.target, full_link_name, destdir, full_dst_dir):
+ if self.do_symlink(s.target, full_link_name, destdir, full_dst_dir, s.allow_missing):
 self.did_install_something = True
 
 def install_man(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:
@@ -721,8 +691,7 @@
 outdir = get_destdir_path(destdir, fullprefix, t.outdir)
 outname = os.path.join(outdir, os.path.basename(fname))
 final_path = os.path.join(d.prefix, t.outdir, os.path.basename(fname))
- aliases = t.aliases
- should_strip = t.strip
+ should_strip = t.strip or (t.can_strip and self.options.strip)
 install_rpath = t.install_rpath
 install_name_mappings = t.install_name_mappings
 install_mode = t.install_mode
@@ -730,18 +699,11 @@
 raise MesonException(f'File {fname!r} could not be found')
 elif os.path.isfile(fname):
 file_copied = self.do_copyfile(fname, outname, makedirs=(dm, outdir))
- self.set_mode(outname, install_mode, d.install_umask)
 if should_strip and d.strip_bin is not None:
 if fname.endswith('.jar'):
 self.log('Not stripping jar target: {}'.format(os.path.basename(fname)))
 continue
- self.log('Stripping target {!r} using {}.'.format(fname, d.strip_bin0))
- returncode, stdo, stde = self.Popen_safe(d.strip_bin + outname)
- if returncode != 0:
- print('Could not strip file.\n')
- print(f'Stdout:\n{stdo}\n')
- print(f'Stderr:\n{stde}\n')
- sys.exit(1)
+ self.do_strip(d.strip_bin, fname, outname)
 if fname.endswith('.js'):
 # Emscripten outputs js files and optionally a wasm file.
 # If one was generated, install it as well.
@@ -756,9 +718,6 @@
 self.do_copydir(d, fname, outname, None, install_mode, dm)
 else:
 raise RuntimeError(f'Unknown file type for {fname!r}')
- for alias, target in aliases.items():
- symlinkfilename = os.path.join(outdir, alias)
- self.do_symlink(target, symlinkfilename, destdir, outdir)
 if file_copied:
 self.did_install_something = True
 try:
@@ -769,7 +728,8 @@
 pass
 else:
 raise
-
+ # file mode needs to be set last, after strip/depfixer editing
+ self.set_mode(outname, install_mode, d.install_umask)
 
 def rebuild_all(wd: str) -> bool:
 if not (Path(wd) / 'build.ninja').is_file():

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mintro.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mintro.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """This is a helper script for IDE developers. It allows you to
 extract information such as list of targets, files, compiler flags,
@@ -21,19 +22,21 @@
 
 import collections
 import json
-from . import build, coredata as cdata
-from . import mesonlib
-from .ast import IntrospectionInterpreter, build_target_functions, AstConditionLevel, AstIDGenerator, AstIndentationGenerator, AstJSONPrinter
-from . import mlog
-from .backend import backends
-from .mparser import BaseNode, FunctionNode, ArrayNode, ArgumentNode, StringNode
-from .interpreter import Interpreter
+import os
 from pathlib import Path, PurePath
 import typing as T
-import os
-import argparse
 
+from . import build, mesonlib, mlog, coredata as cdata
+from .ast import IntrospectionInterpreter, BUILD_TARGET_FUNCTIONS, AstConditionLevel, AstIDGenerator, AstIndentationGenerator, AstJSONPrinter
+from .backend import backends
 from .mesonlib import OptionKey
+from .mparser import FunctionNode, ArrayNode, ArgumentNode, StringNode
+
+if T.TYPE_CHECKING:
+    import argparse
+
+    from .interpreter import Interpreter
+    from .mparser import BaseNode
 
 def get_meson_info_file(info_dir: str) -> str:
     return os.path.join(info_dir, 'meson-info.json')
@@ -107,9 +110,6 @@
         for t in installdata.targets:
             resos.path.join(installdata.build_dir, t.fname) = \
                 os.path.join(installdata.prefix, t.outdir, os.path.basename(t.fname))
-            for alias in t.aliases.keys():
-                resos.path.join(installdata.build_dir, alias) = \
-                    os.path.join(installdata.prefix, t.outdir, os.path.basename(alias))
         for i in installdata.data:
             resi.path = os.path.join(installdata.prefix, i.install_path)
         for i in installdata.headers:
@@ -118,6 +118,9 @@
             resi.path = os.path.join(installdata.prefix, i.install_path)
         for i in installdata.install_subdirs:
             resi.path = os.path.join(installdata.prefix, i.install_path)
+        for s in installdata.symlinks:
+            basename = os.path.basename(s.name)
+            resbasename = os.path.join(installdata.prefix, s.install_path, basename)
     return res
 
 def list_install_plan(installdata: backends.InstallData) -> T.Dictstr, T.Dictstr, T.Dictstr, T.Optionalstr:
@@ -134,14 +137,14 @@
         'data': installdata.data,
         'man': installdata.man,
         'headers': installdata.headers,
+        'install_subdirs': installdata.install_subdirs
     }.items():
-        for data in data_list:
+        # Mypy doesn't recognize SubdirInstallData as a subclass of InstallDataBase
+        for data in data_list: # type: ignoreattr-defined
             data_type = data.data_type or key
             install_path_name = data.install_path_name
             if key == 'headers':  # in the headers, install_path_name is the directory
                 install_path_name = os.path.join(install_path_name, os.path.basename(data.path))
-            elif data_type == 'configure':
-                install_path_name = os.path.join('{prefix}', install_path_name)
 
             plandata_type = plan.get(data_type, {})
             plandata_typedata.path = {
@@ -166,7 +169,7 @@
             args =   # type: T.ListBaseNode
             if isinstance(n, FunctionNode):
                 args = list(n.args.arguments)
-                if n.func_name in build_target_functions:
+                if n.func_name in BUILD_TARGET_FUNCTIONS:
                     args.pop(0)
             elif isinstance(n, ArrayNode):
                 args = n.args.arguments
@@ -216,9 +219,17 @@
     # Fast lookup table for installation files
     install_lookuptable = {}
     for i in installdata.targets:
-        out = os.path.join(installdata.prefix, i.outdir, os.path.basename(i.fname))
-        out += os.path.join(installdata.prefix, i.outdir, os.path.basename(x)) for x in i.aliases
-        install_lookuptableos.path.basename(i.fname) = str(PurePath(x)) for x in out
+        basename = os.path.basename(i.fname)
+        install_lookuptablebasename = str(PurePath(installdata.prefix, i.outdir, basename))
+    for s in installdata.symlinks:
+        # Symlink's target must already be in the table. They share the same list
+        # to support symlinks to symlinks recursively, such as .so -> .so.0 -> .so.1.2.3
+        basename = os.path.basename(s.name)
+        try:
+            install_lookuptablebasename = install_lookuptableos.path.basename(s.target)
+            install_lookuptablebasename.append(str(PurePath(installdata.prefix, s.install_path, basename)))
+        except KeyError:
+            pass
 
     for (idname, target) in builddata.get_targets().items():
         if not isinstance(target, build.Target):
@@ -258,9 +269,9 @@
     test_option_names = {OptionKey('errorlogs'),
                          OptionKey('stdsplit')}
 
-    dir_options: 'cdata.KeyedOptionDictType' = {}
-    test_options: 'cdata.KeyedOptionDictType' = {}
-    core_options: 'cdata.KeyedOptionDictType' = {}
+    dir_options: 'cdata.MutableKeyedOptionDictType' = {}
+    test_options: 'cdata.MutableKeyedOptionDictType' = {}
+    core_options: 'cdata.MutableKeyedOptionDictType' = {}
     for k, v in coredata.options.items():
         if k in dir_option_names:
             dir_optionsk = v
@@ -312,13 +323,13 @@
     filelist =   # type: T.Liststr
     for root, _, files in os.walk(src_dir):
         for f in files:
-            if f == 'meson.build' or f == 'meson_options.txt':
+            if f in {'meson.build', 'meson_options.txt'}:
                 filelist.append(os.path.relpath(os.path.join(root, f), src_dir))
     return filelist
 
 def list_buildsystem_files(builddata: build.Build, interpreter: Interpreter) -> T.Liststr:
     src_dir = builddata.environment.get_source_dir()
-    filelist = interpreter.get_build_def_files()  # type: T.Liststr
+    filelist = list(interpreter.get_build_def_files())
     filelist = PurePath(src_dir, x).as_posix() for x in filelist
     return filelist
 
@@ -477,8 +488,8 @@
             return 1
 
     # Extract introspection information from JSON
-    for i in intro_types.keys():
-        if not intro_typesi.func:
+    for i, v in intro_types.items():
+        if not v.func:
             continue
         if not options.all and not getattr(options, i, False):
             continue
@@ -493,7 +504,6 @@
 updated_introspection_files =   # type: T.Liststr
 
 def write_intro_info(intro_info: T.SequenceT.Tuplestr, T.Uniondict, T.ListT.Any, info_dir: str) -> None:
-    global updated_introspection_files
     for kind, data in intro_info:
         out_file = os.path.join(info_dir, f'intro-{kind}.json')
         tmp_file = os.path.join(info_dir, 'tmp_dump.json')
@@ -501,7 +511,7 @@
             json.dump(data, fp)
             fp.flush() # Not sure if this is needed
         os.replace(tmp_file, out_file)
-        updated_introspection_files += kind
+        updated_introspection_files.append(kind)
 
 def generate_introspection_file(builddata: build.Build, backend: backends.Backend) -> None:
     coredata = builddata.environment.get_coredata()
@@ -532,14 +542,13 @@
     }
 
 def write_meson_info_file(builddata: build.Build, errors: list, build_files_updated: bool = False) -> None:
-    global updated_introspection_files
     info_dir = builddata.environment.info_dir
     info_file = get_meson_info_file(info_dir)
     intro_types = get_meson_introspection_types()
     intro_info = {}
 
-    for i in intro_types.keys():
-        if not intro_typesi.func:
+    for i, v in intro_types.items():
+        if not v.func:
             continue
         intro_infoi = {
             'file': f'intro-{i}.json',

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mlog.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mlog.py Changed

@@ -17,6 +17,9 @@
 import sys
 import time
 import platform
+import shlex
+import subprocess
+import shutil
 import typing as T
 from contextlib import contextmanager
 from pathlib import Path
@@ -28,6 +31,10 @@
 information about Meson runs. Some output goes to screen,
 some to logging dir and some goes to both."""
 
+def is_windows() -> bool:
+    platname = platform.system().lower()
+    return platname == 'windows'
+
 def _windows_ansi() -> bool:
     # windll only exists on windows, so mypy will get mad
     from ctypes import windll, byref  # type: ignore
@@ -49,7 +56,7 @@
         return _colorize_console
 
     try:
-        if platform.system().lower() == 'windows':
+        if is_windows():
             _colorize_console = os.isatty(sys.stdout.fileno()) and _windows_ansi()
         else:
             _colorize_console = os.isatty(sys.stdout.fileno()) and os.environ.get('TERM', 'dumb') != 'dumb'
@@ -63,7 +70,7 @@
     # on Windows, a subprocess might call SetConsoleMode() on the console
     # connected to stdout and turn off ANSI escape processing. Call this after
     # running a subprocess to ensure we turn it on again.
-    if platform.system().lower() == 'windows':
+    if is_windows():
         try:
             delattr(sys.stdout, 'colorize_console')
         except AttributeError:
@@ -80,41 +87,43 @@
 _in_ci = 'CI' in os.environ  # type: bool
 _logged_once = set()         # type: T.SetT.Tuplestr, ...
 log_warnings_counter = 0     # type: int
+log_pager: T.Optional'subprocess.Popen' = None
 
 def disable() -> None:
-    global log_disable_stdout
+    global log_disable_stdout  # pylint: disable=global-statement
     log_disable_stdout = True
 
 def enable() -> None:
-    global log_disable_stdout
+    global log_disable_stdout  # pylint: disable=global-statement
     log_disable_stdout = False
 
 def set_quiet() -> None:
-    global log_errors_only
+    global log_errors_only  # pylint: disable=global-statement
     log_errors_only = True
 
 def set_verbose() -> None:
-    global log_errors_only
+    global log_errors_only  # pylint: disable=global-statement
     log_errors_only = False
 
 def initialize(logdir: str, fatal_warnings: bool = False) -> None:
-    global log_dir, log_file, log_fatal_warnings
+    global log_dir, log_file, log_fatal_warnings  # pylint: disable=global-statement
     log_dir = logdir
     log_file = open(os.path.join(logdir, log_fname), 'w', encoding='utf-8')
     log_fatal_warnings = fatal_warnings
 
 def set_timestamp_start(start: float) -> None:
-    global log_timestamp_start
+    global log_timestamp_start  # pylint: disable=global-statement
     log_timestamp_start = start
 
 def shutdown() -> T.Optionalstr:
-    global log_file
+    global log_file  # pylint: disable=global-statement
     if log_file is not None:
         path = log_file.name
         exception_around_goer = log_file
         log_file = None
         exception_around_goer.close()
         return path
+    stop_pager()
     return None
 
 class AnsiDecorator:
@@ -156,6 +165,9 @@
 def bold(text: str, quoted: bool = False) -> AnsiDecorator:
     return AnsiDecorator(text, "\0331m", quoted=quoted)
 
+def italic(text: str, quoted: bool = False) -> AnsiDecorator:
+    return AnsiDecorator(text, "\0333m", quoted=quoted)
+
 def plain(text: str) -> AnsiDecorator:
     return AnsiDecorator(text, "")
 
@@ -224,7 +236,8 @@
 
     # _Something_ is going to get printed.
     try:
-        print(raw, end='')
+        output = log_pager.stdin if log_pager else None
+        print(raw, end='', file=output)
     except UnicodeEncodeError:
         cleaned = raw.encode('ascii', 'replace').decode('ascii')
         print(cleaned, end='')
@@ -320,12 +333,12 @@
         location_str = get_error_location_string(location_file, location.lineno)
         # Unions are frankly awful, and we have to T.cast here to get mypy
         # to understand that the list concatenation is safe
-        location_list = T.cast(TV_LoggableList, location_str)
+        location_list = T.cast('TV_LoggableList', location_str)
         args = location_list + args
 
     log(*args, once=once, **kwargs)
 
-    global log_warnings_counter
+    global log_warnings_counter  # pylint: disable=global-statement
     log_warnings_counter += 1
 
     if log_fatal_warnings and fatal:
@@ -371,7 +384,13 @@
     if prefix:
         args.append(prefix)
     args.append(str(e))
-    log(*args)
+
+    restore = log_disable_stdout
+    if restore:
+        enable()
+    log(*args, is_error=True)
+    if restore:
+        disable()
 
 # Format a list for logging purposes as a string. It separates
 # all but the last item with commas, and the last with 'and'.
@@ -388,9 +407,59 @@
 
 @contextmanager
 def nested(name: str = '') -> T.GeneratorNone, None, None:
-    global log_depth
     log_depth.append(name)
     try:
         yield
     finally:
         log_depth.pop()
+
+def start_pager() -> None:
+    if not colorize_console():
+        return
+    pager_cmd = 
+    if 'PAGER' in os.environ:
+        pager_cmd = shlex.split(os.environ'PAGER')
+    else:
+        less = shutil.which('less')
+        if not less and is_windows():
+            git = shutil.which('git')
+            if git:
+                path = Path(git).parents1 / 'usr' / 'bin'
+                less = shutil.which('less', path=str(path))
+        if less:
+            pager_cmd = less
+    if not pager_cmd:
+        return
+    global log_pager # pylint: disable=global-statement
+    assert log_pager is None
+    try:
+        # Set 'LESS' environment variable, rather than arguments in
+        # pager_cmd, to also support the case where the user has 'PAGER'
+        # set to 'less'. Arguments set are:
+        # "R" : support color
+        # "X" : do not clear the screen when leaving the pager
+        # "F" : skip the pager if content fits into the screen
+        env = os.environ.copy()
+        if 'LESS' not in env:
+            env'LESS' = 'RXF'
+        # Set "-c" for lv to support color
+        if 'LV' not in env:
+            env'LV' = '-c'
+        log_pager = subprocess.Popen(pager_cmd, stdin=subprocess.PIPE,
+                                     text=True, encoding='utf-8', env=env)
+    except Exception as e:
+        # Ignore errors, unless it is a user defined pager.
+        if 'PAGER' in os.environ:
+            from .mesonlib import MesonException
+            raise MesonException(f'Failed to start pager: {str(e)}')
+
+def stop_pager() -> None:
+    global log_pager # pylint: disable=global-statement
+    if log_pager:
+        try:
+            log_pager.stdin.flush()
+            log_pager.stdin.close()
+        except BrokenPipeError:
+            pass
+        log_pager.wait()
+        log_pager = None

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/__init__.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/__init__.py Changed

@@ -14,18 +14,25 @@
 
 # This file contains the base representation for import('modname')
 
-import os
+from __future__ import annotations
+import dataclasses
 import typing as T
 
-from .. import build, mesonlib
-from ..mesonlib import relpath, HoldableObject, MachineChoice, OptionKey
+from .. import mesonlib
+from ..build import IncludeDirs
 from ..interpreterbase.decorators import noKwargs, noPosargs
+from ..mesonlib import relpath, HoldableObject, MachineChoice
+from ..programs import ExternalProgram
 
 if T.TYPE_CHECKING:
+    from .. import build
     from ..interpreter import Interpreter
+    from ..interpreter.interpreterobjects import MachineHolder
     from ..interpreterbase import TYPE_var, TYPE_kwargs
-    from ..programs import ExternalProgram
+    from ..programs import OverrideProgram
     from ..wrap import WrapMode
+    from ..build import EnvironmentVariables, Executable
+    from ..dependencies import Dependency
 
 class ModuleState:
     """Object passed to all module methods.
@@ -43,6 +50,7 @@
                                     interpreter.environment.get_build_dir())
         self.subproject = interpreter.subproject
         self.subdir = interpreter.subdir
+        self.root_subdir = interpreter.root_subdir
         self.current_lineno = interpreter.current_lineno
         self.environment = interpreter.environment
         self.project_name = interpreter.build.project_name
@@ -80,8 +88,42 @@
 
     def find_program(self, prog: T.Unionstr, T.Liststr, required: bool = True,
                      version_func: T.OptionalT.Callable'ExternalProgram', str = None,
-                     wanted: T.Optionalstr = None, silent: bool = False) -> 'ExternalProgram':
-        return self._interpreter.find_program_impl(prog, required=required, version_func=version_func, wanted=wanted, silent=silent)
+                     wanted: T.Optionalstr = None, silent: bool = False,
+                     for_machine: MachineChoice = MachineChoice.HOST) -> 'ExternalProgram':
+        return self._interpreter.find_program_impl(prog, required=required, version_func=version_func,
+                                                   wanted=wanted, silent=silent, for_machine=for_machine)
+
+    def find_tool(self, name: str, depname: str, varname: str, required: bool = True,
+                  wanted: T.Optionalstr = None) -> T.Union'Executable', ExternalProgram, 'OverrideProgram':
+        # Look in overrides in case it's built as subproject
+        progobj = self._interpreter.program_from_overrides(name, )
+        if progobj is not None:
+            return progobj
+
+        # Look in machine file
+        prog_list = self.environment.lookup_binary_entry(MachineChoice.HOST, name)
+        if prog_list is not None:
+            return ExternalProgram.from_entry(name, prog_list)
+
+        # Check if pkgconfig has a variable
+        dep = self.dependency(depname, native=True, required=False, wanted=wanted)
+        if dep.found() and dep.type_name == 'pkgconfig':
+            value = dep.get_variable(pkgconfig=varname)
+            if value:
+                return ExternalProgram(name, value)
+
+        # Normal program lookup
+        return self.find_program(name, required=required, wanted=wanted)
+
+    def dependency(self, depname: str, native: bool = False, required: bool = True,
+                   wanted: T.Optionalstr = None) -> 'Dependency':
+        kwargs = {'native': native, 'required': required}
+        if wanted:
+            kwargs'version' = wanted
+        # FIXME: Even if we fix the function, mypy still can't figure out what's
+        # going on here. And we really dont want to call interpreter
+        # implementations of meson functions anyway.
+        return self._interpreter.func_dependency(self.current_node, depname, kwargs) # type: ignore
 
     def test(self, args: T.Tuplestr, T.Unionbuild.Executable, build.Jar, 'ExternalProgram', mesonlib.File,
              workdir: T.Optionalstr = None,
@@ -103,6 +145,26 @@
                    module: T.Optionalstr = None) -> T.Unionstr, int, bool, 'WrapMode':
         return self.environment.coredata.get_option(mesonlib.OptionKey(name, subproject, machine, lang, module))
 
+    def is_user_defined_option(self, name: str, subproject: str = '',
+                               machine: MachineChoice = MachineChoice.HOST,
+                               lang: T.Optionalstr = None,
+                               module: T.Optionalstr = None) -> bool:
+        key = mesonlib.OptionKey(name, subproject, machine, lang, module)
+        return key in self._interpreter.user_defined_options.cmd_line_options
+
+    def process_include_dirs(self, dirs: T.IterableT.Unionstr, IncludeDirs) -> T.IterableIncludeDirs:
+        """Convert raw include directory arguments to only IncludeDirs
+
+        :param dirs: An iterable of strings and IncludeDirs
+        :return: None
+        :yield: IncludeDirs objects
+        """
+        for d in dirs:
+            if isinstance(d, IncludeDirs):
+                yield d
+            else:
+                yield self._interpreter.build_incdir_object(d)
+
 
 class ModuleObject(HoldableObject):
     """Base class for all objects returned by modules
@@ -118,25 +180,16 @@
     pass
 
 
-# FIXME: Port all modules to stop using self.interpreter and use API on
-# ModuleState instead. Modules should stop using this class and instead use
-# ModuleObject base class.
-class ExtensionModule(ModuleObject):
-    def __init__(self, interpreter: 'Interpreter') -> None:
-        super().__init__()
-        self.interpreter = interpreter
-        self.methods.update({
-            'found': self.found_method,
-        })
+@dataclasses.dataclass
+class ModuleInfo:
 
-    @noPosargs
-    @noKwargs
-    def found_method(self, state: 'ModuleState', args: T.List'TYPE_var', kwargs: 'TYPE_kwargs') -> bool:
-        return self.found()
+    """Metadata about a Module."""
 
-    @staticmethod
-    def found() -> bool:
-        return True
+    name: str
+    added: T.Optionalstr = None
+    deprecated: T.Optionalstr = None
+    unstable: bool = False
+    stabilized: T.Optionalstr = None
 
 
 class NewExtensionModule(ModuleObject):
@@ -146,6 +199,8 @@
     provides the found method.
     """
 
+    INFO: ModuleInfo
+
     def __init__(self) -> None:
         super().__init__()
         self.methods.update({
@@ -161,6 +216,16 @@
     def found() -> bool:
         return True
 
+    def get_devenv(self) -> T.Optional'EnvironmentVariables':
+        return None
+
+# FIXME: Port all modules to stop using self.interpreter and use API on
+# ModuleState instead. Modules should stop using this class and instead use
+# ModuleObject base class.
+class ExtensionModule(NewExtensionModule):
+    def __init__(self, interpreter: 'Interpreter') -> None:
+        super().__init__()
+        self.interpreter = interpreter
 
 class NotFoundExtensionModule(NewExtensionModule):
 
@@ -169,6 +234,10 @@
     provides the found method.
     """
 
+    def __init__(self, name: str) -> None:
+        super().__init__()
+        self.INFO = ModuleInfo(name)
+
     @staticmethod
     def found() -> bool:
         return False
@@ -182,7 +251,7 @@
     if hasattr(fname, 'fname'):
         fname = fname.fname
     suffix = fname.split('.')-1
-    return suffix in ('gir', 'typelib')
+    return suffix in {'gir', 'typelib'}
 
 
 class ModuleReturnValue:
@@ -191,18 +260,3 @@
         self.return_value = return_value
         assert isinstance(new_objects, list)
         self.new_objects: T.ListT.Union'TYPE_var', 'build.ExecutableSerialisation' = new_objects
-
-class GResourceTarget(build.CustomTarget):
-    pass
-
-class GResourceHeaderTarget(build.CustomTarget):
-    pass
-
-class GirTarget(build.CustomTarget):
-    pass
-
-class TypelibTarget(build.CustomTarget):
-    pass
-
-class VapiTarget(build.CustomTarget):
-    pass

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/cmake.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/cmake.py Changed

@@ -11,20 +11,22 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
 import re
 import os, os.path, pathlib
 import shutil
 import typing as T
 
-from . import ExtensionModule, ModuleReturnValue, ModuleObject
+from . import ExtensionModule, ModuleReturnValue, ModuleObject, ModuleInfo
 
 from .. import build, mesonlib, mlog, dependencies
-from ..cmake import SingleTargetOptions, TargetOptions, cmake_defines_to_args
-from ..interpreter import ConfigurationDataObject, SubprojectHolder
+from ..cmake import TargetOptions, cmake_defines_to_args
+from ..interpreter import SubprojectHolder
+from ..interpreter.type_checking import REQUIRED_KW, INSTALL_DIR_KW, NoneType, in_set_validator
 from ..interpreterbase import (
 FeatureNew,
 FeatureNewKwargs,
- FeatureDeprecatedKwargs,
 
 stringArgs,
 permittedKwargs,
@@ -33,8 +35,40 @@
 
 InvalidArguments,
 InterpreterException,
+
+ typed_pos_args,
+ typed_kwargs,
+ KwargInfo,
+ ContainerTypeInfo,
 )
 
+if T.TYPE_CHECKING:
+ from typing_extensions import TypedDict
+
+ from . import ModuleState
+ from ..cmake import SingleTargetOptions
+ from ..interpreter import kwargs
+
+ class WriteBasicPackageVersionFile(TypedDict):
+
+ arch_independent: bool
+ compatibility: str
+ install_dir: T.Optionalstr
+ name: str
+ version: str
+
+ class ConfigurePackageConfigFile(TypedDict):
+
+ configuration: T.Unionbuild.ConfigurationData, dict
+ input: T.Unionstr, mesonlib.File
+ install_dir: T.Optionalstr
+ name: str
+
+ class Subproject(kwargs.ExtractRequired):
+
+ options: T.OptionalCMakeSubprojectOptions
+ cmake_options: T.Liststr
+
 
 COMPATIBILITIES = 'AnyNewerVersion', 'SameMajorVersion', 'SameMinorVersion', 'ExactVersion'
 
@@ -69,11 +103,12 @@
 '''
 
 class CMakeSubproject(ModuleObject):
- def __init__(self, subp, pv):
+ def __init__(self, subp: SubprojectHolder):
 assert isinstance(subp, SubprojectHolder)
- assert hasattr(subp, 'cm_interpreter')
+ assert subp.cm_interpreter is not None
 super().__init__()
 self.subp = subp
+ self.cm_interpreter = subp.cm_interpreter
 self.methods.update({'get_variable': self.get_variable,
 'dependency': self.dependency,
 'include_directories': self.include_directories,
@@ -88,14 +123,14 @@
 raise InterpreterException('Exactly one argument is required.')
 
 tgt = args0
- res = self.subp.cm_interpreter.target_info(tgt)
+ res = self.cm_interpreter.target_info(tgt)
 if res is None:
 raise InterpreterException(f'The CMake target {tgt} does not exist\n' +
 ' Use the following command in your meson.build to list all available targets:\n\n' +
- ' message(\'CMaket targets:\\n - \' + \'\\n - \'.join(<cmake_subproject>.target_list()))')
+ ' message(\'CMake targets:\\n - \' + \'\\n - \'.join(<cmake_subproject>.target_list()))')
 
 # Make sure that all keys are present (if not this is a bug)
- assert all(x in res for x in 'inc', 'src', 'dep', 'tgt', 'func')
+ assert all(x in res for x in 'inc', 'src', 'dep', 'tgt', 'func')
 return res
 
 @noKwargs
@@ -139,7 +174,7 @@
 @noPosargs
 @noKwargs
 def target_list(self, state, args, kwargs):
- return self.subp.cm_interpreter.target_list()
+ return self.cm_interpreter.target_list()
 
 @noPosargs
 @noKwargs
@@ -212,7 +247,8 @@
 cmake_detected = False
 cmake_root = None
 
- @FeatureNew('CMake Module', '0.50.0')
+ INFO = ModuleInfo('cmake', '0.50.0')
+
 def __init__(self, interpreter):
 super().__init__(interpreter)
 self.methods.update({
@@ -256,31 +292,28 @@
 self.cmake_detected = True
 return True
 
- @permittedKwargs({'version', 'name', 'compatibility', 'install_dir'})
- def write_basic_package_version_file(self, state, _args, kwargs):
- version = kwargs.get('version', None)
- if not isinstance(version, str):
- raise mesonlib.MesonException('Version must be specified.')
-
- name = kwargs.get('name', None)
- if not isinstance(name, str):
- raise mesonlib.MesonException('Name not specified.')
-
- compatibility = kwargs.get('compatibility', 'AnyNewerVersion')
- if not isinstance(compatibility, str):
- raise mesonlib.MesonException('compatibility is not string.')
- if compatibility not in COMPATIBILITIES:
- raise mesonlib.MesonException('compatibility must be either AnyNewerVersion, SameMajorVersion or ExactVersion.')
+ @noPosargs
+ @typed_kwargs(
+ 'cmake.write_basic_package_version_file',
+ KwargInfo('arch_independent', bool, default=False, since='0.62.0'),
+ KwargInfo('compatibility', str, default='AnyNewerVersion', validator=in_set_validator(set(COMPATIBILITIES))),
+ KwargInfo('name', str, required=True),
+ KwargInfo('version', str, required=True),
+ INSTALL_DIR_KW,
+ )
+ def write_basic_package_version_file(self, state, args, kwargs: 'WriteBasicPackageVersionFile'):
+ arch_independent = kwargs'arch_independent'
+ compatibility = kwargs'compatibility'
+ name = kwargs'name'
+ version = kwargs'version'
 
 if not self.detect_cmake(state):
 raise mesonlib.MesonException('Unable to find cmake')
 
- pkgroot = pkgroot_name = kwargs.get('install_dir', None)
+ pkgroot = pkgroot_name = kwargs'install_dir'
 if pkgroot is None:
 pkgroot = os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('libdir')), 'cmake', name)
 pkgroot_name = os.path.join('{libdir}', 'cmake', name)
- if not isinstance(pkgroot, str):
- raise mesonlib.MesonException('Install_dir must be a string.')
 
 template_file = os.path.join(self.cmake_root, 'Modules', f'BasicConfigVersion-{compatibility}.cmake.in')
 if not os.path.exists(template_file):
@@ -290,7 +323,8 @@
 
 conf = {
 'CVF_VERSION': (version, ''),
- 'CMAKE_SIZEOF_VOID_P': (str(self.detect_voidp_size(state.environment)), '')
+ 'CMAKE_SIZEOF_VOID_P': (str(self.detect_voidp_size(state.environment)), ''),
+ 'CVF_ARCH_INDEPENDENT': (arch_independent, ''),
 }
 mesonlib.do_conf_file(template_file, version_file, conf, 'meson')
 
@@ -324,42 +358,37 @@
 shutil.copymode(infile, outfile_tmp)
 mesonlib.replace_if_different(outfile, outfile_tmp)
 
- @permittedKwargs({'input', 'name', 'install_dir', 'configuration'})
- def configure_package_config_file(self, state, args, kwargs):
- if args:
- raise mesonlib.MesonException('configure_package_config_file takes only keyword arguments.')
-
- if 'input' not in kwargs:
- raise mesonlib.MesonException('configure_package_config_file requires "input" keyword.')
+ @noPosargs
+ @typed_kwargs(
+ 'cmake.configure_package_config_file',
+ KwargInfo('configuration', (build.ConfigurationData, dict), required=True),
+ KwargInfo('input',
+ (str, mesonlib.File, ContainerTypeInfo(list, mesonlib.File)), required=True,
+ validator=lambda x: 'requires exactly one file' if isinstance(x, list) and len(x) != 1 else None,
+ convertor=lambda x: x0 if isinstance(x, list) else x),
+ KwargInfo('name', str, required=True),
+ INSTALL_DIR_KW,
+ )
+ def configure_package_config_file(self, state, args, kwargs: 'ConfigurePackageConfigFile'):
 inputfile = kwargs'input'
- if isinstance(inputfile, list):
- if len(inputfile) != 1:
- m = "Keyword argument 'input' requires exactly one file"
- raise mesonlib.MesonException(m)
- inputfile = inputfile0
- if not isinstance(inputfile, (str, mesonlib.File)):
- raise mesonlib.MesonException("input must be a string or a file")
 if isinstance(inputfile, str):
 inputfile = mesonlib.File.from_source_file(state.environment.source_dir, state.subdir, inputfile)
 
 ifile_abs = inputfile.absolute_path(state.environment.source_dir, state.environment.build_dir)
 
- if 'name' not in kwargs:
- raise mesonlib.MesonException('"name" not specified.')
 name = kwargs'name'
 
 (ofile_path, ofile_fname) = os.path.split(os.path.join(state.subdir, f'{name}Config.cmake'))
 ofile_abs = os.path.join(state.environment.build_dir, ofile_path, ofile_fname)
 
- install_dir = kwargs.get('install_dir', os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('libdir')), 'cmake', name))
- if not isinstance(install_dir, str):
- raise mesonlib.MesonException('"install_dir" must be a string.')
+ install_dir = kwargs'install_dir'
+ if install_dir is None:
+ install_dir = os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('libdir')), 'cmake', name)
 
- if 'configuration' not in kwargs:
- raise mesonlib.MesonException('"configuration" not specified.')
 conf = kwargs'configuration'
- if not isinstance(conf, ConfigurationDataObject):
- raise mesonlib.MesonException('Argument "configuration" is not of type configuration_data')
+ if isinstance(conf, dict):
+ FeatureNew.single_use('cmake.configure_package_config_file dict as configuration', '0.62.0', state.subproject, location=state.current_node)
+ conf = build.ConfigurationData(conf)
 
 prefix = state.environment.coredata.get_option(mesonlib.OptionKey('prefix'))
 abs_install_dir = install_dir
@@ -372,12 +401,11 @@
 extra = PACKAGE_INIT_EXT.replace('@absInstallDir@', abs_install_dir)
 extra = extra.replace('@installPrefix@', prefix)
 
- self.create_package_file(ifile_abs, ofile_abs, PACKAGE_RELATIVE_PATH, extra, conf.conf_data)
- conf.mark_used()
+ self.create_package_file(ifile_abs, ofile_abs, PACKAGE_RELATIVE_PATH, extra, conf)
+ conf.used = True
 
 conffile = os.path.normpath(inputfile.relative_name())
- if conffile not in self.interpreter.build_def_files:
- self.interpreter.build_def_files.append(conffile)
+ self.interpreter.build_def_files.add(conffile)
 
 res = build.Data(mesonlib.File(True, ofile_path, ofile_fname), install_dir, install_dir, None, state.subproject)
 self.interpreter.build.data.append(res)
@@ -385,20 +413,35 @@
 return res
 
 @FeatureNew('subproject', '0.51.0')
- @FeatureNewKwargs('subproject', '0.55.0', 'options')
- @FeatureDeprecatedKwargs('subproject', '0.55.0', 'cmake_options')
- @permittedKwargs({'cmake_options', 'required', 'options'})
- @stringArgs
- def subproject(self, state, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Subproject takes exactly one argument')
- if 'cmake_options' in kwargs and 'options' in kwargs:
+ @typed_pos_args('cmake.subproject', str)
+ @typed_kwargs(
+ 'cmake.subproject',
+ REQUIRED_KW,
+ KwargInfo('options', (CMakeSubprojectOptions, NoneType), since='0.55.0'),
+ KwargInfo(
+ 'cmake_options',
+ ContainerTypeInfo(list, str),
+ default=,
+ listify=True,
+ deprecated='0.55.0',
+ deprecated_message='Use options instead',
+ ),
+ )
+ def subproject(self, state: ModuleState, args: T.Tuplestr, kwargs_: Subproject) -> T.UnionSubprojectHolder, CMakeSubproject:
+ if kwargs_'cmake_options' and kwargs_'options' is not None:
 raise InterpreterException('"options" cannot be used together with "cmake_options"')
 dirname = args0
- subp = self.interpreter.do_subproject(dirname, 'cmake', kwargs)
+ kw: kwargs.DoSubproject = {
+ 'required': kwargs_'required',
+ 'options': kwargs_'options',
+ 'cmake_options': kwargs_'cmake_options',
+ 'default_options': ,
+ 'version': ,
+ }
+ subp = self.interpreter.do_subproject(dirname, 'cmake', kw)
 if not subp.found():
 return subp
- return CMakeSubproject(subp, dirname)
+ return CMakeSubproject(subp)
 
 @FeatureNew('subproject_options', '0.55.0')
 @noKwargs

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/cuda.py Added

@@ -0,0 +1,383 @@
+# Copyright 2017 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+import typing as T
+import re
+
+from ..mesonlib import version_compare
+from ..compilers.cuda import CudaCompiler
+
+from . import NewExtensionModule, ModuleInfo
+
+from ..interpreterbase import (
+ flatten, permittedKwargs, noKwargs,
+ InvalidArguments
+)
+
+if T.TYPE_CHECKING:
+ from . import ModuleState
+ from ..compilers import Compiler
+
+class CudaModule(NewExtensionModule):
+
+ INFO = ModuleInfo('CUDA', '0.50.0', unstable=True)
+
+ def __init__(self, *args, **kwargs):
+ super().__init__()
+ self.methods.update({
+ "min_driver_version": self.min_driver_version,
+ "nvcc_arch_flags": self.nvcc_arch_flags,
+ "nvcc_arch_readable": self.nvcc_arch_readable,
+ })
+
+ @noKwargs
+ def min_driver_version(self, state: 'ModuleState',
+ args: T.Tuplestr,
+ kwargs: T.Dictstr, T.Any) -> str:
+ argerror = InvalidArguments('min_driver_version must have exactly one positional argument: ' +
+ 'a CUDA Toolkit version string. Beware that, since CUDA 11.0, ' +
+ 'the CUDA Toolkit\'s components (including NVCC) are versioned ' +
+ 'independently from each other (and the CUDA Toolkit as a whole).')
+
+ if len(args) != 1 or not isinstance(args0, str):
+ raise argerror
+
+ cuda_version = args0
+ driver_version_table = 
+ {'cuda_version': '>=12.0.0', 'windows': '527.41', 'linux': '525.60.13'},
+ {'cuda_version': '>=11.8.0', 'windows': '522.06', 'linux': '520.61.05'},
+ {'cuda_version': '>=11.7.1', 'windows': '516.31', 'linux': '515.48.07'},
+ {'cuda_version': '>=11.7.0', 'windows': '516.01', 'linux': '515.43.04'},
+ {'cuda_version': '>=11.6.1', 'windows': '511.65', 'linux': '510.47.03'},
+ {'cuda_version': '>=11.6.0', 'windows': '511.23', 'linux': '510.39.01'},
+ {'cuda_version': '>=11.5.1', 'windows': '496.13', 'linux': '495.29.05'},
+ {'cuda_version': '>=11.5.0', 'windows': '496.04', 'linux': '495.29.05'},
+ {'cuda_version': '>=11.4.3', 'windows': '472.50', 'linux': '470.82.01'},
+ {'cuda_version': '>=11.4.1', 'windows': '471.41', 'linux': '470.57.02'},
+ {'cuda_version': '>=11.4.0', 'windows': '471.11', 'linux': '470.42.01'},
+ {'cuda_version': '>=11.3.0', 'windows': '465.89', 'linux': '465.19.01'},
+ {'cuda_version': '>=11.2.2', 'windows': '461.33', 'linux': '460.32.03'},
+ {'cuda_version': '>=11.2.1', 'windows': '461.09', 'linux': '460.32.03'},
+ {'cuda_version': '>=11.2.0', 'windows': '460.82', 'linux': '460.27.03'},
+ {'cuda_version': '>=11.1.1', 'windows': '456.81', 'linux': '455.32'},
+ {'cuda_version': '>=11.1.0', 'windows': '456.38', 'linux': '455.23'},
+ {'cuda_version': '>=11.0.3', 'windows': '451.82', 'linux': '450.51.06'},
+ {'cuda_version': '>=11.0.2', 'windows': '451.48', 'linux': '450.51.05'},
+ {'cuda_version': '>=11.0.1', 'windows': '451.22', 'linux': '450.36.06'},
+ {'cuda_version': '>=10.2.89', 'windows': '441.22', 'linux': '440.33'},
+ {'cuda_version': '>=10.1.105', 'windows': '418.96', 'linux': '418.39'},
+ {'cuda_version': '>=10.0.130', 'windows': '411.31', 'linux': '410.48'},
+ {'cuda_version': '>=9.2.148', 'windows': '398.26', 'linux': '396.37'},
+ {'cuda_version': '>=9.2.88', 'windows': '397.44', 'linux': '396.26'},
+ {'cuda_version': '>=9.1.85', 'windows': '391.29', 'linux': '390.46'},
+ {'cuda_version': '>=9.0.76', 'windows': '385.54', 'linux': '384.81'},
+ {'cuda_version': '>=8.0.61', 'windows': '376.51', 'linux': '375.26'},
+ {'cuda_version': '>=8.0.44', 'windows': '369.30', 'linux': '367.48'},
+ {'cuda_version': '>=7.5.16', 'windows': '353.66', 'linux': '352.31'},
+ {'cuda_version': '>=7.0.28', 'windows': '347.62', 'linux': '346.46'},
+ 
+
+ driver_version = 'unknown'
+ for d in driver_version_table:
+ if version_compare(cuda_version, d'cuda_version'):
+ driver_version = d.get(state.host_machine.system, d'linux')
+ break
+
+ return driver_version
+
+ @permittedKwargs('detected')
+ def nvcc_arch_flags(self, state: 'ModuleState',
+ args: T.TupleT.UnionCompiler, CudaCompiler, str,
+ kwargs: T.Dictstr, T.Any) -> T.Liststr:
+ nvcc_arch_args = self._validate_nvcc_arch_args(args, kwargs)
+ ret = self._nvcc_arch_flags(*nvcc_arch_args)0
+ return ret
+
+ @permittedKwargs('detected')
+ def nvcc_arch_readable(self, state: 'ModuleState',
+ args: T.TupleT.UnionCompiler, CudaCompiler, str,
+ kwargs: T.Dictstr, T.Any) -> T.Liststr:
+ nvcc_arch_args = self._validate_nvcc_arch_args(args, kwargs)
+ ret = self._nvcc_arch_flags(*nvcc_arch_args)1
+ return ret
+
+ @staticmethod
+ def _break_arch_string(s):
+ s = re.sub(' \t\r\n,;+', ';', s)
+ s = s.strip(';').split(';')
+ return s
+
+ @staticmethod
+ def _detected_cc_from_compiler(c):
+ if isinstance(c, CudaCompiler):
+ return c.detected_cc
+ return ''
+
+ @staticmethod
+ def _version_from_compiler(c):
+ if isinstance(c, CudaCompiler):
+ return c.version
+ if isinstance(c, str):
+ return c
+ return 'unknown'
+
+ def _validate_nvcc_arch_args(self, args, kwargs):
+ argerror = InvalidArguments('The first argument must be an NVCC compiler object, or its version string!')
+
+ if len(args) < 1:
+ raise argerror
+ else:
+ compiler = args0
+ cuda_version = self._version_from_compiler(compiler)
+ if cuda_version == 'unknown':
+ raise argerror
+
+ arch_list = if len(args) <= 1 else flatten(args1:)
+ arch_list = self._break_arch_string(a) for a in arch_list
+ arch_list = flatten(arch_list)
+ if len(arch_list) > 1 and not set(arch_list).isdisjoint({'All', 'Common', 'Auto'}):
+ raise InvalidArguments('''The special architectures 'All', 'Common' and 'Auto' must appear alone, as a positional argument!''')
+ arch_list = arch_list0 if len(arch_list) == 1 else arch_list
+
+ detected = kwargs.get('detected', self._detected_cc_from_compiler(compiler))
+ detected = flatten(detected)
+ detected = self._break_arch_string(a) for a in detected
+ detected = flatten(detected)
+ if not set(detected).isdisjoint({'All', 'Common', 'Auto'}):
+ raise InvalidArguments('''The special architectures 'All', 'Common' and 'Auto' must appear alone, as a positional argument!''')
+
+ return cuda_version, arch_list, detected
+
+ def _filter_cuda_arch_list(self, cuda_arch_list, lo=None, hi=None, saturate=None):
+ """
+ Filter CUDA arch list (no codenames) for >= low and < hi architecture
+ bounds, and deduplicate.
+ If saturate is provided, architectures >= hi are replaced with saturate.
+ """
+
+ filtered_cuda_arch_list = 
+ for arch in cuda_arch_list:
+ if arch:
+ if lo and version_compare(arch, '<' + lo):
+ continue
+ if hi and version_compare(arch, '>=' + hi):
+ if not saturate:
+ continue
+ arch = saturate
+ if arch not in filtered_cuda_arch_list:
+ filtered_cuda_arch_list.append(arch)
+ return filtered_cuda_arch_list
+
+ def _nvcc_arch_flags(self, cuda_version, cuda_arch_list='Auto', detected=''):
+ """
+ Using the CUDA Toolkit version and the target architectures, compute
+ the NVCC architecture flags.
+ """
+
+ # Replicates much of the logic of
+ # https://github.com/Kitware/CMake/blob/master/Modules/FindCUDA/select_compute_arch.cmake
+ # except that a bug with cuda_arch_list="All" is worked around by
+ # tracking both lower and upper limits on GPU architectures.
+
+ cuda_known_gpu_architectures = 'Fermi', 'Kepler', 'Maxwell' # noqa: E221
+ cuda_common_gpu_architectures = '3.0', '3.5', '5.0' # noqa: E221
+ cuda_hi_limit_gpu_architecture = None # noqa: E221
+ cuda_lo_limit_gpu_architecture = '2.0' # noqa: E221
+ cuda_all_gpu_architectures = '3.0', '3.2', '3.5', '5.0' # noqa: E221
+
+ if version_compare(cuda_version, '<7.0'):
+ cuda_hi_limit_gpu_architecture = '5.2'
+
+ if version_compare(cuda_version, '>=7.0'):
+ cuda_known_gpu_architectures += 'Kepler+Tegra', 'Kepler+Tesla', 'Maxwell+Tegra' # noqa: E221
+ cuda_common_gpu_architectures += '5.2' # noqa: E221
+
+ if version_compare(cuda_version, '<8.0'):
+ cuda_common_gpu_architectures += '5.2+PTX' # noqa: E221
+ cuda_hi_limit_gpu_architecture = '6.0' # noqa: E221
+
+ if version_compare(cuda_version, '>=8.0'):
+ cuda_known_gpu_architectures += 'Pascal', 'Pascal+Tegra' # noqa: E221
+ cuda_common_gpu_architectures += '6.0', '6.1' # noqa: E221
+ cuda_all_gpu_architectures += '6.0', '6.1', '6.2' # noqa: E221
+
+ if version_compare(cuda_version, '<9.0'):
+ cuda_common_gpu_architectures += '6.1+PTX' # noqa: E221
+ cuda_hi_limit_gpu_architecture = '7.0' # noqa: E221
+
+ if version_compare(cuda_version, '>=9.0'):
+ cuda_known_gpu_architectures += 'Volta', 'Xavier' # noqa: E221
+ cuda_common_gpu_architectures += '7.0' # noqa: E221
+ cuda_all_gpu_architectures += '7.0', '7.2' # noqa: E221
+ # https://docs.nvidia.com/cuda/archive/9.0/cuda-toolkit-release-notes/index.html#unsupported-features
+ cuda_lo_limit_gpu_architecture = '3.0' # noqa: E221
+
+ if version_compare(cuda_version, '<10.0'):
+ cuda_common_gpu_architectures += '7.2+PTX' # noqa: E221
+ cuda_hi_limit_gpu_architecture = '8.0' # noqa: E221
+
+ if version_compare(cuda_version, '>=10.0'):
+ cuda_known_gpu_architectures += 'Turing' # noqa: E221
+ cuda_common_gpu_architectures += '7.5' # noqa: E221
+ cuda_all_gpu_architectures += '7.5' # noqa: E221
+
+ if version_compare(cuda_version, '<11.0'):
+ cuda_common_gpu_architectures += '7.5+PTX' # noqa: E221
+ cuda_hi_limit_gpu_architecture = '8.0' # noqa: E221
+
+ if version_compare(cuda_version, '>=11.0'):
+ cuda_known_gpu_architectures += 'Ampere' # noqa: E221
+ cuda_common_gpu_architectures += '8.0' # noqa: E221
+ cuda_all_gpu_architectures += '8.0' # noqa: E221
+ # https://docs.nvidia.com/cuda/archive/11.0/cuda-toolkit-release-notes/index.html#deprecated-features
+ cuda_lo_limit_gpu_architecture = '3.5' # noqa: E221
+
+ if version_compare(cuda_version, '<11.1'):
+ cuda_common_gpu_architectures += '8.0+PTX' # noqa: E221
+ cuda_hi_limit_gpu_architecture = '8.6' # noqa: E221
+
+ if version_compare(cuda_version, '>=11.1'):
+ cuda_common_gpu_architectures += '8.6' # noqa: E221
+ cuda_all_gpu_architectures += '8.6' # noqa: E221
+
+ if version_compare(cuda_version, '<11.8'):
+ cuda_common_gpu_architectures += '8.6+PTX' # noqa: E221
+ cuda_hi_limit_gpu_architecture = '8.7' # noqa: E221
+
+ if version_compare(cuda_version, '>=11.8'):
+ cuda_known_gpu_architectures += 'Orin', 'Lovelace', 'Hopper' # noqa: E221
+ cuda_common_gpu_architectures += '8.9', '9.0', '9.0+PTX' # noqa: E221
+ cuda_all_gpu_architectures += '8.7', '8.9', '9.0' # noqa: E221
+
+ if version_compare(cuda_version, '<12'):
+ cuda_hi_limit_gpu_architecture = '9.1' # noqa: E221
+
+ if version_compare(cuda_version, '>=12.0'):
+ # https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html#deprecated-features (Current)
+ # https://docs.nvidia.com/cuda/archive/12.0/cuda-toolkit-release-notes/index.html#deprecated-features (Eventual?)
+ cuda_lo_limit_gpu_architecture = '5.0' # noqa: E221
+
+ if version_compare(cuda_version, '<13'):
+ cuda_hi_limit_gpu_architecture = '10.0' # noqa: E221
+
+ if not cuda_arch_list:
+ cuda_arch_list = 'Auto'
+
+ if cuda_arch_list == 'All': # noqa: E271
+ cuda_arch_list = cuda_known_gpu_architectures
+ elif cuda_arch_list == 'Common': # noqa: E271
+ cuda_arch_list = cuda_common_gpu_architectures
+ elif cuda_arch_list == 'Auto': # noqa: E271
+ if detected:
+ if isinstance(detected, list):
+ cuda_arch_list = detected
+ else:
+ cuda_arch_list = self._break_arch_string(detected)
+ cuda_arch_list = self._filter_cuda_arch_list(cuda_arch_list,
+ cuda_lo_limit_gpu_architecture,
+ cuda_hi_limit_gpu_architecture,
+ cuda_common_gpu_architectures-1)
+ else:
+ cuda_arch_list = cuda_common_gpu_architectures
+ elif isinstance(cuda_arch_list, str):
+ cuda_arch_list = self._break_arch_string(cuda_arch_list)
+
+ cuda_arch_list = sorted(x for x in set(cuda_arch_list) if x)
+
+ cuda_arch_bin = 
+ cuda_arch_ptx = 
+ for arch_name in cuda_arch_list:
+ arch_bin = 
+ arch_ptx = 
+ add_ptx = arch_name.endswith('+PTX')
+ if add_ptx:
+ arch_name = arch_name:-len('+PTX')
+
+ if re.fullmatch('0-9+\\.0-9(\$0-9+\\.0-9\$)?', arch_name):
+ arch_bin, arch_ptx = arch_name, arch_name
+ else:
+ arch_bin, arch_ptx = {
+ 'Fermi': ('2.0', '2.1(2.0)', ),
+ 'Kepler+Tegra': ('3.2', ),
+ 'Kepler+Tesla': ('3.7', ),
+ 'Kepler': ('3.0', '3.5', '3.5'),
+ 'Maxwell+Tegra': ('5.3', ),
+ 'Maxwell': ('5.0', '5.2', '5.2'),
+ 'Pascal': ('6.0', '6.1', '6.1'),
+ 'Pascal+Tegra': ('6.2', ),
+ 'Volta': ('7.0', '7.0'),
+ 'Xavier': ('7.2', ),
+ 'Turing': ('7.5', '7.5'),
+ 'Ampere': ('8.0', '8.0'),
+ 'Orin': ('8.7', ),
+ 'Lovelace': ('8.9', '8.9'),
+ 'Hopper': ('9.0', '9.0'),
+ }.get(arch_name, (None, None))
+
+ if arch_bin is None:
+ raise InvalidArguments(f'Unknown CUDA Architecture Name {arch_name}!')
+
+ cuda_arch_bin += arch_bin
+
+ if add_ptx:
+ if not arch_ptx:
+ arch_ptx = arch_bin
+ cuda_arch_ptx += arch_ptx
+
+ cuda_arch_bin = sorted(set(cuda_arch_bin))
+ cuda_arch_ptx = sorted(set(cuda_arch_ptx))
+
+ nvcc_flags = 
+ nvcc_archs_readable = 
+
+ for arch in cuda_arch_bin:
+ arch, codev = re.fullmatch(
+ '(0-9+\\.0-9)(?:\$(0-9+\\.0-9)\$)?', arch).groups()
+
+ if version_compare(arch, '<' + cuda_lo_limit_gpu_architecture):
+ continue
+ if cuda_hi_limit_gpu_architecture and version_compare(arch, '>=' + cuda_hi_limit_gpu_architecture):
+ continue
+
+ if codev:
+ arch = arch.replace('.', '')
+ codev = codev.replace('.', '')
+ nvcc_flags += '-gencode', 'arch=compute_' + codev + ',code=sm_' + arch
+ nvcc_archs_readable += 'sm_' + arch
+ else:
+ arch = arch.replace('.', '')
+ nvcc_flags += '-gencode', 'arch=compute_' + arch + ',code=sm_' + arch
+ nvcc_archs_readable += 'sm_' + arch
+
+ for arch in cuda_arch_ptx:
+ arch, codev = re.fullmatch(
+ '(0-9+\\.0-9)(?:\$(0-9+\\.0-9)\$)?', arch).groups()
+
+ if codev:
+ arch = codev
+
+ if version_compare(arch, '<' + cuda_lo_limit_gpu_architecture):
+ continue
+ if cuda_hi_limit_gpu_architecture and version_compare(arch, '>=' + cuda_hi_limit_gpu_architecture):
+ continue
+
+ arch = arch.replace('.', '')
+ nvcc_flags += '-gencode', 'arch=compute_' + arch + ',code=compute_' + arch
+ nvcc_archs_readable += 'compute_' + arch
+
+ return nvcc_flags, nvcc_archs_readable
+
+def initialize(*args, **kwargs):
+ return CudaModule(*args, **kwargs)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/dlang.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/dlang.py Changed

@@ -14,21 +14,23 @@
 
 # This file contains the detection logic for external dependencies that
 # are UI-related.
+from __future__ import annotations
 
 import json
 import os
 
-from . import ExtensionModule
+from . import ExtensionModule, ModuleInfo
 from .. import dependencies
 from .. import mlog
-from ..interpreterbase import FeatureNew
+from ..interpreterbase import typed_pos_args
 from ..mesonlib import Popen_safe, MesonException
 
 class DlangModule(ExtensionModule):
 class_dubbin = None
 init_dub = False
 
- @FeatureNew('Dlang Module', '0.48.0')
+ INFO = ModuleInfo('dlang', '0.48.0')
+
 def __init__(self, interpreter):
 super().__init__(interpreter)
 self.methods.update({
@@ -52,13 +54,11 @@
 if not self.dubbin:
 raise MesonException('DUB not found.')
 
+ @typed_pos_args('dlang.generate_dub_file', str, str)
 def generate_dub_file(self, state, args, kwargs):
 if not DlangModule.init_dub:
 self._init_dub(state)
 
- if len(args) < 2:
- raise MesonException('Missing arguments')
-
 config = {
 'name': args0
 }

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/external_project.py Added

@@ -0,0 +1,307 @@
+# Copyright 2020 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+import os
+import shlex
+import subprocess
+import typing as T
+
+from . import ExtensionModule, ModuleReturnValue, NewExtensionModule, ModuleInfo
+from .. import mlog, build
+from ..compilers.compilers import CFLAGS_MAPPING
+from ..envconfig import ENV_VAR_PROG_MAP
+from ..dependencies import InternalDependency, PkgConfigDependency
+from ..interpreterbase import FeatureNew
+from ..interpreter.type_checking import ENV_KW, DEPENDS_KW
+from ..interpreterbase.decorators import ContainerTypeInfo, KwargInfo, typed_kwargs, typed_pos_args
+from ..mesonlib import (EnvironmentException, MesonException, Popen_safe, MachineChoice,
+                        get_variable_regex, do_replacement, join_args, OptionKey)
+
+if T.TYPE_CHECKING:
+    from typing_extensions import TypedDict
+
+    from . import ModuleState
+    from ..interpreter import Interpreter
+    from ..interpreterbase import TYPE_var
+    from ..build import BuildTarget, CustomTarget
+
+    class Dependency(TypedDict):
+
+        subdir: str
+
+    class AddProject(TypedDict):
+
+        configure_options: T.Liststr
+        cross_configure_options: T.Liststr
+        verbose: bool
+        env: build.EnvironmentVariables
+        depends: T.ListT.UnionBuildTarget, CustomTarget
+
+
+class ExternalProject(NewExtensionModule):
+    def __init__(self,
+                 state: 'ModuleState',
+                 configure_command: str,
+                 configure_options: T.Liststr,
+                 cross_configure_options: T.Liststr,
+                 env: build.EnvironmentVariables,
+                 verbose: bool,
+                 extra_depends: T.ListT.Union'BuildTarget', 'CustomTarget'):
+        super().__init__()
+        self.methods.update({'dependency': self.dependency_method,
+                             })
+
+        self.subdir = Path(state.subdir)
+        self.project_version = state.project_version
+        self.subproject = state.subproject
+        self.env = state.environment
+        self.build_machine = state.build_machine
+        self.host_machine = state.host_machine
+        self.configure_command = configure_command
+        self.configure_options = configure_options
+        self.cross_configure_options = cross_configure_options
+        self.verbose = verbose
+        self.user_env = env
+
+        self.src_dir = Path(self.env.get_source_dir(), self.subdir)
+        self.build_dir = Path(self.env.get_build_dir(), self.subdir, 'build')
+        self.install_dir = Path(self.env.get_build_dir(), self.subdir, 'dist')
+        _p = self.env.coredata.get_option(OptionKey('prefix'))
+        assert isinstance(_p, str), 'for mypy'
+        self.prefix = Path(_p)
+        _l = self.env.coredata.get_option(OptionKey('libdir'))
+        assert isinstance(_l, str), 'for mypy'
+        self.libdir = Path(_l)
+        _i = self.env.coredata.get_option(OptionKey('includedir'))
+        assert isinstance(_i, str), 'for mypy'
+        self.includedir = Path(_i)
+        self.name = self.src_dir.name
+
+        # On Windows if the prefix is "c:/foo" and DESTDIR is "c:/bar", `make`
+        # will install files into "c:/bar/c:/foo" which is an invalid path.
+        # Work around that issue by removing the drive from prefix.
+        if self.prefix.drive:
+            self.prefix = self.prefix.relative_to(self.prefix.drive)
+
+        # self.prefix is an absolute path, so we cannot append it to another path.
+        self.rel_prefix = self.prefix.relative_to(self.prefix.root)
+
+        self._configure(state)
+
+        self.targets = self._create_targets(extra_depends)
+
+    def _configure(self, state: 'ModuleState') -> None:
+        if self.configure_command == 'waf':
+            FeatureNew('Waf external project', '0.60.0').use(self.subproject, state.current_node)
+            waf = state.find_program('waf')
+            configure_cmd = waf.get_command()
+            configure_cmd += 'configure', '-o', str(self.build_dir)
+            workdir = self.src_dir
+            self.make = waf.get_command() + 'build'
+        else:
+            # Assume it's the name of a script in source dir, like 'configure',
+            # 'autogen.sh', etc).
+            configure_path = Path(self.src_dir, self.configure_command)
+            configure_prog = state.find_program(configure_path.as_posix())
+            configure_cmd = configure_prog.get_command()
+            workdir = self.build_dir
+            self.make = state.find_program('make').get_command()
+
+        d = ('PREFIX', '--prefix=@PREFIX@', self.prefix.as_posix()),
+             ('LIBDIR', '--libdir=@PREFIX@/@LIBDIR@', self.libdir.as_posix()),
+             ('INCLUDEDIR', None, self.includedir.as_posix()),
+             
+        self._validate_configure_options(d, state)
+
+        configure_cmd += self._format_options(self.configure_options, d)
+
+        if self.env.is_cross_build():
+            host = '{}-{}-{}'.format(self.host_machine.cpu_family,
+                                     self.build_machine.system,
+                                     self.host_machine.system)
+            d = ('HOST', None, host)
+            configure_cmd += self._format_options(self.cross_configure_options, d)
+
+        # Set common env variables like CFLAGS, CC, etc.
+        link_exelist: T.Liststr = 
+        link_args: T.Liststr = 
+        self.run_env = os.environ.copy()
+        for lang, compiler in self.env.coredata.compilersMachineChoice.HOST.items():
+            if any(lang not in i for i in (ENV_VAR_PROG_MAP, CFLAGS_MAPPING)):
+                continue
+            cargs = self.env.coredata.get_external_args(MachineChoice.HOST, lang)
+            assert isinstance(cargs, list), 'for mypy'
+            self.run_envENV_VAR_PROG_MAPlang = self._quote_and_join(compiler.get_exelist())
+            self.run_envCFLAGS_MAPPINGlang = self._quote_and_join(cargs)
+            if not link_exelist:
+                link_exelist = compiler.get_linker_exelist()
+                _l = self.env.coredata.get_external_link_args(MachineChoice.HOST, lang)
+                assert isinstance(_l, list), 'for mypy'
+                link_args = _l
+        if link_exelist:
+            # FIXME: Do not pass linker because Meson uses CC as linker wrapper,
+            # but autotools often expects the real linker (e.h. GNU ld).
+            # self.run_env'LD' = self._quote_and_join(link_exelist)
+            pass
+        self.run_env'LDFLAGS' = self._quote_and_join(link_args)
+
+        self.run_env = self.user_env.get_env(self.run_env)
+        self.run_env = PkgConfigDependency.setup_env(self.run_env, self.env, MachineChoice.HOST,
+                                                     uninstalled=True)
+
+        self.build_dir.mkdir(parents=True, exist_ok=True)
+        self._run('configure', configure_cmd, workdir)
+
+    def _quote_and_join(self, array: T.Liststr) -> str:
+        return ' '.join(shlex.quote(i) for i in array)
+
+    def _validate_configure_options(self, variables: T.ListT.Tuplestr, str, str, state: 'ModuleState') -> None:
+        # Ensure the user at least try to pass basic info to the build system,
+        # like the prefix, libdir, etc.
+        for key, default, val in variables:
+            if default is None:
+                continue
+            key_format = f'@{key}@'
+            for option in self.configure_options:
+                if key_format in option:
+                    break
+            else:
+                FeatureNew('Default configure_option', '0.57.0').use(self.subproject, state.current_node)
+                self.configure_options.append(default)
+
+    def _format_options(self, options: T.Liststr, variables: T.ListT.Tuplestr, str, str) -> T.Liststr:
+        out: T.Liststr = 
+        missing = set()
+        regex = get_variable_regex('meson')
+        confdata: T.Dictstr, T.Tuplestr, T.Optionalstr = {k: (v, None) for k, _, v in variables}
+        for o in options:
+            arg, missing_vars = do_replacement(regex, o, 'meson', confdata)
+            missing.update(missing_vars)
+            out.append(arg)
+        if missing:
+            var_list = ", ".join(repr(m) for m in sorted(missing))
+            raise EnvironmentException(
+                f"Variables {var_list} in configure options are missing.")
+        return out
+
+    def _run(self, step: str, command: T.Liststr, workdir: Path) -> None:
+        mlog.log(f'External project {self.name}:', mlog.bold(step))
+        m = 'Running command ' + str(command) + ' in directory ' + str(workdir) + '\n'
+        log_filename = Path(mlog.log_dir, f'{self.name}-{step}.log')
+        output = None
+        if not self.verbose:
+            output = open(log_filename, 'w', encoding='utf-8')
+            output.write(m + '\n')
+            output.flush()
+        else:
+            mlog.log(m)
+        p, *_ = Popen_safe(command, cwd=workdir, env=self.run_env,
+                           stderr=subprocess.STDOUT,
+                           stdout=output)
+        if p.returncode != 0:
+            m = f'{step} step returned error code {p.returncode}.'
+            if not self.verbose:
+                m += '\nSee logs: ' + str(log_filename)
+            raise MesonException(m)
+
+    def _create_targets(self, extra_depends: T.ListT.Union'BuildTarget', 'CustomTarget') -> T.List'TYPE_var':
+        cmd = self.env.get_build_command()
+        cmd += '--internal', 'externalproject',
+                '--name', self.name,
+                '--srcdir', self.src_dir.as_posix(),
+                '--builddir', self.build_dir.as_posix(),
+                '--installdir', self.install_dir.as_posix(),
+                '--logdir', mlog.log_dir,
+                '--make', join_args(self.make),
+                
+        if self.verbose:
+            cmd.append('--verbose')
+
+        self.target = build.CustomTarget(
+            self.name,
+            self.subdir.as_posix(),
+            self.subproject,
+            self.env,
+            cmd + '@OUTPUT@', '@DEPFILE@',
+            ,
+            f'{self.name}.stamp',
+            depfile=f'{self.name}.d',
+            console=True,
+            extra_depends=extra_depends,
+        )
+
+        idir = build.InstallDir(self.subdir.as_posix(),
+                                Path('dist', self.rel_prefix).as_posix(),
+                                install_dir='.',
+                                install_dir_name='.',
+                                install_mode=None,
+                                exclude=None,
+                                strip_directory=True,
+                                from_source_dir=False,
+                                subproject=self.subproject)
+
+        return self.target, idir
+
+    @typed_pos_args('external_project.dependency', str)
+    @typed_kwargs('external_project.dependency', KwargInfo('subdir', str, default=''))
+    def dependency_method(self, state: 'ModuleState', args: T.Tuplestr, kwargs: 'Dependency') -> InternalDependency:
+        libname = args0
+
+        abs_includedir = Path(self.install_dir, self.rel_prefix, self.includedir)
+        if kwargs'subdir':
+            abs_includedir = Path(abs_includedir, kwargs'subdir')
+        abs_libdir = Path(self.install_dir, self.rel_prefix, self.libdir)
+
+        version = self.project_version
+        compile_args = f'-I{abs_includedir}'
+        link_args = f'-L{abs_libdir}', f'-l{libname}'
+        sources = self.target
+        dep = InternalDependency(version, , compile_args, link_args, ,
+                                 , sources, , {}, , )
+        return dep
+
+
+class ExternalProjectModule(ExtensionModule):
+
+    INFO = ModuleInfo('External build system', '0.56.0', unstable=True)
+
+    def __init__(self, interpreter: 'Interpreter'):
+        super().__init__(interpreter)
+        self.methods.update({'add_project': self.add_project,
+                             })
+
+    @typed_pos_args('external_project_mod.add_project', str)
+    @typed_kwargs(
+        'external_project.add_project',
+        KwargInfo('configure_options', ContainerTypeInfo(list, str), default=, listify=True),
+        KwargInfo('cross_configure_options', ContainerTypeInfo(list, str), default='--host=@HOST@', listify=True),
+        KwargInfo('verbose', bool, default=False),
+        ENV_KW,
+        DEPENDS_KW.evolve(since='0.63.0'),
+    )
+    def add_project(self, state: 'ModuleState', args: T.Tuplestr, kwargs: 'AddProject') -> ModuleReturnValue:
+        configure_command = args0
+        project = ExternalProject(state,
+                                  configure_command,
+                                  kwargs'configure_options',
+                                  kwargs'cross_configure_options',
+                                  kwargs'env',
+                                  kwargs'verbose',
+                                  kwargs'depends')
+        return ModuleReturnValue(project, project.targets)
+
+
+def initialize(interp: 'Interpreter') -> ExternalProjectModule:
+    return ExternalProjectModule(interp)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/fs.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/fs.py Changed

@@ -12,24 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import typing as T
+from __future__ import annotations
+from pathlib import Path, PurePath, PureWindowsPath
 import hashlib
 import os
-from pathlib import Path, PurePath, PureWindowsPath
+import typing as T
 
+from . import ExtensionModule, ModuleReturnValue, ModuleInfo
 from .. import mlog
-from . import ExtensionModule
+from ..build import CustomTarget, InvalidArguments
+from ..interpreter.type_checking import INSTALL_KW, INSTALL_MODE_KW, INSTALL_TAG_KW, NoneType
+from ..interpreterbase import FeatureNew, KwargInfo, typed_kwargs, typed_pos_args, noKwargs
 from ..mesonlib import (
     File,
-    FileOrString,
     MesonException,
+    has_path_sep,
     path_is_in_root,
 )
-from ..interpreterbase import FeatureNew, KwargInfo, typed_kwargs, typed_pos_args, noKwargs
 
 if T.TYPE_CHECKING:
     from . import ModuleState
     from ..interpreter import Interpreter
+    from ..mesonlib import FileOrString, FileMode
 
     from typing_extensions import TypedDict
 
@@ -38,10 +42,20 @@
 
         encoding: str
 
+    class CopyKw(TypedDict):
+
+        """Kwargs for fs.copy"""
+
+        install: bool
+        install_dir: T.Optionalstr
+        install_mode: FileMode
+        install_tag: T.Optionalstr
+
 
 class FSModule(ExtensionModule):
 
-    @FeatureNew('Fs Module', '0.53.0')
+    INFO = ModuleInfo('fs', '0.53.0')
+
     def __init__(self, interpreter: 'Interpreter') -> None:
         super().__init__(interpreter)
         self.methods.update({
@@ -60,6 +74,7 @@
             'name': self.name,
             'stem': self.stem,
             'read': self.read,
+            'copyfile': self.copyfile,
         })
 
     def _absolute_dir(self, state: 'ModuleState', arg: 'FileOrString') -> Path:
@@ -254,6 +269,47 @@
         self.interpreter.add_build_def_file(path)
         return data
 
+    @FeatureNew('fs.copyfile', '0.64.0')
+    @typed_pos_args('fs.copyfile', (File, str), optargs=str)
+    @typed_kwargs(
+        'fs.copyfile',
+        INSTALL_KW,
+        INSTALL_MODE_KW,
+        INSTALL_TAG_KW,
+        KwargInfo('install_dir', (str, NoneType)),
+    )
+    def copyfile(self, state: ModuleState, args: T.TupleFileOrString, T.Optionalstr,
+                 kwargs: CopyKw) -> ModuleReturnValue:
+        """Copy a file into the build directory at build time."""
+        if kwargs'install' and not kwargs'install_dir':
+            raise InvalidArguments('"install_dir" must be specified when "install" is true')
+
+        src = self.interpreter.source_strings_to_files(args0)0
+
+        # The input is allowed to have path separators, but the output may not,
+        # so use the basename for the default case
+        dest = args1 if args1 else os.path.basename(src.fname)
+        if has_path_sep(dest):
+            raise InvalidArguments('Destination path may not have path separators')
+
+        ct = CustomTarget(
+            dest,
+            state.subdir,
+            state.subproject,
+            state.environment,
+            state.environment.get_build_command() + '--internal', 'copy', '@INPUT@', '@OUTPUT@',
+            src,
+            dest,
+            build_by_default=True,
+            install=kwargs'install',
+            install_dir=kwargs'install_dir',
+            install_mode=kwargs'install_mode',
+            install_tag=kwargs'install_tag',
+            backend=state.backend,
+        )
+
+        return ModuleReturnValue(ct, ct)
+
 
 def initialize(*args: T.Any, **kwargs: T.Any) -> FSModule:
     return FSModule(*args, **kwargs)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/gnome.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/gnome.py Changed

@@ -14,47 +14,51 @@
 
 '''This module provides helper functions for Gnome/GLib related
 functionality such as gobject-introspection, gresources and gtk-doc'''
+from __future__ import annotations
 
 import copy
+import itertools
 import functools
 import os
 import subprocess
 import textwrap
 import typing as T
 
-from . import ExtensionModule
-from . import GResourceTarget, GResourceHeaderTarget, GirTarget, TypelibTarget, VapiTarget
+from . import ExtensionModule, ModuleInfo
 from . import ModuleReturnValue
 from .. import build
 from .. import interpreter
 from .. import mesonlib
 from .. import mlog
-from ..build import BuildTarget, CustomTarget, CustomTargetIndex, GeneratedList, InvalidArguments
+from ..build import CustomTarget, CustomTargetIndex, Executable, GeneratedList, InvalidArguments
 from ..dependencies import Dependency, PkgConfigDependency, InternalDependency
-from ..interpreter.type_checking import DEPENDS_KW, DEPEND_FILES_KW, INSTALL_KW, NoneType, in_set_validator
+from ..interpreter.type_checking import DEPENDS_KW, DEPEND_FILES_KW, INSTALL_DIR_KW, INSTALL_KW, NoneType, SOURCES_KW, in_set_validator
 from ..interpreterbase import noPosargs, noKwargs, FeatureNew, FeatureDeprecated
 from ..interpreterbase import typed_kwargs, KwargInfo, ContainerTypeInfo
 from ..interpreterbase.decorators import typed_pos_args
 from ..mesonlib import (
 MachineChoice, MesonException, OrderedSet, Popen_safe, join_args,
 )
-from ..programs import ExternalProgram, OverrideProgram, EmptyExternalProgram
+from ..programs import OverrideProgram
 from ..scripts.gettext import read_linguas
 
 if T.TYPE_CHECKING:
 from typing_extensions import Literal, TypedDict
 
 from . import ModuleState
+ from ..build import BuildTarget
 from ..compilers import Compiler
 from ..interpreter import Interpreter
 from ..interpreterbase import TYPE_var, TYPE_kwargs
 from ..mesonlib import FileOrString
+ from ..programs import ExternalProgram
 
 class PostInstall(TypedDict):
 glib_compile_schemas: bool
 gio_querymodules: T.Liststr
 gtk_update_icon_cache: bool
 update_desktop_database: bool
+ update_mime_database: bool
 
 class CompileSchemas(TypedDict):
 
@@ -147,7 +151,7 @@
 build_by_default: T.Optionalbool
 depend_files: T.Listmesonlib.File
 extra_args: T.Liststr
- install_dir: T.ListT.Unionstr, bool
+ install_dir: T.Optionalstr
 install_header: bool
 internal: bool
 nostdinc: bool
@@ -211,13 +215,13 @@
 
 _MK_ENUMS_COMMON_KWS: T.ListKwargInfo = 
 INSTALL_KW.evolve(name='install_header'),
+ INSTALL_DIR_KW,
 KwargInfo(
 'sources',
 ContainerTypeInfo(list, (str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)),
 listify=True,
 required=True,
 ),
- KwargInfo('install_dir', (str, NoneType)),
 KwargInfo('identifier_prefix', (str, NoneType)),
 KwargInfo('symbol_prefix', (str, NoneType)),
 
@@ -244,6 +248,21 @@
 return f'element {c+1} {badlist}'
 return None
 
+class GResourceTarget(build.CustomTarget):
+ pass
+
+class GResourceHeaderTarget(build.CustomTarget):
+ pass
+
+class GirTarget(build.CustomTarget):
+ pass
+
+class TypelibTarget(build.CustomTarget):
+ pass
+
+class VapiTarget(build.CustomTarget):
+ pass
+
 # gresource compilation is broken due to the way
 # the resource compiler and Ninja clash about it
 #
@@ -251,17 +270,22 @@
 # https://bugzilla.gnome.org/show_bug.cgi?id=774368
 gresource_dep_needed_version = '>= 2.51.1'
 
-native_glib_version = None
-
 class GnomeModule(ExtensionModule):
+
+ INFO = ModuleInfo('gnome')
+
 def __init__(self, interpreter: 'Interpreter') -> None:
 super().__init__(interpreter)
- self.gir_dep = None
+ self.gir_dep: T.OptionalDependency = None
+ self.giscanner: T.OptionalT.UnionExternalProgram, build.Executable, OverrideProgram = None
+ self.gicompiler: T.OptionalT.UnionExternalProgram, build.Executable, OverrideProgram = None
 self.install_glib_compile_schemas = False
- self.install_gio_querymodules = 
+ self.install_gio_querymodules: T.Liststr = 
 self.install_gtk_update_icon_cache = False
 self.install_update_desktop_database = False
- self.devenv = None
+ self.install_update_mime_database = False
+ self.devenv: T.Optionalbuild.EnvironmentVariables = None
+ self.native_glib_version: T.Optionalstr = None
 self.methods.update({
 'post_install': self.post_install,
 'compile_resources': self.compile_resources,
@@ -277,19 +301,17 @@
 'generate_vapi': self.generate_vapi,
 })
 
- @staticmethod
- def _get_native_glib_version(state: 'ModuleState') -> str:
- global native_glib_version
- if native_glib_version is None:
+ def _get_native_glib_version(self, state: 'ModuleState') -> str:
+ if self.native_glib_version is None:
 glib_dep = PkgConfigDependency('glib-2.0', state.environment,
 {'native': True, 'required': False})
 if glib_dep.found():
- native_glib_version = glib_dep.get_version()
+ self.native_glib_version = glib_dep.get_version()
 else:
 mlog.warning('Could not detect glib version, assuming 2.54. '
 'You may get build errors if your glib is older.')
- native_glib_version = '2.54'
- return native_glib_version
+ self.native_glib_version = '2.54'
+ return self.native_glib_version
 
 @mesonlib.run_once
 def __print_gresources_warning(self, state: 'ModuleState') -> None:
@@ -306,38 +328,13 @@
 mlog.bold('https://github.com/mesonbuild/meson/issues/1387'),
 once=True)
 
- def _get_dep(self, state: 'ModuleState', depname: str, native: bool = False,
- required: bool = True) -> Dependency:
- kwargs = {'native': native, 'required': required}
- return self.interpreter.func_dependency(state.current_node, depname, kwargs)
-
- def _get_native_binary(self, state: 'ModuleState', name: str, depname: str,
- varname: str, required: bool = True) -> T.UnionExternalProgram, OverrideProgram, 'build.Executable':
- # Look in overrides in case glib/gtk/etc are built as subproject
- prog = self.interpreter.program_from_overrides(name, )
- if prog is not None:
- return prog
-
- # Look in machine file
- prog_list = state.environment.lookup_binary_entry(MachineChoice.HOST, name)
- if prog_list is not None:
- return ExternalProgram.from_entry(name, prog_list)
-
- # Check if pkgconfig has a variable
- dep = self._get_dep(state, depname, native=True, required=False)
- if dep.found() and dep.type_name == 'pkgconfig':
- value = dep.get_pkgconfig_variable(varname, {})
- if value:
- return ExternalProgram(name, value)
-
- # Normal program lookup
- return state.find_program(name, required=required)
-
- @typed_kwargs('gnome.post_install',
+ @typed_kwargs(
+ 'gnome.post_install',
 KwargInfo('glib_compile_schemas', bool, default=False),
 KwargInfo('gio_querymodules', ContainerTypeInfo(list, str), default=, listify=True),
 KwargInfo('gtk_update_icon_cache', bool, default=False),
 KwargInfo('update_desktop_database', bool, default=False, since='0.59.0'),
+ KwargInfo('update_mime_database', bool, default=False, since='0.64.0'),
 )
 @noPosargs
 @FeatureNew('gnome.post_install', '0.57.0')
@@ -346,7 +343,7 @@
 datadir_abs = os.path.join(state.environment.get_prefix(), state.environment.get_datadir())
 if kwargs'glib_compile_schemas' and not self.install_glib_compile_schemas:
 self.install_glib_compile_schemas = True
- prog = self._get_native_binary(state, 'glib-compile-schemas', 'gio-2.0', 'glib_compile_schemas')
+ prog = state.find_tool('glib-compile-schemas', 'gio-2.0', 'glib_compile_schemas')
 schemasdir = os.path.join(datadir_abs, 'glib-2.0', 'schemas')
 script = state.backend.get_executable_serialisation(prog, schemasdir)
 script.skip_if_destdir = True
@@ -354,7 +351,7 @@
 for d in kwargs'gio_querymodules':
 if d not in self.install_gio_querymodules:
 self.install_gio_querymodules.append(d)
- prog = self._get_native_binary(state, 'gio-querymodules', 'gio-2.0', 'gio_querymodules')
+ prog = state.find_tool('gio-querymodules', 'gio-2.0', 'gio_querymodules')
 moduledir = os.path.join(state.environment.get_prefix(), d)
 script = state.backend.get_executable_serialisation(prog, moduledir)
 script.skip_if_destdir = True
@@ -376,20 +373,27 @@
 script = state.backend.get_executable_serialisation(prog, '-q', appdir)
 script.skip_if_destdir = True
 rv.append(script)
+ if kwargs'update_mime_database' and not self.install_update_mime_database:
+ self.install_update_mime_database = True
+ prog = state.find_program('update-mime-database')
+ appdir = os.path.join(datadir_abs, 'mime')
+ script = state.backend.get_executable_serialisation(prog, appdir)
+ script.skip_if_destdir = True
+ rv.append(script)
 return ModuleReturnValue(None, rv)
 
- @typed_pos_args('gnome.compile_resources', str, (str, mesonlib.File))
+ @typed_pos_args('gnome.compile_resources', str, (str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList))
 @typed_kwargs(
 'gnome.compile_resources',
 _BUILD_BY_DEFAULT,
 _EXTRA_ARGS_KW,
 INSTALL_KW,
 INSTALL_KW.evolve(name='install_header', since='0.37.0'),
+ INSTALL_DIR_KW,
 KwargInfo('c_name', (str, NoneType)),
 KwargInfo('dependencies', ContainerTypeInfo(list, (mesonlib.File, build.CustomTarget, build.CustomTargetIndex)), default=, listify=True),
 KwargInfo('export', bool, default=False, since='0.37.0'),
 KwargInfo('gresource_bundle', bool, default=False, since='0.37.0'),
- KwargInfo('install_dir', (str, NoneType)),
 KwargInfo('source_dir', ContainerTypeInfo(list, str), default=, listify=True),
 )
 def compile_resources(self, state: 'ModuleState', args: T.Tuplestr, 'FileOrString',
@@ -398,7 +402,7 @@
 glib_version = self._get_native_glib_version(state)
 
 glib_compile_resources = state.find_program('glib-compile-resources')
- cmd = glib_compile_resources, '@INPUT@'
+ cmd: T.ListT.UnionExternalProgram, str = glib_compile_resources, '@INPUT@'
 
 source_dirs = kwargs'source_dir'
 dependencies = kwargs'dependencies'
@@ -433,6 +437,13 @@
 ifile = os.path.join(state.environment.get_build_dir(), input_file.subdir, input_file.fname)
 else:
 ifile = os.path.join(input_file.subdir, input_file.fname)
+
+ elif isinstance(input_file, (build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)):
+ raise MesonException('Resource xml files generated at build-time cannot be used with '
+ 'gnome.compile_resources() in the current version of glib-compile-resources '
+ 'because we need to scan the xml for dependencies due to '
+ '<https://bugzilla.gnome.org/show_bug.cgi?id=774368>\nUse '
+ 'configure_file() instead to generate it at configure-time.')
 else:
 ifile = os.path.join(state.subdir, input_file)
 
@@ -480,44 +491,57 @@
 if install_header and not kwargs'export':
 raise MesonException('GResource header is installed yet export is not enabled')
 
- c_kwargs: T.Dictstr, T.Any = {
- 'build_by_default': kwargs'build_by_default',
- 'depends': depends,
- 'input': input_file,
- 'install': kwargs'install',
- 'install_dir': kwargs'install_dir' or ,
- 'output': output,
- }
+ depfile: T.Optionalstr = None
+ target_cmd: T.ListT.UnionExternalProgram, str
 if not mesonlib.version_compare(glib_version, gresource_dep_needed_version):
 # This will eventually go out of sync if dependencies are added
- c_kwargs'depend_files' = depend_files
- c_kwargs'command' = cmd
+ target_cmd = cmd
 else:
 depfile = f'{output}.d'
- c_kwargs'depfile' = depfile
- c_kwargs'command' = copy.copy(cmd) + '--dependency-file', '@DEPFILE@'
- target_c = GResourceTarget(name, state.subdir, state.subproject, c_kwargs)
+ depend_files = 
+ target_cmd = copy.copy(cmd) + '--dependency-file', '@DEPFILE@'
+ target_c = GResourceTarget(
+ name,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ target_cmd,
+ input_file,
+ output,
+ build_by_default=kwargs'build_by_default',
+ depfile=depfile,
+ depend_files=depend_files,
+ extra_depends=depends,
+ install=kwargs'install',
+ install_dir=kwargs'install_dir' if kwargs'install_dir' else ,
+ install_tag='runtime',
+ )
 
 if gresource: # Only one target for .gresource files
 return ModuleReturnValue(target_c, target_c)
 
- h_kwargs: T.Dictstr, T.Any = {
- 'command': cmd,
- 'input': input_file,
- 'output': f'{target_name}.h',
- # The header doesn't actually care about the files yet it errors if missing
- 'depends': depends,
- 'build_by_default': kwargs'build_by_default',
- 'install_dir': kwargs'install_dir' or state.environment.coredata.get_option(mesonlib.OptionKey('includedir')),
- }
- if install_header:
- h_kwargs'install' = install_header
- target_h = GResourceHeaderTarget(f'{target_name}_h', state.subdir, state.subproject, h_kwargs)
+ install_dir = kwargs'install_dir' or state.environment.coredata.get_option(mesonlib.OptionKey('includedir'))
+ assert isinstance(install_dir, str), 'for mypy'
+ target_h = GResourceHeaderTarget(
+ f'{target_name}_h',
+ state.subdir,
+ state.subproject,
+ state.environment,
+ cmd,
+ input_file,
+ f'{target_name}.h',
+ build_by_default=kwargs'build_by_default',
+ extra_depends=depends,
+ install=install_header,
+ install_dir=install_dir,
+ install_tag='devel',
+ )
 rv = target_c, target_h
 return ModuleReturnValue(rv, rv)
 
+ @staticmethod
 def _get_gresource_dependencies(
- self, state: 'ModuleState', input_file: str, source_dirs: T.Liststr,
+ state: 'ModuleState', input_file: str, source_dirs: T.Liststr,
 dependencies: T.SequenceT.Unionmesonlib.File, build.CustomTarget, build.CustomTargetIndex
 ) -> T.TupleT.Listmesonlib.FileOrString, T.ListT.Unionbuild.CustomTarget, build.CustomTargetIndex, T.Liststr:
 
@@ -591,17 +615,19 @@
 
 def _get_link_args(self, state: 'ModuleState',
 lib: T.Unionbuild.SharedLibrary, build.StaticLibrary,
- depends: T.Listbuild.BuildTarget,
+ depends: T.SequenceT.Unionbuild.BuildTarget, 'build.GeneratedTypes', 'FileOrString', build.StructuredSources,
 include_rpath: bool = False,
- use_gir_args: bool = False) -> T.Liststr:
+ use_gir_args: bool = False
+ ) -> T.TupleT.Liststr, T.ListT.Unionbuild.BuildTarget, 'build.GeneratedTypes', 'FileOrString', build.StructuredSources:
 link_command: T.Liststr = 
+ new_depends = list(depends)
 # Construct link args
 if isinstance(lib, build.SharedLibrary):
 libdir = os.path.join(state.environment.get_build_dir(), state.backend.get_target_dir(lib))
 link_command.append('-L' + libdir)
 if include_rpath:
 link_command.append('-Wl,-rpath,' + libdir)
- depends.append(lib)
+ new_depends.append(lib)
 # Needed for the following binutils bug:
 # https://github.com/mesonbuild/meson/issues/1911
 # However, g-ir-scanner does not understand -Wl,-rpath
@@ -615,21 +641,24 @@
 link_command.append('--extra-library=' + lib.name)
 else:
 link_command.append('-l' + lib.name)
- return link_command
+ return link_command, new_depends
 
- def _get_dependencies_flags(
- self, deps: T.SequenceT.Union'Dependency', build.SharedLibrary, build.StaticLibrary,
- state: 'ModuleState', depends: T.Listbuild.BuildTarget, include_rpath: bool = False,
- use_gir_args: bool = False, separate_nodedup: bool = False
- ) -> T.TupleOrderedSetstr, OrderedSetstr, OrderedSetstr, T.OptionalT.Liststr, OrderedSetstr:
+ def _get_dependencies_flags_raw(
+ self, deps: T.SequenceT.Union'Dependency', build.BuildTarget, build.CustomTarget, build.CustomTargetIndex,
+ state: 'ModuleState',
+ depends: T.SequenceT.Unionbuild.BuildTarget, 'build.GeneratedTypes', 'FileOrString', build.StructuredSources,
+ include_rpath: bool,
+ use_gir_args: bool,
+ ) -> T.TupleOrderedSetstr, OrderedSetT.Unionstr, T.Tuplestr, str, OrderedSetT.Unionstr, T.Tuplestr, str, OrderedSetstr,
+ T.ListT.Unionbuild.BuildTarget, 'build.GeneratedTypes', 'FileOrString', build.StructuredSources:
 cflags: OrderedSetstr = OrderedSet()
- internal_ldflags: OrderedSetstr = OrderedSet()
- external_ldflags: OrderedSetstr = OrderedSet()
 # External linker flags that can't be de-duped reliably because they
- # require two args in order, such as -framework AVFoundation
- external_ldflags_nodedup: T.Liststr = 
+ # require two args in order, such as -framework AVFoundation will be stored as a tuple.
+ internal_ldflags: OrderedSetT.Unionstr, T.Tuplestr, str = OrderedSet()
+ external_ldflags: OrderedSetT.Unionstr, T.Tuplestr, str = OrderedSet()
 gi_includes: OrderedSetstr = OrderedSet()
 deps = mesonlib.listify(deps)
+ depends = list(depends)
 
 for dep in deps:
 if isinstance(dep, Dependency):
@@ -642,21 +671,22 @@
 cflags.update(state.get_include_args(dep.include_directories))
 for lib in dep.libraries:
 if isinstance(lib, build.SharedLibrary):
- internal_ldflags.update(self._get_link_args(state, lib, depends, include_rpath))
- libdepflags = self._get_dependencies_flags(lib.get_external_deps(), state, depends, include_rpath,
- use_gir_args, True)
+ _ld, depends = self._get_link_args(state, lib, depends, include_rpath)
+ internal_ldflags.update(_ld)
+ libdepflags = self._get_dependencies_flags_raw(lib.get_external_deps(), state, depends, include_rpath,
+ use_gir_args)
 cflags.update(libdepflags0)
 internal_ldflags.update(libdepflags1)
 external_ldflags.update(libdepflags2)
- external_ldflags_nodedup += libdepflags3
- gi_includes.update(libdepflags4)
- extdepflags = self._get_dependencies_flags(dep.ext_deps, state, depends, include_rpath,
- use_gir_args, True)
+ gi_includes.update(libdepflags3)
+ depends = libdepflags4
+ extdepflags = self._get_dependencies_flags_raw(dep.ext_deps, state, depends, include_rpath,
+ use_gir_args)
 cflags.update(extdepflags0)
 internal_ldflags.update(extdepflags1)
 external_ldflags.update(extdepflags2)
- external_ldflags_nodedup += extdepflags3
- gi_includes.update(extdepflags4)
+ gi_includes.update(extdepflags3)
+ depends = extdepflags4
 for source in dep.sources:
 if isinstance(source, GirTarget):
 gi_includes.update(os.path.join(state.environment.get_build_dir(),
@@ -684,7 +714,7 @@
 # If it's a framework arg, slurp the framework name too
 # to preserve the order of arguments
 if flag == '-framework':
- external_ldflags_nodedup += flag, next(ldflags)
+ external_ldflags.update((flag, next(ldflags)))
 else:
 external_ldflags.update(flag)
 elif isinstance(dep, (build.StaticLibrary, build.SharedLibrary)):
@@ -695,20 +725,43 @@
 continue
 
 if use_gir_args and self._gir_has_option('--extra-library'):
- def fix_ldflags(ldflags: T.Iterablestr) -> OrderedSetstr:
- fixed_ldflags: OrderedSetstr = OrderedSet()
+ def fix_ldflags(ldflags: T.IterableT.Unionstr, T.Tuplestr, str) -> OrderedSetT.Unionstr, T.Tuplestr, str:
+ fixed_ldflags: OrderedSetT.Unionstr, T.Tuplestr, str = OrderedSet()
 for ldflag in ldflags:
- if ldflag.startswith("-l"):
+ if isinstance(ldflag, str) and ldflag.startswith("-l"):
 ldflag = ldflag.replace('-l', '--extra-library=', 1)
 fixed_ldflags.add(ldflag)
 return fixed_ldflags
 internal_ldflags = fix_ldflags(internal_ldflags)
 external_ldflags = fix_ldflags(external_ldflags)
- if not separate_nodedup:
- external_ldflags.update(external_ldflags_nodedup)
- return cflags, internal_ldflags, external_ldflags, None, gi_includes
- else:
- return cflags, internal_ldflags, external_ldflags, external_ldflags_nodedup, gi_includes
+ return cflags, internal_ldflags, external_ldflags, gi_includes, depends
+
+ def _get_dependencies_flags(
+ self, deps: T.SequenceT.Union'Dependency', build.BuildTarget, build.CustomTarget, build.CustomTargetIndex,
+ state: 'ModuleState',
+ depends: T.SequenceT.Unionbuild.BuildTarget, 'build.GeneratedTypes', 'FileOrString', build.StructuredSources,
+ include_rpath: bool = False,
+ use_gir_args: bool = False,
+ ) -> T.TupleOrderedSetstr, T.Liststr, T.Liststr, OrderedSetstr,
+ T.ListT.Unionbuild.BuildTarget, 'build.GeneratedTypes', 'FileOrString', build.StructuredSources:
+
+ cflags, internal_ldflags_raw, external_ldflags_raw, gi_includes, depends = self._get_dependencies_flags_raw(deps, state, depends, include_rpath, use_gir_args)
+ internal_ldflags: T.Liststr = 
+ external_ldflags: T.Liststr = 
+
+ # Extract non-deduplicable argument groups out of the tuples.
+ for ldflag in internal_ldflags_raw:
+ if isinstance(ldflag, str):
+ internal_ldflags.append(ldflag)
+ else:
+ internal_ldflags.extend(ldflag)
+ for ldflag in external_ldflags_raw:
+ if isinstance(ldflag, str):
+ external_ldflags.append(ldflag)
+ else:
+ external_ldflags.extend(ldflag)
+
+ return cflags, internal_ldflags, external_ldflags, gi_includes, depends
 
 def _unwrap_gir_target(self, girtarget: T.Unionbuild.Executable, build.StaticLibrary, build.SharedLibrary, state: 'ModuleState'
 ) -> T.Unionbuild.Executable, build.StaticLibrary, build.SharedLibrary:
@@ -728,15 +781,17 @@
 def _devenv_prepend(self, varname: str, value: str) -> None:
 if self.devenv is None:
 self.devenv = build.EnvironmentVariables()
- self.interpreter.build.devenv.append(self.devenv)
 self.devenv.prepend(varname, value)
 
+ def get_devenv(self) -> T.Optionalbuild.EnvironmentVariables:
+ return self.devenv
+
 def _get_gir_dep(self, state: 'ModuleState') -> T.TupleDependency, T.Unionbuild.Executable, 'ExternalProgram', 'OverrideProgram',
 T.Unionbuild.Executable, 'ExternalProgram', 'OverrideProgram':
 if not self.gir_dep:
- self.gir_dep = self._get_dep(state, 'gobject-introspection-1.0')
- self.giscanner = self._get_native_binary(state, 'g-ir-scanner', 'gobject-introspection-1.0', 'g_ir_scanner')
- self.gicompiler = self._get_native_binary(state, 'g-ir-compiler', 'gobject-introspection-1.0', 'g_ir_compiler')
+ self.gir_dep = state.dependency('gobject-introspection-1.0')
+ self.giscanner = state.find_tool('g-ir-scanner', 'gobject-introspection-1.0', 'g_ir_scanner')
+ self.gicompiler = state.find_tool('g-ir-compiler', 'gobject-introspection-1.0', 'g_ir_compiler')
 return self.gir_dep, self.giscanner, self.gicompiler
 
 @functools.lru_cache(maxsize=None)
@@ -750,7 +805,8 @@
 return p.returncode == 0 and option in o
 
 # May mutate depends and gir_inc_dirs
- def _scan_include(self, state: 'ModuleState', includes: T.ListT.Unionstr, GirTarget
+ @staticmethod
+ def _scan_include(state: 'ModuleState', includes: T.ListT.Unionstr, GirTarget
 ) -> T.TupleT.Liststr, T.Liststr, T.ListGirTarget:
 ret: T.Liststr = 
 gir_inc_dirs: T.Liststr = 
@@ -766,7 +822,8 @@
 
 return ret, gir_inc_dirs, depends
 
- def _scan_langs(self, state: 'ModuleState', langs: T.Iterablestr) -> T.Liststr:
+ @staticmethod
+ def _scan_langs(state: 'ModuleState', langs: T.Iterablestr) -> T.Liststr:
 ret: T.Liststr = 
 
 for lang in langs:
@@ -777,7 +834,8 @@
 
 return ret
 
- def _scan_gir_targets(self, state: 'ModuleState', girtargets: T.Sequencebuild.BuildTarget) -> T.ListT.Unionstr, build.Executable:
+ @staticmethod
+ def _scan_gir_targets(state: 'ModuleState', girtargets: T.Sequencebuild.BuildTarget) -> T.ListT.Unionstr, build.Executable:
 ret: T.ListT.Unionstr, build.Executable = 
 
 for girtarget in girtargets:
@@ -810,32 +868,36 @@
 
 return ret
 
- def _get_girtargets_langs_compilers(self, girtargets: T.Sequencebuild.BuildTarget) -> T.ListT.Tuplestr, 'Compiler':
+ @staticmethod
+ def _get_girtargets_langs_compilers(girtargets: T.Sequencebuild.BuildTarget) -> T.ListT.Tuplestr, 'Compiler':
 ret: T.ListT.Tuplestr, 'Compiler' = 
 for girtarget in girtargets:
 for lang, compiler in girtarget.compilers.items():
 # XXX: Can you use g-i with any other language?
- if lang in ('c', 'cpp', 'objc', 'objcpp', 'd'):
+ if lang in {'c', 'cpp', 'objc', 'objcpp', 'd'}:
 ret.append((lang, compiler))
 break
 
 return ret
 
- def _get_gir_targets_deps(self, girtargets: T.Sequencebuild.BuildTarget
- ) -> T.ListT.Unionbuild.Target, Dependency:
- ret: T.ListT.Unionbuild.Target, Dependency = 
+ @staticmethod
+ def _get_gir_targets_deps(girtargets: T.Sequencebuild.BuildTarget
+ ) -> T.ListT.Unionbuild.BuildTarget, build.CustomTarget, build.CustomTargetIndex, Dependency:
+ ret: T.ListT.Unionbuild.BuildTarget, build.CustomTarget, build.CustomTargetIndex, Dependency = 
 for girtarget in girtargets:
 ret += girtarget.get_all_link_deps()
 ret += girtarget.get_external_deps()
 return ret
 
- def _get_gir_targets_inc_dirs(self, girtargets: T.Sequencebuild.BuildTarget) -> T.Listbuild.IncludeDirs:
- ret: T.Listbuild.IncludeDirs = 
+ @staticmethod
+ def _get_gir_targets_inc_dirs(girtargets: T.Sequencebuild.BuildTarget) -> OrderedSetbuild.IncludeDirs:
+ ret: OrderedSet = OrderedSet()
 for girtarget in girtargets:
- ret += girtarget.get_include_dirs()
+ ret.update(girtarget.get_include_dirs())
 return ret
 
- def _get_langs_compilers_flags(self, state: 'ModuleState', langs_compilers: T.ListT.Tuplestr, 'Compiler'
+ @staticmethod
+ def _get_langs_compilers_flags(state: 'ModuleState', langs_compilers: T.ListT.Tuplestr, 'Compiler'
 ) -> T.TupleT.Liststr, T.Liststr, T.Liststr:
 cflags: T.Liststr = 
 internal_ldflags: T.Liststr = 
@@ -863,12 +925,13 @@
 
 return cflags, internal_ldflags, external_ldflags
 
- def _make_gir_filelist(self, state: 'ModuleState', srcdir: str, ns: str,
+ @staticmethod
+ def _make_gir_filelist(state: 'ModuleState', srcdir: str, ns: str,
 nsversion: str, girtargets: T.Sequencebuild.BuildTarget,
 libsources: T.SequenceT.Union
 str, mesonlib.File, build.GeneratedList,
 build.CustomTarget, build.CustomTargetIndex
- ) -> str:
+ ) -> str:
 gir_filelist_dir = state.backend.get_target_private_dir_abs(girtargets0)
 if not os.path.isdir(gir_filelist_dir):
 os.mkdir(gir_filelist_dir)
@@ -891,9 +954,14 @@
 
 return gir_filelist_filename
 
- def _make_gir_target(self, state: 'ModuleState', girfile: str, scan_command: T.Liststr,
- generated_files: T.SequenceT.Unionstr, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList,
- depends: T.Listbuild.Target, kwargs: T.Dictstr, T.Any) -> GirTarget:
+ @staticmethod
+ def _make_gir_target(
+ state: 'ModuleState',
+ girfile: str,
+ scan_command: T.SequenceT.Union'FileOrString', Executable, ExternalProgram, OverrideProgram,
+ generated_files: T.SequenceT.Unionstr, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList,
+ depends: T.SequenceT.Union'FileOrString', build.BuildTarget, 'build.GeneratedTypes', build.StructuredSources,
+ kwargs: T.Dictstr, T.Any) -> GirTarget:
 install = kwargs'install_gir'
 if install is None:
 install = kwargs'install'
@@ -904,20 +972,32 @@
 elif install_dir is False:
 install = False
 
- scankwargs = {
- 'input': generated_files,
- 'output': girfile,
- 'command': scan_command,
- 'depends': depends,
- 'install': install,
- 'install_dir': install_dir,
- 'install_tag': 'devel',
- 'build_by_default': kwargs'build_by_default',
- }
-
- return GirTarget(girfile, state.subdir, state.subproject, scankwargs)
+ # g-ir-scanner uses pkg-config to find libraries such as glib. They could
+ # be built as subproject in which case we need to trick it to use
+ # -uninstalled.pc files Meson generated. It also must respect pkgconfig
+ # settings user could have set in machine file, like PKG_CONFIG_LIBDIR,
+ # SYSROOT, etc.
+ run_env = PkgConfigDependency.get_env(state.environment, MachineChoice.HOST, uninstalled=True)
+
+ return GirTarget(
+ girfile,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ scan_command,
+ generated_files,
+ girfile,
+ build_by_default=kwargs'build_by_default',
+ extra_depends=depends,
+ install=install,
+ install_dir=install_dir,
+ install_tag='devel',
+ env=run_env,
+ )
 
- def _make_typelib_target(self, state: 'ModuleState', typelib_output: str, typelib_cmd: T.Liststr,
+ @staticmethod
+ def _make_typelib_target(state: 'ModuleState', typelib_output: str,
+ typelib_cmd: T.SequenceT.Unionstr, build.Executable, ExternalProgram, build.CustomTarget,
 generated_files: T.SequenceT.Unionstr, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList,
 kwargs: T.Dictstr, T.Any) -> TypelibTarget:
 install = kwargs'install_typelib'
@@ -930,31 +1010,38 @@
 elif install_dir is False:
 install = False
 
- typelib_kwargs = {
- 'input': generated_files,
- 'output': typelib_output,
- 'command': typelib_cmd,
- 'install': install,
- 'install_dir': install_dir,
- 'install_tag': 'typelib',
- 'build_by_default': kwargs'build_by_default',
- }
-
- return TypelibTarget(typelib_output, state.subdir, state.subproject, typelib_kwargs)
+ return TypelibTarget(
+ typelib_output,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ typelib_cmd,
+ generated_files,
+ typelib_output,
+ install=install,
+ install_dir=install_dir,
+ install_tag='typelib',
+ build_by_default=kwargs'build_by_default',
+ )
 
- # May mutate depends
- def _gather_typelib_includes_and_update_depends(self, state: 'ModuleState', deps: T.ListDependency, depends: T.Listbuild.Target) -> T.Liststr:
+ @staticmethod
+ def _gather_typelib_includes_and_update_depends(
+ state: 'ModuleState',
+ deps: T.SequenceT.UnionDependency, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex,
+ depends: T.SequenceT.Unionbuild.BuildTarget, 'build.GeneratedTypes', 'FileOrString', build.StructuredSources
+ ) -> T.TupleT.Liststr, T.ListT.Unionbuild.BuildTarget, 'build.GeneratedTypes', 'FileOrString', build.StructuredSources:
 # Need to recursively add deps on GirTarget sources from our
 # dependencies and also find the include directories needed for the
 # typelib generation custom target below.
 typelib_includes: T.Liststr = 
+ new_depends = list(depends)
 for dep in deps:
 # Add a dependency on each GirTarget listed in dependencies and add
 # the directory where it will be generated to the typelib includes
 if isinstance(dep, InternalDependency):
 for source in dep.sources:
 if isinstance(source, GirTarget) and source not in depends:
- depends.append(source)
+ new_depends.append(source)
 subdir = os.path.join(state.environment.get_build_dir(),
 source.get_subdir())
 if subdir not in typelib_includes:
@@ -965,10 +1052,10 @@
 # FIXME: Store this in the original form from declare_dependency()
 # so it can be used here directly.
 elif isinstance(dep, build.SharedLibrary):
- for source in dep.generated:
- if isinstance(source, GirTarget):
+ for g_source in dep.generated:
+ if isinstance(g_source, GirTarget):
 subdir = os.path.join(state.environment.get_build_dir(),
- source.get_subdir())
+ g_source.get_subdir())
 if subdir not in typelib_includes:
 typelib_includes.append(subdir)
 if isinstance(dep, Dependency):
@@ -976,9 +1063,10 @@
 assert isinstance(girdir, str), 'for mypy'
 if girdir and girdir not in typelib_includes:
 typelib_includes.append(girdir)
- return typelib_includes
+ return typelib_includes, new_depends
 
- def _get_external_args_for_langs(self, state: 'ModuleState', langs: T.Sequencestr) -> T.Liststr:
+ @staticmethod
+ def _get_external_args_for_langs(state: 'ModuleState', langs: T.Liststr) -> T.Liststr:
 ret: T.Liststr = 
 for lang in langs:
 ret += mesonlib.listify(state.environment.coredata.get_external_args(MachineChoice.HOST, lang))
@@ -1015,12 +1103,12 @@
 KwargInfo('includes', ContainerTypeInfo(list, (str, GirTarget)), default=, listify=True),
 KwargInfo('install_gir', (bool, NoneType), since='0.61.0'),
 KwargInfo('install_dir_gir', (str, bool, NoneType),
- deprecated_values={False: ('0.61.0', 'Use install_gir to disable installation')},
- validator=lambda x: 'as boolean can only be false' if x is True else None),
+ deprecated_values={False: ('0.61.0', 'Use install_gir to disable installation')},
+ validator=lambda x: 'as boolean can only be false' if x is True else None),
 KwargInfo('install_typelib', (bool, NoneType), since='0.61.0'),
 KwargInfo('install_dir_typelib', (str, bool, NoneType),
- deprecated_values={False: ('0.61.0', 'Use install_typelib to disable installation')},
- validator=lambda x: 'as boolean can only be false' if x is True else None),
+ deprecated_values={False: ('0.61.0', 'Use install_typelib to disable installation')},
+ validator=lambda x: 'as boolean can only be false' if x is True else None),
 KwargInfo('link_with', ContainerTypeInfo(list, (build.SharedLibrary, build.StaticLibrary)), default=, listify=True),
 KwargInfo('namespace', str, required=True),
 KwargInfo('nsversion', str, required=True),
@@ -1030,7 +1118,7 @@
 def generate_gir(self, state: 'ModuleState', args: T.TupleT.ListT.Unionbuild.Executable, build.SharedLibrary, build.StaticLibrary,
 kwargs: 'GenerateGir') -> ModuleReturnValue:
 girtargets = self._unwrap_gir_target(arg, state) for arg in args0
- if len(girtargets) > 1 and any(isinstance(el, build.Executable) for el in girtargets):
+ if len(girtargets) > 1 and any(isinstance(el, build.Executable) for el in girtargets):
 raise MesonException('generate_gir only accepts a single argument when one of the arguments is an executable')
 
 gir_dep, giscanner, gicompiler = self._get_gir_dep(state)
@@ -1043,7 +1131,7 @@
 srcdir = os.path.join(state.environment.get_source_dir(), state.subdir)
 builddir = os.path.join(state.environment.get_build_dir(), state.subdir)
 
- depends: T.ListT.Union'FileOrString', build.GeneratedTypes, build.Executable, build.SharedLibrary, build.StaticLibrary = 
+ depends: T.ListT.Union'FileOrString', 'build.GeneratedTypes', build.BuildTarget, build.StructuredSources = 
 depends.extend(gir_dep.sources)
 depends.extend(girtargets)
 
@@ -1052,11 +1140,11 @@
 deps = self._get_gir_targets_deps(girtargets)
 deps += kwargs'dependencies'
 deps += gir_dep
- typelib_includes = self._gather_typelib_includes_and_update_depends(state, deps, depends)
+ typelib_includes, depends = self._gather_typelib_includes_and_update_depends(state, deps, depends)
 # ldflags will be misinterpreted by gir scanner (showing
 # spurious dependencies) but building GStreamer fails if they
 # are not used here.
- dep_cflags, dep_internal_ldflags, dep_external_ldflags, _, gi_includes = \
+ dep_cflags, dep_internal_ldflags, dep_external_ldflags, gi_includes, depends = \
 self._get_dependencies_flags(deps, state, depends, use_gir_args=True)
 scan_cflags = 
 scan_cflags += list(self._get_scanner_cflags(cflags))
@@ -1074,6 +1162,7 @@
 gir_inc_dirs: T.Liststr = 
 
 scan_command: T.ListT.Unionstr, build.Executable, 'ExternalProgram', 'OverrideProgram' = giscanner
+ scan_command += '--quiet'
 scan_command += '--no-libtool'
 scan_command += '--namespace=' + ns, '--nsversion=' + nsversion
 scan_command += '--warn-all'
@@ -1083,9 +1172,9 @@
 scan_command += '-I' + srcdir, '-I' + builddir
 scan_command += state.get_include_args(girtargets_inc_dirs)
 scan_command += '--filelist=' + self._make_gir_filelist(state, srcdir, ns, nsversion, girtargets, libsources)
- scan_command += mesonlib.listify(self._get_link_args(state, l, depends, use_gir_args=True)
- for l in kwargs'link_with')
-
+ for l in kwargs'link_with':
+ _cflags, depends = self._get_link_args(state, l, depends, use_gir_args=True)
+ scan_command.extend(_cflags)
 _cmd, _ginc, _deps = self._scan_include(state, kwargs'includes')
 scan_command.extend(_cmd)
 gir_inc_dirs.extend(_ginc)
@@ -1098,15 +1187,15 @@
 scan_command += scan_cflags
 scan_command += '--cflags-end'
 scan_command += state.get_include_args(inc_dirs)
- scan_command += state.get_include_args(list(gi_includes) + gir_inc_dirs + inc_dirs, prefix='--add-include-path=')
+ scan_command += state.get_include_args(itertools.chain(gi_includes, gir_inc_dirs, inc_dirs), prefix='--add-include-path=')
 scan_command += list(scan_internal_ldflags)
 scan_command += self._scan_gir_targets(state, girtargets)
 scan_command += self._scan_langs(state, lc0 for lc in langs_compilers)
 scan_command += list(scan_external_ldflags)
 
 if self._gir_has_option('--sources-top-dirs'):
- scan_command += '--sources-top-dirs', os.path.join(state.environment.get_source_dir(), self.interpreter.subproject_dir, state.subproject)
- scan_command += '--sources-top-dirs', os.path.join(state.environment.get_build_dir(), self.interpreter.subproject_dir, state.subproject)
+ scan_command += '--sources-top-dirs', os.path.join(state.environment.get_source_dir(), state.root_subdir)
+ scan_command += '--sources-top-dirs', os.path.join(state.environment.get_build_dir(), state.root_subdir)
 
 if '--warn-error' in scan_command:
 FeatureDeprecated.single_use('gnome.generate_gir argument --warn-error', '0.55.0',
@@ -1116,7 +1205,10 @@
 
 generated_files = f for f in libsources if isinstance(f, (GeneratedList, CustomTarget, CustomTargetIndex))
 
- scan_target = self._make_gir_target(state, girfile, scan_command, generated_files, depends, kwargs)
+ scan_target = self._make_gir_target(
+ state, girfile, scan_command, generated_files, depends,
+ # We have to cast here because mypy can't figure this out
+ T.cast('T.Dictstr, T.Any', kwargs))
 
 typelib_output = f'{ns}-{nsversion}.typelib'
 typelib_cmd = gicompiler, scan_target, '--output', '@OUTPUT@'
@@ -1125,7 +1217,7 @@
 for incdir in typelib_includes:
 typelib_cmd += "--includedir=" + incdir
 
- typelib_target = self._make_typelib_target(state, typelib_output, typelib_cmd, generated_files, kwargs)
+ typelib_target = self._make_typelib_target(state, typelib_output, typelib_cmd, generated_files, T.cast('T.Dictstr, T.Any', kwargs))
 
 self._devenv_prepend('GI_TYPELIB_PATH', os.path.join(state.environment.get_build_dir(), state.subdir))
 
@@ -1139,16 +1231,22 @@
 srcdir = os.path.join(state.build_to_src, state.subdir)
 outdir = state.subdir
 
- cmd = state.find_program('glib-compile-schemas'), '--targetdir', outdir, srcdir
- ct_kwargs = T.cast(T.Dictstr, T.Any, kwargs.copy())
- ct_kwargs'command' = cmd
- ct_kwargs'input' = 
- ct_kwargs'output' = 'gschemas.compiled'
+ cmd: T.ListT.UnionExternalProgram, str = state.find_program('glib-compile-schemas'), '--targetdir', outdir, srcdir
 if state.subdir == '':
 targetname = 'gsettings-compile'
 else:
 targetname = 'gsettings-compile-' + state.subdir.replace('/', '_')
- target_g = build.CustomTarget(targetname, state.subdir, state.subproject, ct_kwargs)
+ target_g = build.CustomTarget(
+ targetname,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ cmd,
+ ,
+ 'gschemas.compiled',
+ build_by_default=kwargs'build_by_default',
+ depend_files=kwargs'depend_files',
+ )
 self._devenv_prepend('GSETTINGS_SCHEMA_DIR', os.path.join(state.environment.get_build_dir(), state.subdir))
 return ModuleReturnValue(target_g, target_g)
 
@@ -1187,7 +1285,7 @@
 
 media = kwargs'media'
 symlinks = kwargs'symlink_media'
- targets: T.ListT.Union'Target', build.Data, build.SymlinkData = 
+ targets: T.ListT.Union'build.Target', build.Data, build.SymlinkData = 
 potargets: T.Listbuild.RunTarget = 
 
 itstool = state.find_program('itstool')
@@ -1197,7 +1295,7 @@
 install_dir = os.path.join(state.environment.get_datadir(), 'help')
 c_install_dir = os.path.join(install_dir, 'C', project_id)
 c_data = build.Data(sources_files, c_install_dir, c_install_dir,
- mesonlib.FileMode(), state.subproject)
+ mesonlib.FileMode(), state.subproject, install_tag='doc')
 targets.append(c_data)
 
 media_files: T.Listmesonlib.File = 
@@ -1207,14 +1305,16 @@
 media_files.append(f)
 m_install_dir = os.path.join(c_install_dir, os.path.dirname(m))
 m_data = build.Data(f, m_install_dir, m_install_dir,
- mesonlib.FileMode(), state.subproject)
+ mesonlib.FileMode(), state.subproject, install_tag='doc')
 targets.append(m_data)
 
 pot_file = os.path.join('@SOURCE_ROOT@', state.subdir, 'C', project_id + '.pot')
 pot_sources = os.path.join('@SOURCE_ROOT@', state.subdir, 'C', s) for s in sources
- pot_args = itstool, '-o', pot_file + pot_sources
+ pot_args: T.ListT.Union'ExternalProgram', str = itstool, '-o', pot_file
+ pot_args.extend(pot_sources)
 pottarget = build.RunTarget(f'help-{project_id}-pot', pot_args, ,
- os.path.join(state.subdir, 'C'), state.subproject)
+ os.path.join(state.subdir, 'C'), state.subproject,
+ state.environment)
 targets.append(pottarget)
 
 for l in langs:
@@ -1224,49 +1324,61 @@
 for i, m in enumerate(media):
 m_dir = os.path.dirname(m)
 m_install_dir = os.path.join(l_install_dir, m_dir)
+ l_data: T.Unionbuild.Data, build.SymlinkData
 if symlinks:
 link_target = os.path.join(os.path.relpath(c_install_dir, start=m_install_dir), m)
 l_data = build.SymlinkData(link_target, os.path.basename(m),
- m_install_dir, state.subproject)
+ m_install_dir, state.subproject, install_tag='doc')
 else:
 try:
 m_file = mesonlib.File.from_source_file(state.environment.source_dir, l_subdir, m)
 except MesonException:
 m_file = media_filesi
 l_data = build.Data(m_file, m_install_dir, m_install_dir,
- mesonlib.FileMode(), state.subproject)
+ mesonlib.FileMode(), state.subproject, install_tag='doc')
 targets.append(l_data)
 
 po_file = l + '.po'
- po_args = msgmerge, '-q', '-o',
- os.path.join('@SOURCE_ROOT@', l_subdir, po_file),
- os.path.join('@SOURCE_ROOT@', l_subdir, po_file), pot_file
+ po_args: T.ListT.Union'ExternalProgram', str = 
+ msgmerge, '-q', '-o',
+ os.path.join('@SOURCE_ROOT@', l_subdir, po_file),
+ os.path.join('@SOURCE_ROOT@', l_subdir, po_file), pot_file
 potarget = build.RunTarget(f'help-{project_id}-{l}-update-po',
- po_args, pottarget, l_subdir, state.subproject)
+ po_args, pottarget, l_subdir, state.subproject,
+ state.environment)
 targets.append(potarget)
 potargets.append(potarget)
 
 gmo_file = project_id + '-' + l + '.gmo'
- gmo_kwargs = {'command': msgfmt, '@INPUT@', '-o', '@OUTPUT@',
- 'input': po_file,
- 'output': gmo_file,
- }
- gmotarget = build.CustomTarget(f'help-{project_id}-{l}-gmo', l_subdir, state.subproject, gmo_kwargs)
+ gmotarget = build.CustomTarget(
+ f'help-{project_id}-{l}-gmo',
+ l_subdir,
+ state.subproject,
+ state.environment,
+ msgfmt, '@INPUT@', '-o', '@OUTPUT@',
+ po_file,
+ gmo_file,
+ install_tag='doc',
+ )
 targets.append(gmotarget)
 
- merge_kwargs = {'command': itstool, '-m', os.path.join(l_subdir, gmo_file),
- '-o', '@OUTDIR@', '@INPUT@',
- 'input': sources_files,
- 'output': sources,
- 'depends': gmotarget,
- 'install': True,
- 'install_dir': l_install_dir,
- }
- mergetarget = build.CustomTarget(f'help-{project_id}-{l}', l_subdir, state.subproject, merge_kwargs)
+ mergetarget = build.CustomTarget(
+ f'help-{project_id}-{l}',
+ l_subdir,
+ state.subproject,
+ state.environment,
+ itstool, '-m', os.path.join(l_subdir, gmo_file), '--lang', l, '-o', '@OUTDIR@', '@INPUT@',
+ sources_files,
+ sources,
+ extra_depends=gmotarget,
+ install=True,
+ install_dir=l_install_dir,
+ install_tag='doc',
+ )
 targets.append(mergetarget)
 
 allpotarget = build.AliasTarget(f'help-{project_id}-update-po', potargets,
- state.subdir, state.subproject)
+ state.subdir, state.subproject, state.environment)
 targets.append(allpotarget)
 
 return ModuleReturnValue(None, targets)
@@ -1298,7 +1410,7 @@
 KwargInfo('mkdb_args', ContainerTypeInfo(list, str), default=, listify=True),
 KwargInfo(
 'mode', str, default='auto', since='0.37.0',
- validator=in_set_validator({'xml', 'sgml', 'none', 'auto'})),
+ validator=in_set_validator({'xml', 'sgml', 'none', 'auto'})),
 KwargInfo('module_version', str, default='', since='0.48.0'),
 KwargInfo('namespace', str, default='', since='0.37.0'),
 KwargInfo('scan_args', ContainerTypeInfo(list, str), default=, listify=True),
@@ -1335,15 +1447,16 @@
 else:
 header_dirs.append(src_dir)
 
- t_args = '--internal', 'gtkdoc',
- '--sourcedir=' + state.environment.get_source_dir(),
- '--builddir=' + state.environment.get_build_dir(),
- '--subdir=' + state.subdir,
- '--headerdirs=' + '@@'.join(header_dirs),
- '--mainfile=' + main_file,
- '--modulename=' + modulename,
- '--moduleversion=' + moduleversion,
- '--mode=' + kwargs'mode'
+ t_args: T.Liststr = 
+ '--internal', 'gtkdoc',
+ '--sourcedir=' + state.environment.get_source_dir(),
+ '--builddir=' + state.environment.get_build_dir(),
+ '--subdir=' + state.subdir,
+ '--headerdirs=' + '@@'.join(header_dirs),
+ '--mainfile=' + main_file,
+ '--modulename=' + modulename,
+ '--moduleversion=' + moduleversion,
+ '--mode=' + kwargs'mode'
 for tool in 'scan', 'scangobj', 'mkdb', 'mkhtml', 'fixxref':
 program_name = 'gtkdoc-' + tool
 program = state.find_program(program_name)
@@ -1351,8 +1464,9 @@
 t_args.append(f'--{program_name}={path}')
 if namespace:
 t_args.append('--namespace=' + namespace)
- if state.environment.need_exe_wrapper() and not isinstance(state.environment.get_exe_wrapper(), EmptyExternalProgram):
- t_args.append('--run=' + ' '.join(state.environment.get_exe_wrapper().get_command()))
+ exe_wrapper = state.environment.get_exe_wrapper()
+ if exe_wrapper:
+ t_args.append('--run=' + ' '.join(exe_wrapper.get_command()))
 t_args.append(f'--htmlargs={"@@".join(kwargs"html_args")}')
 t_args.append(f'--scanargs={"@@".join(kwargs"scan_args")}')
 t_args.append(f'--scanobjsargs={"@@".join(kwargs"scanobjs_args")}')
@@ -1388,15 +1502,22 @@
 t_args.append(f'--expand-content-files={"@@".join(abs_filenames(kwargs"expand_content_files"))}')
 t_args.append(f'--ignore-headers={"@@".join(kwargs"ignore_headers")}')
 t_args.append(f'--installdir={"@@".join(kwargs"install_dir")}')
- t_args += self._get_build_args(kwargs'c_args', kwargs'include_directories',
- kwargs'dependencies', state, depends)
- custom_kwargs = {'output': modulename + '-decl.txt',
- 'command': command + t_args,
- 'depends': depends,
- 'build_always_stale': True,
- }
- custom_target = build.CustomTarget(targetname, state.subdir, state.subproject, custom_kwargs)
- alias_target = build.AliasTarget(targetname, custom_target, state.subdir, state.subproject)
+ build_args, new_depends = self._get_build_args(kwargs'c_args', kwargs'include_directories',
+ kwargs'dependencies', state, depends)
+ t_args.extend(build_args)
+ new_depends.extend(depends)
+ custom_target = build.CustomTarget(
+ targetname,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ command + t_args,
+ ,
+ f'{modulename}-decl.txt',
+ build_always_stale=True,
+ extra_depends=new_depends,
+ )
+ alias_target = build.AliasTarget(targetname, custom_target, state.subdir, state.subproject, state.environment)
 if kwargs'check':
 check_cmd = state.find_program('gtkdoc-check')
 check_env = 'DOC_MODULE=' + modulename,
@@ -1411,10 +1532,12 @@
 
 def _get_build_args(self, c_args: T.Liststr, inc_dirs: T.ListT.Unionstr, build.IncludeDirs,
 deps: T.ListT.UnionDependency, build.SharedLibrary, build.StaticLibrary,
- state: 'ModuleState', depends: T.Listbuild.BuildTarget) -> T.Liststr:
+ state: 'ModuleState',
+ depends: T.SequenceT.Unionbuild.BuildTarget, 'build.GeneratedTypes') -> T.Tuple
+ T.Liststr, T.ListT.Unionbuild.BuildTarget, 'build.GeneratedTypes', 'FileOrString', build.StructuredSources:
 args: T.Liststr = 
 cflags = c_args.copy()
- deps_cflags, internal_ldflags, external_ldflags, *_ = \
+ deps_cflags, internal_ldflags, external_ldflags, _gi_includes, new_depends = \
 self._get_dependencies_flags(deps, state, depends, include_rpath=True)
 
 cflags.extend(deps_cflags)
@@ -1439,18 +1562,18 @@
 if ldflags:
 args += '--ldflags=%s' % join_args(ldflags)
 
- return args
+ return args, new_depends
 
 @noKwargs
 @typed_pos_args('gnome.gtkdoc_html_dir', str)
 def gtkdoc_html_dir(self, state: 'ModuleState', args: T.Tuplestr, kwargs: 'TYPE_kwargs') -> str:
 return os.path.join('share/gtk-doc/html', args0)
 
- @typed_pos_args('gnome.gdbus_codegen', str, optargs=(str, mesonlib.File))
+ @typed_pos_args('gnome.gdbus_codegen', str, optargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList))
 @typed_kwargs(
 'gnome.gdbus_codegen',
 _BUILD_BY_DEFAULT.evolve(since='0.40.0'),
- KwargInfo('sources', ContainerTypeInfo(list, (str, mesonlib.File)), since='0.46.0', default=, listify=True),
+ SOURCES_KW.evolve(since='0.46.0'),
 KwargInfo('extra_args', ContainerTypeInfo(list, str), since='0.47.0', default=, listify=True),
 KwargInfo('interface_prefix', (str, NoneType)),
 KwargInfo('namespace', (str, NoneType)),
@@ -1462,16 +1585,16 @@
 convertor=lambda x: x if x and isinstance(x0, str) else x,
 ),
 KwargInfo('install_header', bool, default=False, since='0.46.0'),
- KwargInfo('install_dir', (str, NoneType), since='0.46.0'),
 KwargInfo('docbook', (str, NoneType)),
 KwargInfo(
 'autocleanup', str, default='default', since='0.47.0',
 validator=in_set_validator({'all', 'none', 'objects'})),
+ INSTALL_DIR_KW.evolve(since='0.46.0')
 )
- def gdbus_codegen(self, state: 'ModuleState', args: T.Tuplestr, T.Optional'FileOrString',
+ def gdbus_codegen(self, state: 'ModuleState', args: T.Tuplestr, T.OptionalT.Union'FileOrString', build.GeneratedTypes,
 kwargs: 'GdbusCodegen') -> ModuleReturnValue:
 namebase = args0
- xml_files: T.List'FileOrString' = args1 if args1 else 
+ xml_files: T.ListT.Union'FileOrString', build.GeneratedTypes = args1 if args1 else 
 cmd: T.ListT.Union'ExternalProgram', str = state.find_program('gdbus-codegen')
 cmd.extend(kwargs'extra_args')
 
@@ -1512,11 +1635,7 @@
 # Added in https://gitlab.gnome.org/GNOME/glib/commit/e4d68c7b3e8b01ab1a4231bf6da21d045cb5a816 (2.55.2)
 # Fixed in https://gitlab.gnome.org/GNOME/glib/commit/cd1f82d8fc741a2203582c12cc21b4dacf7e1872 (2.56.2)
 if mesonlib.version_compare(glib_version, '>= 2.56.2'):
- custom_kwargs = {'input': xml_files,
- 'output': output,
- 'command': cmd + '--body', '--output', '@OUTPUT@', '@INPUT@',
- 'build_by_default': build_by_default
- }
+ c_cmd = cmd + '--body', '--output', '@OUTPUT@', '@INPUT@'
 else:
 if kwargs'docbook' is not None:
 docbook = kwargs'docbook'
@@ -1529,45 +1648,46 @@
 else:
 self._print_gdbus_warning()
 cmd += '--generate-c-code', '@OUTDIR@/' + namebase, '@INPUT@'
+ c_cmd = cmd
 
- custom_kwargs = {'input': xml_files,
- 'output': output,
- 'command': cmd,
- 'build_by_default': build_by_default
- }
-
- cfile_custom_target = build.CustomTarget(output, state.subdir, state.subproject, custom_kwargs)
+ cfile_custom_target = build.CustomTarget(
+ output,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ c_cmd,
+ xml_files,
+ output,
+ build_by_default=build_by_default,
+ )
 targets.append(cfile_custom_target)
 
 output = namebase + '.h'
 if mesonlib.version_compare(glib_version, '>= 2.56.2'):
- custom_kwargs = {'input': xml_files,
- 'output': output,
- 'command': cmd + '--header', '--output', '@OUTPUT@', '@INPUT@',
- 'build_by_default': build_by_default,
- 'install': install_header,
- 'install_dir': install_dir
- }
+ hfile_cmd = cmd + '--header', '--output', '@OUTPUT@', '@INPUT@'
+ depends = 
 else:
- custom_kwargs = {'input': xml_files,
- 'output': output,
- 'command': cmd,
- 'build_by_default': build_by_default,
- 'install': install_header,
- 'install_dir': install_dir,
- 'depends': cfile_custom_target
- }
+ hfile_cmd = cmd
+ depends = cfile_custom_target
 
- hfile_custom_target = build.CustomTarget(output, state.subdir, state.subproject, custom_kwargs)
+ hfile_custom_target = build.CustomTarget(
+ output,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ hfile_cmd,
+ xml_files,
+ output,
+ build_by_default=build_by_default,
+ extra_depends=depends,
+ install=install_header,
+ install_dir=install_dir,
+ install_tag='devel',
+ )
 targets.append(hfile_custom_target)
 
 if kwargs'docbook' is not None:
 docbook = kwargs'docbook'
- if not isinstance(docbook, str):
- raise MesonException('docbook value must be a string.')
-
- docbook_cmd = cmd + '--output-directory', '@OUTDIR@', '--generate-docbook', docbook, '@INPUT@'
-
 # The docbook output is always ${docbook}-${name_of_xml_file}
 output = namebase + '-docbook'
 outputs = 
@@ -1575,20 +1695,23 @@
 outputs.append('{}-{}'.format(docbook, os.path.basename(str(f))))
 
 if mesonlib.version_compare(glib_version, '>= 2.56.2'):
- custom_kwargs = {'input': xml_files,
- 'output': outputs,
- 'command': docbook_cmd,
- 'build_by_default': build_by_default
- }
+ docbook_cmd = cmd + '--output-directory', '@OUTDIR@', '--generate-docbook', docbook, '@INPUT@'
+ depends = 
 else:
- custom_kwargs = {'input': xml_files,
- 'output': outputs,
- 'command': cmd,
- 'build_by_default': build_by_default,
- 'depends': cfile_custom_target
- }
+ docbook_cmd = cmd
+ depends = cfile_custom_target
 
- docbook_custom_target = build.CustomTarget(output, state.subdir, state.subproject, custom_kwargs)
+ docbook_custom_target = build.CustomTarget(
+ output,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ docbook_cmd,
+ xml_files,
+ outputs,
+ build_by_default=build_by_default,
+ extra_depends=depends,
+ )
 targets.append(docbook_custom_target)
 
 return ModuleReturnValue(targets, targets)
@@ -1636,7 +1759,8 @@
 # We always set template as the first element in the source array
 # so --template consumes it.
 h_cmd = cmd + '--template', '@INPUT@'
- h_sources = h_template + kwargs'sources'
+ h_sources: T.ListT.UnionFileOrString, 'build.GeneratedTypes' = h_template
+ h_sources.extend(kwargs'sources')
 h_target = self._make_mkenum_impl(
 state, h_sources, h_output, h_cmd, install=kwargs'install_header',
 install_dir=kwargs'install_dir')
@@ -1647,7 +1771,8 @@
 # We always set template as the first element in the source array
 # so --template consumes it.
 c_cmd = cmd + '--template', '@INPUT@'
- c_sources = c_template + kwargs'sources'
+ c_sources: T.ListT.UnionFileOrString, 'build.GeneratedTypes' = c_template
+ c_sources.extend(kwargs'sources')
 
 depends = kwargs'depends'.copy()
 if h_target is not None:
@@ -1786,21 +1911,29 @@
 *,
 install: bool = False,
 install_dir: T.OptionalT.SequenceT.Unionstr, bool = None,
- depends: T.OptionalT.ListCustomTarget = None) -> build.CustomTarget:
+ depends: T.OptionalT.SequenceT.UnionCustomTarget, CustomTargetIndex, BuildTarget = None
+ ) -> build.CustomTarget:
 real_cmd: T.ListT.Unionstr, ExternalProgram = state.find_program('glib-mkenums', 'mkenums')
 real_cmd.extend(cmd)
- custom_kwargs = {
- 'input': sources,
- 'output': output,
- 'capture': True,
- 'command': real_cmd,
- 'install': install,
- 'install_dir': install_dir or state.environment.coredata.get_option(mesonlib.OptionKey('includedir')),
- 'depends': depends or ,
- }
- return build.CustomTarget(output, state.subdir, state.subproject, custom_kwargs,
- # https://github.com/mesonbuild/meson/issues/973
- absolute_paths=True)
+ _install_dir = install_dir or state.environment.coredata.get_option(mesonlib.OptionKey('includedir'))
+ assert isinstance(_install_dir, str), 'for mypy'
+
+ return build.CustomTarget(
+ output,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ real_cmd,
+ sources,
+ output,
+ capture=True,
+ install=install,
+ install_dir=_install_dir,
+ install_tag='devel',
+ extra_depends=depends,
+ # https://github.com/mesonbuild/meson/issues/973
+ absolute_paths=True,
+ )
 
 @typed_pos_args('gnome.genmarshal', str)
 @typed_kwargs(
@@ -1808,8 +1941,8 @@
 DEPEND_FILES_KW.evolve(since='0.61.0'),
 DEPENDS_KW.evolve(since='0.61.0'),
 INSTALL_KW.evolve(name='install_header'),
+ INSTALL_DIR_KW,
 KwargInfo('extra_args', ContainerTypeInfo(list, str), listify=True, default=),
- KwargInfo('install_dir', (str, NoneType)),
 KwargInfo('internal', bool, default=False),
 KwargInfo('nostdinc', bool, default=False),
 KwargInfo('prefix', (str, NoneType)),
@@ -1840,42 +1973,57 @@
 cmd.append(f'--{k.replace("_", "-")}')
 
 install_header = kwargs'install_header'
- install_dir: T.ListT.Unionstr, bool = kwargs'install_dir' or 
-
-
- custom_kwargs: T.Dictstr, T.Any = {
- 'input': sources,
- 'depend_files': kwargs'depend_files',
- 'install_dir': kwargs'install_dir',
- }
+ capture = False
 
 # https://github.com/GNOME/glib/commit/0fbc98097fac4d3e647684f344e508abae109fdf
 if mesonlib.version_compare(self._get_native_glib_version(state), '>= 2.51.0'):
 cmd += '--output', '@OUTPUT@'
 else:
- custom_kwargs'capture' = True
+ capture = True
 
 header_file = output + '.h'
- custom_kwargs'command' = cmd + '--body', '@INPUT@'
+ h_cmd = cmd + '--header', '@INPUT@'
+ if new_genmarshal:
+ h_cmd += '--pragma-once'
+ header = build.CustomTarget(
+ output + '_h',
+ state.subdir,
+ state.subproject,
+ state.environment,
+ h_cmd,
+ sources,
+ header_file,
+ install=install_header,
+ install_dir=kwargs'install_dir' if kwargs'install_dir' else ,
+ install_tag='devel',
+ capture=capture,
+ depend_files=kwargs'depend_files',
+ )
+
+ c_cmd = cmd + '--body', '@INPUT@'
+ extra_deps: T.Listbuild.CustomTarget = 
 if mesonlib.version_compare(self._get_native_glib_version(state), '>= 2.53.4'):
 # Silence any warnings about missing prototypes
- custom_kwargs'command' += '--include-header', header_file
- custom_kwargs'output' = output + '.c'
- body = build.CustomTarget(output + '_c', state.subdir, state.subproject, custom_kwargs)
-
- custom_kwargs'install' = install_header
- custom_kwargs'install_dir' = install_dir
- if new_genmarshal:
- cmd += '--pragma-once'
- custom_kwargs'command' = cmd + '--header', '@INPUT@'
- custom_kwargs'output' = header_file
- header = build.CustomTarget(output + '_h', state.subdir, state.subproject, custom_kwargs)
+ c_cmd += '--include-header', header_file
+ extra_deps.append(header)
+ body = build.CustomTarget(
+ output + '_c',
+ state.subdir,
+ state.subproject,
+ state.environment,
+ c_cmd,
+ sources,
+ f'{output}.c',
+ capture=capture,
+ depend_files=kwargs'depend_files',
+ extra_depends=extra_deps,
+ )
 
 rv = body, header
 return ModuleReturnValue(rv, rv)
 
 def _extract_vapi_packages(self, state: 'ModuleState', packages: T.ListT.UnionInternalDependency, str,
- ) -> T.TupleT.Liststr, T.Listbuild.Target, T.Liststr, T.Liststr, T.Liststr:
+ ) -> T.TupleT.Liststr, T.ListVapiTarget, T.Liststr, T.Liststr, T.Liststr:
 '''
 Packages are special because we need to:
 - Get a list of packages for the .deps file
@@ -1885,7 +2033,7 @@
 '''
 if not packages:
 return , , , , 
- vapi_depends: T.Listbuild.Target = 
+ vapi_depends: T.ListVapiTarget = 
 vapi_packages: T.Liststr = 
 vapi_includes: T.Liststr = 
 vapi_args: T.Liststr = 
@@ -1922,8 +2070,8 @@
 ofile.write(package + '\n')
 return build.Data(mesonlib.File(True, outdir, fname), install_dir, install_dir, mesonlib.FileMode(), state.subproject)
 
- def _get_vapi_link_with(self, target: build.CustomTarget) -> T.ListT.Unionbuild.BuildTarget, build.CustomTarget:
- link_with: T.ListT.Unionbuild.BuildTarget, build.CustomTarget = 
+ def _get_vapi_link_with(self, target: build.CustomTarget) -> T.Listbuild.LibTypes:
+ link_with: T.Listbuild.LibTypes = 
 for dep in target.get_target_dependencies():
 if isinstance(dep, build.SharedLibrary):
 link_with.append(dep)
@@ -1935,20 +2083,20 @@
 @typed_kwargs(
 'gnome.generate_vapi',
 INSTALL_KW,
+ INSTALL_DIR_KW,
 KwargInfo(
 'sources',
 ContainerTypeInfo(list, (str, GirTarget), allow_empty=False),
 listify=True,
 required=True,
 ),
- KwargInfo('install_dir', (str, NoneType)),
 KwargInfo('vapi_dirs', ContainerTypeInfo(list, str), listify=True, default=),
 KwargInfo('metadata_dirs', ContainerTypeInfo(list, str), listify=True, default=),
 KwargInfo('gir_dirs', ContainerTypeInfo(list, str), listify=True, default=),
 KwargInfo('packages', ContainerTypeInfo(list, (str, InternalDependency)), listify=True, default=),
 )
 def generate_vapi(self, state: 'ModuleState', args: T.Tuplestr, kwargs: 'GenerateVapi') -> ModuleReturnValue:
- created_values: T.ListDependency = 
+ created_values: T.ListT.UnionDependency, build.Data = 
 library = args0
 build_dir = os.path.join(state.environment.get_build_dir(), state.subdir)
 source_dir = os.path.join(state.environment.get_source_dir(), state.subdir)
@@ -1963,7 +2111,7 @@
 
 inputs = kwargs'sources'
 
- link_with = 
+ link_with: T.Listbuild.LibTypes = 
 for i in inputs:
 if isinstance(i, str):
 cmd.append(os.path.join(source_dir, i))
@@ -1975,24 +2123,27 @@
 cmd.append(gir_file)
 
 vapi_output = library + '.vapi'
- custom_kwargs = {
- 'command': cmd,
- 'input': inputs,
- 'output': vapi_output,
- 'depends': vapi_depends,
- }
 datadir = state.environment.coredata.get_option(mesonlib.OptionKey('datadir'))
 assert isinstance(datadir, str), 'for mypy'
 install_dir = kwargs'install_dir' or os.path.join(datadir, 'vala', 'vapi')
- custom_kwargs'install' = kwargs'install'
- custom_kwargs'install_dir' = install_dir
- custom_kwargs'packages' = packages
 
 if kwargs'install':
 # We shouldn't need this locally but we install it
 deps_target = self._generate_deps(state, library, vapi_packages, install_dir)
 created_values.append(deps_target)
- vapi_target = VapiTarget(vapi_output, state.subdir, state.subproject, custom_kwargs)
+ vapi_target = VapiTarget(
+ vapi_output,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ command=cmd,
+ sources=inputs,
+ outputs=vapi_output,
+ extra_depends=vapi_depends,
+ install=kwargs'install',
+ install_dir=install_dir,
+ install_tag='devel',
+ )
 
 # So to try our best to get this to just work we need:
 # - link with with the correct library
@@ -2000,7 +2151,7 @@
 # - add relevant directories to include dirs
 incs = build.IncludeDirs(state.subdir, '.' + vapi_includes, False)
 sources = vapi_target + vapi_depends
- rv = InternalDependency(None, incs, , , link_with, , sources, , {})
+ rv = InternalDependency(None, incs, , , link_with, , sources, , {}, , )
 created_values.append(rv)
 return ModuleReturnValue(rv, created_values)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/hotdoc.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/hotdoc.py Changed

@@ -11,20 +11,25 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 '''This module provides helper functions for generating documentation using hotdoc'''
 
 import os
-from collections import OrderedDict
+import subprocess
 
 from mesonbuild import mesonlib
 from mesonbuild import mlog, build
 from mesonbuild.coredata import MesonException
-from . import ModuleReturnValue
+from . import ModuleReturnValue, ModuleInfo
 from . import ExtensionModule
 from ..dependencies import Dependency, InternalDependency
-from ..interpreterbase import FeatureNew, InvalidArguments, noPosargs, noKwargs
+from ..interpreterbase import (
+    InvalidArguments, noPosargs, noKwargs, typed_kwargs, FeatureDeprecated,
+    ContainerTypeInfo, KwargInfo, typed_pos_args
+)
 from ..interpreter import CustomTargetHolder
+from ..interpreter.type_checking import NoneType
 from ..programs import ExternalProgram
 
 
@@ -36,8 +41,11 @@
 
 MIN_HOTDOC_VERSION = '0.8.100'
 
+file_types = (str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex)
+
 
 class HotdocTargetBuilder:
+
     def __init__(self, name, state, hotdoc, interpreter, kwargs):
         self.hotdoc = hotdoc
         self.build_by_default = kwargs.pop('build_by_default', False)
@@ -45,7 +53,7 @@
         self.name = name
         self.state = state
         self.interpreter = interpreter
-        self.include_paths = OrderedDict()
+        self.include_paths = mesonlib.OrderedSet()
 
         self.builddir = state.environment.get_build_dir()
         self.sourcedir = state.environment.get_source_dir()
@@ -57,17 +65,16 @@
 
         self._extra_extension_paths = set()
         self.extra_assets = set()
-        self._dependencies = 
+        self.extra_depends = 
         self._subprojects = 
 
-    def process_known_arg(self, option, types, argname=None,
-                          value_processor=None, mandatory=False,
-                          force_list=False):
+    def process_known_arg(self, option, argname=None, value_processor=None):
         if not argname:
             argname = option.strip("-").replace("-", "_")
 
-        value, _ = self.get_value(
-            types, argname, None, value_processor, mandatory, force_list)
+        value = self.kwargs.pop(argname)
+        if value is not None and value_processor:
+            value = value_processor(value)
 
         self.set_arg_value(option, value)
 
@@ -146,15 +153,6 @@
 
         return None, None
 
-    def setup_extension_paths(self, paths):
-        if not isinstance(paths, list):
-            paths = paths
-
-        for path in paths:
-            self.add_extension_paths(path)
-
-        return 
-
     def add_extension_paths(self, paths):
         for path in paths:
             if path in self._extra_extension_paths:
@@ -163,10 +161,6 @@
             self._extra_extension_paths.add(path)
             self.cmd.extend("--extra-extension-path", path)
 
-    def process_extra_extension_paths(self):
-        self.get_value(list, str, 'extra_extensions_paths',
-                       default="", value_processor=self.setup_extension_paths)
-
     def replace_dirs_in_string(self, string):
         return string.replace("@SOURCE_ROOT@", self.sourcedir).replace("@BUILD_ROOT@", self.builddir)
 
@@ -174,11 +168,10 @@
         if self.hotdoc.run_hotdoc('--has-extension=gi-extension') != 0:
             return
 
-        value, _ = self.get_value(list, str, 'gi_c_source_roots', default=, force_list=True)
+        value = self.kwargs.pop('gi_c_source_roots')
         value.extend(
-            os.path.join(self.state.environment.get_source_dir(),
-                         self.interpreter.subproject_dir, self.state.subproject),
-            os.path.join(self.state.environment.get_build_dir(), self.interpreter.subproject_dir, self.state.subproject)
+            os.path.join(self.sourcedir, self.state.root_subdir),
+            os.path.join(self.builddir, self.state.root_subdir)
         )
 
         self.cmd += '--gi-c-source-roots' + value
@@ -196,7 +189,7 @@
             elif isinstance(dep, Dependency):
                 cflags.update(dep.get_compile_args())
             elif isinstance(dep, (build.StaticLibrary, build.SharedLibrary)):
-                self._dependencies.append(dep)
+                self.extra_depends.append(dep)
                 for incd in dep.get_include_dirs():
                     cflags.update(incd.get_incdirs())
             elif isinstance(dep, HotdocTarget):
@@ -204,29 +197,27 @@
                 self.process_dependencies(dep.get_target_dependencies())
                 self._subprojects.extend(dep.subprojects)
                 self.process_dependencies(dep.subprojects)
-                self.add_include_path(os.path.join(self.builddir, dep.hotdoc_conf.subdir))
+                self.include_paths.add(os.path.join(self.builddir, dep.hotdoc_conf.subdir))
                 self.cmd += '--extra-assets=' + p for p in dep.extra_assets
                 self.add_extension_paths(dep.extra_extension_paths)
-            elif isinstance(dep, build.CustomTarget) or isinstance(dep, build.BuildTarget):
-                self._dependencies.append(dep)
+            elif isinstance(dep, (build.CustomTarget, build.BuildTarget)):
+                self.extra_depends.append(dep)
             elif isinstance(dep, build.CustomTargetIndex):
-                self._dependencies.append(dep.target)
+                self.extra_depends.append(dep.target)
 
         return f.strip('-I') for f in cflags
 
     def process_extra_assets(self):
-        self._extra_assets, _ = self.get_value("--extra-assets", (str, list), default=,
-                                               force_list=True)
+        self._extra_assets = self.kwargs.pop('extra_assets')
+
         for assets_path in self._extra_assets:
             self.cmd.extend("--extra-assets", assets_path)
 
     def process_subprojects(self):
-        _, value = self.get_value(
-            list, HotdocTarget, argname="subprojects",
-            force_list=True, value_processor=self.process_dependencies)
+        value = self.kwargs.pop('subprojects')
 
-        if value is not None:
-            self._subprojects.extend(value)
+        self.process_dependencies(value)
+        self._subprojects.extend(value)
 
     def flatten_config_command(self):
         cmd = 
@@ -241,10 +232,10 @@
 
                 continue
             elif isinstance(arg, (build.BuildTarget, build.CustomTarget)):
-                self._dependencies.append(arg)
+                self.extra_depends.append(arg)
                 arg = self.interpreter.backend.get_target_filename_abs(arg)
             elif isinstance(arg, build.CustomTargetIndex):
-                self._dependencies.append(arg.target)
+                self.extra_depends.append(arg.target)
                 arg = self.interpreter.backend.get_target_filename_abs(arg)
 
             cmd.append(arg)
@@ -287,27 +278,21 @@
             if arg in self.kwargs:
                 raise InvalidArguments(f'Argument "{arg}" is forbidden.')
 
-    def add_include_path(self, path):
-        self.include_pathspath = path
-
     def make_targets(self):
         self.check_forbidden_args()
-        file_types = (str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex)
-        self.process_known_arg("--index", file_types, mandatory=True, value_processor=self.ensure_file)
-        self.process_known_arg("--project-version", str, mandatory=True)
-        self.process_known_arg("--sitemap", file_types, mandatory=True, value_processor=self.ensure_file)
-        self.process_known_arg("--html-extra-theme", str, value_processor=self.ensure_dir)
-        self.process_known_arg(None, list, "include_paths", force_list=True,
-                               value_processor=lambda x: self.add_include_path(self.ensure_dir(v)) for v in ensure_list(x))
-        self.process_known_arg('--c-include-directories',
-                               Dependency, build.StaticLibrary, build.SharedLibrary, list, argname="dependencies",
-                               force_list=True, value_processor=self.process_dependencies)
+        self.process_known_arg("--index", value_processor=self.ensure_file)
+        self.process_known_arg("--project-version")
+        self.process_known_arg("--sitemap", value_processor=self.ensure_file)
+        self.process_known_arg("--html-extra-theme", value_processor=self.ensure_dir)
+        self.include_paths.update(self.ensure_dir(v) for v in self.kwargs.pop('include_paths'))
+        self.process_known_arg('--c-include-directories', argname="dependencies", value_processor=self.process_dependencies)
         self.process_gi_c_source_roots()
         self.process_extra_assets()
-        self.process_extra_extension_paths()
+        self.add_extension_paths(self.kwargs.pop('extra_extension_paths'))
         self.process_subprojects()
+        self.extra_depends.extend(self.kwargs.pop('depends'))
 
-        install, install = self.get_value(bool, "install", mandatory=False)
+        install = self.kwargs.pop('install')
         self.process_extra_args()
 
         fullname = self.name + '-doc'
@@ -318,17 +303,17 @@
             f.write('{}')
 
         self.cmd += '--conf-file', hotdoc_config_path
-        self.add_include_path(os.path.join(self.builddir, self.subdir))
-        self.add_include_path(os.path.join(self.sourcedir, self.subdir))
+        self.include_paths.add(os.path.join(self.builddir, self.subdir))
+        self.include_paths.add(os.path.join(self.sourcedir, self.subdir))
 
         depfile = os.path.join(self.builddir, self.subdir, self.name + '.deps')
         self.cmd += '--deps-file-dest', depfile
 
-        for path in self.include_paths.keys():
+        for path in self.include_paths:
             self.cmd.extend('--include-path', path)
 
         if self.state.environment.coredata.get_option(mesonlib.OptionKey('werror', subproject=self.state.subproject)):
-            self.cmd.append('--fatal-warning')
+            self.cmd.append('--fatal-warnings')
         self.generate_hotdoc_config()
 
         target_cmd = self.build_command + "--internal", "hotdoc" + \
@@ -338,19 +323,21 @@
         target = HotdocTarget(fullname,
                               subdir=self.subdir,
                               subproject=self.state.subproject,
+                              environment=self.state.environment,
                               hotdoc_conf=mesonlib.File.from_built_file(
                                   self.subdir, hotdoc_config_name),
                               extra_extension_paths=self._extra_extension_paths,
                               extra_assets=self._extra_assets,
                               subprojects=self._subprojects,
                               command=target_cmd,
-                              depends=self._dependencies,
-                              output=fullname,
+                              extra_depends=self.extra_depends,
+                              outputs=fullname,
+                              sources=,
                               depfile=os.path.basename(depfile),
                               build_by_default=self.build_by_default)
 
         install_script = None
-        if install is True:
+        if install:
             install_script = self.state.backend.get_executable_serialisation(self.build_command + 
                 "--internal", "hotdoc",
                 "--install", os.path.join(fullname, 'html'),
@@ -378,8 +365,8 @@
 
 class HotdocTarget(build.CustomTarget):
     def __init__(self, name, subdir, subproject, hotdoc_conf, extra_extension_paths, extra_assets,
-                 subprojects, **kwargs):
-        super().__init__(name, subdir, subproject, kwargs, absolute_paths=True)
+                 subprojects, environment, **kwargs):
+        super().__init__(name, subdir, subproject, environment, **kwargs, absolute_paths=True)
         self.hotdoc_conf = hotdoc_conf
         self.extra_extension_paths = extra_extension_paths
         self.extra_assets = extra_assets
@@ -394,33 +381,67 @@
 
 
 class HotDocModule(ExtensionModule):
-    @FeatureNew('Hotdoc Module', '0.48.0')
+
+    INFO = ModuleInfo('hotdoc', '0.48.0')
+
     def __init__(self, interpreter):
         super().__init__(interpreter)
         self.hotdoc = ExternalProgram('hotdoc')
         if not self.hotdoc.found():
             raise MesonException('hotdoc executable not found')
+        version = self.hotdoc.get_version(interpreter)
+        if not mesonlib.version_compare(version, f'>={MIN_HOTDOC_VERSION}'):
+            raise MesonException(f'hotdoc {MIN_HOTDOC_VERSION} required but not found.)')
 
-        try:
-            from hotdoc.run_hotdoc import run  # noqa: F401
-            self.hotdoc.run_hotdoc = run
-        except Exception as e:
-            raise MesonException(f'hotdoc {MIN_HOTDOC_VERSION} required but not found. ({e})')
+        def run_hotdoc(cmd):
+            return subprocess.run(self.hotdoc.get_command() + cmd, stdout=subprocess.DEVNULL).returncode
+
+        self.hotdoc.run_hotdoc = run_hotdoc
         self.methods.update({
             'has_extensions': self.has_extensions,
             'generate_doc': self.generate_doc,
         })
 
     @noKwargs
+    @typed_pos_args('hotdoc.has_extensions', varargs=str, min_varargs=1)
     def has_extensions(self, state, args, kwargs):
-        return self.hotdoc.run_hotdoc(f'--has-extension={extension}' for extension in args) == 0
-
+        return self.hotdoc.run_hotdoc(f'--has-extension={extension}' for extension in args0) == 0
+
+    @typed_pos_args('hotdoc.generate_doc', str)
+    @typed_kwargs(
+        'hotdoc.generate_doc',
+        KwargInfo('sitemap', file_types, required=True),
+        KwargInfo('index', file_types, required=True),
+        KwargInfo('project_version', str, required=True),
+        KwargInfo('html_extra_theme', (str, NoneType)),
+        KwargInfo('include_paths', ContainerTypeInfo(list, str), listify=True, default=),
+        # --c-include-directories
+        KwargInfo(
+            'dependencies',
+            ContainerTypeInfo(list, (Dependency, build.StaticLibrary, build.SharedLibrary,
+                                     build.CustomTarget, build.CustomTargetIndex)),
+            listify=True,
+            default=,
+        ),
+        KwargInfo(
+            'depends',
+            ContainerTypeInfo(list, (build.CustomTarget, build.CustomTargetIndex)),
+            listify=True,
+            default=,
+            since='0.64.1',
+        ),
+        KwargInfo('gi_c_source_roots', ContainerTypeInfo(list, str), listify=True, default=),
+        KwargInfo('extra_assets', ContainerTypeInfo(list, str), listify=True, default=),
+        KwargInfo('extra_extension_paths', ContainerTypeInfo(list, str), listify=True, default=),
+        KwargInfo('subprojects', ContainerTypeInfo(list, HotdocTarget), listify=True, default=),
+        KwargInfo('install', bool, default=False),
+        allow_unknown=True
+    )
     def generate_doc(self, state, args, kwargs):
-        if len(args) != 1:
-            raise MesonException('One positional argument is'
-                                 ' required for the project name.')
-
         project_name = args0
+        if any(isinstance(x, (build.CustomTarget, build.CustomTargetIndex)) for x in kwargs'dependencies'):
+            FeatureDeprecated.single_use('hotdoc.generate_doc dependencies argument with custom_target',
+                                         '0.64.1', state.subproject, 'use `depends`', state.current_node)
         builder = HotdocTargetBuilder(project_name, state, self.hotdoc, self.interpreter, kwargs)
         target, install_script = builder.make_targets()
         targets = target

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/i18n.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/i18n.py Changed

@@ -11,16 +11,16 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from os import path
-import shutil
 import typing as T
 
-from . import ExtensionModule, ModuleReturnValue
+from . import ExtensionModule, ModuleReturnValue, ModuleInfo
 from .. import build
 from .. import mesonlib
 from .. import mlog
-from ..interpreter.type_checking import CT_BUILD_BY_DEFAULT, CT_INPUT_KW, CT_INSTALL_DIR_KW, CT_INSTALL_TAG_KW, CT_OUTPUT_KW, INSTALL_KW, NoneType, in_set_validator
+from ..interpreter.type_checking import CT_BUILD_BY_DEFAULT, CT_INPUT_KW, INSTALL_TAG_KW, OUTPUT_KW, INSTALL_DIR_KW, INSTALL_KW, NoneType, in_set_validator
 from ..interpreterbase import FeatureNew
 from ..interpreterbase.decorators import ContainerTypeInfo, KwargInfo, noPosargs, typed_kwargs, typed_pos_args
 from ..scripts.gettext import read_linguas
@@ -40,11 +40,11 @@
             str, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex,
             build.ExtractedObjects, build.GeneratedList, ExternalProgram,
             mesonlib.File
-        output: T.Liststr
+        output: str
         build_by_default: bool
         install: bool
-        install_dir: T.ListT.Unionstr, bool
-        install_tag: T.Liststr
+        install_dir: T.Optionalstr
+        install_tag: T.Optionalstr
         args: T.Liststr
         data_dirs: T.Liststr
         po_dir: str
@@ -59,6 +59,20 @@
         languages: T.Liststr
         preset: T.Optionalstr
 
+    class ItsJoinFile(TypedDict):
+
+        input: T.ListT.Union
+            str, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex,
+            build.ExtractedObjects, build.GeneratedList, ExternalProgram,
+            mesonlib.File
+        output: str
+        build_by_default: bool
+        install: bool
+        install_dir: T.Optionalstr
+        install_tag: T.Optionalstr
+        its_files: T.Liststr
+        mo_targets: T.ListT.Unionbuild.BuildTarget, build.CustomTarget, build.CustomTargetIndex
+
 
 _ARGS: KwargInfoT.Liststr = KwargInfo(
     'args',
@@ -110,16 +124,23 @@
 
 
 class I18nModule(ExtensionModule):
+
+    INFO = ModuleInfo('i18n')
+
     def __init__(self, interpreter: 'Interpreter'):
         super().__init__(interpreter)
         self.methods.update({
             'merge_file': self.merge_file,
             'gettext': self.gettext,
+            'itstool_join': self.itstool_join,
         })
-
-    @staticmethod
-    def nogettext_warning() -> None:
-        mlog.warning('Gettext not found, all translation targets will be ignored.', once=True)
+        self.tools: T.Dictstr, T.OptionalExternalProgram = {
+            'itstool': None,
+            'msgfmt': None,
+            'msginit': None,
+            'msgmerge': None,
+            'xgettext': None,
+        }
 
     @staticmethod
     def _get_data_dirs(state: 'ModuleState', dirs: T.Iterablestr) -> T.Liststr:
@@ -133,9 +154,9 @@
         'i18n.merge_file',
         CT_BUILD_BY_DEFAULT,
         CT_INPUT_KW,
-        CT_INSTALL_DIR_KW,
-        CT_INSTALL_TAG_KW,
-        CT_OUTPUT_KW,
+        KwargInfo('install_dir', (str, NoneType)),
+        INSTALL_TAG_KW,
+        OUTPUT_KW,
         INSTALL_KW,
         _ARGS.evolve(since='0.51.0'),
         _DATA_DIRS.evolve(since='0.41.0'),
@@ -143,9 +164,8 @@
         KwargInfo('type', str, default='xml', validator=in_set_validator({'xml', 'desktop'})),
     )
     def merge_file(self, state: 'ModuleState', args: T.List'TYPE_var', kwargs: 'MergeFile') -> ModuleReturnValue:
-        if not shutil.which('xgettext'):
-            self.nogettext_warning()
-            return ModuleReturnValue(None, )
+        if self.tools'msgfmt' is None or not self.tools'msgfmt'.found():
+            self.tools'msgfmt' = state.find_program('msgfmt', for_machine=mesonlib.MachineChoice.BUILD)
         podir = path.join(state.build_to_src, state.subdir, kwargs'po_dir')
 
         ddirs = self._get_data_dirs(state, kwargs'data_dirs')
@@ -156,11 +176,11 @@
         command.extend(state.environment.get_build_command())
         command.extend(
             '--internal', 'msgfmthelper',
-            '@INPUT@', '@OUTPUT@', kwargs'type', podir
+            '--msgfmt=' + self.tools'msgfmt'.get_path(),
         )
         if datadirs:
             command.append(datadirs)
-
+        command.extend('@INPUT@', '@OUTPUT@', kwargs'type', podir)
         if kwargs'args':
             command.append('--')
             command.extend(kwargs'args')
@@ -169,28 +189,31 @@
         if build_by_default is None:
             build_by_default = kwargs'install'
 
-        real_kwargs = {
-            'build_by_default': build_by_default,
-            'command': command,
-            'install': kwargs'install',
-            'install_dir': kwargs'install_dir',
-            'output': kwargs'output',
-            'input': kwargs'input',
-            'install_tag': kwargs'install_tag',
-        }
-
-        ct = build.CustomTarget('', state.subdir, state.subproject,
-                T.cast(T.Dictstr, T.Any, real_kwargs))
+        install_tag = kwargs'install_tag' if kwargs'install_tag' is not None else None
+
+        ct = build.CustomTarget(
+            '',
+            state.subdir,
+            state.subproject,
+            state.environment,
+            command,
+            kwargs'input',
+            kwargs'output',
+            build_by_default=build_by_default,
+            install=kwargs'install',
+            install_dir=kwargs'install_dir' if kwargs'install_dir' is not None else None,
+            install_tag=install_tag,
+        )
 
         return ModuleReturnValue(ct, ct)
 
-    @typed_pos_args('i81n.gettex', str)
+    @typed_pos_args('i81n.gettext', str)
     @typed_kwargs(
         'i18n.gettext',
         _ARGS,
         _DATA_DIRS.evolve(since='0.36.0'),
         INSTALL_KW.evolve(default=True),
-        KwargInfo('install_dir', (str, NoneType), since='0.50.0'),
+        INSTALL_DIR_KW.evolve(since='0.50.0'),
         KwargInfo('languages', ContainerTypeInfo(list, str), default=, listify=True),
         KwargInfo(
             'preset',
@@ -200,9 +223,18 @@
         ),
     )
     def gettext(self, state: 'ModuleState', args: T.Tuplestr, kwargs: 'Gettext') -> ModuleReturnValue:
-        if not shutil.which('xgettext'):
-            self.nogettext_warning()
-            return ModuleReturnValue(None, )
+        for tool, strict in ('msgfmt', True), ('msginit', False), ('msgmerge', False), ('xgettext', False):
+            if self.toolstool is None:
+                self.toolstool = state.find_program(tool, required=False, for_machine=mesonlib.MachineChoice.BUILD)
+            # still not found?
+            if not self.toolstool.found():
+                if strict:
+                    mlog.warning('Gettext not found, all translation (po) targets will be ignored.',
+                                 once=True, location=state.current_node)
+                    return ModuleReturnValue(None, )
+                else:
+                    mlog.warning(f'{tool!r} not found, maintainer targets will not work',
+                                 once=True, fatal=False, location=state.current_node)
         packagename = args0
         pkg_arg = f'--pkgname={packagename}'
 
@@ -223,12 +255,21 @@
 
         extra_arg = '--extra-args=' + '@@'.join(extra_args) if extra_args else None
 
+        source_root = path.join(state.source_root, state.root_subdir)
+        subdir = path.relpath(state.subdir, start=state.root_subdir) if state.subdir else None
+
         potargs = state.environment.get_build_command() + '--internal', 'gettext', 'pot', pkg_arg
+        potargs.append(f'--source-root={source_root}')
+        if subdir:
+            potargs.append(f'--subdir={subdir}')
         if datadirs:
             potargs.append(datadirs)
         if extra_arg:
             potargs.append(extra_arg)
-        pottarget = build.RunTarget(packagename + '-pot', potargs, , state.subdir, state.subproject)
+        if self.tools'xgettext'.found():
+            potargs.append('--xgettext=' + self.tools'xgettext'.get_path())
+        pottarget = build.RunTarget(packagename + '-pot', potargs, , state.subdir, state.subproject,
+                                    state.environment, default_env=False)
         targets.append(pottarget)
 
         install = kwargs'install'
@@ -239,35 +280,111 @@
         for l in languages:
             po_file = mesonlib.File.from_source_file(state.environment.source_dir,
                                                      state.subdir, l+'.po')
-            gmo_kwargs = {'command': 'msgfmt', '@INPUT@', '-o', '@OUTPUT@',
-                          'input': po_file,
-                          'output': packagename+'.mo',
-                          'install': install,
-                          # We have multiple files all installed as packagename+'.mo' in different install subdirs.
-                          # What we really wanted to do, probably, is have a rename: kwarg, but that's not available
-                          # to custom_targets. Crude hack: set the build target's subdir manually.
-                          # Bonus: the build tree has something usable as an uninstalled bindtextdomain() target dir.
-                          'install_dir': path.join(install_dir, l, 'LC_MESSAGES'),
-                          'install_tag': 'i18n',
-                          }
-            gmotarget = build.CustomTarget(f'{packagename}-{l}.mo', path.join(state.subdir, l, 'LC_MESSAGES'), state.subproject, gmo_kwargs)
+            gmotarget = build.CustomTarget(
+                f'{packagename}-{l}.mo',
+                path.join(state.subdir, l, 'LC_MESSAGES'),
+                state.subproject,
+                state.environment,
+                self.tools'msgfmt', '@INPUT@', '-o', '@OUTPUT@',
+                po_file,
+                f'{packagename}.mo',
+                install=install,
+                # We have multiple files all installed as packagename+'.mo' in different install subdirs.
+                # What we really wanted to do, probably, is have a rename: kwarg, but that's not available
+                # to custom_targets. Crude hack: set the build target's subdir manually.
+                # Bonus: the build tree has something usable as an uninstalled bindtextdomain() target dir.
+                install_dir=path.join(install_dir, l, 'LC_MESSAGES'),
+                install_tag='i18n',
+            )
             targets.append(gmotarget)
             gmotargets.append(gmotarget)
 
-        allgmotarget = build.AliasTarget(packagename + '-gmo', gmotargets, state.subdir, state.subproject)
+        allgmotarget = build.AliasTarget(packagename + '-gmo', gmotargets, state.subdir, state.subproject,
+                                         state.environment)
         targets.append(allgmotarget)
 
         updatepoargs = state.environment.get_build_command() + '--internal', 'gettext', 'update_po', pkg_arg
+        updatepoargs.append(f'--source-root={source_root}')
+        if subdir:
+            updatepoargs.append(f'--subdir={subdir}')
         if lang_arg:
             updatepoargs.append(lang_arg)
         if datadirs:
             updatepoargs.append(datadirs)
         if extra_arg:
             updatepoargs.append(extra_arg)
-        updatepotarget = build.RunTarget(packagename + '-update-po', updatepoargs, , state.subdir, state.subproject)
+        for tool in 'msginit', 'msgmerge':
+            if self.toolstool.found():
+                updatepoargs.append(f'--{tool}=' + self.toolstool.get_path())
+        updatepotarget = build.RunTarget(packagename + '-update-po', updatepoargs, , state.subdir, state.subproject,
+                                         state.environment, default_env=False)
         targets.append(updatepotarget)
 
         return ModuleReturnValue(gmotargets, pottarget, updatepotarget, targets)
 
+    @FeatureNew('i18n.itstool_join', '0.62.0')
+    @noPosargs
+    @typed_kwargs(
+        'i18n.itstool_join',
+        CT_BUILD_BY_DEFAULT,
+        CT_INPUT_KW,
+        KwargInfo('install_dir', (str, NoneType)),
+        INSTALL_TAG_KW,
+        OUTPUT_KW,
+        INSTALL_KW,
+        _ARGS.evolve(),
+        KwargInfo('its_files', ContainerTypeInfo(list, str)),
+        KwargInfo('mo_targets', ContainerTypeInfo(list, build.CustomTarget), required=True),
+    )
+    def itstool_join(self, state: 'ModuleState', args: T.List'TYPE_var', kwargs: 'ItsJoinFile') -> ModuleReturnValue:
+        if self.tools'itstool' is None:
+            self.tools'itstool' = state.find_program('itstool', for_machine=mesonlib.MachineChoice.BUILD)
+        mo_targets = kwargs'mo_targets'
+        its_files = kwargs.get('its_files', )
+
+        mo_fnames = 
+        for target in mo_targets:
+            mo_fnames.append(path.join(target.get_subdir(), target.get_outputs()0))
+
+        command: T.ListT.Unionstr, build.BuildTarget, build.CustomTarget,
+                                build.CustomTargetIndex, 'ExternalProgram', mesonlib.File = 
+        command.extend(state.environment.get_build_command())
+        command.extend(
+            '--internal', 'itstool', 'join',
+            '-i', '@INPUT@',
+            '-o', '@OUTPUT@',
+            '--itstool=' + self.tools'itstool'.get_path(),
+        )
+        if its_files:
+            for fname in its_files:
+                if not path.isabs(fname):
+                    fname = path.join(state.environment.source_dir, state.subdir, fname)
+                command.extend('--its', fname)
+        command.extend(mo_fnames)
+
+        build_by_default = kwargs'build_by_default'
+        if build_by_default is None:
+            build_by_default = kwargs'install'
+
+        install_tag = kwargs'install_tag' if kwargs'install_tag' is not None else None
+
+        ct = build.CustomTarget(
+            '',
+            state.subdir,
+            state.subproject,
+            state.environment,
+            command,
+            kwargs'input',
+            kwargs'output',
+            build_by_default=build_by_default,
+            extra_depends=mo_targets,
+            install=kwargs'install',
+            install_dir=kwargs'install_dir' if kwargs'install_dir' is not None else None,
+            install_tag=install_tag,
+        )
+
+        return ModuleReturnValue(ct, ct)
+
+
 def initialize(interp: 'Interpreter') -> I18nModule:
     return I18nModule(interp)

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/icestorm.py Added

@@ -0,0 +1,131 @@
+# Copyright 2017 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+import itertools
+import typing as T
+
+from . import ExtensionModule, ModuleReturnValue, ModuleInfo
+from .. import build
+from .. import mesonlib
+from ..interpreter.type_checking import CT_INPUT_KW
+from ..interpreterbase.decorators import KwargInfo, typed_kwargs, typed_pos_args
+
+if T.TYPE_CHECKING:
+    from typing_extensions import TypedDict
+
+    from . import ModuleState
+    from ..interpreter import Interpreter
+    from ..programs import ExternalProgram
+
+    class ProjectKwargs(TypedDict):
+
+        sources: T.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes
+        constraint_file: T.Unionmesonlib.FileOrString, build.GeneratedTypes
+
+class IceStormModule(ExtensionModule):
+
+    INFO = ModuleInfo('FPGA/Icestorm', '0.45.0', unstable=True)
+
+    def __init__(self, interpreter: Interpreter) -> None:
+        super().__init__(interpreter)
+        self.tools: T.Dictstr, ExternalProgram = {}
+        self.methods.update({
+            'project': self.project,
+        })
+
+    def detect_tools(self, state: ModuleState) -> None:
+        self.tools'yosys' = state.find_program('yosys')
+        self.tools'arachne' = state.find_program('arachne-pnr')
+        self.tools'icepack' = state.find_program('icepack')
+        self.tools'iceprog' = state.find_program('iceprog')
+        self.tools'icetime' = state.find_program('icetime')
+
+    @typed_pos_args('icestorm.project', str,
+                    varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex,
+                             build.GeneratedList))
+    @typed_kwargs(
+        'icestorm.project',
+        CT_INPUT_KW.evolve(name='sources'),
+        KwargInfo(
+            'constraint_file',
+            (str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList),
+            required=True,
+        )
+    )
+    def project(self, state: ModuleState,
+                args: T.Tuplestr, T.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes,
+                kwargs: ProjectKwargs) -> ModuleReturnValue:
+        if not self.tools:
+            self.detect_tools(state)
+        proj_name, arg_sources = args
+        all_sources = self.interpreter.source_strings_to_files(
+            list(itertools.chain(arg_sources, kwargs'sources')))
+
+        blif_target = build.CustomTarget(
+            f'{proj_name}_blif',
+            state.subdir,
+            state.subproject,
+            state.environment,
+            self.tools'yosys', '-q', '-p', 'synth_ice40 -blif @OUTPUT@', '@INPUT@',
+            all_sources,
+            f'{proj_name}.blif',
+        )
+
+        asc_target = build.CustomTarget(
+            f'{proj_name}_asc',
+            state.subdir,
+            state.subproject,
+            state.environment,
+            self.tools'arachne', '-q', '-d', '1k', '-p', '@INPUT@', '-o', '@OUTPUT@',
+            kwargs'constraint_file', blif_target,
+            f'{proj_name}.asc',
+        )
+
+        bin_target = build.CustomTarget(
+            f'{proj_name}_bin',
+            state.subdir,
+            state.subproject,
+            state.environment,
+            self.tools'icepack', '@INPUT@', '@OUTPUT@',
+            asc_target,
+            f'{proj_name}.bin',
+            build_by_default=True,
+        )
+
+        upload_target = build.RunTarget(
+            f'{proj_name}-upload',
+            self.tools'iceprog', bin_target,
+            ,
+            state.subdir,
+            state.subproject,
+            state.environment,
+        )
+
+        time_target = build.RunTarget(
+            f'{proj_name}-time',
+            self.tools'icetime', bin_target,
+            ,
+            state.subdir,
+            state.subproject,
+            state.environment,
+        )
+
+        return ModuleReturnValue(
+            None,
+            blif_target, asc_target, bin_target, upload_target, time_target)
+
+
+def initialize(interp: Interpreter) -> IceStormModule:
+    return IceStormModule(interp)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/java.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/java.py Changed

@@ -11,63 +11,104 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
-import os
 import pathlib
 import typing as T
-from mesonbuild.build import CustomTarget
+
+from mesonbuild import mesonlib
+from mesonbuild.build import CustomTarget, CustomTargetIndex, GeneratedList, Target
 from mesonbuild.compilers import detect_compiler_for
-from mesonbuild.interpreterbase.decorators import FeatureNew, KwargInfo, typed_pos_args, typed_kwargs
-from mesonbuild.interpreter.interpreterobjects import FileHolder
+from mesonbuild.interpreterbase.decorators import ContainerTypeInfo, FeatureDeprecated, FeatureNew, KwargInfo, typed_pos_args, typed_kwargs
 from mesonbuild.mesonlib import version_compare, MachineChoice
-from . import ExtensionModule, ModuleReturnValue, ModuleState
-from ..interpreter import Interpreter
+from . import NewExtensionModule, ModuleReturnValue, ModuleInfo
+from ..interpreter.type_checking import NoneType
+
+if T.TYPE_CHECKING:
+    from . import ModuleState
+    from ..compilers import Compiler
+    from ..interpreter import Interpreter
+
+class JavaModule(NewExtensionModule):
+
+    INFO = ModuleInfo('java', '0.60.0')
 
-class JavaModule(ExtensionModule):
-    @FeatureNew('Java Module', '0.60.0')
     def __init__(self, interpreter: Interpreter):
-        super().__init__(interpreter)
+        super().__init__()
         self.methods.update({
-            'generate_native_header': self.generate_native_header,
+            'generate_native_headers': self.generate_native_headers,
+            'native_headers': self.native_headers,
         })
 
-        if 'java' not in interpreter.environment.coredata.compilersMachineChoice.BUILD:
-            detect_compiler_for(interpreter.environment, 'java', MachineChoice.BUILD)
-        self.javac = interpreter.environment.coredata.compilersMachineChoice.BUILD'java'
+    def __get_java_compiler(self, state: ModuleState) -> Compiler:
+        if 'java' not in state.environment.coredata.compilersMachineChoice.BUILD:
+            detect_compiler_for(state.environment, 'java', MachineChoice.BUILD)
+        return state.environment.coredata.compilersMachineChoice.BUILD'java'
 
-    @typed_pos_args('generate_native_header', (str, FileHolder))
-    @typed_kwargs('java.generate_native_header', KwargInfo('package', str, default=None))
-    def generate_native_header(self, state: ModuleState, args: T.TupleT.Unionstr, FileHolder,
-                               kwargs: T.Dictstr, T.Optionalstr) -> ModuleReturnValue:
-        assert state.backend
+    @FeatureNew('java.generate_native_headers', '0.62.0')
+    @FeatureDeprecated('java.generate_native_headers', '1.0.0')
+    @typed_pos_args(
+        'java.generate_native_headers',
+        varargs=(str, mesonlib.File, Target, CustomTargetIndex, GeneratedList))
+    @typed_kwargs(
+        'java.generate_native_headers',
+        KwargInfo('classes', ContainerTypeInfo(list, str), default=, listify=True, required=True),
+        KwargInfo('package', (str, NoneType), default=None))
+    def generate_native_headers(self, state: ModuleState, args: T.TupleT.Listmesonlib.FileOrString,
+                                kwargs: T.Dictstr, T.Optionalstr) -> ModuleReturnValue:
+        return self.__native_headers(state, args, kwargs)
 
-        package = kwargs.get('package')
+    @FeatureNew('java.native_headers', '1.0.0')
+    @typed_pos_args(
+        'java.native_headers',
+        varargs=(str, mesonlib.File, Target, CustomTargetIndex, GeneratedList))
+    @typed_kwargs(
+        'java.native_headers',
+        KwargInfo('classes', ContainerTypeInfo(list, str), default=, listify=True, required=True),
+        KwargInfo('package', (str, NoneType), default=None))
+    def native_headers(self, state: ModuleState, args: T.TupleT.Listmesonlib.FileOrString,
+                       kwargs: T.Dictstr, T.Optionalstr) -> ModuleReturnValue:
+        return self.__native_headers(state, args, kwargs)
 
-        file = self.interpreter.source_strings_to_files(
-            a.held_object if isinstance(a, FileHolder) else a for a in args)0
+    def __native_headers(self, state: ModuleState, args: T.TupleT.Listmesonlib.FileOrString,
+                         kwargs: T.Dictstr, T.Optionalstr) -> ModuleReturnValue:
+        classes = T.cast('T.Liststr', kwargs.get('classes'))
+        package = kwargs.get('package')
 
         if package:
-            header = f'{package.replace(".", "_")}_{pathlib.Path(file.fname).stem}.h'
-        else:
-            header = f'{pathlib.Path(file.fname).stem}.h'
-
-        ct_kwargs = {
-            'input': file,
-            'output': header,
-            'command': 
-                self.javac.exelist0,
-                '-d',
-                '@PRIVATE_DIR@',
-                '-h',
-                state.subdir,
-                '@INPUT@',
-            
-        }
-
-        target = CustomTarget(os.path.basename(header), state.subdir, state.subproject, backend=state.backend, kwargs=ct_kwargs)
+            sanitized_package = package.replace("-", "_").replace(".", "_")
+
+        headers: T.Liststr = 
+        for clazz in classes:
+            sanitized_clazz = clazz.replace(".", "_")
+            if package:
+                headers.append(f'{sanitized_package}_{sanitized_clazz}.h')
+            else:
+                headers.append(f'{sanitized_clazz}.h')
+
+        javac = self.__get_java_compiler(state)
+
+        command = mesonlib.listify(
+            javac.exelist,
+            '-d',
+            '@PRIVATE_DIR@',
+            '-h',
+            state.subdir,
+            '@INPUT@',
+        )
+
+        prefix = classes0 if not package else package
+
+        target = CustomTarget(f'{prefix}-native-headers',
+                              state.subdir,
+                              state.subproject,
+                              state.environment,
+                              command,
+                              sources=args0, outputs=headers, backend=state.backend)
+
         # It is only known that 1.8.0 won't pre-create the directory. 11 and 16
         # do not exhibit this behavior.
-        if version_compare(self.javac.version, '1.8.0'):
+        if version_compare(javac.version, '1.8.0'):
             pathlib.Path(state.backend.get_target_private_dir_abs(target)).mkdir(parents=True, exist_ok=True)
 
         return ModuleReturnValue(target, target)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/keyval.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/keyval.py Changed

@@ -11,13 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import os
 import typing as T
 
-from . import ExtensionModule
+from . import ExtensionModule, ModuleInfo
 from .. import mesonlib
-from ..interpreterbase import FeatureNew, noKwargs, typed_pos_args
+from ..interpreterbase import noKwargs, typed_pos_args
 
 if T.TYPE_CHECKING:
     from ..interpreter import Interpreter
@@ -25,7 +26,8 @@
 
 class KeyvalModule(ExtensionModule):
 
-    @FeatureNew('Keyval Module', '0.55.0')
+    INFO = ModuleInfo('keyval', '0.55.0', stabilized='0.56.0')
+
     def __init__(self, interp: 'Interpreter'):
         super().__init__(interp)
         self.methods.update({
@@ -63,8 +65,8 @@
         else:
             s = os.path.join(self.interpreter.environment.source_dir, s)
 
-        if s not in self.interpreter.build_def_files and not is_built:
-            self.interpreter.build_def_files.append(s)
+        if not is_built:
+            self.interpreter.build_def_files.add(s)
 
         return self._load_file(s)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/modtest.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/modtest.py Changed

@@ -12,19 +12,33 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import ExtensionModule
-from ..interpreterbase import noKwargs
+from __future__ import annotations
+import typing as T
+
+from . import ExtensionModule, ModuleInfo
+from ..interpreterbase import noKwargs, noPosargs
+
+if T.TYPE_CHECKING:
+    from . import ModuleState
+    from ..interpreter.interpreter import Interpreter
+    from ..interpreterbase.baseobjects import TYPE_kwargs, TYPE_var
+
 
 class TestModule(ExtensionModule):
-    def __init__(self, interpreter):
+
+    INFO = ModuleInfo('modtest')
+
+    def __init__(self, interpreter: Interpreter) -> None:
         super().__init__(interpreter)
         self.methods.update({
             'print_hello': self.print_hello,
         })
 
     @noKwargs
-    def print_hello(self, state, args, kwargs):
+    @noPosargs
+    def print_hello(self, state: ModuleState, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> None:
         print('Hello from a Meson module')
 
-def initialize(*args, **kwargs):
-    return TestModule(*args, **kwargs)
+
+def initialize(interp: Interpreter) -> TestModule:
+    return TestModule(interp)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/pkgconfig.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/pkgconfig.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2015 The Meson development team
+# Copyright 2015-2022 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,79 +12,146 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+from collections import defaultdict
+from dataclasses import dataclass
 from pathlib import PurePath
 import os
 import typing as T
 
-from . import ExtensionModule
+from . import NewExtensionModule, ModuleInfo
 from . import ModuleReturnValue
 from .. import build
 from .. import dependencies
 from .. import mesonlib
 from .. import mlog
+from ..coredata import BUILTIN_DIR_OPTIONS
 from ..dependencies import ThreadDependency
-from ..interpreterbase import permittedKwargs, FeatureNew, FeatureNewKwargs
+from ..interpreter.type_checking import D_MODULE_VERSIONS_KW, INSTALL_DIR_KW, VARIABLES_KW, NoneType
+from ..interpreterbase import FeatureNew, FeatureDeprecated
+from ..interpreterbase.decorators import ContainerTypeInfo, KwargInfo, typed_kwargs, typed_pos_args
 
 if T.TYPE_CHECKING:
+ from typing_extensions import TypedDict
+
 from . import ModuleState
+ from .. import mparser
+ from ..interpreter import Interpreter
+
+ ANY_DEP = T.Uniondependencies.Dependency, build.BuildTargetTypes, str
+ LIBS = T.Unionbuild.LibTypes, str
+
+ class GenerateKw(TypedDict):
+
+ version: T.Optionalstr
+ name: T.Optionalstr
+ filebase: T.Optionalstr
+ description: T.Optionalstr
+ url: str
+ subdirs: T.Liststr
+ conflicts: T.Liststr
+ dataonly: bool
+ libraries: T.ListANY_DEP
+ libraries_private: T.ListANY_DEP
+ requires: T.ListT.Unionstr, build.StaticLibrary, build.SharedLibrary, dependencies.Dependency
+ requires_private: T.ListT.Unionstr, build.StaticLibrary, build.SharedLibrary, dependencies.Dependency
+ install_dir: T.Optionalstr
+ d_module_versions: T.ListT.Unionstr, int
+ extra_cflags: T.Liststr
+ variables: T.Dictstr, str
+ uninstalled_variables: T.Dictstr, str
+ unescaped_variables: T.Dictstr, str
+ unescaped_uninstalled_variables: T.Dictstr, str
+
+
+_PKG_LIBRARIES: KwargInfoT.ListT.Unionstr, dependencies.Dependency, build.SharedLibrary, build.StaticLibrary, build.CustomTarget, build.CustomTargetIndex = KwargInfo(
+ 'libraries',
+ ContainerTypeInfo(list, (str, dependencies.Dependency,
+ build.SharedLibrary, build.StaticLibrary,
+ build.CustomTarget, build.CustomTargetIndex)),
+ default=,
+ listify=True,
+)
+
+_PKG_REQUIRES: KwargInfoT.ListT.Unionstr, build.SharedLibrary, build.StaticLibrary, dependencies.Dependency = KwargInfo(
+ 'requires',
+ ContainerTypeInfo(list, (str, build.SharedLibrary, build.StaticLibrary, dependencies.Dependency)),
+ default=,
+ listify=True,
+)
+
+
+def _as_str(obj: object) -> str:
+ assert isinstance(obj, str)
+ return obj
+
+
+@dataclass
+class MetaData:
+
+ filebase: str
+ display_name: str
+ location: mparser.BaseNode
+ warned: bool = False
 
-already_warned_objs = set()
 
 class DependenciesHelper:
- def __init__(self, state, name):
+ def __init__(self, state: ModuleState, name: str, metadata: T.Dictstr, MetaData) -> None:
 self.state = state
 self.name = name
- self.pub_libs = 
- self.pub_reqs = 
- self.priv_libs = 
- self.priv_reqs = 
- self.cflags = 
- self.version_reqs = {}
- self.link_whole_targets = 
-
- def add_pub_libs(self, libs):
- libs, reqs, cflags = self._process_libs(libs, True)
- self.pub_libs = libs + self.pub_libs # prepend to preserve dependencies
+ self.pub_libs: T.ListLIBS = 
+ self.pub_reqs: T.Liststr = 
+ self.priv_libs: T.ListLIBS = 
+ self.priv_reqs: T.Liststr = 
+ self.cflags: T.Liststr = 
+ self.version_reqs: T.DefaultDictstr, T.Setstr = defaultdict(set)
+ self.link_whole_targets: T.ListT.Unionbuild.CustomTarget, build.CustomTargetIndex, build.StaticLibrary = 
+ self.metadata = metadata
+
+ def add_pub_libs(self, libs: T.ListANY_DEP) -> None:
+ p_libs, reqs, cflags = self._process_libs(libs, True)
+ self.pub_libs = p_libs + self.pub_libs # prepend to preserve dependencies
 self.pub_reqs += reqs
 self.cflags += cflags
 
- def add_priv_libs(self, libs):
- libs, reqs, _ = self._process_libs(libs, False)
- self.priv_libs = libs + self.priv_libs
+ def add_priv_libs(self, libs: T.ListANY_DEP) -> None:
+ p_libs, reqs, _ = self._process_libs(libs, False)
+ self.priv_libs = p_libs + self.priv_libs
 self.priv_reqs += reqs
 
- def add_pub_reqs(self, reqs):
+ def add_pub_reqs(self, reqs: T.ListT.Unionstr, build.StaticLibrary, build.SharedLibrary, dependencies.Dependency) -> None:
 self.pub_reqs += self._process_reqs(reqs)
 
- def add_priv_reqs(self, reqs):
+ def add_priv_reqs(self, reqs: T.ListT.Unionstr, build.StaticLibrary, build.SharedLibrary, dependencies.Dependency) -> None:
 self.priv_reqs += self._process_reqs(reqs)
 
- def _check_generated_pc_deprecation(self, obj):
- if not hasattr(obj, 'generated_pc_warn'):
+ def _check_generated_pc_deprecation(self, obj: T.Unionbuild.CustomTarget, build.CustomTargetIndex, build.StaticLibrary, build.SharedLibrary) -> None:
+ if obj.get_id() in self.metadata:
 return
- name = obj.generated_pc_warn0
- if (name, obj.name) in already_warned_objs:
+ data = self.metadataobj.get_id()
+ if data.warned:
 return
 mlog.deprecation('Library', mlog.bold(obj.name), 'was passed to the '
 '"libraries" keyword argument of a previous call '
 'to generate() method instead of first positional '
- 'argument.', 'Adding', mlog.bold(obj.generated_pc),
+ 'argument.', 'Adding', mlog.bold(data.display_name),
 'to "Requires" field, but this is a deprecated '
 'behaviour that will change in a future version '
 'of Meson. Please report the issue if this '
 'warning cannot be avoided in your case.',
- location=obj.generated_pc_warn1)
- already_warned_objs.add((name, obj.name))
+ location=data.location)
+ data.warned = True
 
- def _process_reqs(self, reqs):
+ def _process_reqs(self, reqs: T.SequenceT.Unionstr, build.StaticLibrary, build.SharedLibrary, dependencies.Dependency) -> T.Liststr:
 '''Returns string names of requirements'''
- processed_reqs = 
+ processed_reqs: T.Liststr = 
 for obj in mesonlib.listify(reqs):
 if not isinstance(obj, str):
 FeatureNew.single_use('pkgconfig.generate requirement from non-string object', '0.46.0', self.state.subproject)
- if hasattr(obj, 'generated_pc'):
+ if (isinstance(obj, (build.CustomTarget, build.CustomTargetIndex, build.SharedLibrary, build.StaticLibrary))
+ and obj.get_id() in self.metadata):
 self._check_generated_pc_deprecation(obj)
- processed_reqs.append(obj.generated_pc)
+ processed_reqs.append(self.metadataobj.get_id().filebase)
 elif isinstance(obj, dependencies.PkgConfigDependency):
 if obj.found():
 processed_reqs.append(obj.name)
@@ -92,7 +159,7 @@
 elif isinstance(obj, str):
 name, version_req = self.split_version_req(obj)
 processed_reqs.append(name)
- self.add_version_reqs(name, version_req)
+ self.add_version_reqs(name, version_req if version_req is not None else None)
 elif isinstance(obj, dependencies.Dependency) and not obj.found():
 pass
 elif isinstance(obj, ThreadDependency):
@@ -100,21 +167,26 @@
 else:
 raise mesonlib.MesonException('requires argument not a string, '
 'library with pkgconfig-generated file '
- 'or pkgconfig-dependency object, got {obj!r}')
+ f'or pkgconfig-dependency object, got {obj!r}')
 return processed_reqs
 
- def add_cflags(self, cflags):
+ def add_cflags(self, cflags: T.Liststr) -> None:
 self.cflags += mesonlib.stringlistify(cflags)
 
- def _process_libs(self, libs, public: bool):
+ def _process_libs(
+ self, libs: T.ListANY_DEP, public: bool
+ ) -> T.TupleT.ListT.Unionstr, build.SharedLibrary, build.StaticLibrary, build.CustomTarget, build.CustomTargetIndex, T.Liststr, T.Liststr:
 libs = mesonlib.listify(libs)
- processed_libs = 
- processed_reqs = 
- processed_cflags = 
+ processed_libs: T.ListT.Unionstr, build.SharedLibrary, build.StaticLibrary, build.CustomTarget, build.CustomTargetIndex = 
+ processed_reqs: T.Liststr = 
+ processed_cflags: T.Liststr = 
 for obj in libs:
- if hasattr(obj, 'generated_pc'):
+ if (isinstance(obj, (build.CustomTarget, build.CustomTargetIndex, build.SharedLibrary, build.StaticLibrary))
+ and obj.get_id() in self.metadata):
 self._check_generated_pc_deprecation(obj)
- processed_reqs.append(obj.generated_pc)
+ processed_reqs.append(self.metadataobj.get_id().filebase)
+ elif isinstance(obj, dependencies.ValgrindDependency):
+ pass
 elif isinstance(obj, dependencies.PkgConfigDependency):
 if obj.found():
 processed_reqs.append(obj.name)
@@ -157,13 +229,21 @@
 
 return processed_libs, processed_reqs, processed_cflags
 
- def _add_lib_dependencies(self, link_targets, link_whole_targets, external_deps, public, private_external_deps=False):
+ def _add_lib_dependencies(
+ self, link_targets: T.Sequencebuild.BuildTargetTypes,
+ link_whole_targets: T.SequenceT.Unionbuild.StaticLibrary, build.CustomTarget, build.CustomTargetIndex,
+ external_deps: T.Listdependencies.Dependency,
+ public: bool,
+ private_external_deps: bool = False) -> None:
 add_libs = self.add_pub_libs if public else self.add_priv_libs
 # Recursively add all linked libraries
 for t in link_targets:
 # Internal libraries (uninstalled static library) will be promoted
 # to link_whole, treat them as such here.
 if t.is_internal():
+ # `is_internal` shouldn't return True for anything but a
+ # StaticLibrary, or a CustomTarget that is a StaticLibrary
+ assert isinstance(t, (build.StaticLibrary, build.CustomTarget, build.CustomTargetIndex)), 'for mypy'
 self._add_link_whole(t, public)
 else:
 add_libs(t)
@@ -171,11 +251,11 @@
 self._add_link_whole(t, public)
 # And finally its external dependencies
 if private_external_deps:
- self.add_priv_libs(external_deps)
+ self.add_priv_libs(T.cast('T.ListANY_DEP', external_deps))
 else:
- add_libs(external_deps)
+ add_libs(T.cast('T.ListANY_DEP', external_deps))
 
- def _add_link_whole(self, t, public):
+ def _add_link_whole(self, t: T.Unionbuild.CustomTarget, build.CustomTargetIndex, build.StaticLibrary, public: bool) -> None:
 # Don't include static libraries that we link_whole. But we still need to
 # include their dependencies: a static library we link_whole
 # could itself link to a shared library or an installed static library.
@@ -186,32 +266,29 @@
 if isinstance(t, build.BuildTarget):
 self._add_lib_dependencies(t.link_targets, t.link_whole_targets, t.external_deps, public)
 
- def add_version_reqs(self, name, version_reqs):
+ def add_version_reqs(self, name: str, version_reqs: T.OptionalT.Liststr) -> None:
 if version_reqs:
- if name not in self.version_reqs:
- self.version_reqsname = set()
 # Note that pkg-config is picky about whitespace.
 # 'foo > 1.2' is ok but 'foo>1.2' is not.
 # foo, bar' is ok, but 'foo,bar' is not.
- new_vreqs = s for s in mesonlib.stringlistify(version_reqs)
- self.version_reqsname.update(new_vreqs)
+ self.version_reqsname.update(version_reqs)
 
- def split_version_req(self, s):
+ def split_version_req(self, s: str) -> T.Tuplestr, T.Optionalstr:
 for op in '>=', '<=', '!=', '==', '=', '>', '<':
 pos = s.find(op)
 if pos > 0:
 return s0:pos.strip(), spos:.strip()
 return s, None
 
- def format_vreq(self, vreq):
+ def format_vreq(self, vreq: str) -> str:
 # vreq are '>=1.0' and pkgconfig wants '>= 1.0'
 for op in '>=', '<=', '!=', '==', '=', '>', '<':
 if vreq.startswith(op):
 return op + ' ' + vreqlen(op):
 return vreq
 
- def format_reqs(self, reqs):
- result = 
+ def format_reqs(self, reqs: T.Liststr) -> str:
+ result: T.Liststr = 
 for name in reqs:
 vreqs = self.version_reqs.get(name, None)
 if vreqs:
@@ -220,21 +297,22 @@
 result += name
 return ', '.join(result)
 
- def remove_dups(self):
+ def remove_dups(self) -> None:
 # Set of ids that have already been handled and should not be added any more
- exclude = set()
+ exclude: T.Setstr = set()
 
 # We can't just check if 'x' is excluded because we could have copies of
 # the same SharedLibrary object for example.
- def _ids(x):
- if hasattr(x, 'generated_pc'):
- yield x.generated_pc
- if isinstance(x, build.Target):
+ def _ids(x: T.Unionstr, build.CustomTarget, build.CustomTargetIndex, build.StaticLibrary, build.SharedLibrary) -> T.Iterablestr:
+ if isinstance(x, str):
+ yield x
+ else:
+ if x.get_id() in self.metadata:
+ yield self.metadatax.get_id().display_name
 yield x.get_id()
- yield x
 
 # Exclude 'x' in all its forms and return if it was already excluded
- def _add_exclude(x):
+ def _add_exclude(x: T.Unionstr, build.CustomTarget, build.CustomTargetIndex, build.StaticLibrary, build.SharedLibrary) -> bool:
 was_excluded = False
 for i in _ids(x):
 if i in exclude:
@@ -247,7 +325,17 @@
 for t in self.link_whole_targets:
 _add_exclude(t)
 
- def _fn(xs, libs=False):
+ # Mypy thinks these overlap, but since List is invariant they don't,
+ # `Liststr`` is not a valid input to `Liststr | BuildTarget`.
+ # pylance/pyright gets this right, but for mypy we have to ignore the
+ # error
+ @T.overload
+ def _fn(xs: T.Liststr, libs: bool = False) -> T.Liststr: ... # type: ignore
+
+ @T.overload
+ def _fn(xs: T.ListLIBS, libs: bool = False) -> T.ListLIBS: ...
+
+ def _fn(xs: T.UnionT.Liststr, T.ListLIBS, libs: bool = False) -> T.UnionT.Liststr, T.ListLIBS:
 # Remove duplicates whilst preserving original order
 result = 
 for x in xs:
@@ -272,15 +360,23 @@
 exclude = set()
 self.cflags = _fn(self.cflags)
 
-class PkgConfigModule(ExtensionModule):
- def __init__(self, interpreter):
- super().__init__(interpreter)
+class PkgConfigModule(NewExtensionModule):
+
+ INFO = ModuleInfo('pkgconfig')
+
+ # Track already generated pkg-config files This is stored as a class
+ # variable so that multiple `import()`s share metadata
+ _metadata: T.ClassVarT.Dictstr, MetaData = {}
+
+ def __init__(self) -> None:
+ super().__init__()
 self.methods.update({
 'generate': self.generate,
 })
 
- def _get_lname(self, l, msg, pcfile, is_custom_target):
- if is_custom_target:
+ def _get_lname(self, l: T.Unionbuild.SharedLibrary, build.StaticLibrary, build.CustomTarget, build.CustomTargetIndex,
+ msg: str, pcfile: str) -> str:
+ if isinstance(l, (build.CustomTargetIndex, build.CustomTarget)):
 basename = os.path.basename(l.get_filename())
 name = os.path.splitext(basename)0
 if name.startswith('lib'):
@@ -303,7 +399,7 @@
 mlog.warning(msg.format(l.name, 'name_prefix', l.name, pcfile))
 return l.name
 
- def _escape(self, value):
+ def _escape(self, value: T.Unionstr, PurePath) -> str:
 '''
 We cannot use quote_arg because it quotes with ' and " which does not
 work with pkg-config and pkgconf at all.
@@ -315,7 +411,7 @@
 value = value.as_posix()
 return value.replace(' ', r'\ ')
 
- def _make_relative(self, prefix, subdir):
+ def _make_relative(self, prefix: T.UnionPurePath, str, subdir: T.UnionPurePath, str) -> str:
 prefix = PurePath(prefix)
 subdir = PurePath(subdir)
 try:
@@ -325,10 +421,50 @@
 # pathlib joining makes sure absolute libdir is not appended to '${prefix}'
 return ('${prefix}' / libdir).as_posix()
 
- def _generate_pkgconfig_file(self, state, deps, subdirs, name, description,
- url, version, pcfile, conflicts, variables,
- unescaped_variables, uninstalled=False, dataonly=False):
+ def _generate_pkgconfig_file(self, state: ModuleState, deps: DependenciesHelper,
+ subdirs: T.Liststr, name: T.Optionalstr,
+ description: T.Optionalstr, url: str, version: str,
+ pcfile: str, conflicts: T.Liststr,
+ variables: T.ListT.Tuplestr, str,
+ unescaped_variables: T.ListT.Tuplestr, str,
+ uninstalled: bool = False, dataonly: bool = False,
+ pkgroot: T.Optionalstr = None) -> None:
 coredata = state.environment.get_coredata()
+ referenced_vars = set()
+ optnames = x.name for x in BUILTIN_DIR_OPTIONS.keys()
+
+ if not dataonly:
+ # includedir is always implied, although libdir may not be
+ # needed for header-only libraries
+ referenced_vars |= {'prefix', 'includedir'}
+ if deps.pub_libs or deps.priv_libs:
+ referenced_vars |= {'libdir'}
+ # also automatically infer variables referenced in other variables
+ implicit_vars_warning = False
+ redundant_vars_warning = False
+ varnames = set()
+ varstrings = set()
+ for k, v in variables + unescaped_variables:
+ varnames |= {k}
+ varstrings |= {v}
+ for optname in optnames:
+ optvar = f'${{{optname}}}'
+ if any(x.startswith(optvar) for x in varstrings):
+ if optname in varnames:
+ redundant_vars_warning = True
+ else:
+ # these 3 vars were always "implicit"
+ if dataonly or optname not in {'prefix', 'includedir', 'libdir'}:
+ implicit_vars_warning = True
+ referenced_vars |= {'prefix', optname}
+ if redundant_vars_warning:
+ FeatureDeprecated.single_use('pkgconfig.generate variable for builtin directories', '0.62.0',
+ state.subproject, 'They will be automatically included when referenced',
+ state.current_node)
+ if implicit_vars_warning:
+ FeatureNew.single_use('pkgconfig.generate implicit variable for builtin directories', '0.62.0',
+ state.subproject, location=state.current_node)
+
 if uninstalled:
 outdir = os.path.join(state.environment.build_dir, 'meson-uninstalled')
 if not os.path.exists(outdir):
@@ -337,18 +473,27 @@
 srcdir = PurePath(state.environment.get_source_dir())
 else:
 outdir = state.environment.scratch_dir
- prefix = PurePath(coredata.get_option(mesonlib.OptionKey('prefix')))
- # These always return paths relative to prefix
- libdir = PurePath(coredata.get_option(mesonlib.OptionKey('libdir')))
- incdir = PurePath(coredata.get_option(mesonlib.OptionKey('includedir')))
+ prefix = PurePath(_as_str(coredata.get_option(mesonlib.OptionKey('prefix'))))
+ if pkgroot:
+ pkgroot_ = PurePath(pkgroot)
+ if not pkgroot_.is_absolute():
+ pkgroot_ = prefix / pkgroot
+ elif prefix not in pkgroot_.parents:
+ raise mesonlib.MesonException('Pkgconfig prefix cannot be outside of the prefix '
+ 'when pkgconfig.relocatable=true. '
+ f'Pkgconfig prefix is {pkgroot_.as_posix()}.')
+ prefix = PurePath('${pcfiledir}', os.path.relpath(prefix, pkgroot_))
 fname = os.path.join(outdir, pcfile)
 with open(fname, 'w', encoding='utf-8') as ofile:
- if not dataonly:
- ofile.write('prefix={}\n'.format(self._escape(prefix)))
- if uninstalled:
- ofile.write('srcdir={}\n'.format(self._escape(srcdir)))
- ofile.write('libdir={}\n'.format(self._escape('${prefix}' / libdir)))
- ofile.write('includedir={}\n'.format(self._escape('${prefix}' / incdir)))
+ for optname in optnames:
+ if optname in referenced_vars - varnames:
+ if optname == 'prefix':
+ ofile.write('prefix={}\n'.format(self._escape(prefix)))
+ else:
+ dirpath = PurePath(_as_str(coredata.get_option(mesonlib.OptionKey(optname))))
+ ofile.write('{}={}\n'.format(optname, self._escape('${prefix}' / dirpath)))
+ if uninstalled and not dataonly:
+ ofile.write('srcdir={}\n'.format(self._escape(srcdir)))
 if variables or unescaped_variables:
 ofile.write('\n')
 for k, v in variables:
@@ -371,7 +516,7 @@
 if len(conflicts) > 0:
 ofile.write('Conflicts: {}\n'.format(' '.join(conflicts)))
 
- def generate_libs_flags(libs):
+ def generate_libs_flags(libs: T.ListLIBS) -> T.Iterablestr:
 msg = 'Library target {0!r} has {1!r} set. Compilers ' \
 'may not find it from its \'-l{2}\' linker flag in the ' \
 '{3!r} pkg-config file.'
@@ -380,6 +525,7 @@
 if isinstance(l, str):
 yield l
 else:
+ install_dir: T.Unionstr, bool
 if uninstalled:
 install_dir = os.path.dirname(state.backend.get_target_filename_abs(l))
 else:
@@ -387,8 +533,7 @@
 install_dir = _i0 if _i else None
 if install_dir is False:
 continue
- is_custom_target = isinstance(l, (build.CustomTarget, build.CustomTargetIndex))
- if not is_custom_target and 'cs' in l.compilers:
+ if isinstance(l, build.BuildTarget) and 'cs' in l.compilers:
 if isinstance(install_dir, str):
 Lflag = '-r{}/{}'.format(self._escape(self._make_relative(prefix, install_dir)), l.filename)
 else: # install_dir is True
@@ -401,16 +546,16 @@
 if Lflag not in Lflags:
 Lflags.append(Lflag)
 yield Lflag
- lname = self._get_lname(l, msg, pcfile, is_custom_target)
+ lname = self._get_lname(l, msg, pcfile)
 # If using a custom suffix, the compiler may not be able to
 # find the library
- if not is_custom_target and l.name_suffix_set:
+ if isinstance(l, build.BuildTarget) and l.name_suffix_set:
 mlog.warning(msg.format(l.name, 'name_suffix', lname, pcfile))
- if is_custom_target or 'cs' not in l.compilers:
+ if isinstance(l, (build.CustomTarget, build.CustomTargetIndex)) or 'cs' not in l.compilers:
 yield f'-l{lname}'
 
- def get_uninstalled_include_dirs(libs):
- result = 
+ def get_uninstalled_include_dirs(libs: T.ListLIBS) -> T.Liststr:
+ result: T.Liststr = 
 for l in libs:
 if isinstance(l, (str, build.CustomTarget, build.CustomTargetIndex)):
 continue
@@ -424,7 +569,7 @@
 result.append(path)
 return result
 
- def generate_uninstalled_cflags(libs):
+ def generate_uninstalled_cflags(libs: T.ListLIBS) -> T.Iterablestr:
 for d in get_uninstalled_include_dirs(libs):
 for basedir in '${prefix}', '${srcdir}':
 path = PurePath(basedir, d)
@@ -435,7 +580,7 @@
 if len(deps.priv_libs) > 0:
 ofile.write('Libs.private: {}\n'.format(' '.join(generate_libs_flags(deps.priv_libs))))
 
- cflags = 
+ cflags: T.Liststr = 
 if uninstalled:
 cflags += generate_uninstalled_cflags(deps.pub_libs + deps.priv_libs)
 else:
@@ -448,80 +593,87 @@
 if cflags and not dataonly:
 ofile.write('Cflags: {}\n'.format(' '.join(cflags)))
 
- @FeatureNewKwargs('pkgconfig.generate', '0.59.0', 'unescaped_variables', 'unescaped_uninstalled_variables')
- @FeatureNewKwargs('pkgconfig.generate', '0.54.0', 'uninstalled_variables')
- @FeatureNewKwargs('pkgconfig.generate', '0.42.0', 'extra_cflags')
- @FeatureNewKwargs('pkgconfig.generate', '0.41.0', 'variables')
- @FeatureNewKwargs('pkgconfig.generate', '0.54.0', 'dataonly')
- @permittedKwargs({'libraries', 'version', 'name', 'description', 'filebase',
- 'subdirs', 'requires', 'requires_private', 'libraries_private',
- 'install_dir', 'extra_cflags', 'variables', 'url', 'd_module_versions',
- 'dataonly', 'conflicts', 'uninstalled_variables',
- 'unescaped_variables', 'unescaped_uninstalled_variables'})
- def generate(self, state: 'ModuleState', args, kwargs):
+ @typed_pos_args('pkgconfig.generate', optargs=(build.SharedLibrary, build.StaticLibrary))
+ @typed_kwargs(
+ 'pkgconfig.generate',
+ D_MODULE_VERSIONS_KW.evolve(since='0.43.0'),
+ INSTALL_DIR_KW,
+ KwargInfo('conflicts', ContainerTypeInfo(list, str), default=, listify=True),
+ KwargInfo('dataonly', bool, default=False, since='0.54.0'),
+ KwargInfo('description', (str, NoneType)),
+ KwargInfo('extra_cflags', ContainerTypeInfo(list, str), default=, listify=True, since='0.42.0'),
+ KwargInfo('filebase', (str, NoneType), validator=lambda x: 'must not be an empty string' if x == '' else None),
+ KwargInfo('name', (str, NoneType), validator=lambda x: 'must not be an empty string' if x == '' else None),
+ KwargInfo('subdirs', ContainerTypeInfo(list, str), default=, listify=True),
+ KwargInfo('url', str, default=''),
+ KwargInfo('version', (str, NoneType)),
+ VARIABLES_KW.evolve(name="unescaped_uninstalled_variables", since='0.59.0'),
+ VARIABLES_KW.evolve(name="unescaped_variables", since='0.59.0'),
+ VARIABLES_KW.evolve(name="uninstalled_variables", since='0.54.0', since_values={dict: '0.56.0'}),
+ VARIABLES_KW.evolve(since='0.41.0', since_values={dict: '0.56.0'}),
+ _PKG_LIBRARIES,
+ _PKG_LIBRARIES.evolve(name='libraries_private'),
+ _PKG_REQUIRES,
+ _PKG_REQUIRES.evolve(name='requires_private'),
+ )
+ def generate(self, state: ModuleState,
+ args: T.TupleT.OptionalT.Unionbuild.SharedLibrary, build.StaticLibrary,
+ kwargs: GenerateKw) -> ModuleReturnValue:
 default_version = state.project_version
- default_install_dir = None
- default_description = None
- default_name = None
- mainlib = None
+ default_install_dir: T.Optionalstr = None
+ default_description: T.Optionalstr = None
+ default_name: T.Optionalstr = None
+ mainlib: T.OptionalT.Unionbuild.SharedLibrary, build.StaticLibrary = None
 default_subdirs = '.'
- if not args and 'version' not in kwargs:
- FeatureNew.single_use('pkgconfig.generate implicit version keyword', '0.46.0', state.subproject)
- elif len(args) == 1:
+ if args0:
 FeatureNew.single_use('pkgconfig.generate optional positional argument', '0.46.0', state.subproject)
 mainlib = args0
- if not isinstance(mainlib, (build.StaticLibrary, build.SharedLibrary)):
- raise mesonlib.MesonException('Pkgconfig_gen first positional argument must be a library object')
 default_name = mainlib.name
 default_description = state.project_name + ': ' + mainlib.name
 install_dir = mainlib.get_custom_install_dir()
 if install_dir and isinstance(install_dir0, str):
 default_install_dir = os.path.join(install_dir0, 'pkgconfig')
- elif len(args) > 1:
- raise mesonlib.MesonException('Too many positional arguments passed to Pkgconfig_gen.')
-
- dataonly = kwargs.get('dataonly', False)
- if not isinstance(dataonly, bool):
- raise mesonlib.MesonException('dataonly must be boolean.')
+ else:
+ if kwargs'version' is None:
+ FeatureNew.single_use('pkgconfig.generate implicit version keyword', '0.46.0', state.subproject)
+ if kwargs'name' is None:
+ raise build.InvalidArguments(
+ 'pkgconfig.generate: if a library is not passed as a '
+ 'positional argument, the name keyword argument is '
+ 'required.')
+
+ dataonly = kwargs'dataonly'
 if dataonly:
 default_subdirs = 
- blocked_vars = 'libraries', 'libraries_private', 'require_private', 'extra_cflags', 'subdirs'
- if any(k in kwargs for k in blocked_vars):
+ blocked_vars = 'libraries', 'libraries_private', 'requires_private', 'extra_cflags', 'subdirs'
+ if any(kwargsk for k in blocked_vars): # type: ignore
 raise mesonlib.MesonException(f'Cannot combine dataonly with any of {blocked_vars}')
+ default_install_dir = os.path.join(state.environment.get_datadir(), 'pkgconfig')
 
- subdirs = mesonlib.stringlistify(kwargs.get('subdirs', default_subdirs))
- version = kwargs.get('version', default_version)
- if not isinstance(version, str):
- raise mesonlib.MesonException('Version must be specified.')
- name = kwargs.get('name', default_name)
- if not isinstance(name, str):
- raise mesonlib.MesonException('Name not specified.')
- filebase = kwargs.get('filebase', name)
- if not isinstance(filebase, str):
- raise mesonlib.MesonException('Filebase must be a string.')
- description = kwargs.get('description', default_description)
- if not isinstance(description, str):
- raise mesonlib.MesonException('Description is not a string.')
- url = kwargs.get('url', '')
- if not isinstance(url, str):
- raise mesonlib.MesonException('URL is not a string.')
- conflicts = mesonlib.stringlistify(kwargs.get('conflicts', ))
+ subdirs = kwargs'subdirs' or default_subdirs
+ version = kwargs'version' if kwargs'version' is not None else default_version
+ name = kwargs'name' if kwargs'name' is not None else default_name
+ assert isinstance(name, str), 'for mypy'
+ filebase = kwargs'filebase' if kwargs'filebase' is not None else name
+ description = kwargs'description' if kwargs'description' is not None else default_description
+ url = kwargs'url'
+ conflicts = kwargs'conflicts'
 
 # Prepend the main library to public libraries list. This is required
 # so dep.add_pub_libs() can handle dependency ordering correctly and put
 # extra libraries after the main library.
- libraries = mesonlib.extract_as_list(kwargs, 'libraries')
+ libraries = kwargs'libraries'.copy()
 if mainlib:
- libraries = mainlib + libraries
+ libraries.insert(0, mainlib)
 
- deps = DependenciesHelper(state, filebase)
+ deps = DependenciesHelper(state, filebase, self._metadata)
 deps.add_pub_libs(libraries)
- deps.add_priv_libs(kwargs.get('libraries_private', ))
- deps.add_pub_reqs(kwargs.get('requires', ))
- deps.add_priv_reqs(kwargs.get('requires_private', ))
- deps.add_cflags(kwargs.get('extra_cflags', ))
+ deps.add_priv_libs(kwargs'libraries_private')
+ deps.add_pub_reqs(kwargs'requires')
+ deps.add_priv_reqs(kwargs'requires_private')
+ deps.add_cflags(kwargs'extra_cflags')
 
- dversions = kwargs.get('d_module_versions', None)
+ dversions = kwargs'd_module_versions'
 if dversions:
 compiler = state.environment.coredata.compilers.host.get('d')
 if compiler:
@@ -529,7 +681,7 @@
 
 deps.remove_dups()
 
- def parse_variable_list(vardict):
+ def parse_variable_list(vardict: T.Dictstr, str) -> T.ListT.Tuplestr, str:
 reserved = 'prefix', 'libdir', 'includedir'
 variables = 
 for name, value in vardict.items():
@@ -538,30 +690,29 @@
 variables.append((name, value))
 return variables
 
- variables = self.interpreter.extract_variables(kwargs, dict_new=True)
- variables = parse_variable_list(variables)
- unescaped_variables = self.interpreter.extract_variables(kwargs, argname='unescaped_variables')
- unescaped_variables = parse_variable_list(unescaped_variables)
+ variables = parse_variable_list(kwargs'variables')
+ unescaped_variables = parse_variable_list(kwargs'unescaped_variables')
 
 pcfile = filebase + '.pc'
- pkgroot = pkgroot_name = kwargs.get('install_dir', default_install_dir)
+ pkgroot = pkgroot_name = kwargs'install_dir' or default_install_dir
 if pkgroot is None:
 if mesonlib.is_freebsd():
- pkgroot = os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('prefix')), 'libdata', 'pkgconfig')
+ pkgroot = os.path.join(_as_str(state.environment.coredata.get_option(mesonlib.OptionKey('prefix'))), 'libdata', 'pkgconfig')
 pkgroot_name = os.path.join('{prefix}', 'libdata', 'pkgconfig')
+ elif mesonlib.is_haiku():
+ pkgroot = os.path.join(_as_str(state.environment.coredata.get_option(mesonlib.OptionKey('prefix'))), 'develop', 'lib', 'pkgconfig')
+ pkgroot_name = os.path.join('{prefix}', 'develop', 'lib', 'pkgconfig')
 else:
- pkgroot = os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('libdir')), 'pkgconfig')
+ pkgroot = os.path.join(_as_str(state.environment.coredata.get_option(mesonlib.OptionKey('libdir'))), 'pkgconfig')
 pkgroot_name = os.path.join('{libdir}', 'pkgconfig')
- if not isinstance(pkgroot, str):
- raise mesonlib.MesonException('Install_dir must be a string.')
+ relocatable = state.get_option('relocatable', module='pkgconfig')
 self._generate_pkgconfig_file(state, deps, subdirs, name, description, url,
 version, pcfile, conflicts, variables,
- unescaped_variables, False, dataonly)
+ unescaped_variables, False, dataonly,
+ pkgroot=pkgroot if relocatable else None)
 res = build.Data(mesonlib.File(True, state.environment.get_scratch_dir(), pcfile), pkgroot, pkgroot_name, None, state.subproject, install_tag='devel')
- variables = self.interpreter.extract_variables(kwargs, argname='uninstalled_variables', dict_new=True)
- variables = parse_variable_list(variables)
- unescaped_variables = self.interpreter.extract_variables(kwargs, argname='unescaped_uninstalled_variables')
- unescaped_variables = parse_variable_list(unescaped_variables)
+ variables = parse_variable_list(kwargs'uninstalled_variables')
+ unescaped_variables = parse_variable_list(kwargs'unescaped_uninstalled_variables')
 
 pcfile = filebase + '-uninstalled.pc'
 self._generate_pkgconfig_file(state, deps, subdirs, name, description, url,
@@ -574,17 +725,18 @@
 # libraries instead of just the main one. Keep doing that but warn if
 # anyone is relying on that deprecated behaviour.
 if mainlib:
- if not hasattr(mainlib, 'generated_pc'):
- mainlib.generated_pc = filebase
+ if mainlib.get_id() not in self._metadata:
+ self._metadatamainlib.get_id() = MetaData(
+ filebase, name, state.current_node)
 else:
 mlog.warning('Already generated a pkg-config file for', mlog.bold(mainlib.name))
 else:
 for lib in deps.pub_libs:
- if not isinstance(lib, str) and not hasattr(lib, 'generated_pc'):
- lib.generated_pc = filebase
- location = state.current_node
- lib.generated_pc_warn = name, location
+ if not isinstance(lib, str) and lib.get_id() not in self._metadata:
+ self._metadatalib.get_id() = MetaData(
+ filebase, name, state.current_node)
 return ModuleReturnValue(res, res)
 
-def initialize(*args, **kwargs):
- return PkgConfigModule(*args, **kwargs)
+
+def initialize(interp: Interpreter) -> PkgConfigModule:
+ return PkgConfigModule()

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/python.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/python.py Changed

@@ -11,24 +11,28 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from pathlib import Path
+import copy
 import functools
 import json
 import os
 import shutil
 import typing as T
 
-from . import ExtensionModule
+from . import ExtensionModule, ModuleInfo
 from .. import mesonlib
 from .. import mlog
 from ..coredata import UserFeatureOption
 from ..build import known_shmod_kwargs
 from ..dependencies import DependencyMethods, PkgConfigDependency, NotFoundDependency, SystemDependency, ExtraFrameworkDependency
 from ..dependencies.base import process_method_kw
+from ..dependencies.detect import get_dep_identifier
 from ..environment import detect_cpu_family
 from ..interpreter import ExternalProgramHolder, extract_required_kwarg, permitted_dependency_kwargs
-from ..interpreter.type_checking import NoneType
+from ..interpreter import primitives as P_OBJ
+from ..interpreter.type_checking import NoneType, PRESERVE_PATH_KW
 from ..interpreterbase import (
 noPosargs, noKwargs, permittedKwargs, ContainerTypeInfo,
 InvalidArguments, typed_pos_args, typed_kwargs, KwargInfo,
@@ -38,37 +42,69 @@
 from ..programs import ExternalProgram, NonExistingExternalProgram
 
 if T.TYPE_CHECKING:
+ from typing_extensions import TypedDict
+
 from . import ModuleState
 from ..build import SharedModule, Data
 from ..dependencies import ExternalDependency, Dependency
 from ..dependencies.factory import DependencyGenerator
 from ..environment import Environment
 from ..interpreter import Interpreter
+ from ..interpreter.kwargs import ExtractRequired
 from ..interpreterbase.interpreterbase import TYPE_var, TYPE_kwargs
 
- from typing_extensions import TypedDict
+ class PythonIntrospectionDict(TypedDict):
 
+ install_paths: T.Dictstr, str
+ is_pypy: bool
+ is_venv: bool
+ link_libpython: bool
+ sysconfig_paths: T.Dictstr, str
+ paths: T.Dictstr, str
+ platform: str
+ suffix: str
+ variables: T.Dictstr, str
+ version: str
 
-mod_kwargs = {'subdir'}
-mod_kwargs.update(known_shmod_kwargs)
-mod_kwargs -= {'name_prefix', 'name_suffix'}
+ class PyInstallKw(TypedDict):
 
+ pure: T.Optionalbool
+ subdir: str
+ install_tag: T.Optionalstr
+
+ class FindInstallationKw(ExtractRequired):
+
+ disabler: bool
+ modules: T.Liststr
+ pure: T.Optionalbool
 
-if T.TYPE_CHECKING:
 _Base = ExternalDependency
 else:
 _Base = object
 
+
+mod_kwargs = {'subdir'}
+mod_kwargs.update(known_shmod_kwargs)
+mod_kwargs -= {'name_prefix', 'name_suffix'}
+
+
 class _PythonDependencyBase(_Base):
 
 def __init__(self, python_holder: 'PythonInstallation', embed: bool):
- self.name = 'python' # override the name from the "real" dependency lookup
 self.embed = embed
 self.version: str = python_holder.version
 self.platform = python_holder.platform
 self.variables = python_holder.variables
 self.paths = python_holder.paths
- self.link_libpython = python_holder.link_libpython
+ # The "-embed" version of python.pc / python-config was introduced in 3.8,
+ # and distutils extension linking was changed to be considered a non embed
+ # usage. Before then, this dependency always uses the embed=True handling
+ # because that is the only one that exists.
+ #
+ # On macOS and some Linux distros (Debian) distutils doesn't link extensions
+ # against libpython, even on 3.7 and below. We call into distutils and
+ # mirror its behavior. See https://github.com/mesonbuild/meson/issues/4117
+ self.link_libpython = python_holder.link_libpython or embed
 self.info: T.OptionalT.Dictstr, str = None
 if mesonlib.version_compare(self.version, '>= 3.0'):
 self.major_version = 3
@@ -79,10 +115,23 @@
 class PythonPkgConfigDependency(PkgConfigDependency, _PythonDependencyBase):
 
 def __init__(self, name: str, environment: 'Environment',
- kwargs: T.Dictstr, T.Any, installation: 'PythonInstallation'):
+ kwargs: T.Dictstr, T.Any, installation: 'PythonInstallation',
+ libpc: bool = False):
+ if libpc:
+ mlog.debug(f'Searching for {name!r} via pkgconfig lookup in LIBPC')
+ else:
+ mlog.debug(f'Searching for {name!r} via fallback pkgconfig lookup in default paths')
+
 PkgConfigDependency.__init__(self, name, environment, kwargs)
 _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False))
 
+ if libpc and not self.is_found:
+ mlog.debug(f'"python-{self.version}" could not be found in LIBPC, this is likely due to a relocated python installation')
+
+ # pkg-config files are usually accurate starting with python 3.8
+ if not self.link_libpython and mesonlib.version_compare(self.version, '< 3.8'):
+ self.link_args = 
+
 
 class PythonFrameworkDependency(ExtraFrameworkDependency, _PythonDependencyBase):
 
@@ -104,6 +153,13 @@
 else:
 self._find_libpy(installation, environment)
 
+ if not self.link_libpython:
+ # match pkg-config behavior
+ self.link_args = 
+
+ if not self.clib_compiler.has_header('Python.h', '', environment, extra_args=self.compile_args):
+ self.is_found = False
+
 def _find_libpy(self, python_holder: 'PythonInstallation', environment: 'Environment') -> None:
 if python_holder.is_pypy:
 if self.major_version == 3:
@@ -124,7 +180,7 @@
 if largs is not None:
 self.link_args = largs
 
- self.is_found = largs is not None or self.link_libpython
+ self.is_found = largs is not None or not self.link_libpython
 
 inc_paths = mesonlib.OrderedSet(
 self.variables.get('INCLUDEPY'),
@@ -145,7 +201,7 @@
 return None
 elif self.platform == 'win32':
 return '32'
- elif self.platform in ('win64', 'win-amd64'):
+ elif self.platform in {'win64', 'win-amd64'}:
 return '64'
 mlog.log(f'Unknown Windows Python platform {self.platform!r}')
 return None
@@ -153,12 +209,20 @@
 def _get_windows_link_args(self) -> T.OptionalT.Liststr:
 if self.platform.startswith('win'):
 vernum = self.variables.get('py_version_nodot')
+ verdot = self.variables.get('py_version_short')
+ imp_lower = self.variables.get('implementation_lower', 'python')
 if self.static:
 libpath = Path('libs') / f'libpython{vernum}.a'
 else:
 comp = self.get_compiler()
 if comp.id == "gcc":
- libpath = Path(f'python{vernum}.dll')
+ if imp_lower == 'pypy' and verdot == '3.8':
+ # The naming changed between 3.8 and 3.9
+ libpath = Path('libpypy3-c.dll')
+ elif imp_lower == 'pypy':
+ libpath = Path(f'libpypy{verdot}-c.dll')
+ else:
+ libpath = Path(f'python{vernum}.dll')
 else:
 libpath = Path('libs') / f'python{vernum}.lib'
 # base_prefix to allow for virtualenvs.
@@ -217,7 +281,8 @@
 self.compile_args += '-I' + path for path in inc_paths if path
 
 # https://sourceforge.net/p/mingw-w64/mailman/message/30504611/
- if pyarch == '64' and self.major_version == 2:
+ # https://github.com/python/cpython/pull/100137
+ if pyarch == '64' and mesonlib.version_compare(self.version, '<3.12'):
 self.compile_args += '-DMS_WIN64'
 
 self.is_found = True
@@ -240,12 +305,15 @@
 # If python-X.Y.pc exists in LIBPC, we will try to use it
 def wrap_in_pythons_pc_dir(name: str, env: 'Environment', kwargs: T.Dictstr, T.Any,
 installation: 'PythonInstallation') -> 'ExternalDependency':
+ if not pkg_libdir:
+ # there is no LIBPC, so we can't search in it
+ return NotFoundDependency('python', env)
+
 old_pkg_libdir = os.environ.pop('PKG_CONFIG_LIBDIR', None)
 old_pkg_path = os.environ.pop('PKG_CONFIG_PATH', None)
- if pkg_libdir:
- os.environ'PKG_CONFIG_LIBDIR' = pkg_libdir
+ os.environ'PKG_CONFIG_LIBDIR' = pkg_libdir
 try:
- return PythonPkgConfigDependency(name, env, kwargs, installation)
+ return PythonPkgConfigDependency(name, env, kwargs, installation, True)
 finally:
 def set_env(name, value):
 if value is not None:
@@ -255,10 +323,11 @@
 set_env('PKG_CONFIG_LIBDIR', old_pkg_libdir)
 set_env('PKG_CONFIG_PATH', old_pkg_path)
 
- candidates.extend(
- functools.partial(wrap_in_pythons_pc_dir, pkg_name, env, kwargs, installation),
- functools.partial(PythonPkgConfigDependency, pkg_name, env, kwargs, installation)
- )
+ candidates.append(functools.partial(wrap_in_pythons_pc_dir, pkg_name, env, kwargs, installation))
+ # We only need to check both, if a python install has a LIBPC. It might point to the wrong location,
+ # e.g. relocated / cross compilation, but the presence of LIBPC indicates we should definitely look for something.
+ if pkg_libdir is not None:
+ candidates.append(functools.partial(PythonPkgConfigDependency, pkg_name, env, kwargs, installation))
 
 if DependencyMethods.SYSTEM in methods:
 candidates.append(functools.partial(PythonSystemDependency, 'python', env, kwargs, installation))
@@ -322,29 +391,29 @@
 variables = sysconfig.get_config_vars()
 variables.update({'base_prefix': getattr(sys, 'base_prefix', sys.prefix)})
 
+if sys.version_info < (3, 0):
+ suffix = variables.get('SO')
+elif sys.version_info < (3, 8, 7):
+ # https://bugs.python.org/issue?@action=redirect&bpo=39825
+ from distutils.sysconfig import get_config_var
+ suffix = get_config_var('EXT_SUFFIX')
+else:
+ suffix = variables.get('EXT_SUFFIX')
+
 print(json.dumps({
 'variables': variables,
 'paths': paths,
+ 'sysconfig_paths': sysconfig.get_paths(),
 'install_paths': install_paths,
 'version': sysconfig.get_python_version(),
 'platform': sysconfig.get_platform(),
 'is_pypy': '__pypy__' in sys.builtin_module_names,
+ 'is_venv': sys.prefix != variables'base_prefix',
 'link_libpython': links_against_libpython(),
+ 'suffix': suffix,
 }))
 '''
 
-if T.TYPE_CHECKING:
- class PythonIntrospectionDict(TypedDict):
-
- install_paths: T.Dictstr, str
- is_pypy: bool
- link_libpython: bool
- paths: T.Dictstr, str
- platform: str
- suffix: str
- variables: T.Dictstr, str
- version: str
-
 
 class PythonExternalProgram(ExternalProgram):
 def __init__(self, name: str, command: T.OptionalT.Liststr = None,
@@ -363,12 +432,15 @@
 self.info: 'PythonIntrospectionDict' = {
 'install_paths': {},
 'is_pypy': False,
+ 'is_venv': False,
 'link_libpython': False,
+ 'sysconfig_paths': {},
 'paths': {},
 'platform': 'sentinal',
 'variables': {},
 'version': '0.0',
 }
+ self.pure: bool = True
 
 def _check_version(self, version: str) -> bool:
 if self.name == 'python2':
@@ -397,8 +469,6 @@
 mlog.debug(stderr)
 
 if info is not None and self._check_version(info'version'):
- variables = info'variables'
- info'suffix' = variables.get('EXT_SUFFIX') or variables.get('SO') or variables.get('.so')
 self.info = T.cast('PythonIntrospectionDict', info)
 self.platlib = self._get_path(state, 'platlib')
 self.purelib = self._get_path(state, 'purelib')
@@ -413,20 +483,27 @@
 return rel_path
 value = state.get_option(f'{key}dir', module='python')
 if value:
+ if state.is_user_defined_option('install_env', module='python'):
+ raise mesonlib.MesonException(f'python.{key}dir and python.install_env are mutually exclusive')
 return value
- return rel_path
 
+ install_env = state.get_option('install_env', module='python')
+ if install_env == 'auto':
+ install_env = 'venv' if self.info'is_venv' else 'system'
 
-_PURE_KW = KwargInfo('pure', bool, default=True)
-_SUBDIR_KW = KwargInfo('subdir', str, default='')
+ if install_env == 'system':
+ rel_path = os.path.join(self.info'variables''prefix', rel_path)
+ elif install_env == 'venv':
+ if not self.info'is_venv':
+ raise mesonlib.MesonException('python.install_env cannot be set to "venv" unless you are in a venv!')
+ # inside a venv, deb_system is *never* active hence info'paths' may be wrong
+ rel_path = self.info'sysconfig_paths'key
 
-if T.TYPE_CHECKING:
+ return rel_path
 
- class PyInstallKw(TypedDict):
 
- pure: bool
- subdir: str
- install_tag: T.Optionalstr
+_PURE_KW = KwargInfo('pure', (bool, NoneType))
+_SUBDIR_KW = KwargInfo('subdir', str, default='')
 
 
 class PythonInstallation(ExternalProgramHolder):
@@ -438,6 +515,7 @@
 self.variables = info'variables'
 self.suffix = info'suffix'
 self.paths = info'paths'
+ self.pure = python.pure
 self.platlib_install_path = os.path.join(prefix, python.platlib)
 self.purelib_install_path = os.path.join(prefix, python.purelib)
 self.version = info'version'
@@ -468,18 +546,19 @@
 if not isinstance(subdir, str):
 raise InvalidArguments('"subdir" argument must be a string.')
 
- kwargs'install_dir' = os.path.join(self.platlib_install_path, subdir)
+ kwargs'install_dir' = self._get_install_dir_impl(False, subdir)
 
- # On macOS and some Linux distros (Debian) distutils doesn't link
- # extensions against libpython. We call into distutils and mirror its
- # behavior. See https://github.com/mesonbuild/meson/issues/4117
- if not self.link_libpython:
- new_deps = 
- for dep in mesonlib.extract_as_list(kwargs, 'dependencies'):
- if isinstance(dep, _PythonDependencyBase):
- dep = dep.get_partial_dependency(compile_args=True)
- new_deps.append(dep)
- kwargs'dependencies' = new_deps
+ new_deps = mesonlib.extract_as_list(kwargs, 'dependencies')
+ has_pydep = any(isinstance(dep, _PythonDependencyBase) for dep in new_deps)
+ if not has_pydep:
+ pydep = self._dependency_method_impl({})
+ if not pydep.found():
+ raise mesonlib.MesonException('Python dependency not found')
+ new_deps.append(pydep)
+ FeatureNew.single_use('python_installation.extension_module with implicit dependency on python',
+ '0.63.0', self.subproject, 'use python_installation.dependency()',
+ self.current_node)
+ kwargs'dependencies' = new_deps
 
 # msys2's python3 has "-cpython-36m.dll", we have to be clever
 # FIXME: explain what the specific cleverness is here
@@ -489,57 +568,83 @@
 kwargs'name_prefix' = ''
 kwargs'name_suffix' = suffix
 
+ if 'gnu_symbol_visibility' not in kwargs and \
+ (self.is_pypy or mesonlib.version_compare(self.version, '>=3.9')):
+ kwargs'gnu_symbol_visibility' = 'inlineshidden'
+
 return self.interpreter.func_shared_module(None, args, kwargs)
 
+ def _dependency_method_impl(self, kwargs: TYPE_kwargs) -> Dependency:
+ for_machine = self.interpreter.machine_from_native_kwarg(kwargs)
+ identifier = get_dep_identifier(self._full_path(), kwargs)
+
+ dep = self.interpreter.coredata.depsfor_machine.get(identifier)
+ if dep is not None:
+ return dep
+
+ new_kwargs = kwargs.copy()
+ new_kwargs'required' = False
+ methods = process_method_kw({DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM}, kwargs)
+ # it's theoretically (though not practically) possible to not bind dep, let's ensure it is.
+ dep: Dependency = NotFoundDependency('python', self.interpreter.environment)
+ for d in python_factory(self.interpreter.environment, for_machine, new_kwargs, methods, self):
+ dep = d()
+ if dep.found():
+ break
+
+ self.interpreter.coredata.depsfor_machine.put(identifier, dep)
+ return dep
+
 @disablerIfNotFound
 @permittedKwargs(permitted_dependency_kwargs | {'embed'})
 @FeatureNewKwargs('python_installation.dependency', '0.53.0', 'embed')
 @noPosargs
 def dependency_method(self, args: T.List'TYPE_var', kwargs: 'TYPE_kwargs') -> 'Dependency':
 disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
- # it's theoretically (though not practically) possible for the else clse
- # to not bind dep, let's ensure it is.
- dep: 'Dependency' = NotFoundDependency('python', self.interpreter.environment)
 if disabled:
 mlog.log('Dependency', mlog.bold('python'), 'skipped: feature', mlog.bold(feature), 'disabled')
+ return NotFoundDependency('python', self.interpreter.environment)
 else:
- new_kwargs = kwargs.copy()
- new_kwargs'required' = False
- methods = process_method_kw({DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM}, kwargs)
- for d in python_factory(self.interpreter.environment,
- MachineChoice.BUILD if kwargs.get('native', False) else MachineChoice.HOST,
- new_kwargs, methods, self):
- dep = d()
- if dep.found():
- break
+ dep = self._dependency_method_impl(kwargs)
 if required and not dep.found():
 raise mesonlib.MesonException('Python dependency not found')
-
- return dep
+ return dep
 
 @typed_pos_args('install_data', varargs=(str, mesonlib.File))
- @typed_kwargs('python_installation.install_sources', _PURE_KW, _SUBDIR_KW,
- KwargInfo('install_tag', (str, NoneType), since='0.60.0'))
+ @typed_kwargs(
+ 'python_installation.install_sources',
+ _PURE_KW,
+ _SUBDIR_KW,
+ PRESERVE_PATH_KW,
+ KwargInfo('install_tag', (str, NoneType), since='0.60.0')
+ )
 def install_sources_method(self, args: T.TupleT.ListT.Unionstr, mesonlib.File,
 kwargs: 'PyInstallKw') -> 'Data':
- tag = kwargs'install_tag' or 'runtime'
+ tag = kwargs'install_tag' or 'python-runtime'
+ pure = kwargs'pure' if kwargs'pure' is not None else self.pure
+ install_dir = self._get_install_dir_impl(pure, kwargs'subdir')
 return self.interpreter.install_data_impl(
 self.interpreter.source_strings_to_files(args0),
- self._get_install_dir_impl(kwargs'pure', kwargs'subdir'),
+ install_dir,
 mesonlib.FileMode(), rename=None, tag=tag, install_data_type='python',
- install_dir_name=self._get_install_dir_name_impl(kwargs'pure', kwargs'subdir'))
+ install_dir_name=install_dir.optname,
+ preserve_path=kwargs'preserve_path')
 
 @noPosargs
 @typed_kwargs('python_installation.install_dir', _PURE_KW, _SUBDIR_KW)
 def get_install_dir_method(self, args: T.List'TYPE_var', kwargs: 'PyInstallKw') -> str:
- return self._get_install_dir_impl(kwargs'pure', kwargs'subdir')
+ pure = kwargs'pure' if kwargs'pure' is not None else self.pure
+ return self._get_install_dir_impl(pure, kwargs'subdir')
 
- def _get_install_dir_impl(self, pure: bool, subdir: str) -> str:
- return os.path.join(
- self.purelib_install_path if pure else self.platlib_install_path, subdir)
+ def _get_install_dir_impl(self, pure: bool, subdir: str) -> P_OBJ.OptionString:
+ if pure:
+ base = self.purelib_install_path
+ name = '{py_purelib}'
+ else:
+ base = self.platlib_install_path
+ name = '{py_platlib}'
 
- def _get_install_dir_name_impl(self, pure: bool, subdir: str) -> str:
- return os.path.join('{py_purelib}' if pure else '{py_platlib}', subdir)
+ return P_OBJ.OptionString(os.path.join(base, subdir), os.path.join(name, subdir))
 
 @noPosargs
 @noKwargs
@@ -585,20 +690,13 @@
 return super().path_method(args, kwargs)
 
 
-if T.TYPE_CHECKING:
- from ..interpreter.kwargs import ExtractRequired
-
- class FindInstallationKw(ExtractRequired):
-
- disabler: bool
- modules: T.Liststr
-
-
 class PythonModule(ExtensionModule):
 
- @FeatureNew('Python Module', '0.46.0')
+ INFO = ModuleInfo('python', '0.46.0')
+
 def __init__(self, interpreter: 'Interpreter') -> None:
 super().__init__(interpreter)
+ self.installations: T.Dictstr, ExternalProgram = {}
 self.methods.update({
 'find_installation': self.find_installation,
 })
@@ -620,6 +718,38 @@
 else:
 return None
 
+ def _find_installation_impl(self, state: 'ModuleState', display_name: str, name_or_path: str, required: bool) -> ExternalProgram:
+ if not name_or_path:
+ python = PythonExternalProgram('python3', mesonlib.python_command)
+ else:
+ tmp_python = ExternalProgram.from_entry(display_name, name_or_path)
+ python = PythonExternalProgram(display_name, ext_prog=tmp_python)
+
+ if not python.found() and mesonlib.is_windows():
+ pythonpath = self._get_win_pythonpath(name_or_path)
+ if pythonpath is not None:
+ name_or_path = pythonpath
+ python = PythonExternalProgram(name_or_path)
+
+ # Last ditch effort, python2 or python3 can be named python
+ # on various platforms, let's not give up just yet, if an executable
+ # named python is available and has a compatible version, let's use
+ # it
+ if not python.found() and name_or_path in {'python2', 'python3'}:
+ python = PythonExternalProgram('python')
+
+ if python.found():
+ if python.sanity(state):
+ return python
+ else:
+ sanitymsg = f'{python} is not a valid python or it is missing distutils'
+ if required:
+ raise mesonlib.MesonException(sanitymsg)
+ else:
+ mlog.warning(sanitymsg, location=state.current_node)
+
+ return NonExistingExternalProgram()
+
 @disablerIfNotFound
 @typed_pos_args('python.find_installation', optargs=str)
 @typed_kwargs(
@@ -627,14 +757,12 @@
 KwargInfo('required', (bool, UserFeatureOption), default=True),
 KwargInfo('disabler', bool, default=False, since='0.49.0'),
 KwargInfo('modules', ContainerTypeInfo(list, str), listify=True, default=, since='0.51.0'),
+ _PURE_KW.evolve(default=True, since='0.64.0'),
 )
 def find_installation(self, state: 'ModuleState', args: T.TupleT.Optionalstr,
 kwargs: 'FindInstallationKw') -> ExternalProgram:
 feature_check = FeatureNew('Passing "feature" option to find_installation', '0.48.0')
 disabled, required, feature = extract_required_kwarg(kwargs, state.subproject, feature_check)
- want_modules = kwargs'modules'
- found_modules: T.Liststr = 
- missing_modules: T.Liststr = 
 
 # FIXME: this code is *full* of sharp corners. It assumes that it's
 # going to get a string value (or now a list of length 1), of `python2`
@@ -653,25 +781,14 @@
 mlog.log('Program', name_or_path or 'python', 'found:', mlog.red('NO'), '(disabled by:', mlog.bold(feature), ')')
 return NonExistingExternalProgram()
 
- if not name_or_path:
- python = PythonExternalProgram('python3', mesonlib.python_command)
- else:
- tmp_python = ExternalProgram.from_entry(display_name, name_or_path)
- python = PythonExternalProgram(display_name, ext_prog=tmp_python)
-
- if not python.found() and mesonlib.is_windows():
- pythonpath = self._get_win_pythonpath(name_or_path)
- if pythonpath is not None:
- name_or_path = pythonpath
- python = PythonExternalProgram(name_or_path)
-
- # Last ditch effort, python2 or python3 can be named python
- # on various platforms, let's not give up just yet, if an executable
- # named python is available and has a compatible version, let's use
- # it
- if not python.found() and name_or_path in 'python2', 'python3':
- python = PythonExternalProgram('python')
+ python = self.installations.get(name_or_path)
+ if not python:
+ python = self._find_installation_impl(state, display_name, name_or_path, required)
+ self.installationsname_or_path = python
 
+ want_modules = kwargs'modules'
+ found_modules: T.Liststr = 
+ missing_modules: T.Liststr = 
 if python.found() and want_modules:
 for mod in want_modules:
 p, *_ = mesonlib.Popen_safe(
@@ -705,14 +822,9 @@
 raise mesonlib.MesonException('{} is missing modules: {}'.format(name_or_path or 'python', ', '.join(missing_modules)))
 return NonExistingExternalProgram()
 else:
- sane = python.sanity(state)
-
- if sane:
- return python
- else:
- if required:
- raise mesonlib.MesonException(f'{python} is not a valid python or it is missing distutils')
- return NonExistingExternalProgram()
+ python = copy.copy(python)
+ python.pure = kwargs'pure'
+ return python
 
 raise mesonlib.MesonBugException('Unreachable code was reached (PythonModule.find_installation).')

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/python3.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/python3.py Changed

@@ -11,19 +11,21 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import sysconfig
 from .. import mesonlib
 
-from . import ExtensionModule
-from ..interpreterbase import noKwargs, permittedKwargs, FeatureDeprecated, FeatureNew
+from . import ExtensionModule, ModuleInfo
+from ..interpreterbase import typed_pos_args, noPosargs, noKwargs, permittedKwargs
 from ..build import known_shmod_kwargs
 from ..programs import ExternalProgram
 
 
 class Python3Module(ExtensionModule):
-    @FeatureNew('python3 module', '0.38.0')
-    @FeatureDeprecated('python3 module', '0.48.0')
+
+    INFO = ModuleInfo('python3', '0.38.0', deprecated='0.48.0')
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.methods.update({
@@ -52,6 +54,7 @@
         kwargs'name_suffix' = suffix
         return self.interpreter.func_shared_module(None, args, kwargs)
 
+    @noPosargs
     @noKwargs
     def find_python(self, state, args, kwargs):
         command = state.environment.lookup_binary_entry(mesonlib.MachineChoice.HOST, 'python3')
@@ -61,14 +64,14 @@
             py3 = ExternalProgram('python3', mesonlib.python_command, silent=True)
         return py3
 
+    @noPosargs
     @noKwargs
     def language_version(self, state, args, kwargs):
         return sysconfig.get_python_version()
 
     @noKwargs
+    @typed_pos_args('python3.sysconfig_path', str)
     def sysconfig_path(self, state, args, kwargs):
-        if len(args) != 1:
-            raise mesonlib.MesonException('sysconfig_path() requires passing the name of path to get.')
         path_name = args0
         valid_names = sysconfig.get_path_names()
         if path_name not in valid_names:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/qt.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/qt.py Changed

@@ -12,6 +12,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import os
 import shutil
@@ -23,17 +24,19 @@
 from .. import coredata
 from .. import mlog
 from ..dependencies import find_external_dependency, Dependency, ExternalLibrary
-from ..mesonlib import MesonException, File, FileOrString, version_compare, Popen_safe
+from ..mesonlib import MesonException, File, version_compare, Popen_safe
 from ..interpreter import extract_required_kwarg
-from ..interpreter.type_checking import NoneType
+from ..interpreter.type_checking import INSTALL_DIR_KW, INSTALL_KW, NoneType
 from ..interpreterbase import ContainerTypeInfo, FeatureDeprecated, KwargInfo, noPosargs, FeatureNew, typed_kwargs
-from ..programs import ExternalProgram, NonExistingExternalProgram
+from ..programs import NonExistingExternalProgram
 
 if T.TYPE_CHECKING:
 from . import ModuleState
 from ..dependencies.qt import QtPkgConfigDependency, QmakeQtDependency
 from ..interpreter import Interpreter
 from ..interpreter import kwargs
+ from ..mesonlib import FileOrString
+ from ..programs import ExternalProgram
 
 QtDependencyType = T.UnionQtPkgConfigDependency, QmakeQtDependency
 
@@ -103,6 +106,8 @@
 def __init__(self, interpreter: 'Interpreter', qt_version: int = 5):
 ExtensionModule.__init__(self, interpreter)
 self.qt_version = qt_version
+ # It is important that this list does not change order as the order of
+ # the returned ExternalPrograms will change as well
 self.tools: T.Dictstr, ExternalProgram = {
 'moc': NonExistingExternalProgram('moc'),
 'uic': NonExistingExternalProgram('uic'),
@@ -120,8 +125,6 @@
 
 def compilers_detect(self, state: 'ModuleState', qt_dep: 'QtDependencyType') -> None:
 """Detect Qt (4 or 5) moc, uic, rcc in the specified bindir or in PATH"""
- # It is important that this list does not change order as the order of
- # the returned ExternalPrograms will change as well
 wanted = f'== {qt_dep.version}'
 
 def gen_bins() -> T.GeneratorT.Tuplestr, str, None, None:
@@ -151,11 +154,11 @@
 # Ensure that the version of qt and each tool are the same
 def get_version(p: ExternalProgram) -> str:
 _, out, err = Popen_safe(p.get_command() + arg)
- if b.startswith('lrelease') or not qt_dep.version.startswith('4'):
+ if name == 'lrelease' or not qt_dep.version.startswith('4'):
 care = out
 else:
 care = err
- return care.split(' ')-1.replace(')', '').strip()
+ return care.rsplit(' ', maxsplit=1)-1.replace(')', '').strip()
 
 p = state.find_program(b, required=False,
 version_func=get_version,
@@ -195,12 +198,11 @@
 abspath: str
 if isinstance(rcc_file, str):
 abspath = os.path.join(state.environment.source_dir, state.subdir, rcc_file)
- rcc_dirname = os.path.dirname(abspath)
 else:
 abspath = rcc_file.absolute_path(state.environment.source_dir, state.environment.build_dir)
- rcc_dirname = os.path.dirname(abspath)
+ rcc_dirname = os.path.dirname(abspath)
 
- # FIXME: what error are we actually trying to check here?
+ # FIXME: what error are we actually trying to check here? (probably parse errors?)
 try:
 tree = ET.parse(abspath)
 root = tree.getroot()
@@ -209,10 +211,14 @@
 if child.tag != 'file':
 mlog.warning("malformed rcc file: ", os.path.join(state.subdir, str(rcc_file)))
 break
+ elif child.text is None:
+ raise MesonException(f'<file> element without a path in {os.path.join(state.subdir, str(rcc_file))}')
 else:
 result.append(child.text)
 
 return rcc_dirname, result
+ except MesonException:
+ raise
 except Exception:
 raise MesonException(f'Unable to parse resource file {abspath}')
 
@@ -332,14 +338,17 @@
 for s in sources:
 qrc_deps.extend(self._parse_qrc_deps(state, s))
 
- rcc_kwargs: T.Dictstr, T.Any = { # TODO: if CustomTarget had typing information we could use that here...
- 'input': sources,
- 'output': name + '.cpp',
- 'command': self.tools'rcc'.get_command() + '-name', name, '-o', '@OUTPUT@' + extra_args + '@INPUT@' + DEPFILE_ARGS,
- 'depend_files': qrc_deps,
- 'depfile': f'{name}.d',
- }
- res_target = build.CustomTarget(name, state.subdir, state.subproject, rcc_kwargs)
+ res_target = build.CustomTarget(
+ name,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ self.tools'rcc'.get_command() + '-name', name, '-o', '@OUTPUT@' + extra_args + '@INPUT@' + DEPFILE_ARGS,
+ sources,
+ f'{name}.cpp',
+ depend_files=qrc_deps,
+ depfile=f'{name}.d',
+ )
 targets.append(res_target)
 else:
 for rcc_file in sources:
@@ -349,14 +358,17 @@
 else:
 basename = os.path.basename(rcc_file.fname)
 name = f'qt{self.qt_version}-{basename.replace(".", "_")}'
- rcc_kwargs = {
- 'input': rcc_file,
- 'output': f'{name}.cpp',
- 'command': self.tools'rcc'.get_command() + '-name', '@BASENAME@', '-o', '@OUTPUT@' + extra_args + '@INPUT@' + DEPFILE_ARGS,
- 'depend_files': qrc_deps,
- 'depfile': f'{name}.d',
- }
- res_target = build.CustomTarget(name, state.subdir, state.subproject, rcc_kwargs)
+ res_target = build.CustomTarget(
+ name,
+ state.subdir,
+ state.subproject,
+ state.environment,
+ self.tools'rcc'.get_command() + '-name', '@BASENAME@', '-o', '@OUTPUT@' + extra_args + '@INPUT@' + DEPFILE_ARGS,
+ rcc_file,
+ f'{name}.cpp',
+ depend_files=qrc_deps,
+ depfile=f'{name}.d',
+ )
 targets.append(res_target)
 
 return targets
@@ -486,7 +498,7 @@
 if _sources:
 FeatureDeprecated.single_use('qt.preprocess positional sources', '0.59', state.subproject, location=state.current_node)
 # List is invariant, os we have to cast...
- sources = T.cast(T.ListT.Unionstr, File, build.GeneratedList, build.CustomTarget,
+ sources = T.cast('T.ListT.Unionstr, File, build.GeneratedList, build.CustomTarget',
 _sources + kwargs'sources')
 for s in sources:
 if not isinstance(s, (str, File)):
@@ -525,8 +537,8 @@
 @typed_kwargs(
 'qt.compile_translations',
 KwargInfo('build_by_default', bool, default=False),
- KwargInfo('install', bool, default=False),
- KwargInfo('install_dir', (str, NoneType)),
+ INSTALL_KW,
+ INSTALL_DIR_KW,
 KwargInfo('method', str, default='auto'),
 KwargInfo('qresource', (str, NoneType), since='0.56.0'),
 KwargInfo('rcc_extra_arguments', ContainerTypeInfo(list, str), listify=True, default=, since='0.56.0'),
@@ -537,7 +549,8 @@
 if any(isinstance(s, (build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)) for s in ts_files):
 FeatureNew.single_use('qt.compile_translations: custom_target or generator for "ts_files" keyword argument',
 '0.60.0', state.subproject, location=state.current_node)
- install_dir = kwargs'install_dir'
+ if kwargs'install' and not kwargs'install_dir':
+ raise MesonException('qt.compile_translations: "install_dir" keyword argument must be set when "install" is true.')
 qresource = kwargs'qresource'
 if qresource:
 if ts_files:
@@ -574,16 +587,20 @@
 ts = os.path.basename(ts)
 else:
 outdir = state.subdir
- cmd = self.tools'lrelease', '@INPUT@', '-qm', '@OUTPUT@'
- lrelease_kwargs: T.Dictstr, T.Any = {
- 'output': '@BASENAME@.qm',
- 'input': ts,
- 'install': kwargs'install',
- 'install_dir': install_dir or ,
- 'install_tag': 'i18n',
- 'build_by_default': kwargs'build_by_default',
- 'command': cmd}
- lrelease_target = build.CustomTarget(f'qt{self.qt_version}-compile-{ts}', outdir, state.subproject, lrelease_kwargs)
+ cmd: T.ListT.UnionExternalProgram, str = self.tools'lrelease', '@INPUT@', '-qm', '@OUTPUT@'
+ lrelease_target = build.CustomTarget(
+ f'qt{self.qt_version}-compile-{ts}',
+ outdir,
+ state.subproject,
+ state.environment,
+ cmd,
+ ts,
+ '@BASENAME@.qm',
+ install=kwargs'install',
+ install_dir=kwargs'install_dir',
+ install_tag='i18n',
+ build_by_default=kwargs'build_by_default',
+ )
 translations.append(lrelease_target)
 if qresource:
 return ModuleReturnValue(results.return_value0, results.new_objects, translations)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/qt4.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/qt4.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/qt5.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/qt5.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/qt6.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/qt6.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/rust.py Added

@@ -0,0 +1,250 @@
+# Copyright © 2020-2022 Intel Corporation
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+import os
+import typing as T
+
+from . import ExtensionModule, ModuleReturnValue, ModuleInfo
+from .. import mlog
+from ..build import BothLibraries, BuildTarget, CustomTargetIndex, Executable, ExtractedObjects, GeneratedList, IncludeDirs, CustomTarget, StructuredSources
+from ..dependencies import Dependency, ExternalLibrary
+from ..interpreter.type_checking import DEPENDENCIES_KW, TEST_KWS, OUTPUT_KW, INCLUDE_DIRECTORIES, include_dir_string_new
+from ..interpreterbase import ContainerTypeInfo, InterpreterException, KwargInfo, typed_kwargs, typed_pos_args, noPosargs
+from ..mesonlib import File
+
+if T.TYPE_CHECKING:
+    from . import ModuleState
+    from ..interpreter import Interpreter
+    from ..interpreter import kwargs as _kwargs
+    from ..interpreter.interpreter import SourceInputs, SourceOutputs
+    from ..programs import ExternalProgram
+
+    from typing_extensions import TypedDict
+
+    class FuncTest(_kwargs.BaseTest):
+
+        dependencies: T.ListT.UnionDependency, ExternalLibrary
+        is_parallel: bool
+
+    class FuncBindgen(TypedDict):
+
+        args: T.Liststr
+        c_args: T.Liststr
+        include_directories: T.ListIncludeDirs
+        input: T.ListSourceInputs
+        output: str
+        dependencies: T.ListT.UnionDependency, ExternalLibrary
+
+
+class RustModule(ExtensionModule):
+
+    """A module that holds helper functions for rust."""
+
+    INFO = ModuleInfo('rust', '0.57.0', stabilized='1.0.0')
+
+    def __init__(self, interpreter: Interpreter) -> None:
+        super().__init__(interpreter)
+        self._bindgen_bin: T.OptionalExternalProgram = None
+        self.methods.update({
+            'test': self.test,
+            'bindgen': self.bindgen,
+        })
+
+    @typed_pos_args('rust.test', str, BuildTarget)
+    @typed_kwargs(
+        'rust.test',
+        *TEST_KWS,
+        DEPENDENCIES_KW,
+        KwargInfo('is_parallel', bool, default=False),
+    )
+    def test(self, state: ModuleState, args: T.Tuplestr, BuildTarget, kwargs: FuncTest) -> ModuleReturnValue:
+        """Generate a rust test target from a given rust target.
+
+        Rust puts it's unitests inside it's main source files, unlike most
+        languages that put them in external files. This means that normally
+        you have to define two separate targets with basically the same
+        arguments to get tests:
+
+        ```meson
+        rust_lib_sources = ...
+        rust_lib = static_library(
+            'rust_lib',
+            rust_lib_sources,
+        )
+
+        rust_lib_test = executable(
+            'rust_lib_test',
+            rust_lib_sources,
+            rust_args : '--test',
+        )
+
+        test(
+            'rust_lib_test',
+            rust_lib_test,
+            protocol : 'rust',
+        )
+        ```
+
+        This is all fine, but not very DRY. This method makes it much easier
+        to define rust tests:
+
+        ```meson
+        rust = import('unstable-rust')
+
+        rust_lib = static_library(
+            'rust_lib',
+            sources,
+        )
+
+        rust.test('rust_lib_test', rust_lib)
+        ```
+        """
+        name = args0
+        base_target: BuildTarget = args1
+        if not base_target.uses_rust():
+            raise InterpreterException('Second positional argument to rustmod.test() must be a rust based target')
+        extra_args = kwargs'args'
+
+        # Delete any arguments we don't want passed
+        if '--test' in extra_args:
+            mlog.warning('Do not add --test to rustmod.test arguments')
+            extra_args.remove('--test')
+        if '--format' in extra_args:
+            mlog.warning('Do not add --format to rustmod.test arguments')
+            i = extra_args.index('--format')
+            # Also delete the argument to --format
+            del extra_argsi + 1
+            del extra_argsi
+        for i, a in enumerate(extra_args):
+            if isinstance(a, str) and a.startswith('--format='):
+                del extra_argsi
+                break
+
+        # We need to cast here, as currently these don't have protocol in them, but test itself does.
+        tkwargs = T.cast('_kwargs.FuncTest', kwargs.copy())
+
+        tkwargs'args' = extra_args + '--test', '--format', 'pretty'
+        tkwargs'protocol' = 'rust'
+
+        new_target_kwargs = base_target.kwargs.copy()
+        # Don't mutate the shallow copied list, instead replace it with a new
+        # one
+        new_target_kwargs'rust_args' = new_target_kwargs.get('rust_args', ) + '--test'
+        new_target_kwargs'install' = False
+        new_target_kwargs'dependencies' = new_target_kwargs.get('dependencies', ) + kwargs'dependencies'
+
+        sources = T.cast('T.ListSourceOutputs', base_target.sources.copy())
+        sources.extend(base_target.generated)
+
+        new_target = Executable(
+            name, base_target.subdir, state.subproject, base_target.for_machine,
+            sources, base_target.structured_sources,
+            base_target.objects, base_target.environment, base_target.compilers,
+            new_target_kwargs
+        )
+
+        test = self.interpreter.make_test(
+            self.interpreter.current_node, (name, new_target), tkwargs)
+
+        return ModuleReturnValue(None, new_target, test)
+
+    @noPosargs
+    @typed_kwargs(
+        'rust.bindgen',
+        KwargInfo('c_args', ContainerTypeInfo(list, str), default=, listify=True),
+        KwargInfo('args', ContainerTypeInfo(list, str), default=, listify=True),
+        KwargInfo(
+            'input',
+            ContainerTypeInfo(list, (File, GeneratedList, BuildTarget, BothLibraries, ExtractedObjects, CustomTargetIndex, CustomTarget, str), allow_empty=False),
+            default=,
+            listify=True,
+            required=True,
+        ),
+        INCLUDE_DIRECTORIES.evolve(feature_validator=include_dir_string_new),
+        OUTPUT_KW,
+        DEPENDENCIES_KW.evolve(since='1.0.0'),
+    )
+    def bindgen(self, state: ModuleState, args: T.List, kwargs: FuncBindgen) -> ModuleReturnValue:
+        """Wrapper around bindgen to simplify it's use.
+
+        The main thing this simplifies is the use of `include_directory`
+        objects, instead of having to pass a plethora of `-I` arguments.
+        """
+        header, *_deps = self.interpreter.source_strings_to_files(kwargs'input')
+
+        # Split File and Target dependencies to add pass to CustomTarget
+        depends: T.ListSourceOutputs = 
+        depend_files: T.ListFile = 
+        for d in _deps:
+            if isinstance(d, File):
+                depend_files.append(d)
+            else:
+                depends.append(d)
+
+        clang_args: T.Liststr = 
+        for i in state.process_include_dirs(kwargs'include_directories'):
+            # bindgen always uses clang, so it's safe to hardcode -I here
+            clang_args.extend(f'-I{x}' for x in i.to_string_list(
+                state.environment.get_source_dir(), state.environment.get_build_dir()))
+
+        for de in kwargs'dependencies':
+            for i in de.get_include_dirs():
+                clang_args.extend(f'-I{x}' for x in i.to_string_list(
+                    state.environment.get_source_dir(), state.environment.get_build_dir()))
+            clang_args.extend(de.get_all_compile_args())
+            for s in de.get_sources():
+                if isinstance(s, File):
+                    depend_files.append(s)
+                elif isinstance(s, CustomTarget):
+                    depends.append(s)
+
+        if self._bindgen_bin is None:
+            self._bindgen_bin = state.find_program('bindgen')
+
+        name: str
+        if isinstance(header, File):
+            name = header.fname
+        elif isinstance(header, (BuildTarget, BothLibraries, ExtractedObjects, StructuredSources)):
+            raise InterpreterException('bindgen source file must be a C header, not an object or build target')
+        else:
+            name = header.get_outputs()0
+
+        cmd = self._bindgen_bin.get_command() + \
+            
+                '@INPUT@', '--output',
+                os.path.join(state.environment.build_dir, '@OUTPUT@')
+             + \
+            kwargs'args' + '--' + kwargs'c_args' + clang_args + \
+            '-MD', '-MQ', '@INPUT@', '-MF', '@DEPFILE@'
+
+        target = CustomTarget(
+            f'rustmod-bindgen-{name}'.replace('/', '_'),
+            state.subdir,
+            state.subproject,
+            state.environment,
+            cmd,
+            header,
+            kwargs'output',
+            depfile='@PLAINNAME@.d',
+            extra_depends=depends,
+            depend_files=depend_files,
+            backend=state.backend,
+        )
+
+        return ModuleReturnValue(target, target)
+
+
+def initialize(interp: Interpreter) -> RustModule:
+    return RustModule(interp)

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/simd.py Added

@@ -0,0 +1,88 @@
+# Copyright 2017 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from .. import mesonlib, compilers, mlog
+from .. import build
+
+from . import ExtensionModule, ModuleInfo
+
+class SimdModule(ExtensionModule):
+
+    INFO = ModuleInfo('SIMD', '0.42.0', unstable=True)
+
+    def __init__(self, interpreter):
+        super().__init__(interpreter)
+        # FIXME add Altivec and AVX512.
+        self.isets = ('mmx',
+                      'sse',
+                      'sse2',
+                      'sse3',
+                      'ssse3',
+                      'sse41',
+                      'sse42',
+                      'avx',
+                      'avx2',
+                      'neon',
+                      )
+        self.methods.update({
+            'check': self.check,
+        })
+
+    def check(self, state, args, kwargs):
+        result = 
+        if len(args) != 1:
+            raise mesonlib.MesonException('Check requires one argument, a name prefix for checks.')
+        prefix = args0
+        if not isinstance(prefix, str):
+            raise mesonlib.MesonException('Argument must be a string.')
+        if 'compiler' not in kwargs:
+            raise mesonlib.MesonException('Must specify compiler keyword')
+        if 'sources' in kwargs:
+            raise mesonlib.MesonException('SIMD module does not support the "sources" keyword')
+        basic_kwargs = {}
+        for key, value in kwargs.items():
+            if key not in self.isets and key != 'compiler':
+                basic_kwargskey = value
+        compiler = kwargs'compiler'
+        if not isinstance(compiler, compilers.compilers.Compiler):
+            raise mesonlib.MesonException('Compiler argument must be a compiler object.')
+        conf = build.ConfigurationData()
+        for iset in self.isets:
+            if iset not in kwargs:
+                continue
+            iset_fname = kwargsiset # Might also be an array or Files. static_library will validate.
+            args = compiler.get_instruction_set_args(iset)
+            if args is None:
+                mlog.log('Compiler supports %s:' % iset, mlog.red('NO'))
+                continue
+            if args:
+                if not compiler.has_multi_arguments(args, state.environment)0:
+                    mlog.log('Compiler supports %s:' % iset, mlog.red('NO'))
+                    continue
+            mlog.log('Compiler supports %s:' % iset, mlog.green('YES'))
+            conf.values'HAVE_' + iset.upper() = ('1', 'Compiler supports %s.' % iset)
+            libname = prefix + '_' + iset
+            lib_kwargs = {'sources': iset_fname,
+                          }
+            lib_kwargs.update(basic_kwargs)
+            langarg_key = compiler.get_language() + '_args'
+            old_lang_args = mesonlib.extract_as_list(lib_kwargs, langarg_key)
+            all_lang_args = old_lang_args + args
+            lib_kwargslangarg_key = all_lang_args
+            result.append(self.interpreter.func_static_lib(None, libname, lib_kwargs))
+        return result, conf
+
+def initialize(*args, **kwargs):
+    return SimdModule(*args, **kwargs)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/sourceset.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/sourceset.py Changed

@@ -12,23 +12,89 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from collections import namedtuple
-from .. import mesonlib
+from __future__ import annotations
+import typing as T
+
+from . import ExtensionModule, ModuleObject, MutableModuleObject, ModuleInfo
 from .. import build
-from ..mesonlib import listify, OrderedSet
-from . import ExtensionModule, ModuleObject, MutableModuleObject
+from .. import dependencies
+from .. import mesonlib
 from ..interpreterbase import (
-    noPosargs, noKwargs, permittedKwargs,
+    noPosargs, noKwargs,
     InterpreterException, InvalidArguments, InvalidCode, FeatureNew,
 )
+from ..interpreterbase.decorators import ContainerTypeInfo, KwargInfo, typed_kwargs, typed_pos_args
+from ..mesonlib import OrderedSet
+
+if T.TYPE_CHECKING:
+    from typing_extensions import TypedDict
+
+    from . import ModuleState
+    from ..interpreter import Interpreter
+    from ..interpreterbase import TYPE_var, TYPE_kwargs
+
+    class AddKwargs(TypedDict):
+
+        when: T.ListT.Unionstr, dependencies.Dependency
+        if_true: T.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes, dependencies.Dependency
+        if_false: T.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes
+
+    class AddAllKw(TypedDict):
+
+        when: T.ListT.Unionstr, dependencies.Dependency
+        if_true: T.ListSourceSetImpl
+
+    class ApplyKw(TypedDict):
+
+        strict: bool
+
+
+_WHEN_KW: KwargInfoT.ListT.Unionstr, dependencies.Dependency = KwargInfo(
+    'when',
+    ContainerTypeInfo(list, (str, dependencies.Dependency)),
+    listify=True,
+    default=,
+)
+
+
+class SourceSetRule(T.NamedTuple):
+    keys: T.Liststr
+    """Configuration keys that enable this rule if true"""
+
+    deps: T.Listdependencies.Dependency
+    """Dependencies that enable this rule if true"""
 
-SourceSetRule = namedtuple('SourceSetRule', 'keys sources if_false sourcesets dependencies extra_deps')
-SourceFiles = namedtuple('SourceFiles', 'sources dependencies')
+    sources: T.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes
+    """Source files added when this rule's conditions are true"""
 
-class SourceSet(MutableModuleObject):
-    def __init__(self, interpreter):
+    extra_deps: T.Listdependencies.Dependency
+    """Dependencies added when this rule's conditions are true, but
+       that do not make the condition false if they're absent."""
+
+    sourcesets: T.ListSourceSetImpl
+    """Other sourcesets added when this rule's conditions are true"""
+
+    if_false: T.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes
+    """Source files added when this rule's conditions are false"""
+
+
+class SourceFiles(T.NamedTuple):
+    sources: OrderedSetT.Unionmesonlib.FileOrString, build.GeneratedTypes
+    deps: OrderedSetdependencies.Dependency
+
+
+class SourceSet:
+    """Base class to avoid circular references.
+
+    Because of error messages, this class is called SourceSet, and the actual
+    implementation is an Impl.
+    """
+
+
+class SourceSetImpl(SourceSet, MutableModuleObject):
+    def __init__(self, interpreter: Interpreter):
         super().__init__()
-        self.rules = 
+        self.rules: T.ListSourceSetRule = 
         self.subproject = interpreter.subproject
         self.environment = interpreter.environment
         self.subdir = interpreter.subdir
@@ -41,79 +107,112 @@
             'apply': self.apply_method,
         })
 
-    def check_source_files(self, arg, allow_deps):
-        sources = 
-        deps = 
-        for x in arg:
-            if isinstance(x, (str, mesonlib.File,
-                              build.GeneratedList, build.CustomTarget,
-                              build.CustomTargetIndex)):
-                sources.append(x)
-            elif hasattr(x, 'found'):
-                if not allow_deps:
-                    msg = 'Dependencies are not allowed in the if_false argument.'
-                    raise InvalidArguments(msg)
+    def check_source_files(self, args: T.SequenceT.Unionmesonlib.FileOrString, build.GeneratedTypes, dependencies.Dependency,
+                           ) -> T.TupleT.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes, T.Listdependencies.Dependency:
+        sources: T.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes = 
+        deps: T.Listdependencies.Dependency = 
+        for x in args:
+            if isinstance(x, dependencies.Dependency):
                 deps.append(x)
             else:
-                msg = 'Sources must be strings or file-like objects.'
-                raise InvalidArguments(msg)
-        mesonlib.check_direntry_issues(sources)
+                sources.append(x)
+        to_check: T.Liststr = 
+
+        # Get the actual output names to check
+        for s in sources:
+            if isinstance(s, str):
+                to_check.append(s)
+            elif isinstance(s, mesonlib.File):
+                to_check.append(s.fname)
+            else:
+                to_check.extend(s.get_outputs())
+        mesonlib.check_direntry_issues(to_check)
         return sources, deps
 
-    def check_conditions(self, arg):
-        keys = 
-        deps = 
-        for x in listify(arg):
+    def check_conditions(self, args: T.SequenceT.Unionstr, dependencies.Dependency
+                         ) -> T.TupleT.Liststr, T.Listdependencies.Dependency:
+        keys: T.Liststr = 
+        deps: T.Listdependencies.Dependency = 
+        for x in args:
             if isinstance(x, str):
                 keys.append(x)
-            elif hasattr(x, 'found'):
-                deps.append(x)
             else:
-                raise InvalidArguments('Conditions must be strings or dependency object')
+                deps.append(x)
         return keys, deps
 
-    @permittedKwargs('when', 'if_false', 'if_true')
-    def add_method(self, state, args, kwargs):
+    @typed_pos_args('sourceset.add', varargs=(str, mesonlib.File, build.GeneratedList, build.CustomTarget, build.CustomTargetIndex, dependencies.Dependency))
+    @typed_kwargs(
+        'sourceset.add',
+        _WHEN_KW,
+        KwargInfo(
+            'if_true',
+            ContainerTypeInfo(list, (str, mesonlib.File, build.GeneratedList, build.CustomTarget, build.CustomTargetIndex, dependencies.Dependency)),
+            listify=True,
+            default=,
+        ),
+        KwargInfo(
+            'if_false',
+            ContainerTypeInfo(list, (str, mesonlib.File, build.GeneratedList, build.CustomTarget, build.CustomTargetIndex)),
+            listify=True,
+            default=,
+        ),
+    )
+    def add_method(self, state: ModuleState,
+                   args: T.TupleT.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes, dependencies.Dependency,
+                   kwargs: AddKwargs) -> None:
         if self.frozen:
             raise InvalidCode('Tried to use \'add\' after querying the source set')
-        when = listify(kwargs.get('when', ))
-        if_true = listify(kwargs.get('if_true', ))
-        if_false = listify(kwargs.get('if_false', ))
-        if not when and not if_true and not if_false:
-            if_true = args
-        elif args:
+        when = kwargs'when'
+        if_true = kwargs'if_true'
+        if_false = kwargs'if_false'
+        if not any(when, if_true, if_false):
+            if_true = args0
+        elif args0:
             raise InterpreterException('add called with both positional and keyword arguments')
         keys, dependencies = self.check_conditions(when)
-        sources, extra_deps = self.check_source_files(if_true, True)
-        if_false, _ = self.check_source_files(if_false, False)
-        self.rules.append(SourceSetRule(keys, sources, if_false, , dependencies, extra_deps))
+        sources, extra_deps = self.check_source_files(if_true)
+        if_false, _ = self.check_source_files(if_false)
+        self.rules.append(SourceSetRule(keys, dependencies, sources, extra_deps, , if_false))
 
-    @permittedKwargs('when', 'if_true')
-    def add_all_method(self, state, args, kwargs):
+    @typed_pos_args('sourceset.add_all', varargs=SourceSet)
+    @typed_kwargs(
+        'sourceset.add_all',
+        _WHEN_KW,
+        KwargInfo(
+            'if_true',
+            ContainerTypeInfo(list, SourceSet),
+            listify=True,
+            default=,
+        )
+    )
+    def add_all_method(self, state: ModuleState, args: T.TupleT.ListSourceSetImpl,
+                       kwargs: AddAllKw) -> None:
         if self.frozen:
             raise InvalidCode('Tried to use \'add_all\' after querying the source set')
-        when = listify(kwargs.get('when', ))
-        if_true = listify(kwargs.get('if_true', ))
+        when = kwargs'when'
+        if_true = kwargs'if_true'
         if not when and not if_true:
-            if_true = args
-        elif args:
+            if_true = args0
+        elif args0:
             raise InterpreterException('add_all called with both positional and keyword arguments')
         keys, dependencies = self.check_conditions(when)
         for s in if_true:
-            if not isinstance(s, SourceSet):
+            if not isinstance(s, SourceSetImpl):
                 raise InvalidCode('Arguments to \'add_all\' after the first must be source sets')
             s.frozen = True
-        self.rules.append(SourceSetRule(keys, , , if_true, dependencies, ))
+        self.rules.append(SourceSetRule(keys, dependencies, , , if_true, ))
 
-    def collect(self, enabled_fn, all_sources, into=None):
+    def collect(self, enabled_fn: T.Callablestr, bool,
+                all_sources: bool,
+                into: T.Optional'SourceFiles' = None) -> SourceFiles:
         if not into:
             into = SourceFiles(OrderedSet(), OrderedSet())
         for entry in self.rules:
-            if all(x.found() for x in entry.dependencies) and \
+            if all(x.found() for x in entry.deps) and \
                all(enabled_fn(key) for key in entry.keys):
                 into.sources.update(entry.sources)
-                into.dependencies.update(entry.dependencies)
-                into.dependencies.update(entry.extra_deps)
+                into.deps.update(entry.deps)
+                into.deps.update(entry.extra_deps)
                 for ss in entry.sourcesets:
                     ss.collect(enabled_fn, all_sources, into)
                 if not all_sources:
@@ -123,7 +222,8 @@
 
     @noKwargs
     @noPosargs
-    def all_sources_method(self, state, args, kwargs):
+    def all_sources_method(self, state: ModuleState, args: T.ListTYPE_var, kwargs: TYPE_kwargs
+                           ) -> T.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes:
         self.frozen = True
         files = self.collect(lambda x: True, True)
         return list(files.sources)
@@ -131,31 +231,36 @@
     @noKwargs
     @noPosargs
     @FeatureNew('source_set.all_dependencies() method', '0.52.0')
-    def all_dependencies_method(self, state, args, kwargs):
+    def all_dependencies_method(self, state: ModuleState, args: T.ListTYPE_var, kwargs: TYPE_kwargs
+                                ) -> T.Listdependencies.Dependency:
         self.frozen = True
         files = self.collect(lambda x: True, True)
-        return list(files.dependencies)
+        return list(files.deps)
 
-    @permittedKwargs('strict')
-    def apply_method(self, state, args, kwargs):
-        if len(args) != 1:
-            raise InterpreterException('Apply takes exactly one argument')
+    @typed_pos_args('sourceset.apply', (build.ConfigurationData, dict))
+    @typed_kwargs('sourceset.apply', KwargInfo('strict', bool, default=True))
+    def apply_method(self, state: ModuleState, args: T.TupleT.Unionbuild.ConfigurationData, T.Dictstr, TYPE_var, kwargs: ApplyKw) -> SourceFilesObject:
         config_data = args0
         self.frozen = True
-        strict = kwargs.get('strict', True)
+        strict = kwargs'strict'
         if isinstance(config_data, dict):
-            def _get_from_config_data(key):
+            def _get_from_config_data(key: str) -> bool:
+                assert isinstance(config_data, dict), 'for mypy'
                 if strict and key not in config_data:
                     raise InterpreterException(f'Entry {key} not in configuration dictionary.')
-                return config_data.get(key, False)
+                return bool(config_data.get(key, False))
         else:
-            config_cache = dict()
+            config_cache: T.Dictstr, bool = {}
 
-            def _get_from_config_data(key):
-                nonlocal config_cache
+            def _get_from_config_data(key: str) -> bool:
+                assert isinstance(config_data, build.ConfigurationData), 'for mypy'
                 if key not in config_cache:
-                    args = key if strict else key, False
-                    config_cachekey = config_data.get_method(args, {})
+                    if key in config_data:
+                        config_cachekey = bool(config_data.get(key)0)
+                    elif strict:
+                        raise InvalidArguments(f'sourceset.apply: key "{key}" not in passed configuration, and strict set.')
+                    else:
+                        config_cachekey = False
                 return config_cachekey
 
         files = self.collect(_get_from_config_data, False)
@@ -163,7 +268,7 @@
         return res
 
 class SourceFilesObject(ModuleObject):
-    def __init__(self, files):
+    def __init__(self, files: SourceFiles):
         super().__init__()
         self.files = files
         self.methods.update({
@@ -173,26 +278,30 @@
 
     @noPosargs
     @noKwargs
-    def sources_method(self, state, args, kwargs):
+    def sources_method(self, state: ModuleState, args: T.ListTYPE_var, kwargs: TYPE_kwargs
+                       ) -> T.ListT.Unionmesonlib.FileOrString, build.GeneratedTypes:
         return list(self.files.sources)
 
     @noPosargs
     @noKwargs
-    def dependencies_method(self, state, args, kwargs):
-        return list(self.files.dependencies)
+    def dependencies_method(self, state: ModuleState, args: T.ListTYPE_var, kwargs: TYPE_kwargs
+                            ) -> T.Listdependencies.Dependency:
+        return list(self.files.deps)
 
 class SourceSetModule(ExtensionModule):
-    @FeatureNew('SourceSet module', '0.51.0')
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+
+    INFO = ModuleInfo('sourceset', '0.51.0')
+
+    def __init__(self, interpreter: Interpreter):
+        super().__init__(interpreter)
         self.methods.update({
             'source_set': self.source_set,
         })
 
     @noKwargs
     @noPosargs
-    def source_set(self, state, args, kwargs):
-        return SourceSet(self.interpreter)
+    def source_set(self, state: ModuleState, args: T.ListTYPE_var, kwargs: TYPE_kwargs) -> SourceSetImpl:
+        return SourceSetImpl(self.interpreter)
 
-def initialize(*args, **kwargs):
-    return SourceSetModule(*args, **kwargs)
+def initialize(interp: Interpreter) -> SourceSetModule:
+    return SourceSetModule(interp)

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/wayland.py Added

@@ -0,0 +1,160 @@
+# Copyright 2022 Mark Bolhuis <mark@bolhuis.dev>
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+import os
+import typing as T
+
+from . import ExtensionModule, ModuleReturnValue, ModuleInfo
+from ..build import CustomTarget
+from ..interpreter.type_checking import NoneType, in_set_validator
+from ..interpreterbase import typed_pos_args, typed_kwargs, KwargInfo
+from ..mesonlib import File, MesonException
+
+if T.TYPE_CHECKING:
+ from typing_extensions import Literal, TypedDict
+
+ from . import ModuleState
+ from ..build import Executable
+ from ..dependencies import Dependency
+ from ..interpreter import Interpreter
+ from ..programs import ExternalProgram
+ from ..mesonlib import FileOrString
+
+ class ScanXML(TypedDict):
+
+ public: bool
+ client: bool
+ server: bool
+ include_core_only: bool
+
+ class FindProtocol(TypedDict):
+
+ state: Literal'stable', 'staging', 'unstable'
+ version: T.Optionalint
+
+class WaylandModule(ExtensionModule):
+
+ INFO = ModuleInfo('wayland', '0.62.0', unstable=True)
+
+ def __init__(self, interpreter: Interpreter) -> None:
+ super().__init__(interpreter)
+
+ self.protocols_dep: T.OptionalDependency = None
+ self.pkgdatadir: T.Optionalstr = None
+ self.scanner_bin: T.OptionalT.UnionExternalProgram, Executable = None
+
+ self.methods.update({
+ 'scan_xml': self.scan_xml,
+ 'find_protocol': self.find_protocol,
+ })
+
+ @typed_pos_args('wayland.scan_xml', varargs=(str, File), min_varargs=1)
+ @typed_kwargs(
+ 'wayland.scan_xml',
+ KwargInfo('public', bool, default=False),
+ KwargInfo('client', bool, default=True),
+ KwargInfo('server', bool, default=False),
+ KwargInfo('include_core_only', bool, default=True, since='0.64.0'),
+ )
+ def scan_xml(self, state: ModuleState, args: T.TupleT.ListFileOrString, kwargs: ScanXML) -> ModuleReturnValue:
+ if self.scanner_bin is None:
+ # wayland-scanner from BUILD machine must have same version as wayland
+ # libraries from HOST machine.
+ dep = state.dependency('wayland-client')
+ self.scanner_bin = state.find_tool('wayland-scanner', 'wayland-scanner', 'wayland_scanner',
+ wanted=dep.version)
+
+ scope = 'public' if kwargs'public' else 'private'
+ # We have to cast because mypy can't deduce these are literals
+ sides = i for i in T.cast("T.ListLiteral'client', 'server'", 'client', 'server') if kwargsi
+ if not sides:
+ raise MesonException('At least one of client or server keyword argument must be set to true.')
+
+ xml_files = self.interpreter.source_strings_to_files(args0)
+ targets: T.ListCustomTarget = 
+ for xml_file in xml_files:
+ name = os.path.splitext(os.path.basename(xml_file.fname))0
+
+ code = CustomTarget(
+ f'{name}-protocol',
+ state.subdir,
+ state.subproject,
+ state.environment,
+ self.scanner_bin, f'{scope}-code', '@INPUT@', '@OUTPUT@',
+ xml_file,
+ f'{name}-protocol.c',
+ backend=state.backend,
+ )
+ targets.append(code)
+
+ for side in sides:
+ command = self.scanner_bin, f'{side}-header', '@INPUT@', '@OUTPUT@'
+ if kwargs'include_core_only':
+ command.append('--include-core-only')
+
+ header = CustomTarget(
+ f'{name}-{side}-protocol',
+ state.subdir,
+ state.subproject,
+ state.environment,
+ command,
+ xml_file,
+ f'{name}-{side}-protocol.h',
+ backend=state.backend,
+ )
+ targets.append(header)
+
+ return ModuleReturnValue(targets, targets)
+
+ @typed_pos_args('wayland.find_protocol', str)
+ @typed_kwargs(
+ 'wayland.find_protocol',
+ KwargInfo('state', str, default='stable', validator=in_set_validator({'stable', 'staging', 'unstable'})),
+ KwargInfo('version', (int, NoneType)),
+ )
+ def find_protocol(self, state: ModuleState, args: T.Tuplestr, kwargs: FindProtocol) -> File:
+ base_name = args0
+ xml_state = kwargs'state'
+ version = kwargs'version'
+
+ if xml_state != 'stable' and version is None:
+ raise MesonException(f'{xml_state} protocols require a version number.')
+
+ if xml_state == 'stable' and version is not None:
+ raise MesonException('stable protocols do not require a version number.')
+
+ if self.protocols_dep is None:
+ self.protocols_dep = state.dependency('wayland-protocols')
+
+ if self.pkgdatadir is None:
+ self.pkgdatadir = self.protocols_dep.get_variable(pkgconfig='pkgdatadir', internal='pkgdatadir')
+
+ if xml_state == 'stable':
+ xml_name = f'{base_name}.xml'
+ elif xml_state == 'staging':
+ xml_name = f'{base_name}-v{version}.xml'
+ else:
+ xml_name = f'{base_name}-unstable-v{version}.xml'
+
+ path = os.path.join(self.pkgdatadir, xml_state, base_name, xml_name)
+
+ if not os.path.exists(path):
+ raise MesonException(f'The file {path} does not exist.')
+
+ return File.from_absolute_file(path)
+
+
+def initialize(interpreter: Interpreter) -> WaylandModule:
+ return WaylandModule(interpreter)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/modules/windows.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/modules/windows.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import enum
 import os
@@ -18,7 +19,7 @@
 import typing as T
 
 
-from . import ExtensionModule
+from . import ExtensionModule, ModuleInfo
 from . import ModuleReturnValue
 from .. import mesonlib, build
 from .. import mlog
@@ -55,6 +56,9 @@
     wrc = 3
 
 class WindowsModule(ExtensionModule):
+
+    INFO = ModuleInfo('windows')
+
     def __init__(self, interpreter: 'Interpreter'):
         super().__init__(interpreter)
         self._rescomp: T.OptionalT.TupleExternalProgram, ResourceCompilerType = None
@@ -108,10 +112,10 @@
 
     @typed_pos_args('windows.compile_resources', varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex), min_varargs=1)
     @typed_kwargs(
-        'winddows.compile_resoures',
+        'windows.compile_resources',
         DEPEND_FILES_KW.evolve(since='0.47.0'),
         DEPENDS_KW.evolve(since='0.47.0'),
-        INCLUDE_DIRECTORIES.evolve(name='include_directories'),
+        INCLUDE_DIRECTORIES,
         KwargInfo('args', ContainerTypeInfo(list, str), default=, listify=True),
     )
     def compile_resources(self, state: 'ModuleState',
@@ -181,26 +185,26 @@
             command: T.ListT.Unionstr, ExternalProgram = 
             command.append(rescomp)
             command.extend(res_args)
-
-            res_kwargs: 'RcKwargs' = {
-                'output': output,
-                'input': src,
-                'depfile': None,
-                'depend_files': wrc_depend_files,
-                'depends': wrc_depends,
-                'command': ,
-            }
-
+            depfile: T.Optionalstr = None
             # instruct binutils windres to generate a preprocessor depfile
             if rescomp_type == ResourceCompilerType.windres:
-                res_kwargs'depfile' = f'{output}.d'
+                depfile = f'{output}.d'
                 command.extend('--preprocessor-arg=-MD',
                                 '--preprocessor-arg=-MQ@OUTPUT@',
                                 '--preprocessor-arg=-MF@DEPFILE@')
 
-            res_kwargs'command' = command
-
-            res_targets.append(build.CustomTarget(name_formatted, state.subdir, state.subproject, res_kwargs))
+            res_targets.append(build.CustomTarget(
+                name_formatted,
+                state.subdir,
+                state.subproject,
+                state.environment,
+                command,
+                src,
+                output,
+                depfile=depfile,
+                depend_files=wrc_depend_files,
+                extra_depends=wrc_depends,
+            ))
 
         return ModuleReturnValue(res_targets, res_targets)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mparser.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mparser.py Changed

@@ -11,16 +11,19 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
+from dataclasses import dataclass
 import re
 import codecs
-import textwrap
 import types
 import typing as T
 from .mesonlib import MesonException
 from . import mlog
 
 if T.TYPE_CHECKING:
+ from typing_extensions import Literal
+
 from .ast import AstVisitor
 
 # This is the regex for the supported escape sequences of a regular string
@@ -87,15 +90,15 @@
 
 TV_TokenTypes = T.TypeVar('TV_TokenTypes', int, str, bool)
 
+@dataclass(eq=False)
 class Token(T.GenericTV_TokenTypes):
- def __init__(self, tid: str, filename: str, line_start: int, lineno: int, colno: int, bytespan: T.Tupleint, int, value: TV_TokenTypes):
- self.tid = tid # type: str
- self.filename = filename # type: str
- self.line_start = line_start # type: int
- self.lineno = lineno # type: int
- self.colno = colno # type: int
- self.bytespan = bytespan # type: T.Tupleint, int
- self.value = value # type: TV_TokenTypes
+ tid: str
+ filename: str
+ line_start: int
+ lineno: int
+ colno: int
+ bytespan: T.Tupleint, int
+ value: TV_TokenTypes
 
 def __eq__(self, other: object) -> bool:
 if isinstance(other, str):
@@ -114,6 +117,7 @@
 self.token_specification = 
 # Need to be sorted longest to shortest.
 ('ignore', re.compile(r' \t')),
+ ('multiline_fstring', re.compile(r"f'''(.|\n)*?'''", re.M)),
 ('fstring', re.compile(r"f'(^'\\|(\\.))*'")),
 ('id', re.compile('_a-zA-Z_0-9a-zA-Z*')),
 ('number', re.compile(r'0bB01+|0oO0-7+|0xX0-9a-fA-F+|0|1-9\d*')),
@@ -174,7 +178,7 @@
 span_end = loc
 bytespan = (span_start, span_end)
 match_text = mo.group()
- if tid == 'ignore' or tid == 'comment':
+ if tid in {'ignore', 'comment'}:
 break
 elif tid == 'lparen':
 par_count += 1
@@ -193,22 +197,27 @@
 elif tid in {'string', 'fstring'}:
 # Handle here and not on the regexp to give a better error message.
 if match_text.find("\n") != -1:
- mlog.warning(textwrap.dedent("""\
- Newline character in a string detected, use ''' (three single quotes) for multiline strings instead.
- This will become a hard error in a future Meson release.\
- """),
- self.getline(line_start),
- str(lineno),
- str(col)
- )
+ msg = ParseException("Newline character in a string detected, use ''' (three single quotes) "
+ "for multiline strings instead.\n"
+ "This will become a hard error in a future Meson release.",
+ self.getline(line_start), lineno, col)
+ mlog.warning(msg, location=BaseNode(lineno, col, filename))
 value = match_text2 if tid == 'fstring' else 1:-1
 try:
 value = ESCAPE_SEQUENCE_SINGLE_RE.sub(decode_match, value)
 except MesonUnicodeDecodeError as err:
 raise MesonException(f"Failed to parse escape sequence: '{err.match}' in string:\n {match_text}")
- elif tid == 'multiline_string':
- tid = 'string'
- value = match_text3:-3
+ elif tid in {'multiline_string', 'multiline_fstring'}:
+ # For multiline strings, parse out the value and pass
+ # through the normal string logic.
+ # For multiline format strings, we have to emit a
+ # different AST node so we can add a feature check,
+ # but otherwise, it follows the normal fstring logic.
+ if tid == 'multiline_string':
+ value = match_text3:-3
+ tid = 'string'
+ else:
+ value = match_text4:-3
 lines = match_text.split('\n')
 if len(lines) > 1:
 lineno += len(lines) - 1
@@ -237,13 +246,19 @@
 if not matched:
 raise ParseException('lexer', self.getline(line_start), lineno, col)
 
+@dataclass(eq=False)
 class BaseNode:
- def __init__(self, lineno: int, colno: int, filename: str, end_lineno: T.Optionalint = None, end_colno: T.Optionalint = None):
- self.lineno = lineno # type: int
- self.colno = colno # type: int
- self.filename = filename # type: str
- self.end_lineno = end_lineno if end_lineno is not None else self.lineno
- self.end_colno = end_colno if end_colno is not None else self.colno
+ lineno: int
+ colno: int
+ filename: str
+ end_lineno: T.Optionalint = None
+ end_colno: T.Optionalint = None
+
+ def __post_init__(self) -> None:
+ if self.end_lineno is None:
+ self.end_lineno = self.lineno
+ if self.end_colno is None:
+ self.end_colno = self.colno
 
 # Attributes for the visitors
 self.level = 0 # type: int
@@ -295,7 +310,11 @@
 assert isinstance(self.value, str)
 
 def __str__(self) -> str:
- return "Format string node: '{self.value}' ({self.lineno}, {self.colno})."
+ return f"Format string node: '{self.value}' ({self.lineno}, {self.colno})."
+
+class MultilineFormatStringNode(FormatStringNode):
+ def __str__(self) -> str:
+ return f"Multiline Format string node: '{self.value}' ({self.lineno}, {self.colno})."
 
 class ContinueNode(ElementaryNode):
 pass
@@ -372,11 +391,11 @@
 self.right = right # type: BaseNode
 
 class ComparisonNode(BaseNode):
- def __init__(self, ctype: str, left: BaseNode, right: BaseNode):
+ def __init__(self, ctype: COMPARISONS, left: BaseNode, right: BaseNode):
 super().__init__(left.lineno, left.colno, left.filename)
 self.left = left # type: BaseNode
 self.right = right # type: BaseNode
- self.ctype = ctype # type: str
+ self.ctype = ctype
 
 class ArithmeticNode(BaseNode):
 def __init__(self, operation: str, left: BaseNode, right: BaseNode):
@@ -461,15 +480,19 @@
 self.trueblock = trueblock # type: BaseNode
 self.falseblock = falseblock # type: BaseNode
 
-comparison_map = {'equal': '==',
- 'nequal': '!=',
- 'lt': '<',
- 'le': '<=',
- 'gt': '>',
- 'ge': '>=',
- 'in': 'in',
- 'notin': 'not in',
- }
+if T.TYPE_CHECKING:
+ COMPARISONS = Literal'==', '!=', '<', '<=', '>=', '>', 'in', 'notin'
+
+comparison_map: T.Mappingstr, COMPARISONS = {
+ 'equal': '==',
+ 'nequal': '!=',
+ 'lt': '<',
+ 'le': '<=',
+ 'gt': '>',
+ 'ge': '>=',
+ 'in': 'in',
+ 'not in': 'notin',
+}
 
 # Recursive descent parser for Meson's definition language.
 # Very basic apart from the fact that we have many precedence
@@ -509,7 +532,7 @@
 return True
 return False
 
- def accept_any(self, tids: T.Sequencestr) -> str:
+ def accept_any(self, tids: T.Tuplestr, ...) -> str:
 tid = self.current.tid
 if tid in tids:
 self.getsym()
@@ -682,6 +705,8 @@
 return StringNode(t)
 if self.accept('fstring'):
 return FormatStringNode(t)
+ if self.accept('multiline_fstring'):
+ return MultilineFormatStringNode(t)
 return EmptyNode(self.current.lineno, self.current.colno, self.current.filename)
 
 def key_values(self) -> ArgumentNode:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/msetup.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/msetup.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import typing as T
 import time
@@ -28,7 +29,8 @@
 from . import build
 from . import mlog, coredata
 from . import mintro
-from .mesonlib import MesonException
+from .mesonlib import MesonException, MachineChoice
+from .dependencies import PkgConfigDependency
 
 git_ignore_file = '''# This file is autogenerated by Meson. If you change or delete it, it won't be recreated.
 *
@@ -164,7 +166,7 @@
             if not reconfigure and not wipe:
                 print('Directory already configured.\n'
                       '\nJust run your build command (e.g. ninja) and Meson will regenerate as necessary.\n'
-                      'If ninja fails, run "ninja reconfigure" or "meson --reconfigure"\n'
+                      'If ninja fails, run "ninja reconfigure" or "meson setup --reconfigure"\n'
                       'to force Meson to regenerate.\n'
                       '\nIf build failures persist, run "meson setup --wipe" to rebuild from scratch\n'
                       'using the same options as passed when configuring the build.'
@@ -230,6 +232,8 @@
         except Exception as e:
             mintro.write_meson_info_file(b, e)
             raise
+
+        cdf: T.Optionalstr = None
         try:
             dumpfile = os.path.join(env.get_scratch_dir(), 'build.dat')
             # We would like to write coredata as late as possible since we use the existence of
@@ -245,7 +249,7 @@
                 profile.runctx('intr.backend.generate()', globals(), locals(), filename=fname)
             else:
                 intr.backend.generate()
-            b.devenv.append(intr.backend.get_devenv())
+            self._finalize_devenv(b, intr)
             build.save(b, dumpfile)
             if env.first_invocation:
                 # Use path resolved by coredata because they could have been
@@ -280,7 +284,7 @@
 
         except Exception as e:
             mintro.write_meson_info_file(b, e)
-            if 'cdf' in locals():
+            if cdf is not None:
                 old_cdf = cdf + '.prev'
                 if os.path.exists(old_cdf):
                     os.replace(old_cdf, cdf)
@@ -288,7 +292,19 @@
                     os.unlink(cdf)
             raise
 
-def run(options: argparse.Namespace) -> int:
+    def _finalize_devenv(self, b: build.Build, intr: interpreter.Interpreter) -> None:
+        b.devenv.append(intr.backend.get_devenv())
+        b.devenv.append(PkgConfigDependency.get_env(intr.environment, MachineChoice.HOST, uninstalled=True))
+        for mod in intr.modules.values():
+            devenv = mod.get_devenv()
+            if devenv:
+                b.devenv.append(devenv)
+
+def run(options: T.Unionargparse.Namespace, T.Liststr) -> int:
+    if not isinstance(options, argparse.Namespace):
+        parser = argparse.ArgumentParser()
+        add_arguments(parser)
+        options = parser.parse_args(options)
     coredata.parse_cmd_line_options(options)
     app = MesonApp(options)
     app.generate()

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/msubprojects.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/msubprojects.py Changed

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, InitVar
 import os, subprocess
 import argparse
 import asyncio
@@ -12,23 +15,30 @@
 
 from . import mlog
 from .mesonlib import quiet_git, GitException, Popen_safe, MesonException, windows_proof_rmtree
-from .wrap.wrap import PackageDefinition, Resolver, WrapException, ALL_TYPES
-from .wrap import wraptool
+from .wrap.wrap import (Resolver, WrapException, ALL_TYPES, PackageDefinition,
+                        parse_patch_url, update_wrap_file, get_releases)
 
 if T.TYPE_CHECKING:
     from typing_extensions import Protocol
 
+    SubParsers = argparse._SubParsersActionargparse.ArgumentParser
+
     class Arguments(Protocol):
         sourcedir: str
         num_processes: int
         subprojects: T.Liststr
         types: str
         subprojects_func: T.Callable, bool
+        allow_insecure: bool
 
     class UpdateArguments(Arguments):
         rebase: bool
         reset: bool
 
+    class UpdateWrapDBArguments(Arguments):
+        force: bool
+        releases: T.Dictstr, T.Any
+
     class CheckoutArguments(Arguments):
         b: bool
         branch_name: str
@@ -50,10 +60,10 @@
 def read_archive_files(path: Path, base_path: Path) -> T.SetPath:
     if path.suffix == '.zip':
         with zipfile.ZipFile(path, 'r') as zip_archive:
-            archive_files = set(base_path / i.filename for i in zip_archive.infolist())
+            archive_files = {base_path / i.filename for i in zip_archive.infolist()}
     else:
         with tarfile.open(path) as tar_archive: # ignore encoding
-            archive_files = set(base_path / i.name for i in tar_archive)
+            archive_files = {base_path / i.name for i in tar_archive}
     return archive_files
 
 class Logger:
@@ -94,18 +104,22 @@
             self.print_progress()
 
 
+@dataclass(eq=False)
 class Runner:
-    def __init__(self, logger: Logger, r: Resolver, wrap: PackageDefinition, repo_dir: str, options: 'Arguments') -> None:
+    logger: Logger
+    r: InitVarResolver
+    wrap: PackageDefinition
+    repo_dir: str
+    options: 'Arguments'
+
+    def __post_init__(self, r: Resolver) -> None:
         # FIXME: Do a copy because Resolver.resolve() is stateful method that
         # cannot be called from multiple threads.
         self.wrap_resolver = copy.copy(r)
-        self.wrap_resolver.dirname = os.path.join(r.subdir_root, wrap.directory)
-        self.wrap = self.wrap_resolver.wrap = wrap
-        self.repo_dir = repo_dir
-        self.options = options
-        self.run_method: T.Callable, bool = options.subprojects_func.__get__(self) # type: ignore
+        self.wrap_resolver.dirname = os.path.join(r.subdir_root, self.wrap.directory)
+        self.wrap_resolver.wrap = self.wrap
+        self.run_method: T.Callable, bool = self.options.subprojects_func.__get__(self)
         self.log_queue: T.ListT.Tuplemlog.TV_LoggableList, T.Any = 
-        self.logger = logger
 
     def log(self, *args: mlog.TV_Loggable, **kwargs: T.Any) -> None:
         self.log_queue.append((list(args), kwargs))
@@ -120,29 +134,53 @@
         self.logger.done(self.wrap.name, self.log_queue)
         return result
 
-    def update_wrapdb_file(self) -> None:
+    @staticmethod
+    def pre_update_wrapdb(options: 'UpdateWrapDBArguments') -> None:
+        options.releases = get_releases(options.allow_insecure)
+
+    def update_wrapdb(self) -> bool:
+        self.log(f'Checking latest WrapDB version for {self.wrap.name}...')
+        options = T.cast('UpdateWrapDBArguments', self.options)
+
+        # Check if this wrap is in WrapDB
+        info = options.releases.get(self.wrap.name)
+        if not info:
+            self.log('  -> Wrap not found in wrapdb')
+            return True
+
+        # Determine current version
         try:
-            patch_url = self.wrap.get('patch_url')
-            branch, revision = wraptool.parse_patch_url(patch_url)
+            wrapdb_version = self.wrap.get('wrapdb_version')
+            branch, revision = wrapdb_version.split('-', 1)
         except WrapException:
-            return
-        new_branch, new_revision = wraptool.get_latest_version(self.wrap.name)
+            # Fallback to parsing the patch URL to determine current version.
+            # This won't work for projects that have upstream Meson support.
+            try:
+                patch_url = self.wrap.get('patch_url')
+                branch, revision = parse_patch_url(patch_url)
+            except WrapException:
+                if not options.force:
+                    self.log('  ->', mlog.red('Could not determine current version, use --force to update any way'))
+                    return False
+                branch = revision = None
+
+        # Download latest wrap if version differs
+        latest_version = info'versions'0
+        new_branch, new_revision = latest_version.rsplit('-', 1)
         if new_branch != branch or new_revision != revision:
-            wraptool.update_wrap_file(self.wrap.filename, self.wrap.name, new_branch, new_revision)
-            self.log('  -> New wrap file downloaded.')
+            filename = self.wrap.filename if self.wrap.has_wrap else f'{self.wrap.filename}.wrap'
+            update_wrap_file(filename, self.wrap.name,
+                             new_branch, new_revision,
+                             options.allow_insecure)
+            self.log('  -> New version downloaded:', mlog.blue(latest_version))
+        else:
+            self.log('  -> Already at latest version:', mlog.blue(latest_version))
+
+        return True
 
     def update_file(self) -> bool:
         options = T.cast('UpdateArguments', self.options)
-
-        self.update_wrapdb_file()
-        if not os.path.isdir(self.repo_dir):
-            # The subproject is not needed, or it is a tarball extracted in
-            # 'libfoo-1.0' directory and the version has been bumped and the new
-            # directory is 'libfoo-2.0'. In that case forcing a meson
-            # reconfigure will download and use the new tarball.
-            self.log('  -> Not used.')
-            return True
-        elif options.reset:
+        if options.reset:
             # Delete existing directory and redownload. It is possible that nothing
             # changed but we have no way to know. Hopefully tarballs are still
             # cached.
@@ -199,6 +237,7 @@
             self.git_stash()
             self.git_output('reset', '--hard', 'FETCH_HEAD')
             self.wrap_resolver.apply_patch()
+            self.wrap_resolver.apply_diff_files()
         except GitException as e:
             self.log('  -> Could not reset', mlog.bold(self.repo_dir), 'to', mlog.bold(revision))
             self.log(mlog.red(e.output))
@@ -240,10 +279,6 @@
 
     def update_git(self) -> bool:
         options = T.cast('UpdateArguments', self.options)
-
-        if not os.path.isdir(self.repo_dir):
-            self.log('  -> Not used.')
-            return True
         if not os.path.exists(os.path.join(self.repo_dir, '.git')):
             if options.reset:
                 # Delete existing directory and redownload
@@ -348,9 +383,6 @@
         self.git_show()
 
     def update_hg(self) -> bool:
-        if not os.path.isdir(self.repo_dir):
-            self.log('  -> Not used.')
-            return True
         revno = self.wrap.get('revision')
         if revno.lower() == 'tip':
             # Failure to do pull is not a fatal error,
@@ -364,9 +396,6 @@
         return True
 
     def update_svn(self) -> bool:
-        if not os.path.isdir(self.repo_dir):
-            self.log('  -> Not used.')
-            return True
         revno = self.wrap.get('revision')
         _, out, _ = Popen_safe('svn', 'info', '--show-item', 'revision', self.repo_dir)
         current_revno = out
@@ -383,19 +412,28 @@
 
     def update(self) -> bool:
         self.log(f'Updating {self.wrap.name}...')
-        if self.wrap.type == 'file':
-            return self.update_file()
+        success = False
+        if not os.path.isdir(self.repo_dir):
+            self.log('  -> Not used.')
+            # It is not an error if we are updating all subprojects.
+            success = not self.options.subprojects
+        elif self.wrap.type == 'file':
+            success = self.update_file()
         elif self.wrap.type == 'git':
-            return self.update_git()
+            success = self.update_git()
         elif self.wrap.type == 'hg':
-            return self.update_hg()
+            success = self.update_hg()
         elif self.wrap.type == 'svn':
-            return self.update_svn()
+            success = self.update_svn()
         elif self.wrap.type is None:
             self.log('  -> Cannot update subproject with no wrap file')
+            # It is not an error if we are updating all subprojects.
+            success = not self.options.subprojects
         else:
             self.log('  -> Cannot update', self.wrap.type, 'subproject')
-        return True
+        if success and os.path.isdir(self.repo_dir):
+            self.wrap.update_hash_cache(self.repo_dir)
+        return success
 
     def checkout(self) -> bool:
         options = T.cast('CheckoutArguments', self.options)
@@ -570,18 +608,30 @@
                    help=f'Comma-separated list of subproject types. Supported types are: {ALL_TYPES_STRING} (default: all)')
     p.add_argument('--num-processes', default=None, type=int,
                    help='How many parallel processes to use (Since 0.59.0).')
+    p.add_argument('--allow-insecure', default=False, action='store_true',
+                   help='Allow insecure server connections.')
 
 def add_subprojects_argument(p: argparse.ArgumentParser) -> None:
     p.add_argument('subprojects', nargs='*',
                    help='List of subprojects (default: all)')
 
+def add_wrap_update_parser(subparsers: 'SubParsers') -> argparse.ArgumentParser:
+    p = subparsers.add_parser('update', help='Update wrap files from WrapDB (Since 0.63.0)')
+    p.add_argument('--force', default=False, action='store_true',
+                   help='Update wraps that does not seems to come from WrapDB')
+    add_common_arguments(p)
+    add_subprojects_argument(p)
+    p.set_defaults(subprojects_func=Runner.update_wrapdb)
+    p.set_defaults(pre_func=Runner.pre_update_wrapdb)
+    return p
+
 def add_arguments(parser: argparse.ArgumentParser) -> None:
     subparsers = parser.add_subparsers(title='Commands', dest='command')
     subparsers.required = True
 
     p = subparsers.add_parser('update', help='Update all subprojects from wrap files')
     p.add_argument('--rebase', default=True, action='store_true',
-                   help='Rebase your branch on top of wrap\'s revision. ' + \
+                   help='Rebase your branch on top of wrap\'s revision. ' +
                         'Deprecated, it is now the default behaviour. (git only)')
     p.add_argument('--reset', default=False, action='store_true',
                    help='Checkout wrap\'s revision and hard reset to that commit. (git only)')
@@ -638,7 +688,7 @@
     if not os.path.isdir(subprojects_dir):
         mlog.log('Directory', mlog.bold(src_dir), 'does not seem to have subprojects.')
         return 0
-    r = Resolver(src_dir, 'subprojects')
+    r = Resolver(src_dir, 'subprojects', wrap_frontend=True, allow_insecure=options.allow_insecure)
     if options.subprojects:
         wraps = wrap for name, wrap in r.wraps.items() if name in options.subprojects
     else:
@@ -653,6 +703,9 @@
     executor = ThreadPoolExecutor(options.num_processes)
     if types:
         wraps = wrap for wrap in wraps if wrap.type in types
+    pre_func = getattr(options, 'pre_func', None)
+    if pre_func:
+        pre_func(options)
     logger = Logger(len(wraps))
     for wrap in wraps:
         dirname = Path(subprojects_dir, wrap.directory).as_posix()

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/mtest.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/mtest.py Changed

@@ -13,9 +13,11 @@
 # limitations under the License.
 
 # A tool to run tests in many different ways.
+from __future__ import annotations
 
 from pathlib import Path
 from collections import deque
+from contextlib import suppress
 from copy import deepcopy
 import argparse
 import asyncio
@@ -49,6 +51,15 @@
 from .programs import ExternalProgram
 from .backend.backends import TestProtocol, TestSerialisation
 
+if T.TYPE_CHECKING:
+ TYPE_TAPResult = T.Union'TAPParser.Test',
+ 'TAPParser.Error',
+ 'TAPParser.Version',
+ 'TAPParser.Plan',
+ 'TAPParser.UnknownLine',
+ 'TAPParser.Bailout'
+
+
 # GNU autotools interprets a return code of 77 from tests it executes to
 # mean that the test should be skipped.
 GNU_SKIP_RETURNCODE = 77
@@ -93,6 +104,9 @@
 return num_workers
 
 def add_arguments(parser: argparse.ArgumentParser) -> None:
+ parser.add_argument('--maxfail', default=0, type=int,
+ help='Number of failing tests before aborting the '
+ 'test run. (default: 0, to disable aborting on failure)')
 parser.add_argument('--repeat', default=1, dest='repeat', type=int,
 help='Number of times to run the tests.')
 parser.add_argument('--no-rebuild', default=False, action='store_true',
@@ -233,7 +247,7 @@
 
 @staticmethod
 def maxlen() -> int:
- return 14 # len(UNEXPECTEDPASS)
+ return 14 # len(UNEXPECTEDPASS)
 
 def is_ok(self) -> bool:
 return self in {TestResult.OK, TestResult.EXPECTEDFAIL}
@@ -267,8 +281,6 @@
 return str(self.colorize('>>> '))
 
 
-TYPE_TAPResult = T.Union'TAPParser.Test', 'TAPParser.Error', 'TAPParser.Version', 'TAPParser.Plan', 'TAPParser.Bailout'
-
 class TAPParser:
 class Plan(T.NamedTuple):
 num_tests: int
@@ -291,6 +303,10 @@
 class Error(T.NamedTuple):
 message: str
 
+ class UnknownLine(T.NamedTuple):
+ message: str
+ lineno: int
+
 class Version(T.NamedTuple):
 version: int
 
@@ -372,7 +388,7 @@
 self.state = self._MAIN
 
 assert self.state == self._MAIN
- if line.startswith('#'):
+ if not line or line.startswith('#'):
 return
 
 m = self._RE_TEST.match(line)
@@ -395,7 +411,7 @@
 yield self.Error('more than one plan found')
 else:
 num_tests = int(m.group(1))
- skipped = (num_tests == 0)
+ skipped = num_tests == 0
 if m.group(2):
 if m.group(2).upper().startswith('SKIP'):
 if num_tests > 0:
@@ -427,10 +443,8 @@
 yield self.Version(version=self.version)
 return
 
- if not line:
- return
-
- yield self.Error(f'unexpected input at line {self.lineno}')
+ # unknown syntax
+ yield self.UnknownLine(line, self.lineno)
 else:
 # end of file
 if self.state == self._YAML:
@@ -486,7 +500,6 @@
 RTRI = "\u25B6 "
 
 def __init__(self) -> None:
- self.update = asyncio.Event()
 self.running_tests = OrderedSet() # type: OrderedSet'TestRun'
 self.progress_test = None # type: T.Optional'TestRun'
 self.progress_task = None # type: T.Optionalasyncio.Future
@@ -551,9 +564,9 @@
 timeout=self.progress_test.timeout,
 durlen=harness.duration_max_len)
 right += 's'
- detail = self.progress_test.detail
- if detail:
- right += ' ' + detail
+ details = self.progress_test.get_details()
+ if details:
+ right += ' ' + details
 
 line = harness.format(self.progress_test, colorize=True,
 max_left_width=self.max_left_width,
@@ -568,7 +581,6 @@
 while not self.stop:
 await self.update.wait()
 self.update.clear()
-
 # We may get here simply because the progress line has been
 # overwritten, so do not always switch. Only do so every
 # second, or if the printed test has finished
@@ -600,17 +612,15 @@
 self.progress_task = asyncio.ensure_future(report_progress())
 
 def start_test(self, harness: 'TestHarness', test: 'TestRun') -> None:
- if harness.options.verbose and test.cmdline:
+ if test.verbose and test.cmdline:
 self.flush()
 print(harness.format(test, mlog.colorize_console(),
 max_left_width=self.max_left_width,
 right=test.res.get_text(mlog.colorize_console())))
 print(test.res.get_command_marker() + test.cmdline)
- if test.needs_parsing:
- pass
- elif not test.is_parallel:
+ if test.direct_stdout:
 print(self.output_start, flush=True)
- else:
+ elif not test.needs_parsing:
 print(flush=True)
 
 self.started_tests += 1
@@ -619,12 +629,12 @@
 self.request_update()
 
 def shorten_log(self, harness: 'TestHarness', result: 'TestRun') -> str:
- if not harness.options.verbose and not harness.options.print_errorlogs:
+ if not result.verbose and not harness.options.print_errorlogs:
 return ''
 
 log = result.get_log(mlog.colorize_console(),
 stderr_only=result.needs_parsing)
- if harness.options.verbose:
+ if result.verbose:
 return log
 
 lines = log.splitlines()
@@ -634,7 +644,7 @@
 return str(mlog.bold('Listing only the last 100 lines from a long log.\n')) + '\n'.join(lines-100:)
 
 def print_log(self, harness: 'TestHarness', result: 'TestRun') -> None:
- if not harness.options.verbose:
+ if not result.verbose:
 cmdline = result.cmdline
 if not cmdline:
 print(result.res.get_command_marker() + result.stdo)
@@ -648,7 +658,7 @@
 print(self.output_end)
 
 def log_subtest(self, harness: 'TestHarness', test: 'TestRun', s: str, result: TestResult) -> None:
- if harness.options.verbose or (harness.options.print_errorlogs and result.is_bad()):
+ if test.verbose or (harness.options.print_errorlogs and result.is_bad()):
 self.flush()
 print(harness.format(test, mlog.colorize_console(), max_left_width=self.max_left_width,
 prefix=self.sub,
@@ -659,21 +669,27 @@
 
 def log(self, harness: 'TestHarness', result: 'TestRun') -> None:
 self.running_tests.remove(result)
- if result.res is TestResult.TIMEOUT and harness.options.verbose:
+ if result.res is TestResult.TIMEOUT and (result.verbose or
+ harness.options.print_errorlogs):
 self.flush()
 print(f'{result.name} time out (After {result.timeout} seconds)')
 
 if not harness.options.quiet or not result.res.is_ok():
 self.flush()
- if harness.options.verbose and not result.is_parallel and result.cmdline and not result.needs_parsing:
+ if result.cmdline and result.direct_stdout:
 print(self.output_end)
 print(harness.format(result, mlog.colorize_console(), max_left_width=self.max_left_width))
 else:
 print(harness.format(result, mlog.colorize_console(), max_left_width=self.max_left_width),
 flush=True)
- if harness.options.verbose or result.res.is_bad():
+ if result.verbose or result.res.is_bad():
 self.print_log(harness, result)
- if harness.options.verbose or result.res.is_bad():
+ if result.warnings:
+ print(flush=True)
+ for w in result.warnings:
+ print(w, flush=True)
+ print(flush=True)
+ if result.verbose or result.res.is_bad():
 print(flush=True)
 
 self.request_update()
@@ -700,14 +716,23 @@
 self.file.write(f'Inherited environment: {inherit_env}\n\n')
 
 def log(self, harness: 'TestHarness', result: 'TestRun') -> None:
- self.file.write(harness.format(result, False) + '\n')
- cmdline = result.cmdline
- if cmdline:
- starttime_str = time.strftime("%H:%M:%S", time.gmtime(result.starttime))
- self.file.write(starttime_str + ' ' + cmdline + '\n')
- self.file.write(dashes('output', '-', 78) + '\n')
- self.file.write(result.get_log())
- self.file.write(dashes('', '-', 78) + '\n\n')
+ title = f'{result.num}/{harness.test_count}'
+ self.file.write(dashes(title, '=', 78) + '\n')
+ self.file.write('test: ' + result.name + '\n')
+ starttime_str = time.strftime("%H:%M:%S", time.gmtime(result.starttime))
+ self.file.write('start time: ' + starttime_str + '\n')
+ self.file.write('duration: ' + '%.2fs' % result.duration + '\n')
+ self.file.write('result: ' + result.get_exit_status() + '\n')
+ if result.cmdline:
+ self.file.write('command: ' + result.cmdline + '\n')
+ if result.stdo:
+ name = 'stdout' if harness.options.split else 'output'
+ self.file.write(dashes(name, '-', 78) + '\n')
+ self.file.write(result.stdo)
+ if result.stde:
+ self.file.write(dashes('stderr', '-', 78) + '\n')
+ self.file.write(result.stde)
+ self.file.write(dashes('', '=', 78) + '\n\n')
 
 async def finish(self, harness: 'TestHarness') -> None:
 if harness.collected_failures:
@@ -769,6 +794,10 @@
 del case.attrib'result'
 for case in suite.findall('.//testcase@timestamp'):
 del case.attrib'timestamp'
+ for case in suite.findall('.//testcase@file'):
+ del case.attrib'file'
+ for case in suite.findall('.//testcase@line'):
+ del case.attrib'line'
 self.root.append(suite)
 return
 
@@ -866,24 +895,27 @@
 return super().__new__(TestRun.PROTOCOL_TO_CLASStest.protocol)
 
 def __init__(self, test: TestSerialisation, test_env: T.Dictstr, str,
- name: str, timeout: T.Optionalint, is_parallel: bool):
+ name: str, timeout: T.Optionalint, is_parallel: bool, verbose: bool):
 self.res = TestResult.PENDING
 self.test = test
 self._num = None # type: T.Optionalint
 self.name = name
 self.timeout = timeout
- self.results = list() # type: T.ListTAPParser.Test
- self.returncode = 0
+ self.results = # type: T.ListTAPParser.Test
+ self.returncode = None # type: T.Optionalint
 self.starttime = None # type: T.Optionalfloat
 self.duration = None # type: T.Optionalfloat
- self.stdo = None # type: T.Optionalstr
- self.stde = None # type: T.Optionalstr
+ self.stdo = ''
+ self.stde = ''
+ self.additional_error = ''
 self.cmd = None # type: T.OptionalT.Liststr
 self.env = test_env # type: T.Dictstr, str
 self.should_fail = test.should_fail
 self.project = test.project_name
 self.junit = None # type: T.Optionalet.ElementTree
 self.is_parallel = is_parallel
+ self.verbose = verbose
+ self.warnings = # type: T.Liststr
 
 def start(self, cmd: T.Liststr) -> None:
 self.res = TestResult.RUNNING
@@ -898,11 +930,10 @@
 return self._num
 
 @property
- def detail(self) -> str:
- if self.res is TestResult.PENDING:
- return ''
- if self.returncode:
- return returncode_to_status(self.returncode)
+ def direct_stdout(self) -> bool:
+ return self.verbose and not self.is_parallel and not self.needs_parsing
+
+ def get_results(self) -> str:
 if self.results:
 # running or succeeded
 passed = sum(x.result.is_ok() for x in self.results)
@@ -913,17 +944,27 @@
 return f'{passed}/{ran} subtests passed'
 return ''
 
- def _complete(self, returncode: int, res: TestResult,
- stdo: T.Optionalstr, stde: T.Optionalstr) -> None:
- assert isinstance(res, TestResult)
- if self.should_fail and res in (TestResult.OK, TestResult.FAIL):
- res = TestResult.UNEXPECTEDPASS if res.is_ok() else TestResult.EXPECTEDFAIL
+ def get_exit_status(self) -> str:
+ return returncode_to_status(self.returncode)
 
- self.res = res
- self.returncode = returncode
+ def get_details(self) -> str:
+ if self.res is TestResult.PENDING:
+ return ''
+ if self.returncode:
+ return self.get_exit_status()
+ return self.get_results()
+
+ def _complete(self) -> None:
+ if self.res == TestResult.RUNNING:
+ self.res = TestResult.OK
+ assert isinstance(self.res, TestResult)
+ if self.should_fail and self.res in (TestResult.OK, TestResult.FAIL):
+ self.res = TestResult.UNEXPECTEDPASS if self.res is TestResult.OK else TestResult.EXPECTEDFAIL
+ if self.stdo and not self.stdo.endswith('\n'):
+ self.stdo += '\n'
+ if self.stde and not self.stde.endswith('\n'):
+ self.stde += '\n'
 self.duration = time.time() - self.starttime
- self.stdo = stdo
- self.stde = stde
 
 @property
 def cmdline(self) -> T.Optionalstr:
@@ -933,17 +974,18 @@
 return env_tuple_to_str(test_only_env) + \
 ' '.join(sh_quote(x) for x in self.cmd)
 
- def complete_skip(self, message: str) -> None:
+ def complete_skip(self) -> None:
 self.starttime = time.time()
- self._complete(GNU_SKIP_RETURNCODE, TestResult.SKIP, message, None)
+ self.returncode = GNU_SKIP_RETURNCODE
+ self.res = TestResult.SKIP
+ self._complete()
 
- def complete(self, returncode: int, res: TestResult,
- stdo: T.Optionalstr, stde: T.Optionalstr) -> None:
- self._complete(returncode, res, stdo, stde)
+ def complete(self) -> None:
+ self._complete()
 
 def get_log(self, colorize: bool = False, stderr_only: bool = False) -> str:
 stdo = '' if stderr_only else self.stdo
- if self.stde:
+ if self.stde or self.additional_error:
 res = ''
 if stdo:
 res += mlog.cyan('stdout:').get_text(colorize) + '\n'
@@ -951,7 +993,7 @@
 if res-1: != '\n':
 res += '\n'
 res += mlog.cyan('stderr:').get_text(colorize) + '\n'
- res += self.stde
+ res += join_lines(self.stde, self.additional_error)
 else:
 res = stdo
 if res and res-1: != '\n':
@@ -962,32 +1004,29 @@
 def needs_parsing(self) -> bool:
 return False
 
- async def parse(self, harness: 'TestHarness', lines: T.AsyncIteratorstr) -> T.TupleTestResult, str:
+ async def parse(self, harness: 'TestHarness', lines: T.AsyncIteratorstr) -> None:
 async for l in lines:
 pass
- return TestResult.OK, ''
 
 
 class TestRunExitCode(TestRun):
 
- def complete(self, returncode: int, res: TestResult,
- stdo: T.Optionalstr, stde: T.Optionalstr) -> None:
- if res:
+ def complete(self) -> None:
+ if self.res != TestResult.RUNNING:
 pass
- elif returncode == GNU_SKIP_RETURNCODE:
- res = TestResult.SKIP
- elif returncode == GNU_ERROR_RETURNCODE:
- res = TestResult.ERROR
+ elif self.returncode == GNU_SKIP_RETURNCODE:
+ self.res = TestResult.SKIP
+ elif self.returncode == GNU_ERROR_RETURNCODE:
+ self.res = TestResult.ERROR
 else:
- res = TestResult.FAIL if bool(returncode) else TestResult.OK
- super().complete(returncode, res, stdo, stde)
+ self.res = TestResult.FAIL if bool(self.returncode) else TestResult.OK
+ super().complete()
 
 TestRun.PROTOCOL_TO_CLASSTestProtocol.EXITCODE = TestRunExitCode
 
 
 class TestRunGTest(TestRunExitCode):
- def complete(self, returncode: int, res: TestResult,
- stdo: T.Optionalstr, stde: T.Optionalstr) -> None:
+ def complete(self) -> None:
 filename = f'{self.test.name}.xml'
 if self.test.workdir:
 filename = os.path.join(self.test.workdir, filename)
@@ -1000,7 +1039,7 @@
 # will handle the failure, don't generate a stacktrace.
 pass
 
- super().complete(returncode, res, stdo, stde)
+ super().complete()
 
 TestRun.PROTOCOL_TO_CLASSTestProtocol.GTEST = TestRunGTest
 
@@ -1010,21 +1049,22 @@
 def needs_parsing(self) -> bool:
 return True
 
- def complete(self, returncode: int, res: TestResult,
- stdo: str, stde: str) -> None:
- if returncode != 0 and not res.was_killed():
- res = TestResult.ERROR
- stde = stde or ''
- stde += f'\n(test program exited with status code {returncode})'
-
- super().complete(returncode, res, stdo, stde)
+ def complete(self) -> None:
+ if self.returncode != 0 and not self.res.was_killed():
+ self.res = TestResult.ERROR
+ self.stde = self.stde or ''
+ self.stde += f'\n(test program exited with status code {self.returncode})'
+ super().complete()
 
- async def parse(self, harness: 'TestHarness', lines: T.AsyncIteratorstr) -> T.TupleTestResult, str:
- res = TestResult.OK
- error = ''
+ async def parse(self, harness: 'TestHarness', lines: T.AsyncIteratorstr) -> None:
+ res = None
+ warnings = # type: T.ListTAPParser.UnknownLine
+ version = 12
 
 async for i in TAPParser().parse_async(lines):
- if isinstance(i, TAPParser.Bailout):
+ if isinstance(i, TAPParser.Version):
+ version = i.version
+ elif isinstance(i, TAPParser.Bailout):
 res = TestResult.ERROR
 harness.log_subtest(self, i.message, res)
 elif isinstance(i, TAPParser.Test):
@@ -1032,14 +1072,29 @@
 if i.result.is_bad():
 res = TestResult.FAIL
 harness.log_subtest(self, i.name or f'subtest {i.number}', i.result)
+ elif isinstance(i, TAPParser.UnknownLine):
+ warnings.append(i)
 elif isinstance(i, TAPParser.Error):
- error = '\nTAP parsing error: ' + i.message
+ self.additional_error += 'TAP parsing error: ' + i.message
 res = TestResult.ERROR
 
+ if warnings:
+ unknown = str(mlog.yellow('UNKNOWN'))
+ width = len(str(max(i.lineno for i in warnings)))
+ for w in warnings:
+ self.warnings.append(f'stdout: {w.lineno:{width}}: {unknown}: {w.message}')
+ if version > 13:
+ self.warnings.append('Unknown TAP output lines have been ignored. Please open a feature request to\n'
+ 'implement them, or prefix them with a # if they are not TAP syntax.')
+ else:
+ self.warnings.append(str(mlog.red('ERROR')) + ': Unknown TAP output lines for a supported TAP version.\n'
+ 'This is probably a bug in the test; if they are not TAP syntax, prefix them with a #')
 if all(t.result is TestResult.SKIP for t in self.results):
 # This includes the case where self.results is empty
 res = TestResult.SKIP
- return res, error
+
+ if res and self.res == TestResult.RUNNING:
+ self.res = res
 
 TestRun.PROTOCOL_TO_CLASSTestProtocol.TAP = TestRunTAP
 
@@ -1049,7 +1104,7 @@
 def needs_parsing(self) -> bool:
 return True
 
- async def parse(self, harness: 'TestHarness', lines: T.AsyncIteratorstr) -> T.TupleTestResult, str:
+ async def parse(self, harness: 'TestHarness', lines: T.AsyncIteratorstr) -> None:
 def parse_res(n: int, name: str, result: str) -> TAPParser.Test:
 if result == 'ok':
 return TAPParser.Test(n, name, TestResult.OK, None)
@@ -1070,14 +1125,18 @@
 harness.log_subtest(self, name, t.result)
 n += 1
 
+ res = None
+
 if all(t.result is TestResult.SKIP for t in self.results):
 # This includes the case where self.results is empty
- return TestResult.SKIP, ''
+ res = TestResult.SKIP
 elif any(t.result is TestResult.ERROR for t in self.results):
- return TestResult.ERROR, ''
+ res = TestResult.ERROR
 elif any(t.result is TestResult.FAIL for t in self.results):
- return TestResult.FAIL, ''
- return TestResult.OK, ''
+ res = TestResult.FAIL
+
+ if res and self.res == TestResult.RUNNING:
+ self.res = res
 
 TestRun.PROTOCOL_TO_CLASSTestProtocol.RUST = TestRunRust
 
@@ -1090,7 +1149,9 @@
 except UnicodeDecodeError:
 return stream.decode('iso-8859-1', errors='ignore')
 
-async def read_decode(reader: asyncio.StreamReader, console_mode: ConsoleUser) -> str:
+async def read_decode(reader: asyncio.StreamReader,
+ queue: T.Optional'asyncio.QueueT.Optionalstr',
+ console_mode: ConsoleUser) -> str:
 stdo_lines = 
 try:
 while not reader.at_eof():
@@ -1101,32 +1162,19 @@
 line_bytes = e.partial
 except asyncio.LimitOverrunError as e:
 line_bytes = await reader.readexactly(e.consumed)
- line = decode(line_bytes)
- stdo_lines.append(line)
- if console_mode is ConsoleUser.STDOUT:
- print(line, end='', flush=True)
- return ''.join(stdo_lines)
- except asyncio.CancelledError:
- return ''.join(stdo_lines)
-
-# Extract lines out of the StreamReader. Print them
-# along the way if requested, and at the end collect
-# them all into a future.
-async def read_decode_lines(reader: asyncio.StreamReader, q: 'asyncio.QueueT.Optionalstr',
- console_mode: ConsoleUser) -> str:
- stdo_lines = 
- try:
- while not reader.at_eof():
- line = decode(await reader.readline())
- stdo_lines.append(line)
- if console_mode is ConsoleUser.STDOUT:
- print(line, end='', flush=True)
- await q.put(line)
+ if line_bytes:
+ line = decode(line_bytes)
+ stdo_lines.append(line)
+ if console_mode is ConsoleUser.STDOUT:
+ print(line, end='', flush=True)
+ if queue:
+ await queue.put(line)
 return ''.join(stdo_lines)
 except asyncio.CancelledError:
 return ''.join(stdo_lines)
 finally:
- await q.put(None)
+ if queue:
+ await queue.put(None)
 
 def run_with_mono(fname: str) -> bool:
 return fname.endswith('.exe') and not (is_windows() or is_cygwin())
@@ -1145,11 +1193,6 @@
 
 # Custom waiting primitives for asyncio
 
-async def try_wait_one(*awaitables: T.Any, timeout: T.OptionalT.Unionint, float) -> None:
- """Wait for completion of one of the given futures, ignoring timeouts."""
- await asyncio.wait(awaitables,
- timeout=timeout, return_when=asyncio.FIRST_COMPLETED)
-
 async def queue_iter(q: 'asyncio.QueueT.Optionalstr') -> T.AsyncIteratorstr:
 while True:
 item = await q.get()
@@ -1204,27 +1247,38 @@
 self._process = p
 self.stdout = stdout
 self.stderr = stderr
- self.stdo_task = None # type: T.Optionalasyncio.Futurestr
- self.stde_task = None # type: T.Optionalasyncio.Futurestr
+ self.stdo_task: T.Optionalasyncio.TaskNone = None
+ self.stde_task: T.Optionalasyncio.TaskNone = None
 self.postwait_fn = postwait_fn # type: T.Callable, None
 self.all_futures = # type: T.Listasyncio.Future
+ self.queue = None # type: T.Optionalasyncio.QueueT.Optionalstr
+
+ def stdout_lines(self) -> T.AsyncIteratorstr:
+ self.queue = asyncio.Queue()
+ return queue_iter(self.queue)
+
+ def communicate(self,
+ test: 'TestRun',
+ console_mode: ConsoleUser) -> T.TupleT.OptionalT.Awaitablestr,
+ T.OptionalT.Awaitablestr:
+ async def collect_stdo(test: 'TestRun',
+ reader: asyncio.StreamReader,
+ console_mode: ConsoleUser) -> None:
+ test.stdo = await read_decode(reader, self.queue, console_mode)
+
+ async def collect_stde(test: 'TestRun',
+ reader: asyncio.StreamReader,
+ console_mode: ConsoleUser) -> None:
+ test.stde = await read_decode(reader, None, console_mode)
 
- def stdout_lines(self, console_mode: ConsoleUser) -> T.AsyncIteratorstr:
- q = asyncio.Queue() # type: asyncio.QueueT.Optionalstr
- decode_coro = read_decode_lines(self._process.stdout, q, console_mode)
- self.stdo_task = asyncio.ensure_future(decode_coro)
- return queue_iter(q)
-
- def communicate(self, console_mode: ConsoleUser) -> T.TupleT.OptionalT.Awaitablestr,
- T.OptionalT.Awaitablestr:
 # asyncio.ensure_future ensures that printing can
 # run in the background, even before it is awaited
 if self.stdo_task is None and self.stdout is not None:
- decode_coro = read_decode(self._process.stdout, console_mode)
+ decode_coro = collect_stdo(test, self._process.stdout, console_mode)
 self.stdo_task = asyncio.ensure_future(decode_coro)
 self.all_futures.append(self.stdo_task)
 if self.stderr is not None and self.stderr != asyncio.subprocess.STDOUT:
- decode_coro = read_decode(self._process.stderr, console_mode)
+ decode_coro = collect_stde(test, self._process.stderr, console_mode)
 self.stde_task = asyncio.ensure_future(decode_coro)
 self.all_futures.append(self.stde_task)
 
@@ -1245,13 +1299,15 @@
 
 # Make sure the termination signal actually kills the process
 # group, otherwise retry with a SIGKILL.
- await try_wait_one(p.wait(), timeout=0.5)
+ with suppress(asyncio.TimeoutError):
+ await asyncio.wait_for(p.wait(), timeout=0.5)
 if p.returncode is not None:
 return None
 
 os.killpg(p.pid, signal.SIGKILL)
 
- await try_wait_one(p.wait(), timeout=1)
+ with suppress(asyncio.TimeoutError):
+ await asyncio.wait_for(p.wait(), timeout=1)
 if p.returncode is not None:
 return None
 
@@ -1259,7 +1315,8 @@
 # Try to kill it one last time with a direct call.
 # If the process has spawned children, they will remain around.
 p.kill()
- await try_wait_one(p.wait(), timeout=1)
+ with suppress(asyncio.TimeoutError):
+ await asyncio.wait_for(p.wait(), timeout=1)
 if p.returncode is not None:
 return None
 return 'Test process could not be killed.'
@@ -1275,26 +1332,24 @@
 if self.stde_task:
 self.stde_task.cancel()
 
- async def wait(self, timeout: T.Optionalint) -> T.Tupleint, TestResult, T.Optionalstr:
+ async def wait(self, test: 'TestRun') -> None:
 p = self._process
- result = None
- additional_error = None
 
 self.all_futures.append(asyncio.ensure_future(p.wait()))
 try:
- await complete_all(self.all_futures, timeout=timeout)
+ await complete_all(self.all_futures, timeout=test.timeout)
 except asyncio.TimeoutError:
- additional_error = await self._kill()
- result = TestResult.TIMEOUT
+ test.additional_error += await self._kill() or ''
+ test.res = TestResult.TIMEOUT
 except asyncio.CancelledError:
 # The main loop must have seen Ctrl-C.
- additional_error = await self._kill()
- result = TestResult.INTERRUPT
+ test.additional_error += await self._kill() or ''
+ test.res = TestResult.INTERRUPT
 finally:
 if self.postwait_fn:
 self.postwait_fn()
 
- return p.returncode or 0, result, additional_error
+ test.returncode = p.returncode or 0
 
 class SingleTestRunner:
 
@@ -1312,7 +1367,8 @@
 if os.path.basename(c).startswith('wine'):
 env'WINEPATH' = get_wine_shortpath(
 winecmd,
- 'Z:' + p for p in self.test.extra_paths + env.get('WINEPATH', '').split(';')
+ 'Z:' + p for p in self.test.extra_paths + env.get('WINEPATH', '').split(';'),
+ self.test.workdir
 )
 break
 
@@ -1334,26 +1390,30 @@
 timeout = self.test.timeout * self.options.timeout_multiplier
 
 is_parallel = test.is_parallel and self.options.num_processes > 1 and not self.options.gdb
- self.runobj = TestRun(test, env, name, timeout, is_parallel)
+ verbose = (test.verbose or self.options.verbose) and not self.options.quiet
+ self.runobj = TestRun(test, env, name, timeout, is_parallel, verbose)
 
 if self.options.gdb:
 self.console_mode = ConsoleUser.GDB
- elif self.options.verbose and not is_parallel and not self.runobj.needs_parsing:
+ elif self.runobj.direct_stdout:
 self.console_mode = ConsoleUser.STDOUT
 else:
 self.console_mode = ConsoleUser.LOGGER
 
 def _get_test_cmd(self) -> T.OptionalT.Liststr:
- if self.test.fname0.endswith('.jar'):
+ testentry = self.test.fname0
+ if self.options.no_rebuild and self.test.cmd_is_built and not os.path.isfile(testentry):
+ raise TestException(f'The test program {testentry!r} does not exist. Cannot run tests before building them.')
+ if testentry.endswith('.jar'):
 return 'java', '-jar' + self.test.fname
- elif not self.test.is_cross_built and run_with_mono(self.test.fname0):
+ elif not self.test.is_cross_built and run_with_mono(testentry):
 return 'mono' + self.test.fname
- elif self.test.cmd_is_built and self.test.is_cross_built and self.test.needs_exe_wrapper:
+ elif self.test.cmd_is_exe and self.test.is_cross_built and self.test.needs_exe_wrapper:
 if self.test.exe_wrapper is None:
 # Can not run test on cross compiled executable
 # because there is no execute wrapper.
 return None
- elif self.test.cmd_is_built:
+ elif self.test.cmd_is_exe:
 # If the command is not built (ie, its a python script),
 # then we don't check for the exe-wrapper
 if not self.test.exe_wrapper.found():
@@ -1383,9 +1443,9 @@
 
 async def run(self, harness: 'TestHarness') -> TestRun:
 if self.cmd is None:
- skip_stdout = 'Not run because can not execute cross compiled binaries.'
+ self.stdo = 'Not run because can not execute cross compiled binaries.'
 harness.log_start_test(self.runobj)
- self.runobj.complete_skip(skip_stdout)
+ self.runobj.complete_skip()
 else:
 cmd = self.cmd + self.test.cmd_args + self.options.test_args
 self.runobj.start(cmd)
@@ -1394,7 +1454,7 @@
 return self.runobj
 
 async def _run_subprocess(self, args: T.Liststr, *,
- stdout: int, stderr: int,
+ stdout: T.Optionalint, stderr: T.Optionalint,
 env: T.Dictstr, str, cwd: T.Optionalstr) -> TestSubprocess:
 # Let gdb handle ^C instead of us
 if self.options.gdb:
@@ -1450,24 +1510,23 @@
 env=self.runobj.env,
 cwd=self.test.workdir)
 
- parse_task = None
 if self.runobj.needs_parsing:
- parse_coro = self.runobj.parse(harness, p.stdout_lines(self.console_mode))
+ parse_coro = self.runobj.parse(harness, p.stdout_lines())
 parse_task = asyncio.ensure_future(parse_coro)
+ else:
+ parse_task = None
 
- stdo_task, stde_task = p.communicate(self.console_mode)
- returncode, result, additional_error = await p.wait(self.runobj.timeout)
+ stdo_task, stde_task = p.communicate(self.runobj, self.console_mode)
+ await p.wait(self.runobj)
 
- if parse_task is not None:
- res, error = await parse_task
- if error:
- additional_error = join_lines(additional_error, error)
- result = result or res
+ if parse_task:
+ await parse_task
+ if stdo_task:
+ await stdo_task
+ if stde_task:
+ await stde_task
 
- stdo = await stdo_task if stdo_task else ''
- stde = await stde_task if stde_task else ''
- stde = join_lines(stde, additional_error)
- self.runobj.complete(returncode, result, stdo, stde)
+ self.runobj.complete()
 
 
 class TestHarness:
@@ -1484,8 +1543,10 @@
 self.name_max_len = 0
 self.is_run = False
 self.loggers = # type: T.ListTestLogger
- self.loggers.append(ConsoleLogger())
+ self.console_logger = ConsoleLogger()
+ self.loggers.append(self.console_logger)
 self.need_console = False
+ self.ninja = None # type: T.Liststr
 
 self.logfile_base = None # type: T.Optionalstr
 if self.options.logbase and not self.options.gdb:
@@ -1500,9 +1561,52 @@
 if namebase:
 self.logfile_base += '-' + namebase.replace(' ', '_')
 
+ self.prepare_build()
+ self.load_metadata()
+
+ ss = set()
+ for t in self.tests:
+ for s in t.suite:
+ ss.add(s)
+ self.suites = list(ss)
+
+ def get_console_logger(self) -> 'ConsoleLogger':
+ assert self.console_logger
+ return self.console_logger
+
+ def prepare_build(self) -> None:
+ if self.options.no_rebuild:
+ return
+
+ if not (Path(self.options.wd) / 'build.ninja').is_file():
+ print('Only ninja backend is supported to rebuild tests before running them.')
+ # Disable, no point in trying to build anything later
+ self.options.no_rebuild = True
+ return
+
+ self.ninja = environment.detect_ninja()
+ if not self.ninja:
+ print("Can't find ninja, can't rebuild test.")
+ # If ninja can't be found return exit code 127, indicating command
+ # not found for shell, which seems appropriate here. This works
+ # nicely for `git bisect run`, telling it to abort - no point in
+ # continuing if there's no ninja.
+ sys.exit(127)
+
+ def load_metadata(self) -> None:
 startdir = os.getcwd()
 try:
 os.chdir(self.options.wd)
+
+ # Before loading build / test data, make sure that the build
+ # configuration does not need to be regenerated. This needs to
+ # happen before rebuild_deps(), because we need the correct list of
+ # tests and their dependencies to compute
+ if not self.options.no_rebuild:
+ ret = subprocess.run(self.ninja + 'build.ninja').returncode
+ if ret != 0:
+ raise TestException(f'Could not configure {self.options.wd!r}')
+
 self.build_data = build.load(os.getcwd())
 if not self.options.setup:
 self.options.setup = self.build_data.test_setup_default_name
@@ -1513,12 +1617,6 @@
 finally:
 os.chdir(startdir)
 
- ss = set()
- for t in self.tests:
- for s in t.suite:
- ss.add(s)
- self.suites = list(ss)
-
 def load_tests(self, file_name: str) -> T.ListTestSerialisation:
 datafile = Path('meson-private') / file_name
 if not datafile.is_file():
@@ -1536,6 +1634,7 @@
 def close_logfiles(self) -> None:
 for l in self.loggers:
 l.close()
+ self.console_logger = None
 
 def get_test_setup(self, test: T.OptionalTestSerialisation) -> build.TestSetup:
 if ':' in self.options.setup:
@@ -1607,18 +1706,19 @@
 def max_left_width(self) -> int:
 return 2 * self.numlen + 2
 
+ def get_test_num_prefix(self, num: int) -> str:
+ return '{num:{numlen}}/{testcount} '.format(numlen=self.numlen,
+ num=num,
+ testcount=self.test_count)
+
 def format(self, result: TestRun, colorize: bool,
 max_left_width: int = 0,
 prefix: str = '',
 left: T.Optionalstr = None,
 middle: T.Optionalstr = None,
 right: T.Optionalstr = None) -> str:
-
 if left is None:
- left = '{num:{numlen}}/{testcount} '.format(
- numlen=self.numlen,
- num=result.num,
- testcount=self.test_count)
+ left = self.get_test_num_prefix(result.num)
 
 # A non-default max_left_width lets the logger print more stuff before the
 # name, while ensuring that the rightmost columns remain aligned.
@@ -1634,14 +1734,13 @@
 res=result.res.get_text(colorize),
 dur=result.duration,
 durlen=self.duration_max_len + 3)
- detail = result.detail
- if detail:
- right += ' ' + detail
+ details = result.get_details()
+ if details:
+ right += ' ' + details
 return prefix + left + middle + right
 
 def summary(self) -> str:
 return textwrap.dedent('''
-
 Ok: {:<4}
 Expected Fail: {:<4}
 Fail: {:<4}
@@ -1661,7 +1760,7 @@
 tests = self.get_tests()
 if not tests:
 return 0
- if not self.options.no_rebuild and not rebuild_deps(self.options.wd, tests):
+ if not self.options.no_rebuild and not rebuild_deps(self.ninja, self.options.wd, tests):
 # We return 125 here in case the build failed.
 # The reason is that exit code 125 tells `git bisect run` that the current
 # commit should be skipped. Thus users can directly use `meson test` to
@@ -1670,6 +1769,8 @@
 sys.exit(125)
 
 self.name_max_len = max(uniwidth(self.get_pretty_suite(test)) for test in tests)
+ self.options.num_processes = min(self.options.num_processes,
+ len(tests) * self.options.repeat)
 startdir = os.getcwd()
 try:
 os.chdir(self.options.wd)
@@ -1838,9 +1939,9 @@
 async def _run_tests(self, runners: T.ListSingleTestRunner) -> None:
 semaphore = asyncio.Semaphore(self.options.num_processes)
 futures = deque() # type: T.Dequeasyncio.Future
- running_tests = dict() # type: T.Dictasyncio.Future, str
+ running_tests = {} # type: T.Dictasyncio.Future, str
 interrupted = False
- ctrlc_times = deque(maxlen=MAX_CTRLC) # type: T.Dequefloat
+ ctrlc_times = deque(maxlen=MAX_CTRLC) # type: T.Dequefloat
 
 async def run_test(test: SingleTestRunner) -> None:
 async with semaphore:
@@ -1848,6 +1949,9 @@
 return
 res = await test.run(self)
 self.process_test_result(res)
+ maxfail = self.options.maxfail
+ if maxfail and self.fail_count >= maxfail and res.res.is_bad():
+ cancel_all_tests()
 
 def test_done(f: asyncio.Future) -> None:
 if not f.cancelled():
@@ -1934,25 +2038,18 @@
 print(th.get_pretty_suite(t))
 return not tests
 
-def rebuild_deps(wd: str, tests: T.ListTestSerialisation) -> bool:
+def rebuild_deps(ninja: T.Liststr, wd: str, tests: T.ListTestSerialisation) -> bool:
 def convert_path_to_target(path: str) -> str:
 path = os.path.relpath(path, wd)
 if os.sep != '/':
 path = path.replace(os.sep, '/')
 return path
 
- if not (Path(wd) / 'build.ninja').is_file():
- print('Only ninja backend is supported to rebuild tests before running them.')
- return True
-
- ninja = environment.detect_ninja()
- if not ninja:
- print("Can't find ninja, can't rebuild test.")
- return False
+ assert len(ninja) > 0
 
- depends = set() # type: T.Setstr
- targets = set() # type: T.Setstr
- intro_targets = dict() # type: T.Dictstr, T.Liststr
+ depends = set() # type: T.Setstr
+ targets = set() # type: T.Setstr
+ intro_targets = {} # type: T.Dictstr, T.Liststr
 for target in load_info_file(get_infodir(wd), kind='targets'):
 intro_targetstarget'id' = 
 convert_path_to_target(f)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/munstable_coredata.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/munstable_coredata.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 
 from . import coredata as cdata
@@ -61,17 +62,17 @@
     coredata = cdata.load(options.builddir)
     backend = coredata.get_option(OptionKey('backend'))
     for k, v in sorted(coredata.__dict__.items()):
-        if k in ('backend_options', 'base_options', 'builtins', 'compiler_options', 'user_options'):
+        if k in {'backend_options', 'base_options', 'builtins', 'compiler_options', 'user_options'}:
             # use `meson configure` to view these
             pass
-        elif k in 'install_guid', 'test_guid', 'regen_guid':
+        elif k in {'install_guid', 'test_guid', 'regen_guid'}:
             if all_backends or backend.startswith('vs'):
                 print(k + ': ' + v)
         elif k == 'target_guids':
             if all_backends or backend.startswith('vs'):
                 print(k + ':')
                 dump_guids(v)
-        elif k in 'lang_guids':
+        elif k == 'lang_guids':
             if all_backends or backend.startswith('vs') or backend == 'xcode':
                 print(k + ':')
                 dump_guids(v)
@@ -103,7 +104,7 @@
                 print('      version: ' + repr(dep.get_version()))
 
             for for_machine in iter(MachineChoice):
-                items_list = list(sorted(vfor_machine.items()))
+                items_list = sorted(vfor_machine.items())
                 if items_list:
                     print(f'Cached dependencies for {for_machine.get_lower_case_name()} machine')
                     for dep_key, deps in items_list:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/optinterpreter.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/optinterpreter.py Changed

@@ -21,7 +21,8 @@
 from . import mlog
 from .interpreterbase import FeatureNew, typed_pos_args, typed_kwargs, ContainerTypeInfo, KwargInfo, permittedKwargs
 if T.TYPE_CHECKING:
-    from .interpreterbase import TV_func, TYPE_var, TYPE_kwargs
+    from .interpreterbase import TYPE_var, TYPE_kwargs
+    from .interpreterbase import SubProject
     from typing_extensions import TypedDict
     FuncOptionArgs = TypedDict('FuncOptionArgs', {
         'type': str,
@@ -31,7 +32,7 @@
         'value': object,
         'min': T.Optionalint,
         'max': T.Optionalint,
-        'deprecated': T.Unionbool, T.Dictstr, str, T.Liststr,
+        'deprecated': T.Unionbool, str, T.Dictstr, str, T.Liststr,
         })
     ParserArgs = TypedDict('ParserArgs', {
         'yield': bool,
@@ -50,8 +51,8 @@
 
 
 class OptionInterpreter:
-    def __init__(self, subproject: str) -> None:
-        self.options: 'coredata.KeyedOptionDictType' = {}
+    def __init__(self, subproject: 'SubProject') -> None:
+        self.options: 'coredata.MutableKeyedOptionDictType' = {}
         self.subproject = subproject
         self.option_types = {'string': self.string_parser,
                              'boolean': self.boolean_parser,
@@ -152,7 +153,7 @@
                   KwargInfo('value', object),
                   KwargInfo('min', (int, type(None))),
                   KwargInfo('max', (int, type(None))),
-                  KwargInfo('deprecated', (bool, ContainerTypeInfo(dict, str), ContainerTypeInfo(list, str)),
+                  KwargInfo('deprecated', (bool, str, ContainerTypeInfo(dict, str), ContainerTypeInfo(list, str)),
                             default=False, since='0.60.0')
                   )
     @typed_pos_args('option', str)
@@ -176,7 +177,8 @@
         parser_kwargs = {k: v for k, v in kwargs.items() if k in known_parser_kwargs and v is not None}
         opt = parser(description, T.cast('ParserArgs', parser_kwargs))
         opt.deprecated = kwargs'deprecated'
-
+        if isinstance(opt.deprecated, str):
+            FeatureNew.single_use('String value to "deprecated" keyword argument', '0.63.0', self.subproject)
         if key in self.options:
             mlog.deprecation(f'Option {opt_name} already exists.')
         self.optionskey = opt

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/programs.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/programs.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 """Representations and logic for External and Internal Programs."""
 
@@ -100,16 +101,25 @@
 '''Human friendly description of the command'''
 return ' '.join(self.command)
 
- def get_version(self, interpreter: 'Interpreter') -> str:
+ def get_version(self, interpreter: T.Optional'Interpreter' = None) -> str:
 if not self.cached_version:
 from . import build
 raw_cmd = self.get_command() + '--version'
- res = interpreter.run_command_impl(interpreter.current_node, (self, '--version'),
- {'capture': True, 'check': True, 'env': build.EnvironmentVariables()},
- True)
- output = res.stdout.strip()
+ if interpreter:
+ res = interpreter.run_command_impl(interpreter.current_node, (self, '--version'),
+ {'capture': True,
+ 'check': True,
+ 'env': build.EnvironmentVariables()},
+ True)
+ o, e = res.stdout, res.stderr
+ else:
+ p, o, e = mesonlib.Popen_safe(raw_cmd)
+ if p.returncode != 0:
+ cmd_str = mesonlib.join_args(raw_cmd)
+ raise mesonlib.MesonException(f'Command {cmd_str!r} failed with status {p.returncode}.')
+ output = o.strip()
 if not output:
- output = res.stderr.strip()
+ output = e.strip()
 match = re.search(r'(0-90-9\.+)', output)
 if not match:
 raise mesonlib.MesonException(f'Could not find a version number in output of {raw_cmd!r}')
@@ -336,25 +346,6 @@
 return False
 
 
-class EmptyExternalProgram(ExternalProgram): # lgtm py/missing-call-to-init
- '''
- A program object that returns an empty list of commands. Used for cases
- such as a cross file exe_wrapper to represent that it's not required.
- '''
-
- def __init__(self) -> None:
- self.name = None
- self.command = 
- self.path = None
-
- def __repr__(self) -> str:
- r = '<{} {!r} -> {!r}>'
- return r.format(self.__class__.__name__, self.name, self.command)
-
- def found(self) -> bool:
- return True
-
-
 class OverrideProgram(ExternalProgram):
 
 """A script overriding a program."""

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/rewriter.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/rewriter.py Changed

@@ -22,15 +22,19 @@
 # - remove files from a target
 # - move targets
 # - reindent?
+from __future__ import annotations
 
-from .ast import IntrospectionInterpreter, build_target_functions, AstConditionLevel, AstIDGenerator, AstIndentationGenerator, AstPrinter
+from .ast import IntrospectionInterpreter, BUILD_TARGET_FUNCTIONS, AstConditionLevel, AstIDGenerator, AstIndentationGenerator, AstPrinter
 from mesonbuild.mesonlib import MesonException
 from . import mlog, environment
 from functools import wraps
-from .mparser import Token, ArrayNode, ArgumentNode, AssignmentNode, BaseNode, BooleanNode, ElementaryNode, IdNode, FunctionNode, StringNode
+from .mparser import Token, ArrayNode, ArgumentNode, AssignmentNode, BooleanNode, ElementaryNode, IdNode, FunctionNode, StringNode
 import json, os, re, sys
 import typing as T
 
+if T.TYPE_CHECKING:
+    from .mparser import BaseNode
+
 class RewriterException(MesonException):
     pass
 
@@ -395,7 +399,7 @@
         def check_list(name: str) -> T.ListBaseNode:
             result = 
             for i in self.interpreter.targets:
-                if name == i'name' or name == i'id':
+                if name in {i'name', i'id'}:
                     result += i
             return result
 
@@ -416,7 +420,7 @@
         if target in self.interpreter.assignments:
             node = self.interpreter.assignmentstarget
             if isinstance(node, FunctionNode):
-                if node.func_name in 'executable', 'jar', 'library', 'shared_library', 'shared_module', 'static_library', 'both_libraries':
+                if node.func_name in {'executable', 'jar', 'library', 'shared_library', 'shared_module', 'static_library', 'both_libraries'}:
                     tgt = self.interpreter.assign_valstarget
 
         return tgt
@@ -436,7 +440,7 @@
         if dependency in self.interpreter.assignments:
             node = self.interpreter.assignmentsdependency
             if isinstance(node, FunctionNode):
-                if node.func_name in 'dependency':
+                if node.func_name == 'dependency':
                     name = self.interpreter.flatten_args(node.args)0
                     dep = check_list(name)
 
@@ -624,7 +628,7 @@
             args = 
             if isinstance(n, FunctionNode):
                 args = list(n.args.arguments)
-                if n.func_name in build_target_functions:
+                if n.func_name in BUILD_TARGET_FUNCTIONS:
                     args.pop(0)
             elif isinstance(n, ArrayNode):
                 args = n.args.arguments
@@ -880,7 +884,7 @@
         # Sort based on line and column in reversed order
         work_nodes = {'node': x, 'action': 'modify'} for x in self.modified_nodes
         work_nodes += {'node': x, 'action': 'rm'} for x in self.to_remove_nodes
-        work_nodes = list(sorted(work_nodes, key=lambda x: (x'node'.lineno, x'node'.colno), reverse=True))
+        work_nodes = sorted(work_nodes, key=lambda x: (x'node'.lineno, x'node'.colno), reverse=True)
         work_nodes += {'node': x, 'action': 'add'} for x in self.to_add_nodes
 
         # Generating the new replacement string
@@ -948,15 +952,15 @@
                 while rawend != '=':
                     end += 1
                 end += 1 # Handle the '='
-                while rawend in ' ', '\n', '\t':
+                while rawend in {' ', '\n', '\t'}:
                     end += 1
 
             filesi'file''raw' = raw:start + i'str' + rawend:
 
         for i in str_list:
-            if i'action' in 'modify', 'rm':
+            if i'action' in {'modify', 'rm'}:
                 remove_node(i)
-            elif i'action' in 'add':
+            elif i'action' == 'add':
                 filesi'file''raw' += i'str' + '\n'
 
         # Write the files back

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/__init__.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/__init__.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/clangformat.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/clangformat.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import argparse
 import subprocess
@@ -18,17 +19,25 @@
 
 from .run_tool import run_tool
 from ..environment import detect_clangformat
+from ..mesonlib import version_compare
+from ..programs import ExternalProgram
 import typing as T
 
 def run_clang_format(fname: Path, exelist: T.Liststr, check: bool) -> subprocess.CompletedProcess:
+    clangformat_10 = False
     if check:
-        original = fname.read_bytes()
+        cformat_ver = ExternalProgram('clang-format', exelist).get_version()
+        if version_compare(cformat_ver, '>=10'):
+            clangformat_10 = True
+            exelist = exelist + '--dry-run', '--Werror'
+        else:
+            original = fname.read_bytes()
     before = fname.stat().st_mtime
     ret = subprocess.run(exelist + '-style=file', '-i', str(fname))
     after = fname.stat().st_mtime
     if before != after:
         print('File reformatted: ', fname)
-        if check:
+        if check and not clangformat_10:
             # Restore the original if only checking.
             fname.write_bytes(original)
             ret.returncode = 1

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/clangtidy.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/clangtidy.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/cleantrees.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/cleantrees.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/cmake_run_ctgt.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/cmake_run_ctgt.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/cmd_or_ps.ps1 -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/cmd_or_ps.ps1 Changed

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/copy.py Added

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/coverage.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/coverage.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from mesonbuild import environment, mesonlib
 
@@ -23,9 +24,25 @@
 
     (gcovr_exe, gcovr_version, lcov_exe, genhtml_exe, llvm_cov_exe) = environment.find_coverage_tools()
 
+    # load config files for tools if available in the source tree
+    # - lcov requires manually specifying a per-project config
+    # - gcovr picks up the per-project config, and also supports filtering files
+    #   so don't exclude subprojects ourselves, if the project has a config,
+    #   because they either don't want that, or should set it themselves
+    lcovrc = os.path.join(source_root, '.lcovrc')
+    if os.path.exists(lcovrc):
+        lcov_config = '--config-file', lcovrc
+    else:
+        lcov_config = 
+
+    gcovr_config = '-e', re.escape(subproject_root)
+
     # gcovr >= 4.2 requires a different syntax for out of source builds
     if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=4.2'):
         gcovr_base_cmd = gcovr_exe, '-r', source_root, build_root
+        # it also started supporting the config file
+        if os.path.exists(os.path.join(source_root, 'gcovr.cfg')):
+            gcovr_config = 
     else:
         gcovr_base_cmd = gcovr_exe, '-r', build_root
 
@@ -36,9 +53,8 @@
 
     if not outputs or 'xml' in outputs:
         if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=3.3'):
-            subprocess.check_call(gcovr_base_cmd +
+            subprocess.check_call(gcovr_base_cmd + gcovr_config +
                                   '-x',
-                                   '-e', re.escape(subproject_root),
                                    '-o', os.path.join(log_dir, 'coverage.xml')
                                     + gcov_exe_args)
             outfiles.append(('Xml', pathlib.Path(log_dir, 'coverage.xml')))
@@ -48,10 +64,9 @@
 
     if not outputs or 'sonarqube' in outputs:
         if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=4.2'):
-            subprocess.check_call(gcovr_base_cmd +
+            subprocess.check_call(gcovr_base_cmd + gcovr_config +
                                   '--sonarqube',
                                    '-o', os.path.join(log_dir, 'sonarqube.xml'),
-                                   '-e', re.escape(subproject_root)
                                     + gcov_exe_args)
             outfiles.append(('Sonarqube', pathlib.Path(log_dir, 'sonarqube.xml')))
         elif outputs:
@@ -60,10 +75,9 @@
 
     if not outputs or 'text' in outputs:
         if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=3.3'):
-            subprocess.check_call(gcovr_base_cmd +
-                                  '-e', re.escape(subproject_root),
-                                   '-o', os.path.join(log_dir, 'coverage.txt')
-                                    + gcov_exe_args)
+            subprocess.check_call(gcovr_base_cmd + gcovr_config +
+                                  '-o', os.path.join(log_dir, 'coverage.txt') +
+                                  gcov_exe_args)
             outfiles.append(('Text', pathlib.Path(log_dir, 'coverage.txt')))
         elif outputs:
             print('gcovr >= 3.3 needed to generate text coverage report')
@@ -96,6 +110,7 @@
                                    '--initial',
                                    '--output-file',
                                    initial_tracefile +
+                                  lcov_config +
                                   gcov_tool_args)
             subprocess.check_call(lcov_exe,
                                    '--directory', build_root,
@@ -103,25 +118,26 @@
                                    '--output-file', run_tracefile,
                                    '--no-checksum',
                                    '--rc', 'lcov_branch_coverage=1' +
+                                  lcov_config +
                                   gcov_tool_args)
             # Join initial and test results.
             subprocess.check_call(lcov_exe,
                                    '-a', initial_tracefile,
                                    '-a', run_tracefile,
                                    '--rc', 'lcov_branch_coverage=1',
-                                   '-o', raw_tracefile)
+                                   '-o', raw_tracefile + lcov_config)
             # Remove all directories outside the source_root from the covinfo
             subprocess.check_call(lcov_exe,
                                    '--extract', raw_tracefile,
                                    os.path.join(source_root, '*'),
                                    '--rc', 'lcov_branch_coverage=1',
-                                   '--output-file', covinfo)
+                                   '--output-file', covinfo + lcov_config)
             # Remove all directories inside subproject dir
             subprocess.check_call(lcov_exe,
                                    '--remove', covinfo,
                                    os.path.join(subproject_root, '*'),
                                    '--rc', 'lcov_branch_coverage=1',
-                                   '--output-file', covinfo)
+                                   '--output-file', covinfo + lcov_config)
             subprocess.check_call(genhtml_exe,
                                    '--prefix', build_root,
                                    '--prefix', source_root,
@@ -136,11 +152,10 @@
             htmloutdir = os.path.join(log_dir, 'coveragereport')
             if not os.path.isdir(htmloutdir):
                 os.mkdir(htmloutdir)
-            subprocess.check_call(gcovr_base_cmd +
+            subprocess.check_call(gcovr_base_cmd + gcovr_config +
                                   '--html',
                                    '--html-details',
                                    '--print-summary',
-                                   '-e', re.escape(subproject_root),
                                    '-o', os.path.join(htmloutdir, 'index.html'),
                                    )
             outfiles.append(('Html', pathlib.Path(htmloutdir, 'index.html')))

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/delwithsuffix.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/delwithsuffix.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/depfixer.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/depfixer.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 
 import sys
@@ -21,7 +22,7 @@
 import subprocess
 import typing as T
 
-from ..mesonlib import OrderedSet, generate_list
+from ..mesonlib import OrderedSet, generate_list, Popen_safe
 
 SHT_STRTAB = 3
 DT_NEEDED = 1
@@ -83,10 +84,8 @@
 class SectionHeader(DataSizes):
     def __init__(self, ifile: T.BinaryIO, ptrsize: int, is_le: bool) -> None:
         super().__init__(ptrsize, is_le)
-        if ptrsize == 64:
-            is_64 = True
-        else:
-            is_64 = False
+        is_64 = ptrsize == 64
+
 # Elf64_Word
         self.sh_name = struct.unpack(self.Word, ifile.read(self.WordSize))0
 # Elf64_Word
@@ -306,7 +305,7 @@
             self.bf.seek(offset)
             name = self.read_str()
             if name.startswith(prefix):
-                basename = name.split(b'/')-1
+                basename = name.rsplit(b'/', maxsplit=1)-1
                 padding = b'\0' * (len(name) - len(basename))
                 newname = basename + padding
                 assert len(newname) == len(name)
@@ -391,9 +390,9 @@
             e.fix_rpath(fname, rpath_dirs_to_remove, new_rpath)
 
 def get_darwin_rpaths_to_remove(fname: str) -> T.Liststr:
-    out = subprocess.check_output('otool', '-l', fname,
-                                  universal_newlines=True,
-                                  stderr=subprocess.DEVNULL)
+    p, out, _ = Popen_safe('otool', '-l', fname, stderr=subprocess.DEVNULL)
+    if p.returncode != 0:
+        raise subprocess.CalledProcessError(p.returncode, p.args, out)
     result = 
     current_cmd = 'FOOBAR'
     for line in out.split('\n'):
@@ -459,7 +458,7 @@
         raise SystemExit(err)
 
 def fix_jar(fname: str) -> None:
-    subprocess.check_call('jar', 'xfv', fname, 'META-INF/MANIFEST.MF')
+    subprocess.check_call('jar', 'xf', fname, 'META-INF/MANIFEST.MF')
     with open('META-INF/MANIFEST.MF', 'r+', encoding='utf-8') as f:
         lines = f.readlines()
         f.seek(0)
@@ -467,10 +466,15 @@
             if not line.startswith('Class-Path:'):
                 f.write(line)
         f.truncate()
-    subprocess.check_call('jar', 'ufm', fname, 'META-INF/MANIFEST.MF')
+    # jar -um doesn't allow removing existing attributes.  Use -uM instead,
+    # which a) removes the existing manifest from the jar and b) disables
+    # special-casing for the manifest file, so we can re-add it as a normal
+    # archive member.  This puts the manifest at the end of the jar rather
+    # than the beginning, but the spec doesn't forbid that.
+    subprocess.check_call('jar', 'ufM', fname, 'META-INF/MANIFEST.MF')
 
 def fix_rpath(fname: str, rpath_dirs_to_remove: T.Setbytes, new_rpath: T.Unionstr, bytes, final_path: str, install_name_mappings: T.Dictstr, str, verbose: bool = True) -> None:
-    global INSTALL_NAME_TOOL
+    global INSTALL_NAME_TOOL  # pylint: disable=global-statement
     # Static libraries, import libraries, debug information, headers, etc
     # never have rpaths
     # DLLs and EXE currently do not need runtime path fixing

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/depscan.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/depscan.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import json
 import os
@@ -20,9 +21,12 @@
 import sys
 import typing as T
 
-from ..backend.ninjabackend import TargetDependencyScannerInfo, ninja_quote
+from ..backend.ninjabackend import ninja_quote
 from ..compilers.compilers import lang_suffixes
 
+if T.TYPE_CHECKING:
+    from ..backend.ninjabackend import TargetDependencyScannerInfo
+
 CPP_IMPORT_RE = re.compile(r'\w*import (a-zA-Z0-9+);')
 CPP_EXPORT_RE = re.compile(r'\w*export module (a-zA-Z0-9+);')
 
@@ -38,16 +42,18 @@
 class DependencyScanner:
     def __init__(self, pickle_file: str, outfile: str, sources: T.Liststr):
         with open(pickle_file, 'rb') as pf:
-            self.target_data = pickle.load(pf) # type: TargetDependencyScannerInfo
+            self.target_data: TargetDependencyScannerInfo = pickle.load(pf)
         self.outfile = outfile
         self.sources = sources
-        self.provided_by = {} # type: T.Dictstr, str
-        self.exports = {} # type: T.Dictstr, str
-        self.needs = {} # type: T.Dictstr, T.Liststr
-        self.sources_with_exports =  # type: T.Liststr
+        self.provided_by: T.Dictstr, str = {}
+        self.exports: T.Dictstr, str = {}
+        self.needs: T.Dictstr, T.Liststr = {}
+        self.sources_with_exports: T.Liststr = 
 
     def scan_file(self, fname: str) -> None:
-        suffix = os.path.splitext(fname)11:.lower()
+        suffix = os.path.splitext(fname)11:
+        if suffix != 'C':
+            suffix = suffix.lower()
         if suffix in lang_suffixes'fortran':
             self.scan_fortran_file(fname)
         elif suffix in lang_suffixes'cpp':
@@ -58,7 +64,7 @@
     def scan_fortran_file(self, fname: str) -> None:
         fpath = pathlib.Path(fname)
         modules_in_this_file = set()
-        for line in fpath.read_text(encoding='utf-8').split('\n'):
+        for line in fpath.read_text(encoding='utf-8', errors='ignore').split('\n'):
             import_match = FORTRAN_USE_RE.match(line)
             export_match = FORTRAN_MODULE_RE.match(line)
             submodule_export_match = FORTRAN_SUBMOD_RE.match(line)
@@ -108,7 +114,7 @@
 
     def scan_cpp_file(self, fname: str) -> None:
         fpath = pathlib.Path(fname)
-        for line in fpath.read_text(encoding='utf-8').split('\n'):
+        for line in fpath.read_text(encoding='utf-8', errors='ignore').split('\n'):
             import_match = CPP_IMPORT_RE.match(line)
             export_match = CPP_EXPORT_RE.match(line)
             if import_match:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/dirchanger.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/dirchanger.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/env2mfile.py Added

@@ -0,0 +1,368 @@
+# Copyright 2022 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+import sys, os, subprocess, shutil
+import shlex
+import typing as T
+
+from .. import envconfig
+from .. import mlog
+from ..compilers import compilers
+from ..compilers.detect import defaults as compiler_names
+
+if T.TYPE_CHECKING:
+    import argparse
+
+def has_for_build() -> bool:
+    for cenv in envconfig.ENV_VAR_COMPILER_MAP.values():
+        if os.environ.get(cenv + '_FOR_BUILD'):
+            return True
+    return False
+
+def add_arguments(parser: 'argparse.ArgumentParser') -> None:
+    parser.add_argument('--debarch', default=None,
+                        help='The dpkg architecture to generate.')
+    parser.add_argument('--gccsuffix', default="",
+                        help='A particular gcc version suffix if necessary.')
+    parser.add_argument('-o', required=True, dest='outfile',
+                        help='The output file.')
+    parser.add_argument('--cross', default=False, action='store_true',
+                        help='Generate a cross compilation file.')
+    parser.add_argument('--native', default=False, action='store_true',
+                        help='Generate a native compilation file.')
+    parser.add_argument('--system', default=None,
+                        help='Define system for cross compilation.')
+    parser.add_argument('--cpu', default=None,
+                        help='Define cpu for cross compilation.')
+    parser.add_argument('--cpu-family', default=None,
+                        help='Define cpu family for cross compilation.')
+    parser.add_argument('--endian', default='little', choices='big', 'little',
+                        help='Define endianness for cross compilation.')
+
+class MachineInfo:
+    def __init__(self) -> None:
+        self.compilers: T.Dictstr, T.Liststr = {}
+        self.binaries: T.Dictstr, T.Liststr = {}
+        self.properties: T.Dictstr, T.Unionstr, T.Liststr = {}
+        self.compile_args: T.Dictstr, T.Liststr = {}
+        self.link_args: T.Dictstr, T.Liststr = {}
+        self.cmake: T.Dictstr, T.Unionstr, T.Liststr = {}
+
+        self.system: T.Optionalstr = None
+        self.cpu: T.Optionalstr = None
+        self.cpu_family: T.Optionalstr = None
+        self.endian: T.Optionalstr = None
+
+#parser = argparse.ArgumentParser(description='''Generate cross compilation definition file for the Meson build system.
+#
+#If you do not specify the --arch argument, Meson assumes that running
+#plain 'dpkg-architecture' will return correct information for the
+#host system.
+#
+#This script must be run in an environment where CPPFLAGS et al are set to the
+#same values used in the actual compilation.
+#'''
+#)
+
+def locate_path(program: str) -> T.Liststr:
+    if os.path.isabs(program):
+        return program
+    for d in os.get_exec_path():
+        f = os.path.join(d, program)
+        if os.access(f, os.X_OK):
+            return f
+    raise ValueError("%s not found on $PATH" % program)
+
+def write_args_line(ofile: T.TextIO, name: str, args: T.Unionstr, T.Liststr) -> None:
+    if len(args) == 0:
+        return
+    if isinstance(args, str):
+        ostr = name + "= '" + args + "'\n"
+    else:
+        ostr = name + ' = '
+        ostr += ', '.join("'" + i + "'" for i in args)
+        ostr += '\n'
+    ofile.write(ostr)
+
+def get_args_from_envvars(infos: MachineInfo) -> None:
+    cppflags = shlex.split(os.environ.get('CPPFLAGS', ''))
+    cflags = shlex.split(os.environ.get('CFLAGS', ''))
+    cxxflags = shlex.split(os.environ.get('CXXFLAGS', ''))
+    objcflags = shlex.split(os.environ.get('OBJCFLAGS', ''))
+    objcxxflags = shlex.split(os.environ.get('OBJCXXFLAGS', ''))
+    ldflags = shlex.split(os.environ.get('LDFLAGS', ''))
+
+    c_args = cppflags + cflags
+    cpp_args = cppflags + cxxflags
+    c_link_args = cflags + ldflags
+    cpp_link_args = cxxflags + ldflags
+
+    objc_args = cppflags + objcflags
+    objcpp_args = cppflags + objcxxflags
+    objc_link_args = objcflags + ldflags
+    objcpp_link_args = objcxxflags + ldflags
+
+    if c_args:
+        infos.compile_args'c' = c_args
+    if c_link_args:
+        infos.link_args'c' = c_link_args
+    if cpp_args:
+        infos.compile_args'cpp' = cpp_args
+    if cpp_link_args:
+        infos.link_args'cpp' = cpp_link_args
+    if objc_args:
+        infos.compile_args'objc' = objc_args
+    if objc_link_args:
+        infos.link_args'objc' = objc_link_args
+    if objcpp_args:
+        infos.compile_args'objcpp' = objcpp_args
+    if objcpp_link_args:
+        infos.link_args'objcpp' = objcpp_link_args
+
+cpu_family_map = {
+    'mips64el': 'mips64',
+    'i686': 'x86',
+}
+cpu_map = {
+    'armhf': 'arm7hlf',
+    'mips64el': 'mips64'
+}
+
+def deb_detect_cmake(infos: MachineInfo, data: T.Dictstr, str) -> None:
+    system_name_map = {'linux': 'Linux', 'kfreebsd': 'kFreeBSD', 'hurd': 'GNU'}
+    system_processor_map = {'arm': 'armv7l', 'mips64el': 'mips64', 'powerpc64le': 'ppc64le'}
+
+    infos.cmake"CMAKE_C_COMPILER" = infos.compilers'c'
+    infos.cmake"CMAKE_CXX_COMPILER" = infos.compilers'cpp'
+    infos.cmake"CMAKE_SYSTEM_NAME" = system_name_mapdata'DEB_HOST_ARCH_OS'
+    infos.cmake"CMAKE_SYSTEM_PROCESSOR" = system_processor_map.get(data'DEB_HOST_GNU_CPU',
+                                                                     data'DEB_HOST_GNU_CPU')
+
+def deb_compiler_lookup(infos: MachineInfo, compilerstems: T.ListT.Tuplestr, str, host_arch: str, gccsuffix: str) -> None:
+    for langname, stem in compilerstems:
+        compilername = f'{host_arch}-{stem}{gccsuffix}'
+        try:
+            p = locate_path(compilername)
+            infos.compilerslangname = p
+        except ValueError:
+            pass
+
+def detect_cross_debianlike(options: T.Any) -> MachineInfo:
+    if options.debarch is None:
+        cmd = 'dpkg-architecture'
+    else:
+        cmd = 'dpkg-architecture', '-a' + options.debarch
+    output = subprocess.check_output(cmd, universal_newlines=True,
+                                     stderr=subprocess.DEVNULL)
+    data = {}
+    for line in output.split('\n'):
+        line = line.strip()
+        if line == '':
+            continue
+        k, v = line.split('=', 1)
+        datak = v
+    host_arch = data'DEB_HOST_GNU_TYPE'
+    host_os = data'DEB_HOST_ARCH_OS'
+    host_cpu_family = cpu_family_map.get(data'DEB_HOST_GNU_CPU',
+                                         data'DEB_HOST_GNU_CPU')
+    host_cpu = cpu_map.get(data'DEB_HOST_ARCH',
+                           data'DEB_HOST_ARCH')
+    host_endian = data'DEB_HOST_ARCH_ENDIAN'
+
+    compilerstems = ('c', 'gcc'),
+                     ('cpp', 'g++'),
+                     ('objc', 'gobjc'),
+                     ('objcpp', 'gobjc++')
+    infos = MachineInfo()
+    deb_compiler_lookup(infos, compilerstems, host_arch, options.gccsuffix)
+    if len(infos.compilers) == 0:
+        print('Warning: no compilers were detected.')
+    infos.binaries'ar' = locate_path("%s-ar" % host_arch)
+    infos.binaries'strip' = locate_path("%s-strip" % host_arch)
+    infos.binaries'objcopy' = locate_path("%s-objcopy" % host_arch)
+    infos.binaries'ld' = locate_path("%s-ld" % host_arch)
+    try:
+        infos.binaries'cmake' = locate_path("cmake")
+        deb_detect_cmake(infos, data)
+    except ValueError:
+        pass
+    try:
+        infos.binaries'pkgconfig' = locate_path("%s-pkg-config" % host_arch)
+    except ValueError:
+        pass # pkg-config is optional
+    try:
+        infos.binaries'cups-config' = locate_path("cups-config")
+    except ValueError:
+        pass
+    infos.system = host_os
+    infos.cpu_family = host_cpu_family
+    infos.cpu = host_cpu
+    infos.endian = host_endian
+
+    get_args_from_envvars(infos)
+    return infos
+
+def write_machine_file(infos: MachineInfo, ofilename: str, write_system_info: bool) -> None:
+    tmpfilename = ofilename + '~'
+    with open(tmpfilename, 'w', encoding='utf-8') as ofile:
+        ofile.write('binaries\n')
+        ofile.write('# Compilers\n')
+        for langname in sorted(infos.compilers.keys()):
+            compiler = infos.compilerslangname
+            write_args_line(ofile, langname, compiler)
+        ofile.write('\n')
+
+        ofile.write('# Other binaries\n')
+        for exename in sorted(infos.binaries.keys()):
+            exe = infos.binariesexename
+            write_args_line(ofile, exename, exe)
+        ofile.write('\n')
+
+        ofile.write('properties\n')
+        all_langs = list(set(infos.compile_args.keys()).union(set(infos.link_args.keys())))
+        all_langs.sort()
+        for lang in all_langs:
+            if lang in infos.compile_args:
+                write_args_line(ofile, lang + '_args', infos.compile_argslang)
+            if lang in infos.link_args:
+                write_args_line(ofile, lang + '_link_args', infos.link_argslang)
+        for k, v in infos.properties.items():
+            write_args_line(ofile, k, v)
+        ofile.write('\n')
+
+        if infos.cmake:
+            ofile.write('cmake\n\n')
+            for k, v in infos.cmake.items():
+                write_args_line(ofile, k, v)
+            ofile.write('\n')
+
+        if write_system_info:
+            ofile.write('host_machine\n')
+            ofile.write(f"cpu = '{infos.cpu}'\n")
+            ofile.write(f"cpu_family = '{infos.cpu_family}'\n")
+            ofile.write(f"endian = '{infos.endian}'\n")
+            ofile.write(f"system = '{infos.system}'\n")
+    os.replace(tmpfilename, ofilename)
+
+def detect_language_args_from_envvars(langname: str, envvar_suffix: str = '') -> T.TupleT.Liststr, T.Liststr:
+    ldflags = tuple(shlex.split(os.environ.get('LDFLAGS' + envvar_suffix, '')))
+    compile_args = shlex.split(os.environ.get(compilers.CFLAGS_MAPPINGlangname + envvar_suffix, ''))
+    if langname in compilers.LANGUAGES_USING_CPPFLAGS:
+        cppflags = tuple(shlex.split(os.environ.get('CPPFLAGS' + envvar_suffix, '')))
+        lang_compile_args = list(cppflags) + compile_args
+    else:
+        lang_compile_args = compile_args
+    lang_link_args = list(ldflags) + compile_args
+    return (lang_compile_args, lang_link_args)
+
+def detect_compilers_from_envvars(envvar_suffix: str = '') -> MachineInfo:
+    infos = MachineInfo()
+    for langname, envvarname in envconfig.ENV_VAR_COMPILER_MAP.items():
+        compilerstr = os.environ.get(envvarname + envvar_suffix)
+        if not compilerstr:
+            continue
+        compiler = shlex.split(compilerstr)
+        infos.compilerslangname = compiler
+        lang_compile_args, lang_link_args = detect_language_args_from_envvars(langname, envvar_suffix)
+        if lang_compile_args:
+            infos.compile_argslangname = lang_compile_args
+        if lang_link_args:
+            infos.link_argslangname = lang_link_args
+    return infos
+
+def detect_binaries_from_envvars(infos: MachineInfo, envvar_suffix: str = '') -> None:
+    for binname, envvar_base in envconfig.ENV_VAR_TOOL_MAP.items():
+        envvar = envvar_base + envvar_suffix
+        binstr = os.environ.get(envvar)
+        if binstr:
+            infos.binariesbinname = shlex.split(binstr)
+
+def detect_cross_system(infos: MachineInfo, options: T.Any) -> None:
+    for optname in ('system', 'cpu', 'cpu_family', 'endian'):
+        v = getattr(options, optname)
+        if not v:
+            mlog.error(f'Cross property "{optname}" missing, set it with --{optname.replace("_", "-")}.')
+            sys.exit(1)
+        setattr(infos, optname, v)
+
+def detect_cross_env(options: T.Any) -> MachineInfo:
+    if options.debarch:
+        print('Detecting cross environment via dpkg-reconfigure.')
+        infos = detect_cross_debianlike(options)
+    else:
+        print('Detecting cross environment via environment variables.')
+        infos = detect_compilers_from_envvars()
+        detect_cross_system(infos, options)
+    return infos
+
+def add_compiler_if_missing(infos: MachineInfo, langname: str, exe_names: T.Liststr) -> None:
+    if langname in infos.compilers:
+        return
+    for exe_name in exe_names:
+        lookup = shutil.which(exe_name)
+        if not lookup:
+            continue
+        compflags, linkflags = detect_language_args_from_envvars(langname)
+        infos.compilerslangname = lookup
+        if compflags:
+            infos.compile_argslangname = compflags
+        if linkflags:
+            infos.link_argslangname = linkflags
+        return
+
+def detect_missing_native_compilers(infos: MachineInfo) -> None:
+    # T.Any per-platform special detection should go here.
+    for langname, exes in compiler_names.items():
+        if langname not in envconfig.ENV_VAR_COMPILER_MAP:
+            continue
+        add_compiler_if_missing(infos, langname, exes)
+
+def detect_missing_native_binaries(infos: MachineInfo) -> None:
+    # T.Any per-platform special detection should go here.
+    for toolname in sorted(envconfig.ENV_VAR_TOOL_MAP.keys()):
+        if toolname in infos.binaries:
+            continue
+        exe = shutil.which(toolname)
+        if exe:
+            infos.binariestoolname = exe
+
+def detect_native_env(options: T.Any) -> MachineInfo:
+    use_for_build = has_for_build()
+    if use_for_build:
+        mlog.log('Using FOR_BUILD envvars for detection')
+        esuffix = '_FOR_BUILD'
+    else:
+        mlog.log('Using regular envvars for detection.')
+        esuffix = ''
+    infos = detect_compilers_from_envvars(esuffix)
+    detect_missing_native_compilers(infos)
+    detect_binaries_from_envvars(infos, esuffix)
+    detect_missing_native_binaries(infos)
+    return infos
+
+def run(options: T.Any) -> None:
+    if options.cross and options.native:
+        sys.exit('You can only specify either --cross or --native, not both.')
+    if not options.cross and not options.native:
+        sys.exit('You must specify --cross or --native.')
+    mlog.notice('This functionality is experimental and subject to change.')
+    detect_cross = options.cross
+    if detect_cross:
+        infos = detect_cross_env(options)
+        write_system_info = True
+    else:
+        infos = detect_native_env(options)
+        write_system_info = False
+    write_machine_file(infos, options.outfile, write_system_info)

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/externalproject.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/externalproject.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import os
 import argparse
@@ -48,16 +49,15 @@
         with open(self.stampfile, 'w', encoding='utf-8'):
             pass
 
-    def gnu_make(self) -> bool:
+    def supports_jobs_flag(self) -> bool:
         p, o, e = Popen_safe(self.make + '--version')
-        if p.returncode == 0 and 'GNU Make' in o:
+        if p.returncode == 0 and ('GNU Make' in o or 'waf' in o):
             return True
         return False
 
     def build(self) -> int:
-        is_make = self.make0 == 'make'
         make_cmd = self.make.copy()
-        if is_make and self.gnu_make():
+        if self.supports_jobs_flag():
             make_cmd.append(f'-j{multiprocessing.cpu_count()}')
         rc = self._run('build', make_cmd)
         if rc != 0:
@@ -65,10 +65,7 @@
 
         install_cmd = self.make.copy()
         install_env = {}
-        if is_make:
-            install_cmd.append(f'DESTDIR={self.install_dir}')
-        else:
-            install_env'DESTDIR' = self.install_dir
+        install_env'DESTDIR' = self.install_dir
         install_cmd.append('install')
         rc = self._run('install', install_cmd, install_env)
         if rc != 0:

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/gettext.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/gettext.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import os
 import argparse
@@ -23,7 +24,11 @@
 parser.add_argument('--datadirs', default='')
 parser.add_argument('--langs', default='')
 parser.add_argument('--localedir', default='')
+parser.add_argument('--source-root', default='')
 parser.add_argument('--subdir', default='')
+parser.add_argument('--xgettext', default='xgettext')
+parser.add_argument('--msgmerge', default='msgmerge')
+parser.add_argument('--msginit', default='msginit')
 parser.add_argument('--extra-args', default='')
 
 def read_linguas(src_sub: str) -> T.Liststr:
@@ -42,7 +47,7 @@
         print(f'Could not find file LINGUAS in {src_sub}')
         return 
 
-def run_potgen(src_sub: str, pkgname: str, datadirs: str, args: T.Liststr) -> int:
+def run_potgen(src_sub: str, xgettext: str, pkgname: str, datadirs: str, args: T.Liststr, source_root: str) -> int:
     listfile = os.path.join(src_sub, 'POTFILES.in')
     if not os.path.exists(listfile):
         listfile = os.path.join(src_sub, 'POTFILES')
@@ -55,18 +60,18 @@
         child_env'GETTEXTDATADIRS' = datadirs
 
     ofile = os.path.join(src_sub, pkgname + '.pot')
-    return subprocess.call('xgettext', '--package-name=' + pkgname, '-p', src_sub, '-f', listfile,
-                            '-D', os.environ'MESON_SOURCE_ROOT', '-k_', '-o', ofile + args,
+    return subprocess.call(xgettext, '--package-name=' + pkgname, '-p', src_sub, '-f', listfile,
+                            '-D', source_root, '-k_', '-o', ofile + args,
                            env=child_env)
 
-def update_po(src_sub: str, pkgname: str, langs: T.Liststr) -> int:
+def update_po(src_sub: str, msgmerge: str, msginit: str, pkgname: str, langs: T.Liststr) -> int:
     potfile = os.path.join(src_sub, pkgname + '.pot')
     for l in langs:
         pofile = os.path.join(src_sub, l + '.po')
         if os.path.exists(pofile):
-            subprocess.check_call('msgmerge', '-q', '-o', pofile, pofile, potfile)
+            subprocess.check_call(msgmerge, '-q', '-o', pofile, pofile, potfile)
         else:
-            subprocess.check_call('msginit', '--input', potfile, '--output-file', pofile, '--locale', l, '--no-translator')
+            subprocess.check_call(msginit, '--input', potfile, '--output-file', pofile, '--locale', l, '--no-translator')
     return 0
 
 def run(args: T.Liststr) -> int:
@@ -74,20 +79,18 @@
     subcmd = options.command
     langs = options.langs.split('@@') if options.langs else None
     extra_args = options.extra_args.split('@@') if options.extra_args else 
-    subdir = os.environ.get('MESON_SUBDIR', '')
-    if options.subdir:
-        subdir = options.subdir
-    src_sub = os.path.join(os.environ'MESON_SOURCE_ROOT', subdir)
+    subdir = options.subdir
+    src_sub = os.path.join(options.source_root, subdir)
 
     if not langs:
         langs = read_linguas(src_sub)
 
     if subcmd == 'pot':
-        return run_potgen(src_sub, options.pkgname, options.datadirs, extra_args)
+        return run_potgen(src_sub, options.xgettext, options.pkgname, options.datadirs, extra_args, options.source_root)
     elif subcmd == 'update_po':
-        if run_potgen(src_sub, options.pkgname, options.datadirs, extra_args) != 0:
+        if run_potgen(src_sub, options.xgettext, options.pkgname, options.datadirs, extra_args, options.source_root) != 0:
             return 1
-        return update_po(src_sub, options.pkgname, langs)
+        return update_po(src_sub, options.msgmerge, options.msginit, options.pkgname, langs)
     else:
         print('Unknown subcommand.')
         return 1

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/gtkdochelper.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/gtkdochelper.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/hotdochelper.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/hotdochelper.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/itstool.py Added

@@ -0,0 +1,86 @@
+# Copyright 2016 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+import os
+import argparse
+import subprocess
+import tempfile
+import shutil
+import typing as T
+
+parser = argparse.ArgumentParser()
+parser.add_argument('command')
+parser.add_argument('--build-dir', default='')
+parser.add_argument('-i', '--input', default='')
+parser.add_argument('-o', '--output', default='')
+parser.add_argument('--itstool', default='itstool')
+parser.add_argument('--its', action='append', default=)
+parser.add_argument('mo_files', nargs='+')
+
+
+def run_join(build_dir: str, itstool: str, its_files: T.Liststr, mo_files: T.Liststr,
+             in_fname: str, out_fname: str) -> int:
+    if not mo_files:
+        print('No mo files specified to use for translation.')
+        return 1
+
+    with tempfile.TemporaryDirectory(prefix=os.path.basename(in_fname), dir=build_dir) as tmp_dir:
+        # copy mo files to have the right names so itstool can infer their locale
+        locale_mo_files = 
+        for mo_file in mo_files:
+            if not os.path.exists(mo_file):
+                print(f'Could not find mo file {mo_file}')
+                return 1
+            if not mo_file.endswith('.mo'):
+                print(f'File is not a mo file: {mo_file}')
+                return 1
+            # determine locale of this mo file
+            parts = mo_file.partition('LC_MESSAGES')
+            if parts0.endswith((os.sep, '/')):
+                locale = os.path.basename(parts0:-1)
+            else:
+                locale = os.path.basename(parts0)
+            tmp_mo_fname = os.path.join(tmp_dir, locale + '.mo')
+            shutil.copy(mo_file, tmp_mo_fname)
+            locale_mo_files.append(tmp_mo_fname)
+
+        cmd = itstool
+        if its_files:
+            for fname in its_files:
+                cmd.extend('-i', fname)
+        cmd.extend('-j', in_fname,
+                    '-o', out_fname)
+        cmd.extend(locale_mo_files)
+
+        return subprocess.call(cmd)
+
+
+def run(args: T.Liststr) -> int:
+    options = parser.parse_args(args)
+    command = options.command
+    build_dir = os.environ.get('MESON_BUILD_ROOT', os.getcwd())
+    if options.build_dir:
+        build_dir = options.build_dir
+
+    if command == 'join':
+        return run_join(build_dir,
+                        options.itstool,
+                        options.its,
+                        options.mo_files,
+                        options.input,
+                        options.output)
+    else:
+        print('Unknown subcommand.')
+        return 1

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/meson_exe.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/meson_exe.py Changed

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 import os
 import sys
@@ -20,10 +21,7 @@
 import typing as T
 import locale
 
-from .. import mesonlib
-from ..backend.backends import ExecutableSerialisation
-
-options = None
+from ..utils.core import ExecutableSerialisation
 
 def buildparser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description='Custom executable wrapper for Meson. Do not run on your own, mmm\'kay?')
@@ -48,10 +46,12 @@
     if exe.extra_paths:
         child_env'PATH' = (os.pathsep.join(exe.extra_paths + '') +
                              child_env'PATH')
-        if exe.exe_wrapper and mesonlib.substring_is_in_list('wine', exe.exe_wrapper.get_command()):
+        if exe.exe_wrapper and any('wine' in i for i in exe.exe_wrapper.get_command()):
+            from .. import mesonlib
             child_env'WINEPATH' = mesonlib.get_wine_shortpath(
                 exe.exe_wrapper.get_command(),
-                'Z:' + p for p in exe.extra_paths + child_env.get('WINEPATH', '').split(';')
+                'Z:' + p for p in exe.extra_paths + child_env.get('WINEPATH', '').split(';'),
+                exe.workdir
             )
 
     stdin = None
@@ -101,7 +101,6 @@
     return 0
 
 def run(args: T.Liststr) -> int:
-    global options
     parser = buildparser()
     options, cmd_args = parser.parse_known_args(args)
     # argparse supports double dash to separate options and positional arguments,

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/msgfmthelper.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/msgfmthelper.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/regen_checker.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/regen_checker.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/run_tool.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/run_tool.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/scanbuild.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/scanbuild.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/symbolextractor.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/symbolextractor.py Changed

@@ -19,6 +19,7 @@
 
 # This file is basically a reimplementation of
 # http://cgit.freedesktop.org/libreoffice/core/commit/?id=3213cd54b76bc80a6f0516aac75a48ff3b2ad67c
+from __future__ import annotations
 
 import typing as T
 import os, sys
@@ -53,7 +54,6 @@
 f.write(text)
 
 def print_tool_warning(tools: T.Liststr, msg: str, stderr: T.Optionalstr = None) -> None:
- global TOOL_WARNING_FILE
 if os.path.exists(TOOL_WARNING_FILE):
 return
 m = f'{tools!r} {msg}. {RELINKING_WARNING}'
@@ -119,7 +119,7 @@
 # Store the size of symbols pointing to data objects so we relink
 # when those change, which is needed because of copy relocations
 # https://github.com/mesonbuild/meson/pull/7132#issuecomment-628353702
- if line_split1.upper() in ('B', 'G', 'D') and len(line_split) >= 4:
+ if line_split1.upper() in {'B', 'G', 'D'} and len(line_split) >= 4:
 entry += line_split3
 result += ' '.join(entry)
 write_if_changed('\n'.join(result) + '\n', outfilename)
@@ -288,6 +288,8 @@
 openbsd_syms(libfilename, outfilename)
 elif mesonlib.is_freebsd():
 freebsd_syms(libfilename, outfilename)
+ elif mesonlib.is_netbsd():
+ freebsd_syms(libfilename, outfilename)
 elif mesonlib.is_windows():
 if os.path.isfile(impfilename):
 windows_syms(impfilename, outfilename)
@@ -314,7 +316,7 @@
 dummy_syms(outfilename)
 
 def run(args: T.Liststr) -> int:
- global TOOL_WARNING_FILE
+ global TOOL_WARNING_FILE # pylint: disable=global-statement
 options = parser.parse_args(args)
 if len(options.args) != 4:
 print('symbolextractor.py <shared library file> <import library> <output file>')

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/tags.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/tags.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/test_loaded_modules.py Added

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/uninstall.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/uninstall.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/scripts/vcstagger.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/vcstagger.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/scripts/yasm.py Added

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/cpptemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/cpptemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/cstemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/cstemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/ctemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/ctemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/cudatemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/cudatemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/dlangtemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/dlangtemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/fortrantemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/fortrantemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/javatemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/javatemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/mesontemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/mesontemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/objcpptemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/objcpptemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/objctemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/objctemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/rusttemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/rusttemplates.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/samplefactory.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/samplefactory.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/sampleimpl.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/sampleimpl.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/templates/valatemplates.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/templates/valatemplates.py Changed

@@ -11,6 +11,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
+
 from mesonbuild.templates.sampleimpl import SampleImpl
 import re
 
@@ -93,9 +95,9 @@
         open(source_name, 'w', encoding='utf-8').write(hello_vala_template.format(project_name=self.name))
         open('meson.build', 'w', encoding='utf-8').write(
             hello_vala_meson_template.format(project_name=self.name,
-                                            exe_name=lowercase_token,
-                                            source_name=source_name,
-                                            version=self.version))
+                                             exe_name=lowercase_token,
+                                             source_name=source_name,
+                                             version=self.version))
 
     def create_library(self) -> None:
         lowercase_token = re.sub(r'^a-z0-9', '_', self.name.lower())

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/utils Added

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/utils/__init__.py Added

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/utils/core.py Added

@@ -0,0 +1,151 @@
+# Copyright 2012-2022 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Contains the strict minimum to run scripts.
+
+When the backend needs to call back into Meson during compilation for running
+scripts or wrapping commands, it is important to load as little python modules
+as possible for performance reasons.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+import os
+import abc
+import typing as T
+
+if T.TYPE_CHECKING:
+ from typing_extensions import Literal
+ from ..mparser import BaseNode
+ from . import programs
+
+ EnvInitValueType = T.Dictstr, T.Unionstr, T.Liststr
+
+
+class MesonException(Exception):
+ '''Exceptions thrown by Meson'''
+
+ def __init__(self, *args: object, file: T.Optionalstr = None,
+ lineno: T.Optionalint = None, colno: T.Optionalint = None):
+ super().__init__(*args)
+ self.file = file
+ self.lineno = lineno
+ self.colno = colno
+
+ @classmethod
+ def from_node(cls, *args: object, node: BaseNode) -> MesonException:
+ """Create a MesonException with location data from a BaseNode
+
+ :param node: A BaseNode to set location data from
+ :return: A Meson Exception instance
+ """
+ return cls(*args, file=node.filename, lineno=node.lineno, colno=node.colno)
+
+class MesonBugException(MesonException):
+ '''Exceptions thrown when there is a clear Meson bug that should be reported'''
+
+ def __init__(self, msg: str, file: T.Optionalstr = None,
+ lineno: T.Optionalint = None, colno: T.Optionalint = None):
+ super().__init__(msg + '\n\n This is a Meson bug and should be reported!',
+ file=file, lineno=lineno, colno=colno)
+
+class HoldableObject(metaclass=abc.ABCMeta):
+ ''' Dummy base class for all objects that can be
+ held by an interpreter.baseobjects.ObjectHolder '''
+
+class EnvironmentVariables(HoldableObject):
+ def __init__(self, values: T.OptionalEnvInitValueType = None,
+ init_method: Literal'set', 'prepend', 'append' = 'set', separator: str = os.pathsep) -> None:
+ self.envvars: T.ListT.TupleT.CallableT.Dictstr, str, str, T.Liststr, str, str, str, T.Liststr, str = 
+ # The set of all env vars we have operations for. Only used for self.has_name()
+ self.varnames: T.Setstr = set()
+
+ if values:
+ init_func = getattr(self, init_method)
+ for name, value in values.items():
+ v = value if isinstance(value, list) else value
+ init_func(name, v, separator)
+
+ def __repr__(self) -> str:
+ repr_str = "<{0}: {1}>"
+ return repr_str.format(self.__class__.__name__, self.envvars)
+
+ def hash(self, hasher: T.Any):
+ myenv = self.get_env({})
+ for key in sorted(myenv.keys()):
+ hasher.update(bytes(key, encoding='utf-8'))
+ hasher.update(b',')
+ hasher.update(bytes(myenvkey, encoding='utf-8'))
+ hasher.update(b';')
+
+ def has_name(self, name: str) -> bool:
+ return name in self.varnames
+
+ def get_names(self) -> T.Setstr:
+ return self.varnames
+
+ def set(self, name: str, values: T.Liststr, separator: str = os.pathsep) -> None:
+ self.varnames.add(name)
+ self.envvars.append((self._set, name, values, separator))
+
+ def append(self, name: str, values: T.Liststr, separator: str = os.pathsep) -> None:
+ self.varnames.add(name)
+ self.envvars.append((self._append, name, values, separator))
+
+ def prepend(self, name: str, values: T.Liststr, separator: str = os.pathsep) -> None:
+ self.varnames.add(name)
+ self.envvars.append((self._prepend, name, values, separator))
+
+ @staticmethod
+ def _set(env: T.Dictstr, str, name: str, values: T.Liststr, separator: str, default_value: T.Optionalstr) -> str:
+ return separator.join(values)
+
+ @staticmethod
+ def _append(env: T.Dictstr, str, name: str, values: T.Liststr, separator: str, default_value: T.Optionalstr) -> str:
+ curr = env.get(name, default_value)
+ return separator.join(values if curr is None else curr + values)
+
+ @staticmethod
+ def _prepend(env: T.Dictstr, str, name: str, values: T.Liststr, separator: str, default_value: T.Optionalstr) -> str:
+ curr = env.get(name, default_value)
+ return separator.join(values if curr is None else values + curr)
+
+ def get_env(self, full_env: T.MutableMappingstr, str, dump: bool = False) -> T.Dictstr, str:
+ env = full_env.copy()
+ for method, name, values, separator in self.envvars:
+ default_value = f'${name}' if dump else None
+ envname = method(env, name, values, separator, default_value)
+ return env
+
+
+@dataclass(eq=False)
+class ExecutableSerialisation:
+
+ # XXX: should capture and feed default to False, instead of None?
+
+ cmd_args: T.Liststr
+ env: T.OptionalEnvironmentVariables = None
+ exe_wrapper: T.Optional'programs.ExternalProgram' = None
+ workdir: T.Optionalstr = None
+ extra_paths: T.OptionalT.List = None
+ capture: T.Optionalbool = None
+ feed: T.Optionalbool = None
+ tag: T.Optionalstr = None
+ verbose: bool = False
+
+ def __post_init__(self) -> None:
+ self.pickled = False
+ self.skip_if_destdir = False
+ self.subproject = ''

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/utils/platform.py Added

@@ -0,0 +1,38 @@
+# SPDX-license-identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+"""base classes providing no-op functionality.."""
+
+import os
+import typing as T
+
+from .. import mlog
+
+__all__ = 'BuildDirLock'
+
+# This needs to be inherited by the specific implementations to make type
+# checking happy
+class BuildDirLock:
+
+    def __init__(self, builddir: str) -> None:
+        self.lockfilename = os.path.join(builddir, 'meson-private/meson.lock')
+
+    def __enter__(self) -> None:
+        mlog.debug('Calling the no-op version of BuildDirLock')
+
+    def __exit__(self, *args: T.Any) -> None:
+        pass

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/utils/posix.py Added

@@ -0,0 +1,43 @@
+# SPDX-license-identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+"""Posix specific implementations of mesonlib functionality."""
+
+import fcntl
+import typing as T
+
+from .universal import MesonException
+from .platform import BuildDirLock as BuildDirLockBase
+
+__all__ = 'BuildDirLock'
+
+class BuildDirLock(BuildDirLockBase):
+
+    def __enter__(self) -> None:
+        self.lockfile = open(self.lockfilename, 'w', encoding='utf-8')
+        try:
+            fcntl.flock(self.lockfile, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except (BlockingIOError, PermissionError):
+            self.lockfile.close()
+            raise MesonException('Some other Meson process is already using this build directory. Exiting.')
+        except OSError as e:
+            self.lockfile.close()
+            raise MesonException(f'Failed to lock the build directory: {e.strerror}')
+
+    def __exit__(self, *args: T.Any) -> None:
+        fcntl.flock(self.lockfile, fcntl.LOCK_UN)
+        self.lockfile.close()

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/utils/universal.py Added

@@ -0,0 +1,2365 @@
+# Copyright 2012-2020 The Meson development team
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""A library of random helper functionality."""
+
+from __future__ import annotations
+from pathlib import Path
+import argparse
+import enum
+import sys
+import stat
+import time
+import abc
+import platform, subprocess, operator, os, shlex, shutil, re
+import collections
+from functools import lru_cache, wraps, total_ordering
+from itertools import tee
+from tempfile import TemporaryDirectory, NamedTemporaryFile
+import typing as T
+import textwrap
+import copy
+import pickle
+import errno
+
+from mesonbuild import mlog
+from .core import MesonException, HoldableObject
+
+if T.TYPE_CHECKING:
+ from typing_extensions import Literal
+
+ from .._typing import ImmutableListProtocol
+ from ..build import ConfigurationData
+ from ..coredata import KeyedOptionDictType, UserOption
+ from ..compilers.compilers import Compiler
+
+FileOrString = T.Union'File', str
+
+_T = T.TypeVar('_T')
+_U = T.TypeVar('_U')
+
+__all__ = 
+ 'GIT',
+ 'python_command',
+ 'project_meson_versions',
+ 'SecondLevelHolder',
+ 'File',
+ 'FileMode',
+ 'GitException',
+ 'LibType',
+ 'MachineChoice',
+ 'EnvironmentException',
+ 'FileOrString',
+ 'GitException',
+ 'OptionKey',
+ 'dump_conf_header',
+ 'OptionOverrideProxy',
+ 'OptionType',
+ 'OrderedSet',
+ 'PerMachine',
+ 'PerMachineDefaultable',
+ 'PerThreeMachine',
+ 'PerThreeMachineDefaultable',
+ 'ProgressBar',
+ 'RealPathAction',
+ 'TemporaryDirectoryWinProof',
+ 'Version',
+ 'check_direntry_issues',
+ 'classify_unity_sources',
+ 'current_vs_supports_modules',
+ 'darwin_get_object_archs',
+ 'default_libdir',
+ 'default_libexecdir',
+ 'default_prefix',
+ 'default_datadir',
+ 'default_includedir',
+ 'default_infodir',
+ 'default_localedir',
+ 'default_mandir',
+ 'default_sbindir',
+ 'default_sysconfdir',
+ 'detect_subprojects',
+ 'detect_vcs',
+ 'do_conf_file',
+ 'do_conf_str',
+ 'do_replacement',
+ 'exe_exists',
+ 'expand_arguments',
+ 'extract_as_list',
+ 'first',
+ 'generate_list',
+ 'get_compiler_for_source',
+ 'get_filenames_templates_dict',
+ 'get_variable_regex',
+ 'get_wine_shortpath',
+ 'git',
+ 'has_path_sep',
+ 'is_aix',
+ 'is_android',
+ 'is_ascii_string',
+ 'is_cygwin',
+ 'is_debianlike',
+ 'is_dragonflybsd',
+ 'is_freebsd',
+ 'is_haiku',
+ 'is_hurd',
+ 'is_irix',
+ 'is_linux',
+ 'is_netbsd',
+ 'is_openbsd',
+ 'is_osx',
+ 'is_qnx',
+ 'is_sunos',
+ 'is_windows',
+ 'is_wsl',
+ 'iter_regexin_iter',
+ 'join_args',
+ 'listify',
+ 'partition',
+ 'path_is_in_root',
+ 'pickle_load',
+ 'Popen_safe',
+ 'quiet_git',
+ 'quote_arg',
+ 'relative_to_if_possible',
+ 'relpath',
+ 'replace_if_different',
+ 'run_once',
+ 'get_meson_command',
+ 'set_meson_command',
+ 'split_args',
+ 'stringlistify',
+ 'substitute_values',
+ 'substring_is_in_list',
+ 'typeslistify',
+ 'verbose_git',
+ 'version_compare',
+ 'version_compare_condition_with_min',
+ 'version_compare_many',
+ 'search_version',
+ 'windows_detect_native_arch',
+ 'windows_proof_rm',
+ 'windows_proof_rmtree',
+
+
+
+# TODO: this is such a hack, this really should be either in coredata or in the
+# interpreter
+# {subproject: project_meson_version}
+project_meson_versions = collections.defaultdict(str) # type: T.DefaultDictstr, str
+
+
+from glob import glob
+
+if os.path.basename(sys.executable) == 'meson.exe':
+ # In Windows and using the MSI installed executable.
+ python_command = sys.executable, 'runpython'
+else:
+ python_command = sys.executable
+_meson_command: T.Optional'ImmutableListProtocolstr' = None
+
+
+class EnvironmentException(MesonException):
+ '''Exceptions thrown while processing and creating the build environment'''
+
+class GitException(MesonException):
+ def __init__(self, msg: str, output: T.Optionalstr = None):
+ super().__init__(msg)
+ self.output = output.strip() if output else ''
+
+GIT = shutil.which('git')
+def git(cmd: T.Liststr, workingdir: T.Unionstr, bytes, os.PathLike, check: bool = False, **kwargs: T.Any) -> T.Tuplesubprocess.Popen, str, str:
+ cmd = GIT + cmd
+ p, o, e = Popen_safe(cmd, cwd=workingdir, **kwargs)
+ if check and p.returncode != 0:
+ raise GitException('Git command failed: ' + str(cmd), e)
+ return p, o, e
+
+def quiet_git(cmd: T.Liststr, workingdir: T.Unionstr, bytes, os.PathLike, check: bool = False) -> T.Tuplebool, str:
+ if not GIT:
+ m = 'Git program not found.'
+ if check:
+ raise GitException(m)
+ return False, m
+ p, o, e = git(cmd, workingdir, check)
+ if p.returncode != 0:
+ return False, e
+ return True, o
+
+def verbose_git(cmd: T.Liststr, workingdir: T.Unionstr, bytes, os.PathLike, check: bool = False) -> bool:
+ if not GIT:
+ m = 'Git program not found.'
+ if check:
+ raise GitException(m)
+ return False
+ p, _, _ = git(cmd, workingdir, check, stdout=None, stderr=None)
+ return p.returncode == 0
+
+def set_meson_command(mainfile: str) -> None:
+ global _meson_command # pylint: disable=global-statement
+ # On UNIX-like systems `meson` is a Python script
+ # On Windows `meson` and `meson.exe` are wrapper exes
+ if not mainfile.endswith('.py'):
+ _meson_command = mainfile
+ elif os.path.isabs(mainfile) and mainfile.endswith('mesonmain.py'):
+ # Can't actually run meson with an absolute path to mesonmain.py, it must be run as -m mesonbuild.mesonmain
+ _meson_command = python_command + '-m', 'mesonbuild.mesonmain'
+ else:
+ # Either run uninstalled, or full path to meson-script.py
+ _meson_command = python_command + mainfile
+ # We print this value for unit tests.
+ if 'MESON_COMMAND_TESTS' in os.environ:
+ mlog.log(f'meson_command is {_meson_command!r}')
+
+
+def get_meson_command() -> T.Optional'ImmutableListProtocolstr':
+ return _meson_command
+
+
+def is_ascii_string(astring: T.Unionstr, bytes) -> bool:
+ try:
+ if isinstance(astring, str):
+ astring.encode('ascii')
+ elif isinstance(astring, bytes):
+ astring.decode('ascii')
+ except UnicodeDecodeError:
+ return False
+ return True
+
+
+def check_direntry_issues(direntry_array: T.UnionT.IterableT.Unionstr, bytes, str, bytes) -> None:
+ import locale
+ # Warn if the locale is not UTF-8. This can cause various unfixable issues
+ # such as os.stat not being able to decode filenames with unicode in them.
+ # There is no way to reset both the preferred encoding and the filesystem
+ # encoding, so we can just warn about it.
+ e = locale.getpreferredencoding()
+ if e.upper() != 'UTF-8' and not is_windows():
+ if isinstance(direntry_array, (str, bytes)):
+ direntry_array = direntry_array
+ for de in direntry_array:
+ if is_ascii_string(de):
+ continue
+ mlog.warning(textwrap.dedent(f'''
+ You are using {e!r} which is not a Unicode-compatible
+ locale but you are trying to access a file system entry called {de!r} which is
+ not pure ASCII. This may cause problems.
+ '''), file=sys.stderr)
+
+class SecondLevelHolder(HoldableObject, metaclass=abc.ABCMeta):
+ ''' A second level object holder. The primary purpose
+ of such objects is to hold multiple objects with one
+ default option. '''
+
+ @abc.abstractmethod
+ def get_default_object(self) -> HoldableObject: ...
+
+class FileMode:
+ # The first triad is for owner permissions, the second for group permissions,
+ # and the third for others (everyone else).
+ # For the 1st character:
+ # 'r' means can read
+ # '-' means not allowed
+ # For the 2nd character:
+ # 'w' means can write
+ # '-' means not allowed
+ # For the 3rd character:
+ # 'x' means can execute
+ # 's' means can execute and setuid/setgid is set (owner/group triads only)
+ # 'S' means cannot execute and setuid/setgid is set (owner/group triads only)
+ # 't' means can execute and sticky bit is set ("others" triads only)
+ # 'T' means cannot execute and sticky bit is set ("others" triads only)
+ # '-' means none of these are allowed
+ #
+ # The meanings of 'rwx' perms is not obvious for directories; see:
+ # https://www.hackinglinuxexposed.com/articles/20030424.html
+ #
+ # For information on this notation such as setuid/setgid/sticky bits, see:
+ # https://en.wikipedia.org/wiki/File_system_permissions#Symbolic_notation
+ symbolic_perms_regex = re.compile('r-w-xsS-' # Owner perms
+ 'r-w-xsS-' # Group perms
+ 'r-w-xtT-') # Others perms
+
+ def __init__(self, perms: T.Optionalstr = None, owner: T.Unionstr, int, None = None,
+ group: T.Unionstr, int, None = None):
+ self.perms_s = perms
+ self.perms = self.perms_s_to_bits(perms)
+ self.owner = owner
+ self.group = group
+
+ def __repr__(self) -> str:
+ ret = '<FileMode: {!r} owner={} group={}'
+ return ret.format(self.perms_s, self.owner, self.group)
+
+ @classmethod
+ def perms_s_to_bits(cls, perms_s: T.Optionalstr) -> int:
+ '''
+ Does the opposite of stat.filemode(), converts strings of the form
+ 'rwxr-xr-x' to st_mode enums which can be passed to os.chmod()
+ '''
+ if perms_s is None:
+ # No perms specified, we will not touch the permissions
+ return -1
+ eg = 'rwxr-xr-x'
+ if not isinstance(perms_s, str):
+ raise MesonException(f'Install perms must be a string. For example, {eg!r}')
+ if len(perms_s) != 9 or not cls.symbolic_perms_regex.match(perms_s):
+ raise MesonException(f'File perms {perms_s!r} must be exactly 9 chars. For example, {eg!r}')
+ perms = 0
+ # Owner perms
+ if perms_s0 == 'r':
+ perms |= stat.S_IRUSR
+ if perms_s1 == 'w':
+ perms |= stat.S_IWUSR
+ if perms_s2 == 'x':
+ perms |= stat.S_IXUSR
+ elif perms_s2 == 'S':
+ perms |= stat.S_ISUID
+ elif perms_s2 == 's':
+ perms |= stat.S_IXUSR
+ perms |= stat.S_ISUID
+ # Group perms
+ if perms_s3 == 'r':
+ perms |= stat.S_IRGRP
+ if perms_s4 == 'w':
+ perms |= stat.S_IWGRP
+ if perms_s5 == 'x':
+ perms |= stat.S_IXGRP
+ elif perms_s5 == 'S':
+ perms |= stat.S_ISGID
+ elif perms_s5 == 's':
+ perms |= stat.S_IXGRP
+ perms |= stat.S_ISGID
+ # Others perms
+ if perms_s6 == 'r':
+ perms |= stat.S_IROTH
+ if perms_s7 == 'w':
+ perms |= stat.S_IWOTH
+ if perms_s8 == 'x':
+ perms |= stat.S_IXOTH
+ elif perms_s8 == 'T':
+ perms |= stat.S_ISVTX
+ elif perms_s8 == 't':
+ perms |= stat.S_IXOTH
+ perms |= stat.S_ISVTX
+ return perms
+
+dot_C_dot_H_warning = """You are using .C or .H files in your project. This is deprecated.
+ Currently, Meson treats this as C++ code, but they
+ used to be treated as C code.
+ Note that the situation is a bit more complex if you are using the
+ Visual Studio compiler, as it treats .C files as C code, unless you add
+ the /TP compiler flag, but this is unreliable.
+ See https://github.com/mesonbuild/meson/pull/8747 for the discussions."""
+class File(HoldableObject):
+ def __init__(self, is_built: bool, subdir: str, fname: str):
+ if fname.endswith(".C") or fname.endswith(".H"):
+ mlog.warning(dot_C_dot_H_warning, once=True)
+ self.is_built = is_built
+ self.subdir = subdir
+ self.fname = fname
+ self.hash = hash((is_built, subdir, fname))
+
+ def __str__(self) -> str:
+ return self.relative_name()
+
+ def __repr__(self) -> str:
+ ret = '<File: {0}'
+ if not self.is_built:
+ ret += ' (not built)'
+ ret += '>'
+ return ret.format(self.relative_name())
+
+ @staticmethod
+ @lru_cache(maxsize=None)
+ def from_source_file(source_root: str, subdir: str, fname: str) -> 'File':
+ if not os.path.isfile(os.path.join(source_root, subdir, fname)):
+ raise MesonException(f'File {fname} does not exist.')
+ return File(False, subdir, fname)
+
+ @staticmethod
+ def from_built_file(subdir: str, fname: str) -> 'File':
+ return File(True, subdir, fname)
+
+ @staticmethod
+ def from_built_relative(relative: str) -> 'File':
+ dirpart, fnamepart = os.path.split(relative)
+ return File(True, dirpart, fnamepart)
+
+ @staticmethod
+ def from_absolute_file(fname: str) -> 'File':
+ return File(False, '', fname)
+
+ @lru_cache(maxsize=None)
+ def rel_to_builddir(self, build_to_src: str) -> str:
+ if self.is_built:
+ return self.relative_name()
+ else:
+ return os.path.join(build_to_src, self.subdir, self.fname)
+
+ @lru_cache(maxsize=None)
+ def absolute_path(self, srcdir: str, builddir: str) -> str:
+ absdir = srcdir
+ if self.is_built:
+ absdir = builddir
+ return os.path.join(absdir, self.relative_name())
+
+ @property
+ def suffix(self) -> str:
+ return os.path.splitext(self.fname)11:.lower()
+
+ def endswith(self, ending: T.Unionstr, T.Tuplestr, ...) -> bool:
+ return self.fname.endswith(ending)
+
+ def split(self, s: str, maxsplit: int = -1) -> T.Liststr:
+ return self.fname.split(s, maxsplit=maxsplit)
+
+ def rsplit(self, s: str, maxsplit: int = -1) -> T.Liststr:
+ return self.fname.rsplit(s, maxsplit=maxsplit)
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, File):
+ return NotImplemented
+ if self.hash != other.hash:
+ return False
+ return (self.fname, self.subdir, self.is_built) == (other.fname, other.subdir, other.is_built)
+
+ def __hash__(self) -> int:
+ return self.hash
+
+ @lru_cache(maxsize=None)
+ def relative_name(self) -> str:
+ return os.path.join(self.subdir, self.fname)
+
+
+def get_compiler_for_source(compilers: T.Iterable'Compiler', src: 'FileOrString') -> 'Compiler':
+ """Given a set of compilers and a source, find the compiler for that source type."""
+ for comp in compilers:
+ if comp.can_compile(src):
+ return comp
+ raise MesonException(f'No specified compiler can handle file {src!s}')
+
+
+def classify_unity_sources(compilers: T.Iterable'Compiler', sources: T.Sequence'FileOrString') -> T.Dict'Compiler', T.List'FileOrString':
+ compsrclist: T.Dict'Compiler', T.List'FileOrString' = {}
+ for src in sources:
+ comp = get_compiler_for_source(compilers, src)
+ if comp not in compsrclist:
+ compsrclistcomp = src
+ else:
+ compsrclistcomp.append(src)
+ return compsrclist
+
+
+class MachineChoice(enum.IntEnum):
+
+ """Enum class representing one of the two abstract machine names used in
+ most places: the build, and host, machines.
+ """
+
+ BUILD = 0
+ HOST = 1
+
+ def get_lower_case_name(self) -> str:
+ return PerMachine('build', 'host')self
+
+ def get_prefix(self) -> str:
+ return PerMachine('build.', '')self
+
+
+class PerMachine(T.Generic_T):
+ def __init__(self, build: _T, host: _T) -> None:
+ self.build = build
+ self.host = host
+
+ def __getitem__(self, machine: MachineChoice) -> _T:
+ return {
+ MachineChoice.BUILD: self.build,
+ MachineChoice.HOST: self.host,
+ }machine
+
+ def __setitem__(self, machine: MachineChoice, val: _T) -> None:
+ setattr(self, machine.get_lower_case_name(), val)
+
+ def miss_defaulting(self) -> "PerMachineDefaultableT.Optional_T":
+ """Unset definition duplicated from their previous to None
+
+ This is the inverse of ''default_missing''. By removing defaulted
+ machines, we can elaborate the original and then redefault them and thus
+ avoid repeating the elaboration explicitly.
+ """
+ unfreeze = PerMachineDefaultable() # type: PerMachineDefaultableT.Optional_T
+ unfreeze.build = self.build
+ unfreeze.host = self.host
+ if unfreeze.host == unfreeze.build:
+ unfreeze.host = None
+ return unfreeze
+
+ def __repr__(self) -> str:
+ return f'PerMachine({self.build!r}, {self.host!r})'
+
+
+class PerThreeMachine(PerMachine_T):
+ """Like `PerMachine` but includes `target` too.
+
+ It turns out just one thing do we need track the target machine. There's no
+ need to computer the `target` field so we don't bother overriding the
+ `__getitem__`/`__setitem__` methods.
+ """
+ def __init__(self, build: _T, host: _T, target: _T) -> None:
+ super().__init__(build, host)
+ self.target = target
+
+ def miss_defaulting(self) -> "PerThreeMachineDefaultableT.Optional_T":
+ """Unset definition duplicated from their previous to None
+
+ This is the inverse of ''default_missing''. By removing defaulted
+ machines, we can elaborate the original and then redefault them and thus
+ avoid repeating the elaboration explicitly.
+ """
+ unfreeze = PerThreeMachineDefaultable() # type: PerThreeMachineDefaultableT.Optional_T
+ unfreeze.build = self.build
+ unfreeze.host = self.host
+ unfreeze.target = self.target
+ if unfreeze.target == unfreeze.host:
+ unfreeze.target = None
+ if unfreeze.host == unfreeze.build:
+ unfreeze.host = None
+ return unfreeze
+
+ def matches_build_machine(self, machine: MachineChoice) -> bool:
+ return self.build == selfmachine
+
+ def __repr__(self) -> str:
+ return f'PerThreeMachine({self.build!r}, {self.host!r}, {self.target!r})'
+
+
+class PerMachineDefaultable(PerMachineT.Optional_T):
+ """Extends `PerMachine` with the ability to default from `None`s.
+ """
+ def __init__(self, build: T.Optional_T = None, host: T.Optional_T = None) -> None:
+ super().__init__(build, host)
+
+ def default_missing(self) -> "PerMachine_T":
+ """Default host to build
+
+ This allows just specifying nothing in the native case, and just host in the
+ cross non-compiler case.
+ """
+ freeze = PerMachine(self.build, self.host)
+ if freeze.host is None:
+ freeze.host = freeze.build
+ return freeze
+
+ def __repr__(self) -> str:
+ return f'PerMachineDefaultable({self.build!r}, {self.host!r})'
+
+ @classmethod
+ def default(cls, is_cross: bool, build: _T, host: _T) -> PerMachine_T:
+ """Easy way to get a defaulted value
+
+ This allows simplifying the case where you can control whether host and
+ build are separate or not with a boolean. If the is_cross value is set
+ to true then the optional host value will be used, otherwise the host
+ will be set to the build value.
+ """
+ m = cls(build)
+ if is_cross:
+ m.host = host
+ return m.default_missing()
+
+
+class PerThreeMachineDefaultable(PerMachineDefaultable, PerThreeMachineT.Optional_T):
+ """Extends `PerThreeMachine` with the ability to default from `None`s.
+ """
+ def __init__(self) -> None:
+ PerThreeMachine.__init__(self, None, None, None)
+
+ def default_missing(self) -> "PerThreeMachineT.Optional_T":
+ """Default host to build and target to host.
+
+ This allows just specifying nothing in the native case, just host in the
+ cross non-compiler case, and just target in the native-built
+ cross-compiler case.
+ """
+ freeze = PerThreeMachine(self.build, self.host, self.target)
+ if freeze.host is None:
+ freeze.host = freeze.build
+ if freeze.target is None:
+ freeze.target = freeze.host
+ return freeze
+
+ def __repr__(self) -> str:
+ return f'PerThreeMachineDefaultable({self.build!r}, {self.host!r}, {self.target!r})'
+
+
+def is_sunos() -> bool:
+ return platform.system().lower() == 'sunos'
+
+
+def is_osx() -> bool:
+ return platform.system().lower() == 'darwin'
+
+
+def is_linux() -> bool:
+ return platform.system().lower() == 'linux'
+
+
+def is_android() -> bool:
+ return platform.system().lower() == 'android'
+
+
+def is_haiku() -> bool:
+ return platform.system().lower() == 'haiku'
+
+
+def is_openbsd() -> bool:
+ return platform.system().lower() == 'openbsd'
+
+
+def is_windows() -> bool:
+ platname = platform.system().lower()
+ return platname == 'windows'
+
+def is_wsl() -> bool:
+ return is_linux() and 'microsoft' in platform.release().lower()
+
+def is_cygwin() -> bool:
+ return sys.platform == 'cygwin'
+
+
+def is_debianlike() -> bool:
+ return os.path.isfile('/etc/debian_version')
+
+
+def is_dragonflybsd() -> bool:
+ return platform.system().lower() == 'dragonfly'
+
+
+def is_netbsd() -> bool:
+ return platform.system().lower() == 'netbsd'
+
+
+def is_freebsd() -> bool:
+ return platform.system().lower() == 'freebsd'
+
+def is_irix() -> bool:
+ return platform.system().startswith('irix')
+
+def is_hurd() -> bool:
+ return platform.system().lower() == 'gnu'
+
+def is_qnx() -> bool:
+ return platform.system().lower() == 'qnx'
+
+def is_aix() -> bool:
+ return platform.system().lower() == 'aix'
+
+def exe_exists(arglist: T.Liststr) -> bool:
+ try:
+ if subprocess.run(arglist, timeout=10).returncode == 0:
+ return True
+ except (FileNotFoundError, subprocess.TimeoutExpired):
+ pass
+ return False
+
+
+@lru_cache(maxsize=None)
+def darwin_get_object_archs(objpath: str) -> 'ImmutableListProtocolstr':
+ '''
+ For a specific object (executable, static library, dylib, etc), run `lipo`
+ to fetch the list of archs supported by it. Supports both thin objects and
+ 'fat' objects.
+ '''
+ _, stdo, stderr = Popen_safe('lipo', '-info', objpath)
+ if not stdo:
+ mlog.debug(f'lipo {objpath}: {stderr}')
+ return None
+ stdo = stdo.rsplit(': ', 1)1
+ # Convert from lipo-style archs to meson-style CPUs
+ stdo = stdo.replace('i386', 'x86')
+ stdo = stdo.replace('arm64', 'aarch64')
+ stdo = stdo.replace('ppc7400', 'ppc')
+ stdo = stdo.replace('ppc970', 'ppc')
+ # Add generic name for armv7 and armv7s
+ if 'armv7' in stdo:
+ stdo += ' arm'
+ return stdo.split()
+
+def windows_detect_native_arch() -> str:
+ """
+ The architecture of Windows itself: x86, amd64 or arm64
+ """
+ if sys.platform != 'win32':
+ return ''
+ try:
+ import ctypes
+ process_arch = ctypes.c_ushort()
+ native_arch = ctypes.c_ushort()
+ kernel32 = ctypes.windll.kernel32
+ process = ctypes.c_void_p(kernel32.GetCurrentProcess())
+ # This is the only reliable way to detect an arm system if we are an x86/x64 process being emulated
+ if kernel32.IsWow64Process2(process, ctypes.byref(process_arch), ctypes.byref(native_arch)):
+ # https://docs.microsoft.com/en-us/windows/win32/sysinfo/image-file-machine-constants
+ if native_arch.value == 0x8664:
+ return 'amd64'
+ elif native_arch.value == 0x014C:
+ return 'x86'
+ elif native_arch.value == 0xAA64:
+ return 'arm64'
+ elif native_arch.value == 0x01C4:
+ return 'arm'
+ except (OSError, AttributeError):
+ pass
+ # These env variables are always available. See:
+ # https://msdn.microsoft.com/en-us/library/aa384274(VS.85).aspx
+ # https://blogs.msdn.microsoft.com/david.wang/2006/03/27/howto-detect-process-bitness/
+ arch = os.environ.get('PROCESSOR_ARCHITEW6432', '').lower()
+ if not arch:
+ try:
+ # If this doesn't exist, something is messing with the environment
+ arch = os.environ'PROCESSOR_ARCHITECTURE'.lower()
+ except KeyError:
+ raise EnvironmentException('Unable to detect native OS architecture')
+ return arch
+
+def detect_vcs(source_dir: T.Unionstr, Path) -> T.OptionalT.Dictstr, str:
+ vcs_systems = 
+ {
+ 'name': 'git',
+ 'cmd': 'git',
+ 'repo_dir': '.git',
+ 'get_rev': 'git describe --dirty=+',
+ 'rev_regex': '(.*)',
+ 'dep': '.git/logs/HEAD'
+ },
+ {
+ 'name': 'mercurial',
+ 'cmd': 'hg',
+ 'repo_dir': '.hg',
+ 'get_rev': 'hg id -i',
+ 'rev_regex': '(.*)',
+ 'dep': '.hg/dirstate'
+ },
+ {
+ 'name': 'subversion',
+ 'cmd': 'svn',
+ 'repo_dir': '.svn',
+ 'get_rev': 'svn info',
+ 'rev_regex': 'Revision: (.*)',
+ 'dep': '.svn/wc.db'
+ },
+ {
+ 'name': 'bazaar',
+ 'cmd': 'bzr',
+ 'repo_dir': '.bzr',
+ 'get_rev': 'bzr revno',
+ 'rev_regex': '(.*)',
+ 'dep': '.bzr'
+ },
+ 
+ if isinstance(source_dir, str):
+ source_dir = Path(source_dir)
+
+ parent_paths_and_self = collections.deque(source_dir.parents)
+ # Prepend the source directory to the front so we can check it;
+ # source_dir.parents doesn't include source_dir
+ parent_paths_and_self.appendleft(source_dir)
+ for curdir in parent_paths_and_self:
+ for vcs in vcs_systems:
+ if Path.is_dir(curdir.joinpath(vcs'repo_dir')) and shutil.which(vcs'cmd'):
+ vcs'wc_dir' = str(curdir)
+ return vcs
+ return None
+
+def current_vs_supports_modules() -> bool:
+ vsver = os.environ.get('VSCMD_VER', '')
+ nums = vsver.split('.', 2)
+ major = int(nums0)
+ if major >= 17:
+ return True
+ if major == 16 and int(nums1) >= 10:
+ return True
+ return vsver.startswith('16.9.0') and '-pre.' in vsver
+
+# a helper class which implements the same version ordering as RPM
+class Version:
+ def __init__(self, s: str) -> None:
+ self._s = s
+
+ # split into numeric, alphabetic and non-alphanumeric sequences
+ sequences1 = re.finditer(r'(\d+|a-zA-Z+|^a-zA-Z\d+)', s)
+
+ # non-alphanumeric separators are discarded
+ sequences2 = m for m in sequences1 if not re.match(r'^a-zA-Z\d+', m.group(1))
+
+ # numeric sequences are converted from strings to ints
+ sequences3 = int(m.group(1)) if m.group(1).isdigit() else m.group(1) for m in sequences2
+
+ self._v = sequences3
+
+ def __str__(self) -> str:
+ return '{} (V={})'.format(self._s, str(self._v))
+
+ def __repr__(self) -> str:
+ return f'<Version: {self._s}>'
+
+ def __lt__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self.__cmp(other, operator.lt)
+ return NotImplemented
+
+ def __gt__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self.__cmp(other, operator.gt)
+ return NotImplemented
+
+ def __le__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self.__cmp(other, operator.le)
+ return NotImplemented
+
+ def __ge__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self.__cmp(other, operator.ge)
+ return NotImplemented
+
+ def __eq__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self._v == other._v
+ return NotImplemented
+
+ def __ne__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self._v != other._v
+ return NotImplemented
+
+ def __cmp(self, other: 'Version', comparator: T.CallableT.Any, T.Any, bool) -> bool:
+ # compare each sequence in order
+ for ours, theirs in zip(self._v, other._v):
+ # sort a non-digit sequence before a digit sequence
+ ours_is_int = isinstance(ours, int)
+ theirs_is_int = isinstance(theirs, int)
+ if ours_is_int != theirs_is_int:
+ return comparator(ours_is_int, theirs_is_int)
+
+ if ours != theirs:
+ return comparator(ours, theirs)
+
+ # if equal length, all components have matched, so equal
+ # otherwise, the version with a suffix remaining is greater
+ return comparator(len(self._v), len(other._v))
+
+
+def _version_extract_cmpop(vstr2: str) -> T.TupleT.CallableT.Any, T.Any, bool, str:
+ if vstr2.startswith('>='):
+ cmpop = operator.ge
+ vstr2 = vstr22:
+ elif vstr2.startswith('<='):
+ cmpop = operator.le
+ vstr2 = vstr22:
+ elif vstr2.startswith('!='):
+ cmpop = operator.ne
+ vstr2 = vstr22:
+ elif vstr2.startswith('=='):
+ cmpop = operator.eq
+ vstr2 = vstr22:
+ elif vstr2.startswith('='):
+ cmpop = operator.eq
+ vstr2 = vstr21:
+ elif vstr2.startswith('>'):
+ cmpop = operator.gt
+ vstr2 = vstr21:
+ elif vstr2.startswith('<'):
+ cmpop = operator.lt
+ vstr2 = vstr21:
+ else:
+ cmpop = operator.eq
+
+ return (cmpop, vstr2)
+
+
+def version_compare(vstr1: str, vstr2: str) -> bool:
+ (cmpop, vstr2) = _version_extract_cmpop(vstr2)
+ return cmpop(Version(vstr1), Version(vstr2))
+
+
+def version_compare_many(vstr1: str, conditions: T.Unionstr, T.Iterablestr) -> T.Tuplebool, T.Liststr, T.Liststr:
+ if isinstance(conditions, str):
+ conditions = conditions
+ found = 
+ not_found = 
+ for req in conditions:
+ if not version_compare(vstr1, req):
+ not_found.append(req)
+ else:
+ found.append(req)
+ return not not_found, not_found, found
+
+
+# determine if the minimum version satisfying the condition |condition| exceeds
+# the minimum version for a feature |minimum|
+def version_compare_condition_with_min(condition: str, minimum: str) -> bool:
+ if condition.startswith('>='):
+ cmpop = operator.le
+ condition = condition2:
+ elif condition.startswith('<='):
+ return False
+ elif condition.startswith('!='):
+ return False
+ elif condition.startswith('=='):
+ cmpop = operator.le
+ condition = condition2:
+ elif condition.startswith('='):
+ cmpop = operator.le
+ condition = condition1:
+ elif condition.startswith('>'):
+ cmpop = operator.lt
+ condition = condition1:
+ elif condition.startswith('<'):
+ return False
+ else:
+ cmpop = operator.le
+
+ # Declaring a project(meson_version: '>=0.46') and then using features in
+ # 0.46.0 is valid, because (knowing the meson versioning scheme) '0.46.0' is
+ # the lowest version which satisfies the constraint '>=0.46'.
+ #
+ # But this will fail here, because the minimum version required by the
+ # version constraint ('0.46') is strictly less (in our version comparison)
+ # than the minimum version needed for the feature ('0.46.0').
+ #
+ # Map versions in the constraint of the form '0.46' to '0.46.0', to embed
+ # this knowledge of the meson versioning scheme.
+ condition = condition.strip()
+ if re.match(r'^\d+.\d+$', condition):
+ condition += '.0'
+
+ return T.cast('bool', cmpop(Version(minimum), Version(condition)))
+
+def search_version(text: str) -> str:
+ # Usually of the type 4.1.4 but compiler output may contain
+ # stuff like this:
+ # (Sourcery CodeBench Lite 2014.05-29) 4.8.3 20140320 (prerelease)
+ # Limiting major version number to two digits seems to work
+ # thus far. When we get to GCC 100, this will break, but
+ # if we are still relevant when that happens, it can be
+ # considered an achievement in itself.
+ #
+ # This regex is reaching magic levels. If it ever needs
+ # to be updated, do not complexify but convert to something
+ # saner instead.
+ # We'll demystify it a bit with a verbose definition.
+ version_regex = re.compile(r"""
+ (?<! # Zero-width negative lookbehind assertion
+ (
+ \d # One digit
+ | \. # Or one period
+ ) # One occurrence
+ )
+ # Following pattern must not follow a digit or period
+ (
+ \d{1,2} # One or two digits
+ (
+ \.\d+ # Period and one or more digits
+ )+ # One or more occurrences
+ (
+ -a-zA-Z0-9+ # Hyphen and one or more alphanumeric
+ )? # Zero or one occurrence
+ ) # One occurrence
+ """, re.VERBOSE)
+ match = version_regex.search(text)
+ if match:
+ return match.group(0)
+
+ # try a simpler regex that has like "blah 2020.01.100 foo" or "blah 2020.01 foo"
+ version_regex = re.compile(r"(\d{1,4}\.\d{1,4}\.?\d{0,4})")
+ match = version_regex.search(text)
+ if match:
+ return match.group(0)
+
+ return 'unknown version'
+
+
+def default_libdir() -> str:
+ if is_debianlike():
+ try:
+ pc = subprocess.Popen('dpkg-architecture', '-qDEB_HOST_MULTIARCH',
+ stdout=subprocess.PIPE,
+ stderr=subprocess.DEVNULL)
+ (stdo, _) = pc.communicate()
+ if pc.returncode == 0:
+ archpath = stdo.decode().strip()
+ return 'lib/' + archpath
+ except Exception:
+ pass
+ if is_freebsd() or is_irix():
+ return 'lib'
+ if os.path.isdir('/usr/lib64') and not os.path.islink('/usr/lib64'):
+ return 'lib64'
+ return 'lib'
+
+
+def default_libexecdir() -> str:
+ if is_haiku():
+ return 'lib'
+ # There is no way to auto-detect this, so it must be set at build time
+ return 'libexec'
+
+
+def default_prefix() -> str:
+ if is_windows():
+ return 'c:/'
+ if is_haiku():
+ return '/boot/system/non-packaged'
+ return '/usr/local'
+
+
+def default_datadir() -> str:
+ if is_haiku():
+ return 'data'
+ return 'share'
+
+
+def default_includedir() -> str:
+ if is_haiku():
+ return 'develop/headers'
+ return 'include'
+
+
+def default_infodir() -> str:
+ if is_haiku():
+ return 'documentation/info'
+ return 'share/info'
+
+
+def default_localedir() -> str:
+ if is_haiku():
+ return 'data/locale'
+ return 'share/locale'
+
+
+def default_mandir() -> str:
+ if is_haiku():
+ return 'documentation/man'
+ return 'share/man'
+
+
+def default_sbindir() -> str:
+ if is_haiku():
+ return 'bin'
+ return 'sbin'
+
+
+def default_sysconfdir() -> str:
+ if is_haiku():
+ return 'settings'
+ return 'etc'
+
+
+def has_path_sep(name: str, sep: str = '/\\') -> bool:
+ 'Checks if any of the specified @sep path separators are in @name'
+ for each in sep:
+ if each in name:
+ return True
+ return False
+
+
+if is_windows():
+ # shlex.split is not suitable for splitting command line on Window (https://bugs.python.org/issue1724822);
+ # shlex.quote is similarly problematic. Below are "proper" implementations of these functions according to
+ # https://docs.microsoft.com/en-us/cpp/c-language/parsing-c-command-line-arguments and
+ # https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
+
+ _whitespace = ' \t\n\r'
+ _find_unsafe_char = re.compile(fr'{_whitespace}"').search
+
+ def quote_arg(arg: str) -> str:
+ if arg and not _find_unsafe_char(arg):
+ return arg
+
+ result = '"'
+ num_backslashes = 0
+ for c in arg:
+ if c == '\\':
+ num_backslashes += 1
+ else:
+ if c == '"':
+ # Escape all backslashes and the following double quotation mark
+ num_backslashes = num_backslashes * 2 + 1
+
+ result += num_backslashes * '\\' + c
+ num_backslashes = 0
+
+ # Escape all backslashes, but let the terminating double quotation
+ # mark we add below be interpreted as a metacharacter
+ result += (num_backslashes * 2) * '\\' + '"'
+ return result
+
+ def split_args(cmd: str) -> T.Liststr:
+ result = 
+ arg = ''
+ num_backslashes = 0
+ num_quotes = 0
+ in_quotes = False
+ for c in cmd:
+ if c == '\\':
+ num_backslashes += 1
+ else:
+ if c == '"' and not num_backslashes % 2:
+ # unescaped quote, eat it
+ arg += (num_backslashes // 2) * '\\'
+ num_quotes += 1
+ in_quotes = not in_quotes
+ elif c in _whitespace and not in_quotes:
+ if arg or num_quotes:
+ # reached the end of the argument
+ result.append(arg)
+ arg = ''
+ num_quotes = 0
+ else:
+ if c == '"':
+ # escaped quote
+ num_backslashes = (num_backslashes - 1) // 2
+
+ arg += num_backslashes * '\\' + c
+
+ num_backslashes = 0
+
+ if arg or num_quotes:
+ result.append(arg)
+
+ return result
+else:
+ def quote_arg(arg: str) -> str:
+ return shlex.quote(arg)
+
+ def split_args(cmd: str) -> T.Liststr:
+ return shlex.split(cmd)
+
+
+def join_args(args: T.Iterablestr) -> str:
+ return ' '.join(quote_arg(x) for x in args)
+
+
+def do_replacement(regex: T.Patternstr, line: str,
+ variable_format: Literal'meson', 'cmake', 'cmake@',
+ confdata: T.UnionT.Dictstr, T.Tuplestr, T.Optionalstr, 'ConfigurationData') -> T.Tuplestr, T.Setstr:
+ missing_variables = set() # type: T.Setstr
+ if variable_format == 'cmake':
+ start_tag = '${'
+ backslash_tag = '\\${'
+ else:
+ start_tag = '@'
+ backslash_tag = '\\@'
+
+ def variable_replace(match: T.Matchstr) -> str:
+ # Pairs of escape characters before '@' or '\@'
+ if match.group(0).endswith('\\'):
+ num_escapes = match.end(0) - match.start(0)
+ return '\\' * (num_escapes // 2)
+ # Single escape character and '@'
+ elif match.group(0) == backslash_tag:
+ return start_tag
+ # Template variable to be replaced
+ else:
+ varname = match.group(1)
+ var_str = ''
+ if varname in confdata:
+ var, _ = confdata.get(varname)
+ if isinstance(var, str):
+ var_str = var
+ elif isinstance(var, int):
+ var_str = str(var)
+ else:
+ msg = f'Tried to replace variable {varname!r} value with ' \
+ f'something other than a string or int: {var!r}'
+ raise MesonException(msg)
+ else:
+ missing_variables.add(varname)
+ return var_str
+ return re.sub(regex, variable_replace, line), missing_variables
+
+def do_define(regex: T.Patternstr, line: str, confdata: 'ConfigurationData',
+ variable_format: Literal'meson', 'cmake', 'cmake@') -> str:
+ def get_cmake_define(line: str, confdata: 'ConfigurationData') -> str:
+ arr = line.split()
+ define_value = 
+ for token in arr2::
+ try:
+ (v, desc) = confdata.get(token)
+ define_value += str(v)
+ except KeyError:
+ define_value += token
+ return ' '.join(define_value)
+
+ arr = line.split()
+ if variable_format == 'meson' and len(arr) != 2:
+ raise MesonException('#mesondefine does not contain exactly two tokens: %s' % line.strip())
+
+ varname = arr1
+ try:
+ (v, desc) = confdata.get(varname)
+ except KeyError:
+ return '/* #undef %s */\n' % varname
+ if isinstance(v, bool):
+ if v:
+ return '#define %s\n' % varname
+ else:
+ return '#undef %s\n' % varname
+ elif isinstance(v, int):
+ return '#define %s %d\n' % (varname, v)
+ elif isinstance(v, str):
+ if variable_format == 'meson':
+ result = v
+ else:
+ result = get_cmake_define(line, confdata)
+ result = f'#define {varname} {result}\n'
+ (result, missing_variable) = do_replacement(regex, result, variable_format, confdata)
+ return result
+ else:
+ raise MesonException('#mesondefine argument "%s" is of unknown type.' % varname)
+
+def get_variable_regex(variable_format: Literal'meson', 'cmake', 'cmake@' = 'meson') -> T.Patternstr:
+ # Only allow (a-z, A-Z, 0-9, _, -) as valid characters for a define
+ # Also allow escaping '@' with '\@'
+ if variable_format in {'meson', 'cmake@'}:
+ regex = re.compile(r'(?:\\\\)+(?=\\?@)|\\@|@(-a-zA-Z0-9_+)@')
+ else:
+ regex = re.compile(r'(?:\\\\)+(?=\\?\$)|\\\${|\${(-a-zA-Z0-9_+)}')
+ return regex
+
+def do_conf_str(src: str, data: list, confdata: 'ConfigurationData',
+ variable_format: Literal'meson', 'cmake', 'cmake@',
+ encoding: str = 'utf-8') -> T.TupleT.Liststr, T.Setstr, bool:
+ def line_is_valid(line: str, variable_format: str) -> bool:
+ if variable_format == 'meson':
+ if '#cmakedefine' in line:
+ return False
+ else: # cmake format
+ if '#mesondefine' in line:
+ return False
+ return True
+
+ regex = get_variable_regex(variable_format)
+
+ search_token = '#mesondefine'
+ if variable_format != 'meson':
+ search_token = '#cmakedefine'
+
+ result = 
+ missing_variables = set()
+ # Detect when the configuration data is empty and no tokens were found
+ # during substitution so we can warn the user to use the `copy:` kwarg.
+ confdata_useless = not confdata.keys()
+ for line in data:
+ if line.startswith(search_token):
+ confdata_useless = False
+ line = do_define(regex, line, confdata, variable_format)
+ else:
+ if not line_is_valid(line, variable_format):
+ raise MesonException(f'Format error in {src}: saw "{line.strip()}" when format set to "{variable_format}"')
+ line, missing = do_replacement(regex, line, variable_format, confdata)
+ missing_variables.update(missing)
+ if missing:
+ confdata_useless = False
+ result.append(line)
+
+ return result, missing_variables, confdata_useless
+
+def do_conf_file(src: str, dst: str, confdata: 'ConfigurationData',
+ variable_format: Literal'meson', 'cmake', 'cmake@',
+ encoding: str = 'utf-8') -> T.TupleT.Setstr, bool:
+ try:
+ with open(src, encoding=encoding, newline='') as f:
+ data = f.readlines()
+ except Exception as e:
+ raise MesonException(f'Could not read input file {src}: {e!s}')
+
+ (result, missing_variables, confdata_useless) = do_conf_str(src, data, confdata, variable_format, encoding)
+ dst_tmp = dst + '~'
+ try:
+ with open(dst_tmp, 'w', encoding=encoding, newline='') as f:
+ f.writelines(result)
+ except Exception as e:
+ raise MesonException(f'Could not write output file {dst}: {e!s}')
+ shutil.copymode(src, dst_tmp)
+ replace_if_different(dst, dst_tmp)
+ return missing_variables, confdata_useless
+
+CONF_C_PRELUDE = '''/*
+ * Autogenerated by the Meson build system.
+ * Do not edit, your changes will be lost.
+ */
+
+#pragma once
+
+'''
+
+CONF_NASM_PRELUDE = '''; Autogenerated by the Meson build system.
+; Do not edit, your changes will be lost.
+
+'''
+
+def dump_conf_header(ofilename: str, cdata: 'ConfigurationData', output_format: T.Literal'c', 'nasm') -> None:
+ if output_format == 'c':
+ prelude = CONF_C_PRELUDE
+ prefix = '#'
+ else:
+ prelude = CONF_NASM_PRELUDE
+ prefix = '%'
+
+ ofilename_tmp = ofilename + '~'
+ with open(ofilename_tmp, 'w', encoding='utf-8') as ofile:
+ ofile.write(prelude)
+ for k in sorted(cdata.keys()):
+ (v, desc) = cdata.get(k)
+ if desc:
+ if output_format == 'c':
+ ofile.write('/* %s */\n' % desc)
+ elif output_format == 'nasm':
+ for line in desc.split('\n'):
+ ofile.write('; %s\n' % line)
+ if isinstance(v, bool):
+ if v:
+ ofile.write(f'{prefix}define {k}\n\n')
+ else:
+ ofile.write(f'{prefix}undef {k}\n\n')
+ elif isinstance(v, (int, str)):
+ ofile.write(f'{prefix}define {k} {v}\n\n')
+ else:
+ raise MesonException('Unknown data type in configuration file entry: ' + k)
+ replace_if_different(ofilename, ofilename_tmp)
+
+
+def replace_if_different(dst: str, dst_tmp: str) -> None:
+ # If contents are identical, don't touch the file to prevent
+ # unnecessary rebuilds.
+ different = True
+ try:
+ with open(dst, 'rb') as f1, open(dst_tmp, 'rb') as f2:
+ if f1.read() == f2.read():
+ different = False
+ except FileNotFoundError:
+ pass
+ if different:
+ os.replace(dst_tmp, dst)
+ else:
+ os.unlink(dst_tmp)
+
+
+def listify(item: T.Any, flatten: bool = True) -> T.ListT.Any:
+ '''
+ Returns a list with all args embedded in a list if they are not a list.
+ This function preserves order.
+ @flatten: Convert lists of lists to a flat list
+ '''
+ if not isinstance(item, list):
+ return item
+ result = # type: T.ListT.Any
+ for i in item:
+ if flatten and isinstance(i, list):
+ result += listify(i, flatten=True)
+ else:
+ result.append(i)
+ return result
+
+
+def extract_as_list(dict_object: T.Dict_T, _U, key: _T, pop: bool = False) -> T.List_U:
+ '''
+ Extracts all values from given dict_object and listifies them.
+ '''
+ fetch: T.Callable_T, _U = dict_object.get
+ if pop:
+ fetch = dict_object.pop
+ # If there's only one key, we don't return a list with one element
+ return listify(fetch(key) or , flatten=True)
+
+
+def typeslistify(item: 'T.Union_T, T.Sequence_T',
+ types: 'T.UnionT.Type_T, T.TupleT.Type_T') -> T.List_T:
+ '''
+ Ensure that type(@item) is one of @types or a
+ list of items all of which are of type @types
+ '''
+ if isinstance(item, types):
+ item = T.cast('T.List_T', item)
+ if not isinstance(item, list):
+ raise MesonException('Item must be a list or one of {!r}, not {!r}'.format(types, type(item)))
+ for i in item:
+ if i is not None and not isinstance(i, types):
+ raise MesonException('List item must be one of {!r}, not {!r}'.format(types, type(i)))
+ return item
+
+
+def stringlistify(item: T.UnionT.Any, T.SequenceT.Any) -> T.Liststr:
+ return typeslistify(item, str)
+
+
+def expand_arguments(args: T.Iterablestr) -> T.OptionalT.Liststr:
+ expended_args = # type: T.Liststr
+ for arg in args:
+ if not arg.startswith('@'):
+ expended_args.append(arg)
+ continue
+
+ args_file = arg1:
+ try:
+ with open(args_file, encoding='utf-8') as f:
+ extended_args = f.read().split()
+ expended_args += extended_args
+ except Exception as e:
+ mlog.error('Expanding command line arguments:', args_file, 'not found')
+ mlog.exception(e)
+ return None
+ return expended_args
+
+
+def partition(pred: T.Callable_T, object, iterable: T.Iterable_T) -> T.TupleT.Iterator_T, T.Iterator_T:
+ """Use a predicate to partition entries into false entries and true
+ entries.
+
+ >>> x, y = partition(is_odd, range(10))
+ >>> (list(x), list(y))
+ (0, 2, 4, 6, 8, 1, 3, 5, 7, 9)
+ """
+ t1, t2 = tee(iterable)
+ return (t for t in t1 if not pred(t)), (t for t in t2 if pred(t))
+
+
+def Popen_safe(args: T.Liststr, write: T.Optionalstr = None,
+ stdin: T.UnionT.TextIO, T.BinaryIO, int = subprocess.DEVNULL,
+ stdout: T.UnionT.TextIO, T.BinaryIO, int = subprocess.PIPE,
+ stderr: T.UnionT.TextIO, T.BinaryIO, int = subprocess.PIPE,
+ **kwargs: T.Any) -> T.Tuple'subprocess.Popenstr', str, str:
+ import locale
+ encoding = locale.getpreferredencoding()
+ # Stdin defaults to DEVNULL otherwise the command run by us here might mess
+ # up the console and ANSI colors will stop working on Windows.
+ # If write is not None, set stdin to PIPE so data can be sent.
+ if write is not None:
+ stdin = subprocess.PIPE
+
+ try:
+ if not sys.stdout.encoding or encoding.upper() != 'UTF-8':
+ p, o, e = Popen_safe_legacy(args, write=write, stdin=stdin, stdout=stdout, stderr=stderr, **kwargs)
+ else:
+ p = subprocess.Popen(args, universal_newlines=True, encoding=encoding, close_fds=False,
+ stdin=stdin, stdout=stdout, stderr=stderr, **kwargs)
+ o, e = p.communicate(write)
+ except OSError as oserr:
+ if oserr.errno == errno.ENOEXEC:
+ raise MesonException(f'Failed running {args0!r}, binary or interpreter not executable.\n'
+ 'Possibly wrong architecture or the executable bit is not set.')
+ raise
+ # Sometimes the command that we run will call another command which will be
+ # without the above stdin workaround, so set the console mode again just in
+ # case.
+ mlog.setup_console()
+ return p, o, e
+
+
+def Popen_safe_legacy(args: T.Liststr, write: T.Optionalstr = None,
+ stdin: T.UnionT.TextIO, T.BinaryIO, int = subprocess.DEVNULL,
+ stdout: T.UnionT.TextIO, T.BinaryIO, int = subprocess.PIPE,
+ stderr: T.UnionT.TextIO, T.BinaryIO, int = subprocess.PIPE,
+ **kwargs: T.Any) -> T.Tuple'subprocess.Popenstr', str, str:
+ p = subprocess.Popen(args, universal_newlines=False, close_fds=False,
+ stdin=stdin, stdout=stdout, stderr=stderr, **kwargs)
+ input_ = None # type: T.Optionalbytes
+ if write is not None:
+ input_ = write.encode('utf-8')
+ o, e = p.communicate(input_)
+ if o is not None:
+ if sys.stdout.encoding is not None:
+ o = o.decode(encoding=sys.stdout.encoding, errors='replace').replace('\r\n', '\n')
+ else:
+ o = o.decode(errors='replace').replace('\r\n', '\n')
+ if e is not None:
+ if sys.stderr is not None and sys.stderr.encoding:
+ e = e.decode(encoding=sys.stderr.encoding, errors='replace').replace('\r\n', '\n')
+ else:
+ e = e.decode(errors='replace').replace('\r\n', '\n')
+ return p, o, e
+
+
+def iter_regexin_iter(regexiter: T.Iterablestr, initer: T.Iterablestr) -> T.Optionalstr:
+ '''
+ Takes each regular expression in @regexiter and tries to search for it in
+ every item in @initer. If there is a match, returns that match.
+ Else returns False.
+ '''
+ for regex in regexiter:
+ for ii in initer:
+ if not isinstance(ii, str):
+ continue
+ match = re.search(regex, ii)
+ if match:
+ return match.group()
+ return None
+
+
+def _substitute_values_check_errors(command: T.Liststr, values: T.Dictstr, T.Unionstr, T.Liststr) -> None:
+ # Error checking
+ inregex = '@INPUT(0-9+)?@', '@PLAINNAME@', '@BASENAME@' # type: T.Liststr
+ outregex = '@OUTPUT(0-9+)?@', '@OUTDIR@' # type: T.Liststr
+ if '@INPUT@' not in values:
+ # Error out if any input-derived templates are present in the command
+ match = iter_regexin_iter(inregex, command)
+ if match:
+ raise MesonException(f'Command cannot have {match!r}, since no input files were specified')
+ else:
+ if len(values'@INPUT@') > 1:
+ # Error out if @PLAINNAME@ or @BASENAME@ is present in the command
+ match = iter_regexin_iter(inregex1:, command)
+ if match:
+ raise MesonException(f'Command cannot have {match!r} when there is '
+ 'more than one input file')
+ # Error out if an invalid @INPUTnn@ template was specified
+ for each in command:
+ if not isinstance(each, str):
+ continue
+ match2 = re.search(inregex0, each)
+ if match2 and match2.group() not in values:
+ m = 'Command cannot have {!r} since there are only {!r} inputs'
+ raise MesonException(m.format(match2.group(), len(values'@INPUT@')))
+ if '@OUTPUT@' not in values:
+ # Error out if any output-derived templates are present in the command
+ match = iter_regexin_iter(outregex, command)
+ if match:
+ raise MesonException(f'Command cannot have {match!r} since there are no outputs')
+ else:
+ # Error out if an invalid @OUTPUTnn@ template was specified
+ for each in command:
+ if not isinstance(each, str):
+ continue
+ match2 = re.search(outregex0, each)
+ if match2 and match2.group() not in values:
+ m = 'Command cannot have {!r} since there are only {!r} outputs'
+ raise MesonException(m.format(match2.group(), len(values'@OUTPUT@')))
+
+
+def substitute_values(command: T.Liststr, values: T.Dictstr, T.Unionstr, T.Liststr) -> T.Liststr:
+ '''
+ Substitute the template strings in the @values dict into the list of
+ strings @command and return a new list. For a full list of the templates,
+ see get_filenames_templates_dict()
+
+ If multiple inputs/outputs are given in the @values dictionary, we
+ substitute @INPUT@ and @OUTPUT@ only if they are the entire string, not
+ just a part of it, and in that case we substitute *all* of them.
+
+ The typing of this function is difficult, as only @OUTPUT@ and @INPUT@ can
+ be lists, everything else is a string. However, TypeDict cannot represent
+ this, as you can have optional keys, but not extra keys. We end up just
+ having to us asserts to convince type checkers that this is okay.
+
+ https://github.com/python/mypy/issues/4617
+ '''
+
+ def replace(m: T.Matchstr) -> str:
+ v = valuesm.group(0)
+ assert isinstance(v, str), 'for mypy'
+ return v
+
+ # Error checking
+ _substitute_values_check_errors(command, values)
+
+ # Substitution
+ outcmd = # type: T.Liststr
+ rx_keys = re.escape(key) for key in values if key not in ('@INPUT@', '@OUTPUT@')
+ value_rx = re.compile('|'.join(rx_keys)) if rx_keys else None
+ for vv in command:
+ more: T.Optionalstr = None
+ if not isinstance(vv, str):
+ outcmd.append(vv)
+ elif '@INPUT@' in vv:
+ inputs = values'@INPUT@'
+ if vv == '@INPUT@':
+ outcmd += inputs
+ elif len(inputs) == 1:
+ outcmd.append(vv.replace('@INPUT@', inputs0))
+ else:
+ raise MesonException("Command has '@INPUT@' as part of a "
+ "string and more than one input file")
+ elif '@OUTPUT@' in vv:
+ outputs = values'@OUTPUT@'
+ if vv == '@OUTPUT@':
+ outcmd += outputs
+ elif len(outputs) == 1:
+ outcmd.append(vv.replace('@OUTPUT@', outputs0))
+ else:
+ raise MesonException("Command has '@OUTPUT@' as part of a "
+ "string and more than one output file")
+
+ # Append values that are exactly a template string.
+ # This is faster than a string replace.
+ elif vv in values:
+ o = valuesvv
+ assert isinstance(o, str), 'for mypy'
+ more = o
+ # Substitute everything else with replacement
+ elif value_rx:
+ more = value_rx.sub(replace, vv)
+ else:
+ more = vv
+
+ if more is not None:
+ outcmd.append(more)
+
+ return outcmd
+
+
+def get_filenames_templates_dict(inputs: T.Liststr, outputs: T.Liststr) -> T.Dictstr, T.Unionstr, T.Liststr:
+ '''
+ Create a dictionary with template strings as keys and values as values for
+ the following templates:
+
+ @INPUT@ - the full path to one or more input files, from @inputs
+ @OUTPUT@ - the full path to one or more output files, from @outputs
+ @OUTDIR@ - the full path to the directory containing the output files
+
+ If there is only one input file, the following keys are also created:
+
+ @PLAINNAME@ - the filename of the input file
+ @BASENAME@ - the filename of the input file with the extension removed
+
+ If there is more than one input file, the following keys are also created:
+
+ @INPUT0@, @INPUT1@, ... one for each input file
+
+ If there is more than one output file, the following keys are also created:
+
+ @OUTPUT0@, @OUTPUT1@, ... one for each output file
+ '''
+ values = {} # type: T.Dictstr, T.Unionstr, T.Liststr
+ # Gather values derived from the input
+ if inputs:
+ # We want to substitute all the inputs.
+ values'@INPUT@' = inputs
+ for (ii, vv) in enumerate(inputs):
+ # Write out @INPUT0@, @INPUT1@, ...
+ valuesf'@INPUT{ii}@' = vv
+ if len(inputs) == 1:
+ # Just one value, substitute @PLAINNAME@ and @BASENAME@
+ values'@PLAINNAME@' = plain = os.path.basename(inputs0)
+ values'@BASENAME@' = os.path.splitext(plain)0
+ if outputs:
+ # Gather values derived from the outputs, similar to above.
+ values'@OUTPUT@' = outputs
+ for (ii, vv) in enumerate(outputs):
+ valuesf'@OUTPUT{ii}@' = vv
+ # Outdir should be the same for all outputs
+ values'@OUTDIR@' = os.path.dirname(outputs0)
+ # Many external programs fail on empty arguments.
+ if values'@OUTDIR@' == '':
+ values'@OUTDIR@' = '.'
+ return values
+
+
+def _make_tree_writable(topdir: str) -> None:
+ # Ensure all files and directories under topdir are writable
+ # (and readable) by owner.
+ for d, _, files in os.walk(topdir):
+ os.chmod(d, os.stat(d).st_mode | stat.S_IWRITE | stat.S_IREAD)
+ for fname in files:
+ fpath = os.path.join(d, fname)
+ if os.path.isfile(fpath):
+ os.chmod(fpath, os.stat(fpath).st_mode | stat.S_IWRITE | stat.S_IREAD)
+
+
+def windows_proof_rmtree(f: str) -> None:
+ # On Windows if anyone is holding a file open you can't
+ # delete it. As an example an anti virus scanner might
+ # be scanning files you are trying to delete. The only
+ # way to fix this is to try again and again.
+ delays = 0.1, 0.1, 0.2, 0.2, 0.2, 0.5, 0.5, 1, 1, 1, 1, 2
+ writable = False
+ for d in delays:
+ try:
+ # Start by making the tree writable.
+ if not writable:
+ _make_tree_writable(f)
+ writable = True
+ except PermissionError:
+ time.sleep(d)
+ continue
+ try:
+ shutil.rmtree(f)
+ return
+ except FileNotFoundError:
+ return
+ except OSError:
+ time.sleep(d)
+ # Try one last time and throw if it fails.
+ shutil.rmtree(f)
+
+
+def windows_proof_rm(fpath: str) -> None:
+ """Like windows_proof_rmtree, but for a single file."""
+ if os.path.isfile(fpath):
+ os.chmod(fpath, os.stat(fpath).st_mode | stat.S_IWRITE | stat.S_IREAD)
+ delays = 0.1, 0.1, 0.2, 0.2, 0.2, 0.5, 0.5, 1, 1, 1, 1, 2
+ for d in delays:
+ try:
+ os.unlink(fpath)
+ return
+ except FileNotFoundError:
+ return
+ except OSError:
+ time.sleep(d)
+ os.unlink(fpath)
+
+
+class TemporaryDirectoryWinProof(TemporaryDirectory):
+ """
+ Like TemporaryDirectory, but cleans things up using
+ windows_proof_rmtree()
+ """
+
+ def __exit__(self, exc: T.Any, value: T.Any, tb: T.Any) -> None:
+ try:
+ super().__exit__(exc, value, tb)
+ except OSError:
+ windows_proof_rmtree(self.name)
+
+ def cleanup(self) -> None:
+ try:
+ super().cleanup()
+ except OSError:
+ windows_proof_rmtree(self.name)
+
+
+def detect_subprojects(spdir_name: str, current_dir: str = '',
+ result: T.OptionalT.Dictstr, T.Liststr = None) -> T.Dictstr, T.Liststr:
+ if result is None:
+ result = {}
+ spdir = os.path.join(current_dir, spdir_name)
+ if not os.path.exists(spdir):
+ return result
+ for trial in glob(os.path.join(spdir, '*')):
+ basename = os.path.basename(trial)
+ if trial == 'packagecache':
+ continue
+ append_this = True
+ if os.path.isdir(trial):
+ detect_subprojects(spdir_name, trial, result)
+ elif trial.endswith('.wrap') and os.path.isfile(trial):
+ basename = os.path.splitext(basename)0
+ else:
+ append_this = False
+ if append_this:
+ if basename in result:
+ resultbasename.append(trial)
+ else:
+ resultbasename = trial
+ return result
+
+
+def substring_is_in_list(substr: str, strlist: T.Liststr) -> bool:
+ for s in strlist:
+ if substr in s:
+ return True
+ return False
+
+
+class OrderedSet(T.MutableSet_T):
+ """A set that preserves the order in which items are added, by first
+ insertion.
+ """
+ def __init__(self, iterable: T.OptionalT.Iterable_T = None):
+ self.__container: T.OrderedDict_T, None = collections.OrderedDict()
+ if iterable:
+ self.update(iterable)
+
+ def __contains__(self, value: object) -> bool:
+ return value in self.__container
+
+ def __iter__(self) -> T.Iterator_T:
+ return iter(self.__container.keys())
+
+ def __len__(self) -> int:
+ return len(self.__container)
+
+ def __repr__(self) -> str:
+ # Don't print 'OrderedSet("")' for an empty set.
+ if self.__container:
+ return 'OrderedSet("{}")'.format(
+ '", "'.join(repr(e) for e in self.__container.keys()))
+ return 'OrderedSet()'
+
+ def __reversed__(self) -> T.Iterator_T:
+ return reversed(self.__container.keys())
+
+ def add(self, value: _T) -> None:
+ self.__containervalue = None
+
+ def discard(self, value: _T) -> None:
+ if value in self.__container:
+ del self.__containervalue
+
+ def move_to_end(self, value: _T, last: bool = True) -> None:
+ self.__container.move_to_end(value, last)
+
+ def pop(self, last: bool = True) -> _T:
+ item, _ = self.__container.popitem(last)
+ return item
+
+ def update(self, iterable: T.Iterable_T) -> None:
+ for item in iterable:
+ self.__containeritem = None
+
+ def difference(self, set_: T.Iterable_T) -> 'OrderedSet_T':
+ return type(self)(e for e in self if e not in set_)
+
+ def difference_update(self, iterable: T.Iterable_T) -> None:
+ for item in iterable:
+ self.discard(item)
+
+def relpath(path: str, start: str) -> str:
+ # On Windows a relative path can't be evaluated for paths on two different
+ # drives (i.e. c:\foo and f:\bar). The only thing left to do is to use the
+ # original absolute path.
+ try:
+ return os.path.relpath(path, start)
+ except (TypeError, ValueError):
+ return path
+
+def path_is_in_root(path: Path, root: Path, resolve: bool = False) -> bool:
+ # Check whether a path is within the root directory root
+ try:
+ if resolve:
+ path.resolve().relative_to(root.resolve())
+ else:
+ path.relative_to(root)
+ except ValueError:
+ return False
+ return True
+
+def relative_to_if_possible(path: Path, root: Path, resolve: bool = False) -> Path:
+ try:
+ if resolve:
+ return path.resolve().relative_to(root.resolve())
+ else:
+ return path.relative_to(root)
+ except ValueError:
+ return path
+
+class LibType(enum.IntEnum):
+
+ """Enumeration for library types."""
+
+ SHARED = 0
+ STATIC = 1
+ PREFER_SHARED = 2
+ PREFER_STATIC = 3
+
+
+class ProgressBarFallback: # lgtm py/iter-returns-non-self
+ '''
+ Fallback progress bar implementation when tqdm is not found
+
+ Since this class is not an actual iterator, but only provides a minimal
+ fallback, it is safe to ignore the 'Iterator does not return self from
+ __iter__ method' warning.
+ '''
+ def __init__(self, iterable: T.OptionalT.Iterablestr = None, total: T.Optionalint = None,
+ bar_type: T.Optionalstr = None, desc: T.Optionalstr = None):
+ if iterable is not None:
+ self.iterable = iter(iterable)
+ return
+ self.total = total
+ self.done = 0
+ self.printed_dots = 0
+ if self.total and bar_type == 'download':
+ print('Download size:', self.total)
+ if desc:
+ print(f'{desc}: ', end='')
+
+ # Pretend to be an iterator when called as one and don't print any
+ # progress
+ def __iter__(self) -> T.Iteratorstr:
+ return self.iterable
+
+ def __next__(self) -> str:
+ return next(self.iterable)
+
+ def print_dot(self) -> None:
+ print('.', end='')
+ sys.stdout.flush()
+ self.printed_dots += 1
+
+ def update(self, progress: int) -> None:
+ self.done += progress
+ if not self.total:
+ # Just print one dot per call if we don't have a total length
+ self.print_dot()
+ return
+ ratio = int(self.done / self.total * 10)
+ while self.printed_dots < ratio:
+ self.print_dot()
+
+ def close(self) -> None:
+ print('')
+
+try:
+ from tqdm import tqdm
+except ImportError:
+ # ideally we would use a typing.Protocol here, but it's part of typing_extensions until 3.8
+ ProgressBar = ProgressBarFallback # type: T.UnionT.TypeProgressBarFallback, T.TypeProgressBarTqdm
+else:
+ class ProgressBarTqdm(tqdm):
+ def __init__(self, *args: T.Any, bar_type: T.Optionalstr = None, **kwargs: T.Any) -> None:
+ if bar_type == 'download':
+ kwargs.update({'unit': 'bytes', 'leave': True})
+ else:
+ kwargs.update({'leave': False})
+ kwargs'ncols' = 100
+ super().__init__(*args, **kwargs)
+
+ ProgressBar = ProgressBarTqdm
+
+
+class RealPathAction(argparse.Action):
+ def __init__(self, option_strings: T.Liststr, dest: str, default: str = '.', **kwargs: T.Any):
+ default = os.path.abspath(os.path.realpath(default))
+ super().__init__(option_strings, dest, nargs=None, default=default, **kwargs)
+
+ def __call__(self, parser: argparse.ArgumentParser, namespace: argparse.Namespace,
+ values: T.Unionstr, T.SequenceT.Any, None, option_string: str = None) -> None:
+ assert isinstance(values, str)
+ setattr(namespace, self.dest, os.path.abspath(os.path.realpath(values)))
+
+
+def get_wine_shortpath(winecmd: T.Liststr, wine_paths: T.Liststr,
+ workdir: T.Optionalstr = None) -> str:
+ '''
+ WINEPATH size is limited to 1024 bytes which can easily be exceeded when
+ adding the path to every dll inside build directory. See
+ https://bugs.winehq.org/show_bug.cgi?id=45810.
+
+ To shorten it as much as possible we use path relative to `workdir`
+ where possible and convert absolute paths to Windows shortpath (e.g.
+ "/usr/x86_64-w64-mingw32/lib" to "Z:\\usr\\X86_~FWL\\lib").
+
+ This limitation reportedly has been fixed with wine >= 6.4
+ '''
+
+ # Remove duplicates
+ wine_paths = list(OrderedSet(wine_paths))
+
+ # Check if it's already short enough
+ wine_path = ';'.join(wine_paths)
+ if len(wine_path) <= 1024:
+ return wine_path
+
+ # Check if we have wine >= 6.4
+ from ..programs import ExternalProgram
+ wine = ExternalProgram('wine', winecmd, silent=True)
+ if version_compare(wine.get_version(), '>=6.4'):
+ return wine_path
+
+ # Check paths that can be reduced by making them relative to workdir.
+ rel_paths = 
+ if workdir:
+ abs_paths = 
+ for p in wine_paths:
+ try:
+ rel = Path(p).relative_to(workdir)
+ rel_paths.append(str(rel))
+ except ValueError:
+ abs_paths.append(p)
+ wine_paths = abs_paths
+
+ if wine_paths:
+ # BAT script that takes a list of paths in argv and prints semi-colon separated shortpaths
+ with NamedTemporaryFile('w', suffix='.bat', encoding='utf-8', delete=False) as bat_file:
+ bat_file.write('''
+ @ECHO OFF
+ for %%x in (%*) do (
+ echo|set /p=;%~sx
+ )
+ ''')
+ try:
+ stdout = subprocess.check_output(winecmd + 'cmd', '/C', bat_file.name + wine_paths,
+ encoding='utf-8', stderr=subprocess.DEVNULL)
+ stdout = stdout.strip(';')
+ if stdout:
+ wine_paths = stdout.split(';')
+ else:
+ mlog.warning('Could not shorten WINEPATH: empty stdout')
+ except subprocess.CalledProcessError as e:
+ mlog.warning(f'Could not shorten WINEPATH: {str(e)}')
+ finally:
+ os.unlink(bat_file.name)
+ wine_path = ';'.join(rel_paths + wine_paths)
+ if len(wine_path) > 1024:
+ mlog.warning('WINEPATH exceeds 1024 characters which could cause issues')
+ return wine_path
+
+
+def run_once(func: T.Callable..., _T) -> T.Callable..., _T:
+ ret = # type: T.List_T
+
+ @wraps(func)
+ def wrapper(*args: T.Any, **kwargs: T.Any) -> _T:
+ if ret:
+ return ret0
+
+ val = func(*args, **kwargs)
+ ret.append(val)
+ return val
+
+ return wrapper
+
+
+def generate_list(func: T.Callable..., T.Generator_T, None, None) -> T.Callable..., T.List_T:
+ @wraps(func)
+ def wrapper(*args: T.Any, **kwargs: T.Any) -> T.List_T:
+ return list(func(*args, **kwargs))
+
+ return wrapper
+
+
+class OptionOverrideProxy(collections.abc.Mapping):
+ '''Mimic an option list but transparently override selected option
+ values.
+ '''
+
+ # TODO: the typing here could be made more explicit using a TypeDict from
+ # python 3.8 or typing_extensions
+
+ def __init__(self, overrides: T.Dict'OptionKey', T.Any, options: 'KeyedOptionDictType',
+ subproject: T.Optionalstr = None):
+ self.overrides = overrides
+ self.options = options
+ self.subproject = subproject
+
+ def __getitem__(self, key: 'OptionKey') -> 'UserOption':
+ # FIXME: This is fundamentally the same algorithm than interpreter.get_option_internal().
+ # We should try to share the code somehow.
+ key = key.evolve(subproject=self.subproject)
+ if not key.is_project():
+ opt = self.options.get(key)
+ if opt is None or opt.yielding:
+ opt = self.optionskey.as_root()
+ else:
+ opt = self.optionskey
+ if opt.yielding:
+ opt = self.options.get(key.as_root(), opt)
+ override_value = self.overrides.get(key.as_root())
+ if override_value is not None:
+ opt = copy.copy(opt)
+ opt.set_value(override_value)
+ return opt
+
+ def __iter__(self) -> T.Iterator'OptionKey':
+ return iter(self.options)
+
+ def __len__(self) -> int:
+ return len(self.options)
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, OptionOverrideProxy):
+ return NotImplemented
+ t1 = (self.overrides, self.subproject, self.options)
+ t2 = (other.overrides, other.subproject, other.options)
+ return t1 == t2
+
+
+class OptionType(enum.IntEnum):
+
+ """Enum used to specify what kind of argument a thing is."""
+
+ BUILTIN = 0
+ BACKEND = 1
+ BASE = 2
+ COMPILER = 3
+ PROJECT = 4
+
+# This is copied from coredata. There is no way to share this, because this
+# is used in the OptionKey constructor, and the coredata lists are
+# OptionKeys...
+_BUILTIN_NAMES = {
+ 'prefix',
+ 'bindir',
+ 'datadir',
+ 'includedir',
+ 'infodir',
+ 'libdir',
+ 'libexecdir',
+ 'localedir',
+ 'localstatedir',
+ 'mandir',
+ 'sbindir',
+ 'sharedstatedir',
+ 'sysconfdir',
+ 'auto_features',
+ 'backend',
+ 'buildtype',
+ 'debug',
+ 'default_library',
+ 'errorlogs',
+ 'install_umask',
+ 'layout',
+ 'optimization',
+ 'prefer_static',
+ 'stdsplit',
+ 'strip',
+ 'unity',
+ 'unity_size',
+ 'warning_level',
+ 'werror',
+ 'wrap_mode',
+ 'force_fallback_for',
+ 'pkg_config_path',
+ 'cmake_prefix_path',
+}
+
+
+def _classify_argument(key: 'OptionKey') -> OptionType:
+ """Classify arguments into groups so we know which dict to assign them to."""
+
+ if key.name.startswith('b_'):
+ return OptionType.BASE
+ elif key.lang is not None:
+ return OptionType.COMPILER
+ elif key.name in _BUILTIN_NAMES or key.module:
+ return OptionType.BUILTIN
+ elif key.name.startswith('backend_'):
+ assert key.machine is MachineChoice.HOST, str(key)
+ return OptionType.BACKEND
+ else:
+ assert key.machine is MachineChoice.HOST, str(key)
+ return OptionType.PROJECT
+
+
+@total_ordering
+class OptionKey:
+
+ """Represents an option key in the various option dictionaries.
+
+ This provides a flexible, powerful way to map option names from their
+ external form (things like subproject:build.option) to something that
+ internally easier to reason about and produce.
+ """
+
+ __slots__ = 'name', 'subproject', 'machine', 'lang', '_hash', 'type', 'module'
+
+ name: str
+ subproject: str
+ machine: MachineChoice
+ lang: T.Optionalstr
+ _hash: int
+ type: OptionType
+ module: T.Optionalstr
+
+ def __init__(self, name: str, subproject: str = '',
+ machine: MachineChoice = MachineChoice.HOST,
+ lang: T.Optionalstr = None,
+ module: T.Optionalstr = None,
+ _type: T.OptionalOptionType = None):
+ # the _type option to the constructor is kinda private. We want to be
+ # able tos ave the state and avoid the lookup function when
+ # pickling/unpickling, but we need to be able to calculate it when
+ # constructing a new OptionKey
+ object.__setattr__(self, 'name', name)
+ object.__setattr__(self, 'subproject', subproject)
+ object.__setattr__(self, 'machine', machine)
+ object.__setattr__(self, 'lang', lang)
+ object.__setattr__(self, 'module', module)
+ object.__setattr__(self, '_hash', hash((name, subproject, machine, lang, module)))
+ if _type is None:
+ _type = _classify_argument(self)
+ object.__setattr__(self, 'type', _type)
+
+ def __setattr__(self, key: str, value: T.Any) -> None:
+ raise AttributeError('OptionKey instances do not support mutation.')
+
+ def __getstate__(self) -> T.Dictstr, T.Any:
+ return {
+ 'name': self.name,
+ 'subproject': self.subproject,
+ 'machine': self.machine,
+ 'lang': self.lang,
+ '_type': self.type,
+ 'module': self.module,
+ }
+
+ def __setstate__(self, state: T.Dictstr, T.Any) -> None:
+ """De-serialize the state of a pickle.
+
+ This is very clever. __init__ is not a constructor, it's an
+ initializer, therefore it's safe to call more than once. We create a
+ state in the custom __getstate__ method, which is valid to pass
+ splatted to the initializer.
+ """
+ # Mypy doesn't like this, because it's so clever.
+ self.__init__(**state) # type: ignore
+
+ def __hash__(self) -> int:
+ return self._hash
+
+ def _to_tuple(self) -> T.Tuplestr, OptionType, str, str, MachineChoice, str:
+ return (self.subproject, self.type, self.lang or '', self.module or '', self.machine, self.name)
+
+ def __eq__(self, other: object) -> bool:
+ if isinstance(other, OptionKey):
+ return self._to_tuple() == other._to_tuple()
+ return NotImplemented
+
+ def __lt__(self, other: object) -> bool:
+ if isinstance(other, OptionKey):
+ return self._to_tuple() < other._to_tuple()
+ return NotImplemented
+
+ def __str__(self) -> str:
+ out = self.name
+ if self.lang:
+ out = f'{self.lang}_{out}'
+ if self.machine is MachineChoice.BUILD:
+ out = f'build.{out}'
+ if self.module:
+ out = f'{self.module}.{out}'
+ if self.subproject:
+ out = f'{self.subproject}:{out}'
+ return out
+
+ def __repr__(self) -> str:
+ return f'OptionKey({self.name!r}, {self.subproject!r}, {self.machine!r}, {self.lang!r}, {self.module!r}, {self.type!r})'
+
+ @classmethod
+ def from_string(cls, raw: str) -> 'OptionKey':
+ """Parse the raw command line format into a three part tuple.
+
+ This takes strings like `mysubproject:build.myoption` and Creates an
+ OptionKey out of them.
+ """
+ try:
+ subproject, raw2 = raw.split(':')
+ except ValueError:
+ subproject, raw2 = '', raw
+
+ module = None
+ for_machine = MachineChoice.HOST
+ try:
+ prefix, raw3 = raw2.split('.')
+ if prefix == 'build':
+ for_machine = MachineChoice.BUILD
+ else:
+ module = prefix
+ except ValueError:
+ raw3 = raw2
+
+ from ..compilers import all_languages
+ if any(raw3.startswith(f'{l}_') for l in all_languages):
+ lang, opt = raw3.split('_', 1)
+ else:
+ lang, opt = None, raw3
+ assert ':' not in opt
+ assert '.' not in opt
+
+ return cls(opt, subproject, for_machine, lang, module)
+
+ def evolve(self, name: T.Optionalstr = None, subproject: T.Optionalstr = None,
+ machine: T.OptionalMachineChoice = None, lang: T.Optionalstr = '',
+ module: T.Optionalstr = '') -> 'OptionKey':
+ """Create a new copy of this key, but with alterted members.
+
+ For example:
+ >>> a = OptionKey('foo', '', MachineChoice.Host)
+ >>> b = OptionKey('foo', 'bar', MachineChoice.Host)
+ >>> b == a.evolve(subproject='bar')
+ True
+ """
+ # We have to be a little clever with lang here, because lang is valid
+ # as None, for non-compiler options
+ return OptionKey(
+ name if name is not None else self.name,
+ subproject if subproject is not None else self.subproject,
+ machine if machine is not None else self.machine,
+ lang if lang != '' else self.lang,
+ module if module != '' else self.module
+ )
+
+ def as_root(self) -> 'OptionKey':
+ """Convenience method for key.evolve(subproject='')."""
+ return self.evolve(subproject='')
+
+ def as_build(self) -> 'OptionKey':
+ """Convenience method for key.evolve(machine=MachinceChoice.BUILD)."""
+ return self.evolve(machine=MachineChoice.BUILD)
+
+ def as_host(self) -> 'OptionKey':
+ """Convenience method for key.evolve(machine=MachinceChoice.HOST)."""
+ return self.evolve(machine=MachineChoice.HOST)
+
+ def is_backend(self) -> bool:
+ """Convenience method to check if this is a backend option."""
+ return self.type is OptionType.BACKEND
+
+ def is_builtin(self) -> bool:
+ """Convenience method to check if this is a builtin option."""
+ return self.type is OptionType.BUILTIN
+
+ def is_compiler(self) -> bool:
+ """Convenience method to check if this is a builtin option."""
+ return self.type is OptionType.COMPILER
+
+ def is_project(self) -> bool:
+ """Convenience method to check if this is a project option."""
+ return self.type is OptionType.PROJECT
+
+ def is_base(self) -> bool:
+ """Convenience method to check if this is a base option."""
+ return self.type is OptionType.BASE
+
+def pickle_load(filename: str, object_name: str, object_type: T.Type) -> T.Any:
+ load_fail_msg = f'{object_name} file {filename!r} is corrupted. Try with a fresh build tree.'
+ try:
+ with open(filename, 'rb') as f:
+ obj = pickle.load(f)
+ except (pickle.UnpicklingError, EOFError):
+ raise MesonException(load_fail_msg)
+ except (TypeError, ModuleNotFoundError, AttributeError):
+ build_dir = os.path.dirname(os.path.dirname(filename))
+ raise MesonException(
+ f"{object_name} file {filename!r} references functions or classes that don't "
+ "exist. This probably means that it was generated with an old "
+ "version of meson. Try running from the source directory "
+ f'meson setup {build_dir} --wipe')
+ if not isinstance(obj, object_type):
+ raise MesonException(load_fail_msg)
+ from ..coredata import version as coredata_version
+ from ..coredata import major_versions_differ, MesonVersionMismatchException
+ version = getattr(obj, 'version', None)
+ if version is None:
+ version = obj.environment.coredata.version
+ if major_versions_differ(version, coredata_version):
+ raise MesonVersionMismatchException(version, coredata_version)
+ return obj
+
+
+def first(iter: T.Iterable_T, predicate: T.Callable_T, bool) -> T.Optional_T:
+ """Find the first entry in an iterable where the given predicate is true
+
+ :param iter: The iterable to search
+ :param predicate: A finding function that takes an element from the iterable
+ and returns True if found, otherwise False
+ :return: The first found element, or None if it is not found
+ """
+ for i in iter:
+ if predicate(i):
+ return i
+ return None

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/utils/vsenv.py Added

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import json
+import pathlib
+import shutil
+import tempfile
+
+from .. import mlog
+from .universal import MesonException, is_windows, windows_detect_native_arch
+
+
+__all__ = 
+    'setup_vsenv',
+
+
+
+bat_template = '''@ECHO OFF
+
+call "{}"
+
+ECHO {}
+SET
+'''
+
+# If on Windows and VS is installed but not set up in the environment,
+# set it to be runnable. In this way Meson can be directly invoked
+# from any shell, VS Code etc.
+def _setup_vsenv(force: bool) -> bool:
+    if not is_windows():
+        return False
+    if os.environ.get('OSTYPE') == 'cygwin':
+        return False
+    if 'MESON_FORCE_VSENV_FOR_UNITTEST' not in os.environ:
+        # VSINSTALL is set when running setvars from a Visual Studio installation
+        # Tested with Visual Studio 2012 and 2017
+        if 'VSINSTALLDIR' in os.environ:
+            return False
+        # Check explicitly for cl when on Windows
+        if shutil.which('cl.exe'):
+            return False
+    if not force:
+        if shutil.which('cc'):
+            return False
+        if shutil.which('gcc'):
+            return False
+        if shutil.which('clang'):
+            return False
+        if shutil.which('clang-cl'):
+            return False
+
+    root = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles")
+    bat_locator_bin = pathlib.Path(root, 'Microsoft Visual Studio/Installer/vswhere.exe')
+    if not bat_locator_bin.exists():
+        raise MesonException(f'Could not find {bat_locator_bin}')
+    bat_json = subprocess.check_output(
+        
+            str(bat_locator_bin),
+            '-latest',
+            '-prerelease',
+            '-requiresAny',
+            '-requires', 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
+            '-requires', 'Microsoft.VisualStudio.Workload.WDExpress',
+            '-products', '*',
+            '-utf8',
+            '-format',
+            'json'
+        
+    )
+    bat_info = json.loads(bat_json)
+    if not bat_info:
+        # VS installer instelled but not VS itself maybe?
+        raise MesonException('Could not parse vswhere.exe output')
+    bat_root = pathlib.Path(bat_info0'installationPath')
+    if windows_detect_native_arch() == 'arm64':
+        bat_path = bat_root / 'VC/Auxiliary/Build/vcvarsarm64.bat'
+        if not bat_path.exists():
+            bat_path = bat_root / 'VC/Auxiliary/Build/vcvarsx86_arm64.bat'
+    else:
+        bat_path = bat_root / 'VC/Auxiliary/Build/vcvars64.bat'
+        # if VS is not found try VS Express
+        if not bat_path.exists():
+            bat_path = bat_root / 'VC/Auxiliary/Build/vcvarsx86_amd64.bat'
+    if not bat_path.exists():
+        raise MesonException(f'Could not find {bat_path}')
+
+    mlog.log('Activating VS', bat_info0'catalog''productDisplayVersion')
+    bat_separator = '---SPLIT---'
+    bat_contents = bat_template.format(bat_path, bat_separator)
+    bat_file = tempfile.NamedTemporaryFile('w', suffix='.bat', encoding='utf-8', delete=False)
+    bat_file.write(bat_contents)
+    bat_file.flush()
+    bat_file.close()
+    bat_output = subprocess.check_output(bat_file.name, universal_newlines=True)
+    os.unlink(bat_file.name)
+    bat_lines = bat_output.split('\n')
+    bat_separator_seen = False
+    for bat_line in bat_lines:
+        if bat_line == bat_separator:
+            bat_separator_seen = True
+            continue
+        if not bat_separator_seen:
+            continue
+        if not bat_line:
+            continue
+        try:
+            k, v = bat_line.split('=', 1)
+        except ValueError:
+            # there is no "=", ignore junk data
+            pass
+        else:
+            os.environk = v
+    return True
+
+def setup_vsenv(force: bool = False) -> bool:
+    try:
+        return _setup_vsenv(force)
+    except MesonException as e:
+        if force:
+            raise
+        mlog.warning('Failed to activate VS environment:', str(e))
+        return False

_service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/utils/win32.py Added

@@ -0,0 +1,40 @@
+# SPDX-license-identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+"""Windows specific implementations of mesonlib functionality."""
+
+import msvcrt
+import typing as T
+
+from .universal import MesonException
+from .platform import BuildDirLock as BuildDirLockBase
+
+__all__ = 'BuildDirLock'
+
+class BuildDirLock(BuildDirLockBase):
+
+    def __enter__(self) -> None:
+        self.lockfile = open(self.lockfilename, 'w', encoding='utf-8')
+        try:
+            msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_NBLCK, 1)
+        except (BlockingIOError, PermissionError):
+            self.lockfile.close()
+            raise MesonException('Some other Meson process is already using this build directory. Exiting.')
+
+    def __exit__(self, *args: T.Any) -> None:
+        msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_UNLCK, 1)
+        self.lockfile.close()

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/wrap/wrap.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/wrap/wrap.py Changed

@@ -11,9 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 from .. import mlog
 import contextlib
+from dataclasses import dataclass
 import urllib.request
 import urllib.error
 import urllib.parse
@@ -25,14 +27,20 @@
 import subprocess
 import sys
 import configparser
+import time
 import typing as T
 import textwrap
+import json
 
+from base64 import b64encode
+from netrc import netrc
 from pathlib import Path
+
 from . import WrapMode
 from .. import coredata
-from ..mesonlib import quiet_git, GIT, ProgressBar, MesonException
+from ..mesonlib import quiet_git, GIT, ProgressBar, MesonException, windows_proof_rmtree, Popen_safe
 from ..interpreterbase import FeatureNew
+from ..interpreterbase import SubProject
 from .. import mesonlib
 
 if T.TYPE_CHECKING:
@@ -52,6 +60,8 @@
 
 ALL_TYPES = 'file', 'git', 'hg', 'svn'
 
+PATCH = shutil.which('patch')
+
 def whitelist_wrapdb(urlstr: str) -> urllib.parse.ParseResult:
     """ raises WrapException if not whitelisted subdomain """
     url = urllib.parse.urlparse(urlstr)
@@ -63,26 +73,71 @@
         raise WrapException(f'WrapDB did not have expected SSL https url, instead got {urlstr}')
     return url
 
-def open_wrapdburl(urlstring: str) -> 'http.client.HTTPResponse':
-    global SSL_WARNING_PRINTED
+def open_wrapdburl(urlstring: str, allow_insecure: bool = False, have_opt: bool = False) -> 'http.client.HTTPResponse':
+    if have_opt:
+        insecure_msg = '\n\n    To allow connecting anyway, pass `--allow-insecure`.'
+    else:
+        insecure_msg = ''
 
     url = whitelist_wrapdb(urlstring)
     if has_ssl:
         try:
             return T.cast('http.client.HTTPResponse', urllib.request.urlopen(urllib.parse.urlunparse(url), timeout=REQ_TIMEOUT))
         except urllib.error.URLError as excp:
-            raise WrapException(f'WrapDB connection failed to {urlstring} with error {excp}')
-
-    # following code is only for those without Python SSL
+            msg = f'WrapDB connection failed to {urlstring} with error {excp}.'
+            if isinstance(excp.reason, ssl.SSLCertVerificationError):
+                if allow_insecure:
+                    mlog.warning(f'{msg}\n\n    Proceeding without authentication.')
+                else:
+                    raise WrapException(f'{msg}{insecure_msg}')
+            else:
+                raise WrapException(msg)
+    elif not allow_insecure:
+        raise WrapException(f'SSL module not available in {sys.executable}: Cannot contact the WrapDB.{insecure_msg}')
+    else:
+        # following code is only for those without Python SSL
+        global SSL_WARNING_PRINTED  # pylint: disable=global-statement
+        if not SSL_WARNING_PRINTED:
+            mlog.warning(f'SSL module not available in {sys.executable}: WrapDB traffic not authenticated.')
+            SSL_WARNING_PRINTED = True
+
+    # If we got this far, allow_insecure was manually passed
     nossl_url = url._replace(scheme='http')
-    if not SSL_WARNING_PRINTED:
-        mlog.warning(f'SSL module not available in {sys.executable}: WrapDB traffic not authenticated.')
-        SSL_WARNING_PRINTED = True
     try:
         return T.cast('http.client.HTTPResponse', urllib.request.urlopen(urllib.parse.urlunparse(nossl_url), timeout=REQ_TIMEOUT))
     except urllib.error.URLError as excp:
         raise WrapException(f'WrapDB connection failed to {urlstring} with error {excp}')
 
+def get_releases_data(allow_insecure: bool) -> bytes:
+    url = open_wrapdburl('https://wrapdb.mesonbuild.com/v2/releases.json', allow_insecure, True)
+    return url.read()
+
+def get_releases(allow_insecure: bool) -> T.Dictstr, T.Any:
+    data = get_releases_data(allow_insecure)
+    return T.cast('T.Dictstr, T.Any', json.loads(data.decode()))
+
+def update_wrap_file(wrapfile: str, name: str, new_version: str, new_revision: str, allow_insecure: bool) -> None:
+    url = open_wrapdburl(f'https://wrapdb.mesonbuild.com/v2/{name}_{new_version}-{new_revision}/{name}.wrap',
+                         allow_insecure, True)
+    with open(wrapfile, 'wb') as f:
+        f.write(url.read())
+
+def parse_patch_url(patch_url: str) -> T.Tuplestr, str:
+    u = urllib.parse.urlparse(patch_url)
+    if u.netloc != 'wrapdb.mesonbuild.com':
+        raise WrapException(f'URL {patch_url} does not seems to be a wrapdb patch')
+    arr = u.path.strip('/').split('/')
+    if arr0 == 'v1':
+        # e.g. https://wrapdb.mesonbuild.com/v1/projects/zlib/1.2.11/5/get_zip
+        return arr-3, arr-2
+    elif arr0 == 'v2':
+        # e.g. https://wrapdb.mesonbuild.com/v2/zlib_1.2.11-5/get_patch
+        tag = arr-2
+        _, version = tag.rsplit('_', 1)
+        version, revision = version.rsplit('-', 1)
+        return version, revision
+    else:
+        raise WrapException(f'Invalid wrapdb URL {patch_url}')
 
 class WrapException(MesonException):
     pass
@@ -93,27 +148,30 @@
 class PackageDefinition:
     def __init__(self, fname: str, subproject: str = ''):
         self.filename = fname
-        self.subproject = subproject
+        self.subproject = SubProject(subproject)
         self.type = None  # type: T.Optionalstr
         self.values = {} # type: T.Dictstr, str
         self.provided_deps = {} # type: T.Dictstr, T.Optionalstr
         self.provided_programs =  # type: T.Liststr
+        self.diff_files =  # type: T.ListPath
         self.basename = os.path.basename(fname)
         self.has_wrap = self.basename.endswith('.wrap')
         self.name = self.basename:-5 if self.has_wrap else self.basename
-        self.directory = self.name
-        self.provided_depsself.name = None
+        # must be lowercase for consistency with dep=variable assignment
+        self.provided_depsself.name.lower() = None
+        # What the original file name was before redirection
         self.original_filename = fname
         self.redirected = False
         if self.has_wrap:
             self.parse_wrap()
+            with open(fname, 'r', encoding='utf-8') as file:
+                self.wrapfile_hash = hashlib.sha256(file.read().encode('utf-8')).hexdigest()
         self.directory = self.values.get('directory', self.name)
         if os.path.dirname(self.directory):
             raise WrapException('Directory key must be a name and not a path')
         if self.type and self.type not in ALL_TYPES:
             raise WrapException(f'Unknown wrap type {self.type!r}')
         self.filesdir = os.path.join(os.path.dirname(self.filename), 'packagefiles')
-        # What the original file name was before redirection
 
     def parse_wrap(self) -> None:
         try:
@@ -159,14 +217,24 @@
             raise WrapException(f'{self.wrap_section!r} is not a valid first section in {self.basename}')
         self.type = self.wrap_section5:
         self.values = dict(configself.wrap_section)
+        if 'diff_files' in self.values:
+            FeatureNew('Wrap files with diff_files', '0.63.0').use(self.subproject)
+            for s in self.values'diff_files'.split(','):
+                path = Path(s.strip())
+                if path.is_absolute():
+                    raise WrapException('diff_files paths cannot be absolute')
+                if '..' in path.parts:
+                    raise WrapException('diff_files paths cannot contain ".."')
+                self.diff_files.append(path)
 
     def parse_provide_section(self, config: configparser.ConfigParser) -> None:
         if config.has_section('provide'):
             for k, v in config'provide'.items():
                 if k == 'dependency_names':
                     # A comma separated list of dependency names that does not
-                    # need a variable name
-                    names_dict = {n.strip(): None for n in v.split(',')}
+                    # need a variable name; must be lowercase for consistency with
+                    # dep=variable assignment
+                    names_dict = {n.strip().lower(): None for n in v.split(',')}
                     self.provided_deps.update(names_dict)
                     continue
                 if k == 'program_names':
@@ -187,6 +255,14 @@
         except KeyError:
             raise WrapException(f'Missing key {key!r} in {self.basename}')
 
+    def get_hashfile(self, subproject_directory: str) -> str:
+        return os.path.join(subproject_directory, '.meson-subproject-wrap-hash.txt')
+
+    def update_hash_cache(self, subproject_directory: str) -> None:
+        if self.has_wrap:
+            with open(self.get_hashfile(subproject_directory), 'w', encoding='utf-8') as file:
+                file.write(self.wrapfile_hash + '\n')
+
 def get_directory(subdir_root: str, packagename: str) -> str:
     fname = os.path.join(subdir_root, packagename + '.wrap')
     if os.path.isfile(fname):
@@ -203,52 +279,100 @@
     except mesonlib.GitException as e:
         raise WrapException(str(e))
 
+@dataclass(eq=False)
 class Resolver:
-    def __init__(self, source_dir: str, subdir: str, subproject: str = '', wrap_mode: WrapMode = WrapMode.default) -> None:
-        self.source_dir = source_dir
-        self.subdir = subdir
-        self.subproject = subproject
-        self.wrap_mode = wrap_mode
-        self.subdir_root = os.path.join(source_dir, subdir)
+    source_dir: str
+    subdir: str
+    subproject: str = ''
+    wrap_mode: WrapMode = WrapMode.default
+    wrap_frontend: bool = False
+    allow_insecure: bool = False
+
+    def __post_init__(self) -> None:
+        self.subdir_root = os.path.join(self.source_dir, self.subdir)
         self.cachedir = os.path.join(self.subdir_root, 'packagecache')
         self.wraps = {} # type: T.Dictstr, PackageDefinition
+        self.netrc: T.Optionalnetrc = None
         self.provided_deps = {} # type: T.Dictstr, PackageDefinition
         self.provided_programs = {} # type: T.Dictstr, PackageDefinition
+        self.wrapdb: T.Dictstr, T.Any = {}
+        self.wrapdb_provided_deps: T.Dictstr, str = {}
+        self.wrapdb_provided_programs: T.Dictstr, str = {}
         self.load_wraps()
+        self.load_netrc()
+        self.load_wrapdb()
+
+    def load_netrc(self) -> None:
+        try:
+            self.netrc = netrc()
+        except FileNotFoundError:
+            return
+        except Exception as e:
+            mlog.warning(f'failed to process netrc file: {e}.', fatal=False)
 
     def load_wraps(self) -> None:
         if not os.path.isdir(self.subdir_root):
             return
         root, dirs, files = next(os.walk(self.subdir_root))
+        ignore_dirs = {'packagecache', 'packagefiles'}
         for i in files:
             if not i.endswith('.wrap'):
                 continue
             fname = os.path.join(self.subdir_root, i)
             wrap = PackageDefinition(fname, self.subproject)
             self.wrapswrap.name = wrap
-            if wrap.directory in dirs:
-                dirs.remove(wrap.directory)
+            ignore_dirs |= {wrap.directory, wrap.name}
         # Add dummy package definition for directories not associated with a wrap file.
         for i in dirs:
-            if i in 'packagecache', 'packagefiles':
+            if i in ignore_dirs:
                 continue
             fname = os.path.join(self.subdir_root, i)
             wrap = PackageDefinition(fname, self.subproject)
             self.wrapswrap.name = wrap
 
         for wrap in self.wraps.values():
-            for k in wrap.provided_deps.keys():
-                if k in self.provided_deps:
-                    prev_wrap = self.provided_depsk
-                    m = f'Multiple wrap files provide {k!r} dependency: {wrap.basename} and {prev_wrap.basename}'
-                    raise WrapException(m)
-                self.provided_depsk = wrap
-            for k in wrap.provided_programs:
-                if k in self.provided_programs:
-                    prev_wrap = self.provided_programsk
-                    m = f'Multiple wrap files provide {k!r} program: {wrap.basename} and {prev_wrap.basename}'
-                    raise WrapException(m)
-                self.provided_programsk = wrap
+            self.add_wrap(wrap)
+
+    def add_wrap(self, wrap: PackageDefinition) -> None:
+        for k in wrap.provided_deps.keys():
+            if k in self.provided_deps:
+                prev_wrap = self.provided_depsk
+                m = f'Multiple wrap files provide {k!r} dependency: {wrap.basename} and {prev_wrap.basename}'
+                raise WrapException(m)
+            self.provided_depsk = wrap
+        for k in wrap.provided_programs:
+            if k in self.provided_programs:
+                prev_wrap = self.provided_programsk
+                m = f'Multiple wrap files provide {k!r} program: {wrap.basename} and {prev_wrap.basename}'
+                raise WrapException(m)
+            self.provided_programsk = wrap
+
+    def load_wrapdb(self) -> None:
+        try:
+            with Path(self.subdir_root, 'wrapdb.json').open('r', encoding='utf-8') as f:
+                self.wrapdb = json.load(f)
+        except FileNotFoundError:
+            return
+        for name, info in self.wrapdb.items():
+            self.wrapdb_provided_deps.update({i: name for i in info.get('dependency_names', )})
+            self.wrapdb_provided_programs.update({i: name for i in info.get('program_names', )})
+
+    def get_from_wrapdb(self, subp_name: str) -> PackageDefinition:
+        info = self.wrapdb.get(subp_name)
+        if not info:
+            return None
+        self.check_can_download()
+        latest_version = info'versions'0
+        version, revision = latest_version.rsplit('-', 1)
+        url = urllib.request.urlopen(f'https://wrapdb.mesonbuild.com/v2/{subp_name}_{version}-{revision}/{subp_name}.wrap')
+        fname = Path(self.subdir_root, f'{subp_name}.wrap')
+        with fname.open('wb') as f:
+            f.write(url.read())
+        mlog.log(f'Installed {subp_name} version {version} revision {revision}')
+        wrap = PackageDefinition(str(fname))
+        self.wrapswrap.name = wrap
+        self.add_wrap(wrap)
+        return wrap
 
     def merge_wraps(self, other_resolver: 'Resolver') -> None:
         for k, v in other_resolver.wraps.items():
@@ -266,7 +390,8 @@
         if wrap:
             dep_var = wrap.provided_deps.get(packagename)
             return wrap.name, dep_var
-        return None, None
+        wrap_name = self.wrapdb_provided_deps.get(packagename)
+        return wrap_name, None
 
     def get_varname(self, subp_name: str, depname: str) -> T.Optionalstr:
         wrap = self.wraps.get(subp_name)
@@ -277,6 +402,9 @@
             wrap = self.provided_programs.get(name)
             if wrap:
                 return wrap.name
+            wrap_name = self.wrapdb_provided_programs.get(name)
+            if wrap_name:
+                return wrap_name
         return None
 
     def resolve(self, packagename: str, method: str) -> str:
@@ -284,15 +412,20 @@
         self.directory = packagename
         self.wrap = self.wraps.get(packagename)
         if not self.wrap:
+            self.wrap = self.get_from_wrapdb(packagename)
+        if not self.wrap:
             m = f'Neither a subproject directory nor a {self.packagename}.wrap file was found.'
             raise WrapNotFoundException(m)
         self.directory = self.wrap.directory
 
         if self.wrap.has_wrap:
-            # We have a .wrap file, source code will be placed into main
-            # project's subproject_dir even if the wrap file comes from another
-            # subproject.
-            self.dirname = os.path.join(self.subdir_root, self.directory)
+            # We have a .wrap file, use directory relative to the location of
+            # the wrap file if it exists, otherwise source code will be placed
+            # into main project's subproject_dir even if the wrap file comes
+            # from another subproject.
+            self.dirname = os.path.join(os.path.dirname(self.wrap.filename), self.wrap.directory)
+            if not os.path.exists(self.dirname):
+                self.dirname = os.path.join(self.subdir_root, self.directory)
             # Check if the wrap comes from the main project.
             main_fname = os.path.join(self.subdir_root, self.wrap.basename)
             if self.wrap.filename != main_fname:
@@ -311,16 +444,16 @@
             self.dirname = self.wrap.filename
         rel_path = os.path.relpath(self.dirname, self.source_dir)
 
-        meson_file = os.path.join(self.dirname, 'meson.build')
-        cmake_file = os.path.join(self.dirname, 'CMakeLists.txt')
-
-        if method not in 'meson', 'cmake':
+        if method == 'meson':
+            buildfile = os.path.join(self.dirname, 'meson.build')
+        elif method == 'cmake':
+            buildfile = os.path.join(self.dirname, 'CMakeLists.txt')
+        else:
             raise WrapException('Only the methods "meson" and "cmake" are supported')
 
         # The directory is there and has meson.build? Great, use it.
-        if method == 'meson' and os.path.exists(meson_file):
-            return rel_path
-        if method == 'cmake' and os.path.exists(cmake_file):
+        if os.path.exists(buildfile):
+            self.validate()
             return rel_path
 
         # Check if the subproject is a git submodule
@@ -342,13 +475,21 @@
                     self.get_svn()
                 else:
                     raise WrapException(f'Unknown wrap type {self.wrap.type!r}')
-            self.apply_patch()
+            try:
+                self.apply_patch()
+                self.apply_diff_files()
+            except Exception:
+                windows_proof_rmtree(self.dirname)
+                raise
 
         # A meson.build or CMakeLists.txt file is required in the directory
-        if method == 'meson' and not os.path.exists(meson_file):
-            raise WrapException('Subproject exists but has no meson.build file')
-        if method == 'cmake' and not os.path.exists(cmake_file):
-            raise WrapException('Subproject exists but has no CMakeLists.txt file')
+        if not os.path.exists(buildfile):
+            raise WrapException(f'Subproject exists but has no {os.path.basename(buildfile)} file')
+
+        # At this point, the subproject has been successfully resolved for the
+        # first time so save off the hash of the entire wrap file for future
+        # reference.
+        self.wrap.update_hash_cache(self.dirname)
 
         return rel_path
 
@@ -364,12 +505,16 @@
         # definitely cannot try to conveniently set up a submodule.
         if not GIT:
             return False
+        # Does the directory exist? Even uninitialised submodules checkout an
+        # empty directory to work in
+        if not os.path.isdir(self.dirname):
+            return False
         # Are we in a git repository?
-        ret, out = quiet_git('rev-parse', self.subdir_root)
+        ret, out = quiet_git('rev-parse', Path(self.dirname).parent)
         if not ret:
             return False
         # Is `dirname` a submodule?
-        ret, out = quiet_git('submodule', 'status', self.dirname, self.subdir_root)
+        ret, out = quiet_git('submodule', 'status', '.', self.dirname)
         if not ret:
             return False
         # Submodule has not been added, add it
@@ -380,11 +525,12 @@
             raise WrapException('git submodule has merge conflicts')
         # Submodule exists, but is deinitialized or wasn't initialized
         elif out.startswith('-'):
-            if verbose_git('submodule', 'update', '--init', self.dirname, self.subdir_root):
+            if verbose_git('submodule', 'update', '--init', '.', self.dirname):
                 return True
             raise WrapException('git submodule failed to init')
         # Submodule looks fine, but maybe it wasn't populated properly. Do a checkout.
         elif out.startswith(' '):
+            verbose_git('submodule', 'update', '.', self.dirname)
             verbose_git('checkout', '.', self.dirname)
             # Even if checkout failed, try building it anyway and let the user
             # handle any problems manually.
@@ -437,8 +583,11 @@
                         verbose_git('fetch', self.wrap.get('url'), revno, self.dirname, check=True)
                         verbose_git(checkout_cmd, self.dirname, check=True)
             else:
-                verbose_git('clone', *depth_option, '--branch', revno, self.wrap.get('url'),
-                             self.directory, self.subdir_root, check=True)
+                args = '-c', 'advice.detachedHead=false', 'clone', *depth_option
+                if revno.lower() != 'head':
+                    args += '--branch', revno
+                args += self.wrap.get('url'), self.directory
+                verbose_git(args, self.subdir_root, check=True)
             if self.wrap.values.get('clone-recursive', '').lower() == 'true':
                 verbose_git('submodule', 'update', '--init', '--checkout', '--recursive', *depth_option,
                             self.dirname, check=True)
@@ -446,9 +595,29 @@
             if push_url:
                 verbose_git('remote', 'set-url', '--push', 'origin', push_url, self.dirname, check=True)
 
+    def validate(self) -> None:
+        # This check is only for subprojects with wraps.
+        if not self.wrap.has_wrap:
+            return
+
+        # Retrieve original hash, if it exists.
+        hashfile = self.wrap.get_hashfile(self.dirname)
+        if os.path.isfile(hashfile):
+            with open(hashfile, 'r', encoding='utf-8') as file:
+                expected_hash = file.read().strip()
+        else:
+            # If stored hash doesn't exist then don't warn.
+            return
+
+        actual_hash = self.wrap.wrapfile_hash
+
+        # Compare hashes and warn the user if they don't match.
+        if expected_hash != actual_hash:
+            mlog.warning(f'Subproject {self.wrap.name}\'s revision may be out of date; its wrap file has changed since it was first configured')
+
     def is_git_full_commit_id(self, revno: str) -> bool:
         result = False
-        if len(revno) in (40, 64): # 40 for sha1, 64 for upcoming sha256
+        if len(revno) in {40, 64}: # 40 for sha1, 64 for upcoming sha256
             result = all(ch in '0123456789AaBbCcDdEeFf' for ch in revno)
         return result
 
@@ -471,23 +640,47 @@
         subprocess.check_call(svn, 'checkout', '-r', revno, self.wrap.get('url'),
                                self.directory, cwd=self.subdir_root)
 
+    def get_netrc_credentials(self, netloc: str) -> T.OptionalT.Tuplestr, str:
+        if self.netrc is None or netloc not in self.netrc.hosts:
+            return None
+
+        login, account, password = self.netrc.authenticators(netloc)
+        if account is not None:
+            login = account
+
+        return login, password
+
     def get_data(self, urlstring: str) -> T.Tuplestr, str:
         blocksize = 10 * 1024
         h = hashlib.sha256()
         tmpfile = tempfile.NamedTemporaryFile(mode='wb', dir=self.cachedir, delete=False)
         url = urllib.parse.urlparse(urlstring)
         if url.hostname and url.hostname.endswith(WHITELIST_SUBDOMAIN):
-            resp = open_wrapdburl(urlstring)
+            resp = open_wrapdburl(urlstring, allow_insecure=self.allow_insecure, have_opt=self.wrap_frontend)
         elif WHITELIST_SUBDOMAIN in urlstring:
             raise WrapException(f'{urlstring} may be a WrapDB-impersonating URL')
         else:
+            headers = {'User-Agent': f'mesonbuild/{coredata.version}'}
+            creds = self.get_netrc_credentials(url.netloc)
+
+            if creds is not None and '@' not in url.netloc:
+                login, password = creds
+                if url.scheme == 'https':
+                    enc_creds = b64encode(f'{login}:{password}'.encode()).decode()
+                    headers.update({'Authorization': f'Basic {enc_creds}'})
+                elif url.scheme == 'ftp':
+                    urlstring = urllib.parse.urlunparse(url._replace(netloc=f'{login}:{password}@{url.netloc}'))
+                else:
+                    mlog.warning('Meson is not going to use netrc credentials for protocols other than https/ftp',
+                                 fatal=False)
+
             try:
-                req = urllib.request.Request(urlstring, headers={'User-Agent': f'mesonbuild/{coredata.version}'})
+                req = urllib.request.Request(urlstring, headers=headers)
                 resp = urllib.request.urlopen(req, timeout=REQ_TIMEOUT)
             except urllib.error.URLError as e:
                 mlog.log(str(e))
                 raise WrapException(f'could not get {urlstring} is the internet available?')
-        with contextlib.closing(resp) as resp:
+        with contextlib.closing(resp) as resp, tmpfile as tmpfile:
             try:
                 dlsize = int(resp.info()'Content-Length')
             except TypeError:
@@ -527,12 +720,22 @@
         if dhash != expected:
             raise WrapException(f'Incorrect hash for {what}:\n {expected} expected\n {dhash} actual.')
 
+    def get_data_with_backoff(self, urlstring: str) -> T.Tuplestr, str:
+        delays = 1, 2, 4, 8, 16
+        for d in delays:
+            try:
+                return self.get_data(urlstring)
+            except Exception as e:
+                mlog.warning(f'failed to download with error: {e}. Trying after a delay...', fatal=False)
+                time.sleep(d)
+        return self.get_data(urlstring)
+
     def download(self, what: str, ofname: str, fallback: bool = False) -> None:
         self.check_can_download()
         srcurl = self.wrap.get(what + ('_fallback_url' if fallback else '_url'))
         mlog.log('Downloading', mlog.bold(self.packagename), what, 'from', mlog.bold(srcurl))
         try:
-            dhash, tmpfile = self.get_data(srcurl)
+            dhash, tmpfile = self.get_data_with_backoff(srcurl)
             expected = self.wrap.get(what + '_hash').lower()
             if dhash != expected:
                 os.remove(tmpfile)
@@ -587,6 +790,29 @@
                 raise WrapException(f'patch directory does not exist: {patch_dir}')
             self.copy_tree(src_dir, self.dirname)
 
+    def apply_diff_files(self) -> None:
+        for filename in self.wrap.diff_files:
+            mlog.log(f'Applying diff file "{filename}"')
+            path = Path(self.wrap.filesdir) / filename
+            if not path.exists():
+                raise WrapException(f'Diff file "{path}" does not exist')
+            relpath = os.path.relpath(str(path), self.dirname)
+            if PATCH:
+                cmd = PATCH, '-f', '-p1', '-i', relpath
+            elif GIT:
+                # If the `patch` command is not available, fall back to `git
+                # apply`. The `--work-tree` is necessary in case we're inside a
+                # Git repository: by default, Git will try to apply the patch to
+                # the repository root.
+                cmd = GIT, '--work-tree', '.', 'apply', '-p1', relpath
+            else:
+                raise WrapException('Missing "patch" or "git" commands to apply diff files')
+
+            p, out, _ = Popen_safe(cmd, cwd=self.dirname, stderr=subprocess.STDOUT)
+            if p.returncode != 0:
+                mlog.log(out.strip())
+                raise WrapException(f'Failed to apply diff file "{filename}"')
+
     def copy_tree(self, root_src_dir: str, root_dst_dir: str) -> None:
         """
         Copy directory tree. Overwrites also read only files.

_service:tar_scm:meson-0.61.5.tar.gz/mesonbuild/wrap/wraptool.py -> _service:tar_scm:meson-1.0.1.tar.gz/mesonbuild/wrap/wraptool.py Changed

@@ -11,19 +11,19 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
-import json
 import sys, os
 import configparser
 import shutil
 import typing as T
 
 from glob import glob
-from urllib.parse import urlparse
-from urllib.request import urlopen
-from .wrap import WrapException
+from .wrap import (open_wrapdburl, WrapException, get_releases, get_releases_data,
+                   update_wrap_file, parse_patch_url)
+from pathlib import Path
 
-from .. import mesonlib
+from .. import mesonlib, msubprojects
 
 if T.TYPE_CHECKING:
     import argparse
@@ -33,43 +33,53 @@
     subparsers.required = True
 
     p = subparsers.add_parser('list', help='show all available projects')
+    p.add_argument('--allow-insecure', default=False, action='store_true',
+                   help='Allow insecure server connections.')
     p.set_defaults(wrap_func=list_projects)
 
     p = subparsers.add_parser('search', help='search the db by name')
+    p.add_argument('--allow-insecure', default=False, action='store_true',
+                   help='Allow insecure server connections.')
     p.add_argument('name')
     p.set_defaults(wrap_func=search)
 
     p = subparsers.add_parser('install', help='install the specified project')
+    p.add_argument('--allow-insecure', default=False, action='store_true',
+                   help='Allow insecure server connections.')
     p.add_argument('name')
     p.set_defaults(wrap_func=install)
 
-    p = subparsers.add_parser('update', help='update the project to its newest available release')
-    p.add_argument('name')
-    p.set_defaults(wrap_func=update)
+    p = msubprojects.add_wrap_update_parser(subparsers)
+    p.set_defaults(wrap_func=msubprojects.run)
 
     p = subparsers.add_parser('info', help='show available versions of a project')
+    p.add_argument('--allow-insecure', default=False, action='store_true',
+                   help='Allow insecure server connections.')
     p.add_argument('name')
     p.set_defaults(wrap_func=info)
 
     p = subparsers.add_parser('status', help='show installed and available versions of your projects')
+    p.add_argument('--allow-insecure', default=False, action='store_true',
+                   help='Allow insecure server connections.')
     p.set_defaults(wrap_func=status)
 
     p = subparsers.add_parser('promote', help='bring a subsubproject up to the master project')
     p.add_argument('project_path')
     p.set_defaults(wrap_func=promote)
 
-def get_releases() -> T.Dictstr, T.Any:
-    url = urlopen('https://wrapdb.mesonbuild.com/v2/releases.json')
-    return T.cast(T.Dictstr, T.Any, json.loads(url.read().decode()))
+    p = subparsers.add_parser('update-db', help='Update list of projects available in WrapDB (Since 0.61.0)')
+    p.add_argument('--allow-insecure', default=False, action='store_true',
+                   help='Allow insecure server connections.')
+    p.set_defaults(wrap_func=update_db)
 
 def list_projects(options: 'argparse.Namespace') -> None:
-    releases = get_releases()
+    releases = get_releases(options.allow_insecure)
     for p in releases.keys():
         print(p)
 
 def search(options: 'argparse.Namespace') -> None:
     name = options.name
-    releases = get_releases()
+    releases = get_releases(options.allow_insecure)
     for p, info in releases.items():
         if p.find(name) != -1:
             print(p)
@@ -78,8 +88,8 @@
                 if dep.find(name) != -1:
                     print(f'Dependency {dep} found in wrap {p}')
 
-def get_latest_version(name: str) -> T.Tuplestr, str:
-    releases = get_releases()
+def get_latest_version(name: str, allow_insecure: bool) -> T.Tuplestr, str:
+    releases = get_releases(allow_insecure)
     info = releases.get(name)
     if not info:
         raise WrapException(f'Wrap {name} not found in wrapdb')
@@ -96,41 +106,31 @@
     wrapfile = os.path.join('subprojects', name + '.wrap')
     if os.path.exists(wrapfile):
         raise SystemExit('Wrap file already exists.')
-    (version, revision) = get_latest_version(name)
-    url = urlopen(f'https://wrapdb.mesonbuild.com/v2/{name}_{version}-{revision}/{name}.wrap')
+    (version, revision) = get_latest_version(name, options.allow_insecure)
+    url = open_wrapdburl(f'https://wrapdb.mesonbuild.com/v2/{name}_{version}-{revision}/{name}.wrap', options.allow_insecure, True)
     with open(wrapfile, 'wb') as f:
         f.write(url.read())
     print(f'Installed {name} version {version} revision {revision}')
 
-def parse_patch_url(patch_url: str) -> T.Tuplestr, str:
-    u = urlparse(patch_url)
-    if u.netloc != 'wrapdb.mesonbuild.com':
-        raise WrapException(f'URL {patch_url} does not seems to be a wrapdb patch')
-    arr = u.path.strip('/').split('/')
-    if arr0 == 'v1':
-        # e.g. https://wrapdb.mesonbuild.com/v1/projects/zlib/1.2.11/5/get_zip
-        return arr-3, arr-2
-    elif arr0 == 'v2':
-        # e.g. https://wrapdb.mesonbuild.com/v2/zlib_1.2.11-5/get_patch
-        tag = arr-2
-        _, version = tag.rsplit('_', 1)
-        version, revision = version.rsplit('-', 1)
-        return version, revision
-    else:
-        raise WrapException(f'Invalid wrapdb URL {patch_url}')
-
-def get_current_version(wrapfile: str) -> T.Tuplestr, str, str, str, str:
+def get_current_version(wrapfile: str) -> T.Tuplestr, str, str, str, T.Optionalstr:
     cp = configparser.ConfigParser(interpolation=None)
     cp.read(wrapfile)
-    wrap_data = cp'wrap-file'
-    patch_url = wrap_data'patch_url'
-    branch, revision = parse_patch_url(patch_url)
-    return branch, revision, wrap_data'directory', wrap_data'source_filename', wrap_data'patch_filename'
-
-def update_wrap_file(wrapfile: str, name: str, new_version: str, new_revision: str) -> None:
-    url = urlopen(f'https://wrapdb.mesonbuild.com/v2/{name}_{new_version}-{new_revision}/{name}.wrap')
-    with open(wrapfile, 'wb') as f:
-        f.write(url.read())
+    try:
+        wrap_data = cp'wrap-file'
+    except KeyError:
+        raise WrapException('Not a wrap-file, cannot have come from the wrapdb')
+    try:
+        patch_url = wrap_data'patch_url'
+    except KeyError:
+        # We assume a wrap without a patch_url is probably just an pointer to upstream's
+        # build files. The version should be in the tarball filename, even if it isn't
+        # purely guaranteed. The wrapdb revision should be 1 because it just needs uploading once.
+        branch = mesonlib.search_version(wrap_data'source_filename')
+        revision, patch_filename = '1', None
+    else:
+        branch, revision = parse_patch_url(patch_url)
+        patch_filename = wrap_data'patch_filename'
+    return branch, revision, wrap_data'directory', wrap_data'source_filename', patch_filename
 
 def update(options: 'argparse.Namespace') -> None:
     name = options.name
@@ -140,25 +140,26 @@
     if not os.path.exists(wrapfile):
         raise SystemExit('Project ' + name + ' is not in use.')
     (branch, revision, subdir, src_file, patch_file) = get_current_version(wrapfile)
-    (new_branch, new_revision) = get_latest_version(name)
+    (new_branch, new_revision) = get_latest_version(name, options.allow_insecure)
     if new_branch == branch and new_revision == revision:
         print('Project ' + name + ' is already up to date.')
         raise SystemExit
-    update_wrap_file(wrapfile, name, new_branch, new_revision)
+    update_wrap_file(wrapfile, name, new_branch, new_revision, options.allow_insecure)
     shutil.rmtree(os.path.join('subprojects', subdir), ignore_errors=True)
     try:
         os.unlink(os.path.join('subprojects/packagecache', src_file))
     except FileNotFoundError:
         pass
-    try:
-        os.unlink(os.path.join('subprojects/packagecache', patch_file))
-    except FileNotFoundError:
-        pass
+    if patch_file is not None:
+        try:
+            os.unlink(os.path.join('subprojects/packagecache', patch_file))
+        except FileNotFoundError:
+            pass
     print(f'Updated {name} version {new_branch} revision {new_revision}')
 
 def info(options: 'argparse.Namespace') -> None:
     name = options.name
-    releases = get_releases()
+    releases = get_releases(options.allow_insecure)
     info = releases.get(name)
     if not info:
         raise WrapException(f'Wrap {name} not found in wrapdb')
@@ -205,20 +206,26 @@
     for w in glob('subprojects/*.wrap'):
         name = os.path.basename(w):-5
         try:
-            (latest_branch, latest_revision) = get_latest_version(name)
+            (latest_branch, latest_revision) = get_latest_version(name, options.allow_insecure)
         except Exception:
             print('', name, 'not available in wrapdb.', file=sys.stderr)
             continue
         try:
             (current_branch, current_revision, _, _, _) = get_current_version(w)
         except Exception:
-            print('Wrap file not from wrapdb.', file=sys.stderr)
+            print('', name, 'Wrap file not from wrapdb.', file=sys.stderr)
             continue
         if current_branch == latest_branch and current_revision == latest_revision:
             print('', name, f'up to date. Branch {current_branch}, revision {current_revision}.')
         else:
             print('', name, f'not up to date. Have {current_branch} {current_revision}, but {latest_branch} {latest_revision} is available.')
 
+def update_db(options: 'argparse.Namespace') -> None:
+    data = get_releases_data(options.allow_insecure)
+    Path('subprojects').mkdir(exist_ok=True)
+    with Path('subprojects/wrapdb.json').open('wb') as f:
+        f.write(data)
+
 def run(options: 'argparse.Namespace') -> int:
     options.wrap_func(options)
     return 0

_service:tar_scm:meson-0.61.5.tar.gz/packaging/create_zipapp.py -> _service:tar_scm:meson-1.0.1.tar.gz/packaging/create_zipapp.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/packaging/hook-mesonbuild.py -> _service:tar_scm:meson-1.0.1.tar.gz/packaging/hook-mesonbuild.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/pyproject.toml -> _service:tar_scm:meson-1.0.1.tar.gz/pyproject.toml Changed

_service:tar_scm:meson-0.61.5.tar.gz/run_meson_command_tests.py -> _service:tar_scm:meson-1.0.1.tar.gz/run_meson_command_tests.py Changed

@@ -19,29 +19,44 @@
 import unittest
 import subprocess
 import zipapp
+import sysconfig
 from pathlib import Path
 
 from mesonbuild.mesonlib import windows_proof_rmtree, python_command, is_windows
 from mesonbuild.coredata import version as meson_version
 
-# Handle the scheme that Debian patches in the as default
-import sysconfig
-# This function was renamed and made public in Python 3.10
-if hasattr(sysconfig, 'get_default_scheme'):
- scheme = sysconfig.get_default_scheme()
-else:
- scheme = sysconfig._get_default_scheme()
-if scheme == 'posix_local':
- scheme = 'posix_prefix'
+scheme = None
+
+def needs_debian_path_hack():
+ try:
+ import setuptools
+ return int(setuptools.__version__.split('.')0) < 65
+ except ModuleNotFoundError:
+ return False
+
+if needs_debian_path_hack():
+ # Handle the scheme that Debian patches in the as default
+ # This function was renamed and made public in Python 3.10
+ if hasattr(sysconfig, 'get_default_scheme'):
+ scheme = sysconfig.get_default_scheme()
+ else:
+ scheme = sysconfig._get_default_scheme()
+ if scheme == 'posix_local':
+ scheme = 'posix_prefix'
 
 def get_pypath():
- pypath = sysconfig.get_path('purelib', scheme=scheme, vars={'base': ''})
+ if scheme:
+ pypath = sysconfig.get_path('purelib', scheme=scheme, vars={'base': ''})
+ else:
+ pypath = sysconfig.get_path('purelib', vars={'base': ''})
 # Ensure that / is the path separator and not \, then strip /
 return Path(pypath).as_posix().strip('/')
 
 def get_pybindir():
 # 'Scripts' on Windows and 'bin' on other platforms including MSYS
- return sysconfig.get_path('scripts', scheme=scheme, vars={'base': ''}).strip('\\/')
+ if scheme:
+ return sysconfig.get_path('scripts', scheme=scheme, vars={'base': ''}).strip('\\/')
+ return sysconfig.get_path('scripts', vars={'base': ''}).strip('\\/')
 
 class CommandTests(unittest.TestCase):
 '''
@@ -69,7 +84,7 @@
 os.chdir(str(self.orig_dir))
 super().tearDown()
 
- def _run(self, command, workdir=None):
+ def _run(self, command, workdir=None, env=None):
 '''
 Run a command while printing the stdout, and also return a copy of it
 '''
@@ -77,7 +92,7 @@
 # between CI issue and test bug in that case. Set timeout and fail loud
 # instead.
 p = subprocess.run(command, stdout=subprocess.PIPE,
- env=os.environ.copy(), universal_newlines=True,
+ env=env, text=True,
 cwd=workdir, timeout=60 * 5)
 print(p.stdout)
 if p.returncode != 0:
@@ -117,13 +132,17 @@
 bindir = (self.tmpdir / 'bin')
 bindir.mkdir()
 (bindir / 'meson').symlink_to(self.src_root / 'meson.py')
+ (bindir / 'python3').symlink_to(python_command0)
 os.environ'PATH' = str(bindir) + os.pathsep + os.environ'PATH'
+ # use our overridden PATH-compatible python
+ path_resolved_meson_command = resolved_meson_command.copy()
+ path_resolved_meson_command0 = str(bindir / 'python3')
 # See if it works!
 meson_py = 'meson'
 meson_setup = meson_py, 'setup'
 meson_command = meson_setup + self.meson_args
 stdo = self._run(meson_command + self.testdir, builddir)
- self.assertMesonCommandIs(stdo.split('\n')0, resolved_meson_command)
+ self.assertMesonCommandIs(stdo.split('\n')0, path_resolved_meson_command)
 
 def test_meson_installed(self):
 # Install meson
@@ -191,6 +210,21 @@
 self._run(script.as_posix(), source, '--outfile', target, '--interpreter', python_command0)
 self._run(target.as_posix(), '--help')
 
+ def test_meson_runpython(self):
+ meson_command = str(self.src_root / 'meson.py')
+ script_file = str(self.src_root / 'foo.py')
+ test_command = 'import sys; print(sys.argv1)'
+ env = os.environ.copy()
+ del env'MESON_COMMAND_TESTS'
+ with open(script_file, 'w') as f:
+ f.write('#!/usr/bin/env python3\n\n')
+ f.write(f'{test_command}\n')
+
+ for cmd in '-c', test_command, 'fake argument', script_file, 'fake argument':
+ pyout = self._run(python_command + cmd)
+ mesonout = self._run(python_command + meson_command, 'runpython' + cmd, env=env)
+ self.assertEqual(pyout, mesonout)
+
 
 if __name__ == '__main__':
 print('Meson build system', meson_version, 'Command Tests')

_service:tar_scm:meson-0.61.5.tar.gz/run_mypy.py -> _service:tar_scm:meson-1.0.1.tar.gz/run_mypy.py Changed

@@ -11,20 +11,21 @@
 
 modules = 
     # fully typed submodules
-    # 'mesonbuild/ast',
-    'mesonbuild/cmake',
-    'mesonbuild/compilers',
-    'mesonbuild/dependencies',
-    'mesonbuild/interpreter/primitives',
-    'mesonbuild/interpreterbase',
-    'mesonbuild/linkers',
-    'mesonbuild/scripts',
-    'mesonbuild/wrap',
+    # 'mesonbuild/ast/',
+    'mesonbuild/cmake/',
+    'mesonbuild/compilers/',
+    'mesonbuild/dependencies/',
+    'mesonbuild/interpreter/primitives/',
+    'mesonbuild/interpreterbase/',
+    'mesonbuild/linkers/',
+    'mesonbuild/scripts/',
+    'mesonbuild/wrap/',
 
     # specific files
     'mesonbuild/arglist.py',
     'mesonbuild/backend/backends.py',
     # 'mesonbuild/coredata.py',
+    'mesonbuild/depfile.py',
     'mesonbuild/envconfig.py',
     'mesonbuild/interpreter/compiler.py',
     'mesonbuild/interpreter/mesonmain.py',
@@ -32,20 +33,26 @@
     'mesonbuild/interpreter/type_checking.py',
     'mesonbuild/mcompile.py',
     'mesonbuild/mdevenv.py',
-    'mesonbuild/mesonlib/platform.py',
-    'mesonbuild/mesonlib/universal.py',
+    'mesonbuild/utils/platform.py',
+    'mesonbuild/utils/universal.py',
     'mesonbuild/minit.py',
     'mesonbuild/minstall.py',
     'mesonbuild/mintro.py',
     'mesonbuild/mlog.py',
     'mesonbuild/msubprojects.py',
+    'mesonbuild/modules/external_project.py',
     'mesonbuild/modules/fs.py',
+    'mesonbuild/modules/gnome.py',
     'mesonbuild/modules/i18n.py',
+    'mesonbuild/modules/icestorm.py',
     'mesonbuild/modules/java.py',
     'mesonbuild/modules/keyval.py',
+    'mesonbuild/modules/modtest.py',
+    'mesonbuild/modules/pkgconfig.py',
     'mesonbuild/modules/qt.py',
-    'mesonbuild/modules/unstable_external_project.py',
-    'mesonbuild/modules/unstable_rust.py',
+    'mesonbuild/modules/rust.py',
+    'mesonbuild/modules/sourceset.py',
+    'mesonbuild/modules/wayland.py',
     'mesonbuild/modules/windows.py',
     'mesonbuild/mparser.py',
     'mesonbuild/msetup.py',
@@ -62,9 +69,9 @@
 
 
 if os.name == 'posix':
-    modules.append('mesonbuild/mesonlib/posix.py')
+    modules.append('mesonbuild/utils/posix.py')
 elif os.name == 'nt':
-    modules.append('mesonbuild/mesonlib/win32.py')
+    modules.append('mesonbuild/utils/win32.py')
 
 def check_mypy() -> None:
     try:
@@ -84,6 +91,8 @@
     args =   # type: T.Liststr
 
     parser = argparse.ArgumentParser(description='Process some integers.')
+    parser.add_argument('files', nargs='*')
+    parser.add_argument('-q', '--quiet', action='store_true', help='do not print informational messages')
     parser.add_argument('-p', '--pretty', action='store_true', help='pretty print mypy errors')
     parser.add_argument('-C', '--clear', action='store_true', help='clear the terminal before running mypy')
 
@@ -94,12 +103,31 @@
     if opts.clear:
         print('\x1bc', end='', flush=True)
 
-    print('Running mypy (this can take some time) ...')
-    p = subprocess.run(
-        sys.executable, '-m', 'mypy' + args + modules,
-        cwd=root,
-    )
-    return p.returncode
+    to_check =  # type: T.Liststr
+    if opts.files:
+        for f in opts.files:
+            if f in modules:
+                to_check.append(f)
+            elif any(f.startswith(i) for i in modules):
+                to_check.append(f)
+            else:
+                if not opts.quiet:
+                    print(f'skipping {f!r} because it is not yet typed')
+    else:
+        to_check.extend(modules)
+
+    if to_check:
+        if not opts.quiet:
+            print('Running mypy (this can take some time) ...')
+        p = subprocess.run(
+            sys.executable, '-m', 'mypy', '--python-version', '3.10' + args + to_check,
+            cwd=root,
+        )
+        return p.returncode
+    else:
+        if not opts.quiet:
+            print('nothing to do...')
+        return 0
 
 if __name__ == '__main__':
     sys.exit(main())

_service:tar_scm:meson-0.61.5.tar.gz/run_project_tests.py -> _service:tar_scm:meson-1.0.1.tar.gz/run_project_tests.py Changed

@@ -13,6 +13,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from __future__ import annotations
 
 # Work around some pathlib bugs...
 from mesonbuild import _pathlib
@@ -84,7 +85,7 @@
 ALL_TESTS = 'cmake', 'common', 'native', 'warning-meson', 'failing-meson', 'failing-build', 'failing-test',
              'keyval', 'platform-osx', 'platform-windows', 'platform-linux',
              'java', 'C#', 'vala', 'cython', 'rust', 'd', 'objective c', 'objective c++',
-             'fortran', 'swift', 'cuda', 'python3', 'python', 'fpga', 'frameworks', 'nasm', 'wasm',
+             'fortran', 'swift', 'cuda', 'python3', 'python', 'fpga', 'frameworks', 'nasm', 'wasm', 'wayland'
              
 
 
@@ -176,7 +177,15 @@
                 return p
             if self.typ == 'python_lib':
                 return p.with_suffix(python_suffix)
-        if self.typ in 'file', 'dir':
+            if self.typ == 'py_implib':
+                p = p.with_suffix(python_suffix)
+                if env.machines.host.is_windows() and canonical_compiler == 'msvc':
+                    return p.with_suffix('.lib')
+                elif env.machines.host.is_windows() or env.machines.host.is_cygwin():
+                    return p.with_suffix('.dll.a')
+                else:
+                    return None
+        elif self.typ in {'file', 'dir'}:
             return p
         elif self.typ == 'shared_lib':
             if env.machines.host.is_windows() or env.machines.host.is_cygwin():
@@ -210,15 +219,13 @@
             if self.version:
                 p = p.with_name('{}-{}'.format(p.name, self.version0))
             return p.with_suffix('.pdb') if has_pdb else None
-        elif self.typ in {'implib', 'implibempty', 'py_implib'}:
+        elif self.typ in {'implib', 'implibempty'}:
             if env.machines.host.is_windows() and canonical_compiler == 'msvc':
                 # only MSVC doesn't generate empty implibs
                 if self.typ == 'implibempty' and compiler == 'msvc':
                     return None
                 return p.parent / (re.sub(r'^lib', '', p.name) + '.lib')
             elif env.machines.host.is_windows() or env.machines.host.is_cygwin():
-                if self.typ == 'py_implib':
-                    p = p.with_suffix(python_suffix)
                 return p.with_suffix('.dll.a')
             else:
                 return None
@@ -245,7 +252,7 @@
 
 @functools.total_ordering
 class TestDef:
-    def __init__(self, path: Path, name: T.Optionalstr, args: T.Liststr, skip: bool = False):
+    def __init__(self, path: Path, name: T.Optionalstr, args: T.Liststr, skip: bool = False, skip_category: bool = False):
         self.category = path.parts1
         self.path = path
         self.name = name
@@ -255,6 +262,7 @@
         self.installed_files =   # type: T.ListInstalledFile
         self.do_not_set_opts =   # type: T.Liststr
         self.stdout =  # type: T.ListT.Dictstr, str
+        self.skip_category = skip_category
         self.skip_expected = False
 
         # Always print a stack trace for Meson exceptions
@@ -470,7 +478,7 @@
                     sub = r'\\'
                 else:
                     sub = r'\\\\'
-                expected_line = re.sub(r'/(?=.*(WARNING|ERROR))', sub, expected_line)
+                expected_line = re.sub(r'/(?=.*(WARNING|ERROR|DEPRECATION))', sub, expected_line)
 
             m = OutputMatch(how, expected_line, count)
             if count == 0:
@@ -634,7 +642,7 @@
               should_fail: str) -> TestResult:
     gen_start = time.time()
     # Configure in-process
-    gen_args =   # type: T.Liststr
+    gen_args = 'setup'
     if 'prefix' not in test.do_not_set_opts:
         gen_args += '--prefix', 'x:/usr' if mesonlib.is_windows() else '--prefix', '/usr'
     if 'libdir' not in test.do_not_set_opts:
@@ -650,7 +658,8 @@
     (returncode, stdo, stde) = run_configure(gen_args, env=test.env, catch_exception=True)
     try:
         logfile = Path(test_build_dir, 'meson-logs', 'meson-log.txt')
-        mesonlog = logfile.open(errors='ignore', encoding='utf-8').read()
+        with logfile.open(errors='ignore', encoding='utf-8') as fid:
+            mesonlog = fid.read()
     except Exception:
         mesonlog = no_meson_log_msg
     cicmds = run_ci_commands(mesonlog)
@@ -781,7 +790,7 @@
     return (skip, skip_expected)
 
 
-def load_test_json(t: TestDef, stdout_mandatory: bool) -> T.ListTestDef:
+def load_test_json(t: TestDef, stdout_mandatory: bool, skip_category: bool = False) -> T.ListTestDef:
     all_tests: T.ListTestDef = 
     test_def = {}
     test_def_file = t.path / 'test.json'
@@ -830,15 +839,15 @@
         t.stdout = stdout
         return t
 
-    new_opt_list: T.ListT.ListT.Tuplestr, bool, bool
+    new_opt_list: T.ListT.ListT.Tuplestr, str, bool, bool
 
     # 'matrix; entry is present, so build multiple tests from matrix definition
-    opt_list =   # type: T.ListT.ListT.Tuplestr, bool, bool
+    opt_list =   # type: T.ListT.ListT.Tuplestr, str, bool, bool
     matrix = test_def'matrix'
     assert "options" in matrix
     for key, val in matrix"options".items():
         assert isinstance(val, list)
-        tmp_opts =   # type: T.ListT.Tuplestr, bool, bool
+        tmp_opts =   # type: T.ListT.Tuplestr, str, bool, bool
         for i in val:
             assert isinstance(i, dict)
             assert "val" in i
@@ -854,10 +863,10 @@
 
             # Add an empty matrix entry
             if i'val' is None:
-                tmp_opts += (None, skip, skip_expected)
+                tmp_opts += (key, None, skip, skip_expected)
                 continue
 
-            tmp_opts += ('{}={}'.format(key, i'val'), skip, skip_expected)
+            tmp_opts += (key, i'val', skip, skip_expected)
 
         if opt_list:
             new_opt_list = 
@@ -874,10 +883,10 @@
         new_opt_list = 
         for i in opt_list:
             exclude = False
-            opt_names = x0 for x in i
+            opt_tuple = (x0, x1) for x in i
             for j in matrix'exclude':
-                ex_list = f'{k}={v}' for k, v in j.items()
-                if all(x in opt_names for x in ex_list):
+                ex_list = (k, v) for k, v in j.items()
+                if all(x in opt_tuple for x in ex_list):
                     exclude = True
                     break
 
@@ -887,11 +896,11 @@
         opt_list = new_opt_list
 
     for i in opt_list:
-        name = ' '.join(x0 for x in i if x0 is not None)
-        opts = '-D' + x0 for x in i if x0 is not None
-        skip = any(x1 for x in i)
-        skip_expected = any(x2 for x in i)
-        test = TestDef(t.path, name, opts, skip or t.skip)
+        name = ' '.join(f'{x0}={x1}' for x in i if x1 is not None)
+        opts = f'-D{x0}={x1}' for x in i if x1 is not None
+        skip = any(x2 for x in i)
+        skip_expected = any(x3 for x in i)
+        test = TestDef(t.path, name, opts, skip or t.skip, skip_category)
         test.env.update(env)
         test.installed_files = installed
         test.do_not_set_opts = do_not_set_opts
@@ -902,7 +911,7 @@
     return all_tests
 
 
-def gather_tests(testdir: Path, stdout_mandatory: bool, only: T.Liststr) -> T.ListTestDef:
+def gather_tests(testdir: Path, stdout_mandatory: bool, only: T.Liststr, skip_category: bool) -> T.ListTestDef:
     all_tests: T.ListTestDef = 
     for t in testdir.iterdir():
         # Filter non-tests files (dot files, etc)
@@ -910,8 +919,8 @@
             continue
         if only and not any(t.name.startswith(prefix) for prefix in only):
             continue
-        test_def = TestDef(t, None, )
-        all_tests.extend(load_test_json(test_def, stdout_mandatory))
+        test_def = TestDef(t, None, , skip_category=skip_category)
+        all_tests.extend(load_test_json(test_def, stdout_mandatory, skip_category))
     return sorted(all_tests)
 
 
@@ -927,8 +936,7 @@
         # that exists but segfaults every time the compiler is run.
         # Don't know why. Don't know how to fix. Skip in this case.
         cp = subprocess.run('dmd', '--version',
-                            stdout=subprocess.PIPE,
-                            stderr=subprocess.PIPE)
+                            capture_output=True)
         if cp.stdout == b'':
             return False
         return True
@@ -1034,6 +1042,13 @@
             return True
     return False
 
+def should_skip_wayland() -> bool:
+    if mesonlib.is_windows() or mesonlib.is_osx():
+        return True
+    if not shutil.which('wayland-scanner'):
+        return True
+    return False
+
 def detect_tests_to_run(only: T.Dictstr, T.Liststr, use_tmp: bool) -> T.ListT.Tuplestr, T.ListTestDef, bool:
     """
     Parameters
@@ -1051,7 +1066,12 @@
                        shutil.which('flang') or
                        shutil.which('pgfortran') or
                        shutil.which('nagfor') or
-                       shutil.which('ifort'))
+                       shutil.which('ifort') or
+                       shutil.which('ifx'))
+
+    skip_cmake = ((os.environ.get('compiler') == 'msvc2015' and under_ci) or
+                  'cmake' not in tool_vers_map or
+                  not mesonlib.version_compare(tool_vers_map'cmake', '>=3.14'))
 
     class TestCategory:
         def __init__(self, category: str, subdir: str, skip: bool = False, stdout_mandatory: bool = False):
@@ -1061,7 +1081,7 @@
             self.stdout_mandatory = stdout_mandatory  # expected stdout is mandatory for tests in this category
 
     all_tests = 
-        TestCategory('cmake', 'cmake', not shutil.which('cmake') or (os.environ.get('compiler') == 'msvc2015' and under_ci)),
+        TestCategory('cmake', 'cmake', skip_cmake),
         TestCategory('common', 'common'),
         TestCategory('native', 'native'),
         TestCategory('warning-meson', 'warning', stdout_mandatory=True),
@@ -1072,7 +1092,7 @@
         TestCategory('platform-osx', 'osx', not mesonlib.is_osx()),
         TestCategory('platform-windows', 'windows', not mesonlib.is_windows() and not mesonlib.is_cygwin()),
         TestCategory('platform-linux', 'linuxlike', mesonlib.is_osx() or mesonlib.is_windows()),
-        TestCategory('java', 'java', backend is not Backend.ninja or mesonlib.is_osx() or not have_java()),
+        TestCategory('java', 'java', backend is not Backend.ninja or not have_java()),
         TestCategory('C#', 'csharp', skip_csharp(backend)),
         TestCategory('vala', 'vala', backend is not Backend.ninja or not shutil.which(os.environ.get('VALAC', 'valac'))),
         TestCategory('cython', 'cython', backend is not Backend.ninja or not shutil.which(os.environ.get('CYTHON', 'cython'))),
@@ -1084,12 +1104,13 @@
         TestCategory('swift', 'swift', backend not in (Backend.ninja, Backend.xcode) or not shutil.which('swiftc')),
         # CUDA tests on Windows: use Ninja backend:  python run_project_tests.py --only cuda --backend ninja
         TestCategory('cuda', 'cuda', backend not in (Backend.ninja, Backend.xcode) or not shutil.which('nvcc')),
-        TestCategory('python3', 'python3', backend is not Backend.ninja),
+        TestCategory('python3', 'python3', backend is not Backend.ninja or 'python3' not in sys.executable),
         TestCategory('python', 'python'),
         TestCategory('fpga', 'fpga', shutil.which('yosys') is None),
         TestCategory('frameworks', 'frameworks'),
         TestCategory('nasm', 'nasm'),
         TestCategory('wasm', 'wasm', shutil.which('emcc') is None or backend is not Backend.ninja),
+        TestCategory('wayland', 'wayland', should_skip_wayland()),
     
 
     categories = t.category for t in all_tests
@@ -1100,7 +1121,7 @@
             assert key in categories, f'key `{key}` is not a recognized category'
         all_tests = t for t in all_tests if t.category in only.keys()
 
-    gathered_tests = (t.category, gather_tests(Path('test cases', t.subdir), t.stdout_mandatory, onlyt.category), t.skip) for t in all_tests
+    gathered_tests = (t.category, gather_tests(Path('test cases', t.subdir), t.stdout_mandatory, onlyt.category, t.skip), t.skip) for t in all_tests
     return gathered_tests
 
 def run_tests(all_tests: T.ListT.Tuplestr, T.ListTestDef, bool,
@@ -1165,6 +1186,12 @@
 
 RunFutureUnion = T.UnionTestRunFuture, LogRunFuture
 
+def test_emits_skip_msg(line: str) -> bool:
+    for prefix in {'Problem encountered', 'Assert failed', 'Failed to configure the CMake subproject'}:
+        if f'{prefix}: MESON_SKIP_TEST' in line:
+            return True
+    return False
+
 def _run_tests(all_tests: T.ListT.Tuplestr, T.ListTestDef, bool,
                log_name_base: str,
                failfast: bool,
@@ -1222,19 +1249,21 @@
     # Ensure we only cancel once
     tests_canceled = False
 
-    # Optionally enable the tqdm progress bar
+    # Optionally enable the tqdm progress bar, but only if there is at least
+    # one LogRunFuture and one TestRunFuture
     global safe_print
     futures_iter: T.IterableRunFutureUnion = futures
-    try:
-        from tqdm import tqdm
-        futures_iter = tqdm(futures, desc='Running tests', unit='test')
+    if len(futures) > 2 and sys.stdout.isatty():
+        try:
+            from tqdm import tqdm
+            futures_iter = tqdm(futures, desc='Running tests', unit='test')
 
-        def tqdm_print(*args: mlog.TV_Loggable, sep: str = ' ') -> None:
-            tqdm.write(sep.join(str(x) for x in args))
+            def tqdm_print(*args: mlog.TV_Loggable, sep: str = ' ') -> None:
+                tqdm.write(sep.join(str(x) for x in args))
 
-        safe_print = tqdm_print
-    except ImportError:
-        pass
+            safe_print = tqdm_print
+        except ImportError:
+            pass
 
     # Wait and handle the test results and print the stored log output
     for f in futures_iter:
@@ -1271,10 +1300,19 @@
         if result is None:
             # skipped due to skipped category skip or 'tools:' or 'skip_on_env:'
             is_skipped = True
+            skip_reason = 'not run because preconditions were not met'
             skip_as_expected = True
         else:
             # skipped due to test outputting 'MESON_SKIP_TEST'
-            is_skipped = 'MESON_SKIP_TEST' in result.stdo
+            for l in result.stdo.splitlines():
+                if test_emits_skip_msg(l):
+                    is_skipped = True
+                    offset = l.index('MESON_SKIP_TEST') + 16
+                    skip_reason = loffset:.strip()
+                    break
+            else:
+                is_skipped = False
+                skip_reason = ''
             if not skip_dont_care(t):
                 skip_as_expected = (is_skipped == t.skip_expected)
             else:
@@ -1285,6 +1323,8 @@
 
         if is_skipped and skip_as_expected:
             f.update_log(TestStatus.SKIP)
+            if not t.skip_category:
+                safe_print(bold('Reason:'), skip_reason)
             current_test = ET.SubElement(current_suite, 'testcase', {'name': testname, 'classname': t.category})
             ET.SubElement(current_test, 'skipped', {})
             continue
@@ -1292,7 +1332,7 @@
         if not skip_as_expected:
             failing_tests += 1
             if is_skipped:
-                skip_msg = 'Test asked to be skipped, but was not expected to'
+                skip_msg = f'Test asked to be skipped ({skip_reason}), but was not expected to'
                 status = TestStatus.UNEXSKIP
             else:
                 skip_msg = 'Test ran, but was expected to be skipped'
@@ -1300,6 +1340,7 @@
             result.msg = f"{skip_msg} for MESON_CI_JOBNAME '{ci_jobname}'"
 
             f.update_log(status)
+            safe_print(bold('Reason:'), result.msg)
             current_test = ET.SubElement(current_suite, 'testcase', {'name': testname, 'classname': t.category})
             ET.SubElement(current_test, 'failure', {'message': result.msg})
             continue
@@ -1375,7 +1416,7 @@
     meson_commands = mesonlib.python_command + get_meson_script()
     with TemporaryDirectoryWinProof(prefix='b ', dir=None if use_tmpdir else '.') as build_dir:
         print('Checking that configuring works...')
-        gen_cmd = meson_commands + testdir, build_dir + backend_flags + extra_args
+        gen_cmd = meson_commands + 'setup' , testdir, build_dir + backend_flags + extra_args
         pc, o, e = Popen_safe(gen_cmd)
         if pc.returncode != 0:
             raise RuntimeError(f'Failed to configure {testdir!r}:\n{e}\n{o}')
@@ -1550,7 +1591,7 @@
     clear_transitive_files()
 
     print('Meson build system', meson_version, 'Project Tests')
-    print('Using python', sys.version.split('\n')0)
+    print('Using python', sys.version.split('\n')0, f'({sys.executable!r})')
     if 'VSCMD_VER' in os.environ:
         print('VSCMD version', os.environ'VSCMD_VER')
     setup_commands(options.backend)

_service:tar_scm:meson-0.61.5.tar.gz/run_single_test.py -> _service:tar_scm:meson-1.0.1.tar.gz/run_single_test.py Changed

@@ -13,7 +13,7 @@
 import typing as T
 
 from mesonbuild import mlog
-from run_project_tests import TestDef, load_test_json, run_test, BuildStep
+from run_project_tests import TestDef, load_test_json, run_test, BuildStep, test_emits_skip_msg
 from run_project_tests import setup_commands, detect_system_compiler, print_tool_versions
 
 if T.TYPE_CHECKING:
@@ -26,11 +26,14 @@
         case: pathlib.Path
         subtests: T.Listint
         backend: str
+        extra_args: T.Liststr
 
 
 def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument('case', type=pathlib.Path, help='The test case to run')
+    parser.add_argument('extra_args', nargs='*',
+                        help='arguments that are passed directly to Meson (remember to have -- before these).')
     parser.add_argument('--subtest', type=int, action='append', dest='subtests', help='which subtests to run')
     parser.add_argument('--backend', action='store', help="Which backend to use")
     parser.add_argument('--cross-file', action='store', help='File describing cross compilation environment.')
@@ -56,10 +59,24 @@
             return 'meson'
         return ''
 
-    results = run_test(t, t.args, should_fail(t.path), args.use_tmpdir) for t in tests
+    results = run_test(t, t.args + args.extra_args, should_fail(t.path), args.use_tmpdir) for t in tests
     failed = False
     for test, result in zip(tests, results):
-        if (result is None) or ('MESON_SKIP_TEST' in result.stdo):
+        if result is None:
+            is_skipped = True
+            skip_reason = 'not run because preconditions were not met'
+        else:
+            for l in result.stdo.splitlines():
+                if test_emits_skip_msg(l):
+                    is_skipped = True
+                    offset = l.index('MESON_SKIP_TEST') + 16
+                    skip_reason = loffset:.strip()
+                    break
+            else:
+                is_skipped = False
+                skip_reason = ''
+
+        if is_skipped:
             msg = mlog.yellow('SKIP:')
         elif result.msg:
             msg = mlog.red('FAIL:')
@@ -67,6 +84,8 @@
         else:
             msg = mlog.green('PASS:')
         mlog.log(msg, *test.display_name())
+        if skip_reason:
+            mlog.log(mlog.bold('Reason:'), skip_reason)
         if result is not None and result.msg and 'MESON_SKIP_TEST' not in result.stdo:
             mlog.log('reason:', result.msg)
             if result.step is BuildStep.configure:

_service:tar_scm:meson-0.61.5.tar.gz/run_tests.py -> _service:tar_scm:meson-1.0.1.tar.gz/run_tests.py Changed

@@ -34,13 +34,14 @@
 from unittest import mock
 import typing as T
 
-from mesonbuild import compilers
+from mesonbuild.compilers.c import CCompiler
+from mesonbuild.compilers.detect import detect_c_compiler
 from mesonbuild import dependencies
 from mesonbuild import mesonlib
 from mesonbuild import mesonmain
 from mesonbuild import mtest
 from mesonbuild import mlog
-from mesonbuild.environment import Environment, detect_ninja
+from mesonbuild.environment import Environment, detect_ninja, detect_machine_info
 from mesonbuild.coredata import backendlist, version as meson_version
 from mesonbuild.mesonlib import OptionKey, setup_vsenv
 
@@ -75,6 +76,15 @@
 os.environ'PYTHONWARNDEFAULTENCODING' = '1'
 # work around https://bugs.python.org/issue34624
 os.environ'MESON_RUNNING_IN_PROJECT_TESTS' = '1'
+# python 3.11 adds a warning that in 3.15, UTF-8 mode will be default.
+# This is fantastic news, we'd love that. Less fantastic: this warning is silly,
+# we *want* these checks to be affected. Plus, the recommended alternative API
+# would (in addition to warning people when UTF-8 mode removed the problem) also
+# require using a minimum python version of 3.11 (in which the warning was added)
+# or add verbose if/else soup.
+if sys.version_info >= (3, 10):
+    import warnings
+    warnings.filterwarnings('ignore', message="UTF-8 Mode affects .*getpreferredencoding", category=EncodingWarning)
 
 def guess_backend(backend_str: str, msbuild_exe: str) -> T.Tuple'Backend', T.Liststr:
     # Auto-detect backend if unspecified
@@ -153,6 +163,17 @@
     env.machines.host.cpu_family = 'x86_64' # Used on macOS inside find_library
     return env
 
+def get_convincing_fake_env_and_cc(bdir, prefix):
+    '''
+    Return a fake env and C compiler with the fake env
+    machine info properly detected using that compiler.
+    Useful for running compiler checks in the unit tests.
+    '''
+    env = get_fake_env('', bdir, prefix)
+    cc = detect_c_compiler(env, mesonlib.MachineChoice.HOST)
+    # Detect machine info
+    env.machines.host = detect_machine_info({'c':cc})
+    return (env, cc)
 
 Backend = Enum('Backend', 'ninja vs xcode')
 
@@ -279,8 +300,8 @@
     return returncode, stdout.getvalue()
 
 def clear_meson_configure_class_caches() -> None:
-    compilers.CCompiler.find_library_cache = {}
-    compilers.CCompiler.find_framework_cache = {}
+    CCompiler.find_library_cache = {}
+    CCompiler.find_framework_cache = {}
     dependencies.PkgConfigDependency.pkgbin_cache = {}
     dependencies.PkgConfigDependency.class_pkgbin = mesonlib.PerMachine(None, None)
     mesonlib.project_meson_versions = collections.defaultdict(str)
@@ -322,6 +343,10 @@
     print('')
     print(flush=True)
 
+def subprocess_call(cmd, **kwargs):
+    print(f'$ {mesonlib.join_args(cmd)}')
+    return subprocess.call(cmd, **kwargs)
+
 def main():
     print_system_info()
     parser = argparse.ArgumentParser()
@@ -359,7 +384,7 @@
         cmd = mesonlib.python_command + 'run_meson_command_tests.py', '-v'
         if options.failfast:
             cmd += '--failfast'
-        returncode += subprocess.call(cmd, env=env)
+        returncode += subprocess_call(cmd, env=env)
         if options.failfast and returncode != 0:
             return returncode
         if no_unittests:
@@ -372,11 +397,11 @@
             cmd = mesonlib.python_command + 'run_unittests.py', '--backend=' + backend.name, '-v'
             if options.failfast:
                 cmd += '--failfast'
-            returncode += subprocess.call(cmd, env=env)
+            returncode += subprocess_call(cmd, env=env)
             if options.failfast and returncode != 0:
                 return returncode
         cmd = mesonlib.python_command + 'run_project_tests.py' + sys.argv1:
-        returncode += subprocess.call(cmd, env=env)
+        returncode += subprocess_call(cmd, env=env)
     else:
         cross_test_args = mesonlib.python_command + 'run_cross_test.py'
         for cf in options.cross:
@@ -387,7 +412,7 @@
                 cmd += '--failfast'
             if options.cross_only:
                 cmd += '--cross-only'
-            returncode += subprocess.call(cmd, env=env)
+            returncode += subprocess_call(cmd, env=env)
             if options.failfast and returncode != 0:
                 return returncode
     return returncode

_service:tar_scm:meson-0.61.5.tar.gz/setup.cfg -> _service:tar_scm:meson-1.0.1.tar.gz/setup.cfg Changed

@@ -23,18 +23,17 @@
 Operating System :: POSIX :: BSD
 Operating System :: POSIX :: Linux
 Programming Language :: Python :: 3 :: Only
- Programming Language :: Python :: 3.6
 Programming Language :: Python :: 3.7
 Programming Language :: Python :: 3.8
 Programming Language :: Python :: 3.9
+ Programming Language :: Python :: 3.10
+ Programming Language :: Python :: 3.11
 Topic :: Software Development :: Build Tools
 long_description = Meson is a cross-platform build system designed to be both as fast and as user friendly as possible. It supports many languages and compilers, including GCC, Clang, PGI, Intel, and Visual Studio. Its build definitions are written in a simple non-Turing complete DSL.
 
 options
 packages = find:
-python_requires = >= 3.6
-setup_requires =
- setuptools
+python_requires = >= 3.7
 
 options.entry_points
 console_scripts =
@@ -49,12 +48,14 @@
 mypy
 typing_extensions; python_version <"3.8"
 
+# this must be synced with packaging/hook-mesonbuild.py
 options.package_data
 mesonbuild.scripts = cmd_or_ps.ps1
+mesonbuild.cmake.data = *
+mesonbuild.dependencies.data = *
 
 options.packages.find
 include = mesonbuild, mesonbuild.*
-exclude = *.data
 
 tool:pytest
 python_classes =

_service:tar_scm:meson-0.61.5.tar.gz/setup.py -> _service:tar_scm:meson-1.0.1.tar.gz/setup.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/skip_ci.py -> _service:tar_scm:meson-1.0.1.tar.gz/skip_ci.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/cmake/12 generator expressions/subprojects/cmMod/CMakeLists.txt -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/12 generator expressions/subprojects/cmMod/CMakeLists.txt Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/cmake/12 generator expressions/subprojects/cmMod/include/cmMod.hpp -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/12 generator expressions/subprojects/cmMod/include/cmMod.hpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/12 generator expressions/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/cmake/19 advanced options/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/19 advanced options/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/cmake/2 advanced/subprojects/cmMod/CMakeLists.txt -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/2 advanced/subprojects/cmMod/CMakeLists.txt Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/cmake/2 advanced/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/2 advanced/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/cmake/20 cmake file/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/20 cmake file/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/cmake/3 advanced no dep/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/3 advanced no dep/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/cmake/8 custom command/subprojects/cmMod/CMakeLists.txt -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/8 custom command/subprojects/cmMod/CMakeLists.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/8 custom command/subprojects/cmMod/mycpy Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/cmake/8 custom command/subprojects/cmMod/mycpy/.gitkeep Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/10 man install/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/10 man install/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/101 testframework options/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/101 testframework options/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/105 generatorcustom/gen.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/105 generatorcustom/host.c Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/105 generatorcustom/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/105 generatorcustom/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/106 multiple dir configure file/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/106 multiple dir configure file/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/108 ternary/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/108 ternary/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/109 custom target capture/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/109 custom target capture/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/111 pathjoin/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/111 pathjoin/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/113 interpreter copy mutable var on assignment/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/113 interpreter copy mutable var on assignment/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/114 skip/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/114 skip/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/12 data/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/12 data/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/123 custom target directory install/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/123 custom target directory install/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/13 pch/linkwhole Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/13 pch/linkwhole/lib1.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/13 pch/linkwhole/lib2.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/13 pch/linkwhole/main.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/13 pch/linkwhole/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/13 pch/linkwhole/pch1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/13 pch/linkwhole/pch1/pch_one.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/13 pch/linkwhole/pch2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/13 pch/linkwhole/pch2/pch_two.h Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/13 pch/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/13 pch/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/132 get define/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/132 get define/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/136 empty build file/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/136 empty build file/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/139 mesonintrospect from scripts/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/139 mesonintrospect from scripts/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/14 configure file/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/14 configure file/meson.build Changed

@@ -1,4 +1,6 @@
-project('configure file test', 'c', meson_version: '>=0.47.0')
+project('configure file test', 'c', meson_version: '>=0.63.0')
+
+fs = import('fs')
 
 conf = configuration_data()
 
@@ -188,6 +190,9 @@
 endif
 # Now the same, but using a File object as an argument.
 inf2 = files('invalid-utf8.bin.in')0
+outf = configure_file(input : inf2,
+  output : 'invalid-utf8.bin',
+  copy: true)
 ret = run_command(check_file, inf2, outf, check: false)
 if ret.returncode() != 0
   error('Error running command: @0@\n@1@'.format(ret.stdout(), ret.stderr()))
@@ -202,6 +207,25 @@
   error('Error running command: @0@\n@1@'.format(ret.stdout(), ret.stderr()))
 endif
 
+# Test the fs replacement
+# Test copying of an empty configuration data object
+inf = 'invalid-utf8.bin.in'
+outf = fs.copyfile(inf, 'invalid-utf8-1.bin',
+  install: true,
+  install_dir: get_option('datadir') / meson.project_name(),
+  install_tag: 'copyfile',
+)
+test('fs.copyfile string', check_file, args: files(inf), outf)
+
+# Test with default outname of string
+outf = fs.copyfile(inf)
+test('fs.copyfile default name', check_file, args: files(inf), outf)
+
+# Now the same, but using a File object as an argument.
+inf2 = files('invalid-utf8.bin.in')0
+outf = fs.copyfile(inf2, 'invalid-utf8-2.bin')
+test('fs.copyfile file', check_file, args: inf2, outf)
+
 # Test non isolatin1 encoded input file which fails to decode with utf-8
 conf8 = configuration_data()
 conf8.set('var', 'foo')
@@ -275,9 +299,6 @@
 
 test('configure-file', test_file)
 
-cdata = configuration_data()
-cdata.set('invalid_value', 'array')
-
 # Dictionaries
 
 cdata = configuration_data({

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/14 configure file/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/14 configure file/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/140 custom target multiple outputs/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/140 custom target multiple outputs/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/141 special characters/arg-char-test.c -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/141 special characters/arg-char-test.c Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/141 special characters/arg-string-test.c -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/141 special characters/arg-string-test.c Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/141 special characters/arg-unquoted-test.c -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/141 special characters/arg-unquoted-test.c Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/143 list of file sources/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/143 list of file sources/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/148 shared module resolving symbol in executable/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/148 shared module resolving symbol in executable/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/153 wrap file should not failed/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/153 wrap file should not failed/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/153 wrap file should not failed/subprojects/packagefiles/patchfile Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/153 wrap file should not failed/subprojects/packagefiles/patchfile/0001-Change-foo-to-executable.patch Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/153 wrap file should not failed/subprojects/packagefiles/patchfile/0001-Change-return-value-to-43.patch Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/153 wrap file should not failed/subprojects/packagefiles/patchfile/0002-Change-return-value-to-44.patch Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/153 wrap file should not failed/subprojects/patchfile.wrap Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/16 comparison/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/16 comparison/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/162 subdir if_found/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/162 subdir if_found/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/163 default options prefix dependent defaults/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/163 default options prefix dependent defaults/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/166 yield/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/166 yield/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/166 yield/subprojects/sub/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/166 yield/subprojects/sub/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/176 subproject version/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/176 subproject version/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/176 subproject version/subprojects/a/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/176 subproject version/subprojects/a/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/177 subdir_done/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/177 subdir_done/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/178 bothlibraries/foo.cpp Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/178 bothlibraries/main2.c Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/178 bothlibraries/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/178 bothlibraries/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/187 args flattening/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/187 args flattening/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/190 install_mode/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/190 install_mode/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/190 install_mode/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/190 install_mode/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/191 subproject array version/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/191 subproject array version/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/191 subproject array version/subprojects/foo/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/191 subproject array version/subprojects/foo/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/193 feature option disabled/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/193 feature option disabled/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/197 function attributes/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/197 function attributes/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/202 custom target build by default/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/202 custom target build by default/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/206 tap tests/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/206 tap tests/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/212 source set configuration_data/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/212 source set configuration_data/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/215 source set realistic example/dummy.cpp Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/215 source set realistic example/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/215 source set realistic example/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/216 custom target input extracted objects/check_object.py -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/216 custom target input extracted objects/check_object.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/216 custom target input extracted objects/libdir/gen.py Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/216 custom target input extracted objects/libdir/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/216 custom target input extracted objects/libdir/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/216 custom target input extracted objects/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/216 custom target input extracted objects/meson.build Changed

@@ -14,5 +14,35 @@
 custom_target('check',
   input: objlib.extract_objects('source.c'),
   output: 'objcheck',
-  command: checker, '@INPUT@', '@OUTPUT@',
+  command: checker, '1', '@OUTPUT@', '@INPUT@',
+  build_by_default: true)
+
+custom_target('checkct',
+  input: objlib.extract_objects(ctsrc),
+  output: 'objcheck-ct',
+  command: checker, '1', '@OUTPUT@', '@INPUT@',
+  build_by_default: true)
+
+custom_target('checkcti',
+  input: objlib.extract_objects(ctsrc0),
+  output: 'objcheck-cti',
+  command: checker, '1', '@OUTPUT@', '@INPUT@',
+  build_by_default: true)
+
+custom_target('checkgen',
+  input: objlib.extract_objects(gensrc),
+  output: 'objcheck-gen',
+  command: checker, '1', '@OUTPUT@', '@INPUT@',
+  build_by_default: true)
+
+custom_target('checkall',
+  input: objlib.extract_all_objects(recursive: false),
+  output: 'objcheck-all',
+  command: checker, '3', '@OUTPUT@', '@INPUT@',
+  build_by_default: true)
+
+custom_target('checkall-recursive',
+  input: objlib.extract_all_objects(recursive: true),
+  output: 'objcheck-all-recursive',
+  command: checker, '4', '@OUTPUT@', '@INPUT@',
   build_by_default: true)

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/217 test priorities/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/217 test priorities/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/223 persubproject options/main.cpp Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/223 persubproject options/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/223 persubproject options/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/223 persubproject options/subprojects/sub1/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/223 persubproject options/subprojects/sub1/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/223 persubproject options/subprojects/sub2/foo.cpp Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/223 persubproject options/subprojects/sub2/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/223 persubproject options/subprojects/sub2/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/230 external project/libfoo/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/230 external project/libfoo/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/232 dependency allow_fallback/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/232 dependency allow_fallback/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/237 fstrings/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/237 fstrings/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/238 dependency include_type inconsistency/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/238 dependency include_type inconsistency/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/238 dependency include_type inconsistency/subprojects/baz/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/238 dependency include_type inconsistency/subprojects/baz/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/238 dependency include_type inconsistency/subprojects/foo/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/238 dependency include_type inconsistency/subprojects/foo/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/239 includedir violation/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/239 includedir violation/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/239 includedir violation/subprojects/sub/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/239 includedir violation/subprojects/sub/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/240 dependency native host == build/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/240 dependency native host == build/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/242 custom target feed/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/242 custom target feed/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/246 dependency fallbacks/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/246 dependency fallbacks/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/247 deprecated option/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/247 deprecated option/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/247 deprecated option/meson_options.txt -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/247 deprecated option/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/251 add_project_dependencies Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/251 add_project_dependencies/inc Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/251 add_project_dependencies/inc/lib.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/251 add_project_dependencies/lib.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/251 add_project_dependencies/main.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/251 add_project_dependencies/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir1/bad Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir1/file1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir1/file2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir1/file3 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir2/bad Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir2/file1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir2/file2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir2/file3 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir3 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir3/bad Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir3/file1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir3/file2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/dir3/file3 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/pysrc Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/pysrc/__init__.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/pysrc/bad.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/pysrc/bar.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/pysrc/foo.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/pysrc/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/pysrc/submod Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/pysrc/submod/__init__.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/pysrc/submod/bad.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/pysrc/submod/baz.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/252 install data structured/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables/subprojects/subfiles Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables/subprojects/subfiles/foo.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables/subprojects/subfiles/meson.build Added

@@ -0,0 +1,29 @@
+project('dependency variable resource')
+
+files_dep = declare_dependency(
+    variables: 
+      'pkgdatadir=@0@/subdir'.format(meson.current_source_dir()),
+      'pkgdatadir2=@0@/subdir2'.format(meson.current_source_dir()),
+      'pkgdatadir3=@0@'.format(meson.current_source_dir()),
+    
+)
+
+install_data('subdir/foo.c', install_dir: get_option('datadir') / 'subdir')
+install_subdir('subdir2', install_dir: get_option('datadir'))
+install_data('foo.c', install_dir: get_option('datadir'))
+
+import('pkgconfig').generate(
+    name: 'depvar_resource',
+    description: 'Get a resource file from pkgconfig or a subproject',
+    version: '0.1',
+    variables: 
+      'pkgdatadir=${datadir}/subdir',
+      'pkgdatadir2=${datadir}/subdir2',
+    ,
+    uninstalled_variables: 
+      'pkgdatadir=@0@/subdir'.format(meson.current_source_dir()),
+      'pkgdatadir2=@0@/subdir2'.format(meson.current_source_dir()),
+      'pkgdatadir3=@0@'.format(meson.current_source_dir()),
+    ,
+    dataonly: true,
+)

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables/subprojects/subfiles/subdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables/subprojects/subfiles/subdir/foo.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables/subprojects/subfiles/subdir2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables/subprojects/subfiles/subdir2/foo.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/253 subproject dependency variables/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/254 long output Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/254 long output/dumper.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/254 long output/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/255 module warnings Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/255 module warnings/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/255 module warnings/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/256 subproject extracted objects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/256 subproject extracted objects/foo.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/256 subproject extracted objects/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/256 subproject extracted objects/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/256 subproject extracted objects/subprojects/myobjects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/256 subproject extracted objects/subprojects/myobjects/cpplib.cpp Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/256 subproject extracted objects/subprojects/myobjects/cpplib.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/256 subproject extracted objects/subprojects/myobjects/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/256 subproject extracted objects/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/257 generated header dep Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/257 generated header dep/foo.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/257 generated header dep/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/258 subsubproject inplace Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/258 subsubproject inplace/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/258 subsubproject inplace/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/258 subsubproject inplace/subprojects/sub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/258 subsubproject inplace/subprojects/sub/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/258 subsubproject inplace/subprojects/sub/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/258 subsubproject inplace/subprojects/sub/subprojects/subsub-1.0 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/258 subsubproject inplace/subprojects/sub/subprojects/subsub-1.0/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/258 subsubproject inplace/subprojects/sub/subprojects/subsub.wrap Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/259 preprocess Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/259 preprocess/bar.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/259 preprocess/foo.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/259 preprocess/foo.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/259 preprocess/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/259 preprocess/src Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/259 preprocess/src/file.map.in Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/259 preprocess/src/meson.build Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/26 find program/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/26 find program/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/34 logic ops/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/34 logic ops/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/35 string operations/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/35 string operations/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/43 subproject options/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/43 subproject options/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/43 subproject options/subprojects/subproject/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/43 subproject options/subprojects/subproject/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/44 pkgconfig-gen/dependencies/dummy.c Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/44 pkgconfig-gen/dependencies/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/44 pkgconfig-gen/dependencies/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/44 pkgconfig-gen/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/44 pkgconfig-gen/meson.build Changed

@@ -1,4 +1,4 @@
-project('pkgconfig-gen', 'c')
+project('pkgconfig-gen', 'c', meson_version: '>=0.60.0')
 
 # Some CI runners does not have zlib, just skip them as we need some common
 # external dependency.
@@ -38,9 +38,15 @@
   libraries_private : lib, '-lz',
 )
 
-test('pkgconfig-validation', pkgconfig,
+env = environment()
+env.prepend('PKG_CONFIG_PATH', meson.current_build_dir() / 'meson-private')
+
+test(
+  'pkgconfig-validation',
+  pkgconfig,
   args: '--validate', 'simple',
-  env:  'PKG_CONFIG_PATH=' + meson.current_build_dir() + '/meson-private' )
+  env : env,
+)
 
 answerlib = shared_library('answer', 'answer.c')
 
@@ -147,5 +153,26 @@
   output: fs.name(outfile),
   command: python, '-c', script,
 )
-simple6 = library('simple6', link_with: ct)
+simple6 = library('simple6', 'dependencies/dummy.c', link_with: ct)
 pkgg.generate(simple6)
+
+# implicit variables
+pkgg.generate(
+  name : 'libvartest',
+  description : 'Check that implicit vars are created',
+  version : libver,
+  variables: 'datadir=${prefix}/data', 'foo=${datadir}/foo', 'bar=${bindir}/bar'
+)
+pkgg.generate(
+  name : 'libvartest2',
+  description : 'Check that libdir is not an implicit var',
+  version : libver,
+  variables: 'bar=${libdir}/bar'
+)
+
+# Regression test: variables kwarg should listify single string value
+pkgg.generate(
+  name : 'libvartest3',
+  description : 'Check that variables can be single string',
+  variables: 'foo=bar',
+)

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/44 pkgconfig-gen/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/44 pkgconfig-gen/test.json Changed

@@ -6,12 +6,28 @@
     {"type": "file", "file": "usr/lib/pkgconfig/libanswer.pc"},
     {"type": "file", "file": "usr/lib/pkgconfig/libfoo.pc"},
     {"type": "file", "file": "usr/lib/pkgconfig/libhello.pc"},
-    {"type": "file", "file": "usr/lib/pkgconfig/libhello_nolib.pc"},
+    {"type": "file", "file": "usr/lib/pkgconfig/libvartest.pc"},
+    {"type": "file", "file": "usr/lib/pkgconfig/libvartest2.pc"},
+    {"type": "file", "file": "usr/lib/pkgconfig/libvartest3.pc"},
     {"type": "file", "file": "usr/lib/pkgconfig/simple2.pc"},
     {"type": "file", "file": "usr/lib/pkgconfig/simple3.pc"},
     {"type": "file", "file": "usr/lib/pkgconfig/simple5.pc"},
     {"type": "file", "file": "usr/lib/pkgconfig/simple6.pc"},
     {"type": "file", "file": "usr/lib/pkgconfig/ct.pc"},
-    {"type": "file", "file": "usr/lib/pkgconfig/ct0.pc"}
+    {"type": "file", "file": "usr/lib/pkgconfig/ct0.pc"},
+    {"type": "file", "file": "usr/share/pkgconfig/libhello_nolib.pc"}
+  ,
+  "stdout": 
+    {
+      "line": "test cases/common/44 pkgconfig-gen/meson.build:164: WARNING: Project targets '>=0.60.0' but uses feature introduced in '0.62.0': pkgconfig.generate implicit variable for builtin directories."
+    },
+    {
+      "line": "test cases/common/44 pkgconfig-gen/meson.build:170: WARNING: Project targets '>=0.60.0' but uses feature introduced in '0.62.0': pkgconfig.generate implicit variable for builtin directories.",
+      "count": 0
+    },
+    {
+      "comment": "This will either match in the future-deprecated notice summary, or match the warning summary",
+      "line": " * 0.62.0: {'pkgconfig.generate variable for builtin directories'}"
+    }
   
 }

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/49 custom target/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/49 custom target/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/51 run target/.clang-format Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/51 run target/.clang-tidy Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/51 run target/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/51 run target/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/56 array methods/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/56 array methods/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/59 install subdir/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/59 install subdir/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/61 number arithmetic/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/61 number arithmetic/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/62 string arithmetic/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/62 string arithmetic/meson.build Changed

@@ -1,16 +1,49 @@
-project('string arithmetic', 'c')
+project('string arithmetic', meson_version: '>=0.62.0')
 
-if 'foo' + 'bar' != 'foobar'
-  error('String concatenation is broken')
-endif
-
-if 'foo' + 'bar' + 'baz' != 'foobarbaz'
-  error('Many-string concatenation is broken')
-endif
+assert('foo' + 'bar' == 'foobar')
+assert('foo' + 'bar' + 'baz' == 'foobarbaz')
 
 a = 'a'
 b = 'b'
+assert(a + b + 'c' == 'abc')
+
+# ------------------------------------------------------------------------------
+# format strings:
+# ------------------------------------------------------------------------------
+sub1 = 'the'
+sub2 = ' quick\n'
+sub3 = '    brown'
+sub4 = '\nfox'
+x = f'@sub1@@sub2@@sub3@@sub4@'
+
+assert(x == sub1 + sub2 + sub3 + sub4)
+assert(x == 'the quick\n    brown\nfox')
+
+# ------------------------------------------------------------------------------
+#  multi-line format strings
+# ------------------------------------------------------------------------------
+y_actual = f'''This is a multi-line comment with string substitution:
+  "@sub1@@sub2@@sub3@@sub4@"
+
+And I can even substitute the entry multiple times!
+
+@sub1@
+@sub2@
+@sub3@
+'''
+
+y_expect = '''This is a multi-line comment with string substitution:
+  "the quick
+    brown
+fox"
+
+And I can even substitute the entry multiple times!
+
+the
+ quick
 
-if a + b + 'c' != 'abc'
-  error('String concat with variables is broken.')
-endif
+    brown
+'''
+message('actual=' + y_actual)
+message('expect=' + y_expect)
+assert(y_actual == y_expect)

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/62 string arithmetic/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/63 array arithmetic/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/63 array arithmetic/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/64 arithmetic bidmas/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/64 arithmetic bidmas/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/66 vcstag/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/66 vcstag/meson.build Changed

@@ -9,9 +9,34 @@
 command : 'git', 'show-ref', '-s', 'refs/heads/master',
 fallback : '1.0.0')
 
+version_src_notfound_fallback = vcs_tag(input : 'vcstag.c.in',
+output : 'vcstag-notfound-fallback.c',
+command : 'git-but-not-found-sorry', 'show-ref', '-s', 'refs/heads/master',
+fallback : '1.0.0')
+
 version_src_fallback = vcs_tag(input : 'vcstag.c.in',
 output : 'vcstag-fallback.c')
 
-executable('tagprog', 'tagprog.c', version_src)
+git = find_program('git')
+
+version_src_git_program = vcs_tag(input : 'vcstag.c.in',
+output : 'vcstag-git-program.c',
+command : git, 'rev-parse', 'HEAD',
+fallback : '1.0.0')
+
+version_src_file = vcs_tag(input : 'vcstag.c.in',
+output : 'vcstag-file.c',
+command : files('version.py'))
+
+tagprog = executable('tagprog', 'tagprog.c', version_src)
+
+version_src_executable = vcs_tag(input : 'vcstag.c.in',
+output : 'vcstag-executable.c',
+command : tagprog)
+
 executable('tagprog-custom', 'tagprog.c', version_src_custom)
 executable('tagprog-fallback', 'tagprog.c', version_src_fallback)
+executable('tagprog-notfound-fallback', 'tagprog.c', version_src_notfound_fallback)
+executable('tagprog-git-program', 'tagprog.c', version_src_git_program)
+executable('tagprog-executable', 'tagprog.c', version_src_executable)
+executable('tagprog-file', 'tagprog.c', version_src_file)

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/66 vcstag/version.py Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/67 modules/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/67 modules/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/69 configure file in custom target/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/69 configure file in custom target/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/70 external test program/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/70 external test program/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/71 ctarget dependency/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/71 ctarget dependency/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/84 plusassign/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/84 plusassign/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/85 skip subdir/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/85 skip subdir/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/9 header install/child Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/common/9 header install/child/childdir.h Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/9 header install/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/9 header install/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/9 header install/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/9 header install/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/94 threads/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/94 threads/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/94 threads/threadprog.c -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/94 threads/threadprog.c Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/common/97 find program path/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/common/97 find program path/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/cython/2 generated sources/includestuff.pyx Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/cython/2 generated sources/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/cython/2 generated sources/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/cython/2 generated sources/simpleinclude.pyx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/cython/2 generated sources/simplestuff.pxi Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/cython/2 generated sources/stuff.pxi.in Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/13 declare dep Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/13 declare dep/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/13 declare dep/test.d Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/13 declare dep/views Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/13 declare dep/views/test.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/14 dub with deps Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/14 dub with deps/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/14 dub with deps/test.d Added

@@ -0,0 +1,59 @@
+module test;
+
+// testing import dirs
+import xlsx;
+
+// dependency of xlsx
+import dxml.dom;
+
+const xml = "\n" ~
+ "<root>\n" ~
+ " <foo>some text<whatever/></foo>\n" ~
+ " <bar/>\n" ~
+ " <baz></baz>\n" ~
+ "</root>";
+
+int main()
+{
+ // testing versions
+ version (Have_dxml)
+ {
+ import std.range.primitives : empty;
+
+ auto dom = parseDOM(xml);
+ assert(dom.type == EntityType.elementStart);
+ assert(dom.name.empty);
+ assert(dom.children.length == 2);
+
+ assert(dom.children0.type == EntityType.comment);
+ assert(dom.children0.text == " comment ");
+
+ auto root = dom.children1;
+ assert(root.type == EntityType.elementStart);
+ assert(root.name == "root");
+ assert(root.children.length == 3);
+
+ auto foo = root.children0;
+ assert(foo.type == EntityType.elementStart);
+ assert(foo.name == "foo");
+ assert(foo.children.length == 2);
+
+ assert(foo.children0.type == EntityType.text);
+ assert(foo.children0.text == "some text");
+
+ assert(foo.children1.type == EntityType.elementEmpty);
+ assert(foo.children1.name == "whatever");
+
+ assert(root.children1.type == EntityType.elementEmpty);
+ assert(root.children1.name == "bar");
+
+ assert(root.children2.type == EntityType.elementStart);
+ assert(root.children2.name == "baz");
+ assert(root.children2.children.length == 0);
+ return 0;
+ }
+ else
+ {
+ return 1;
+ }
+}

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/15 compiler run checks Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/15 compiler run checks/meson.build Added

@@ -0,0 +1,50 @@
+project('test-d-run-checks', 'd')
+
+dc = meson.get_compiler('d')
+
+run_sizeof = dc.run('int main() { return (void*).sizeof; }')
+if run_sizeof.returncode() == 8
+    run_versions = 'Is64bits'
+elif run_sizeof.returncode() == 4
+    run_versions = 'Is32bits'
+endif
+run_sizeof_exe = executable('run_sizeof', 'test_sizeof.d',
+    d_module_versions: run_versions,
+)
+test('test D compiler run', run_sizeof_exe)
+
+sizeof_sizeof = dc.sizeof('void*')
+if sizeof_sizeof == 8
+    run_versions = 'Is64bits'
+elif sizeof_sizeof == 4
+    run_versions = 'Is32bits'
+endif
+sizeof_sizeof_exe = executable('sizeof_sizeof', 'test_sizeof.d',
+    d_module_versions: run_versions,
+)
+test('test D compiler sizeof', sizeof_sizeof_exe)
+
+if not dc.has_header('std.stdio')
+    error('Could not find std.stdio import')
+endif
+
+if dc.has_header('not_a_d_module')
+    error('has_header inconsistent result')
+endif
+
+# same checks as C/C++ alignments (D has same alignment requirements as C)
+
+# These tests should return the same value on all
+# platforms. If (and when) they don't, fix 'em up.
+if dc.alignment('char') != 1
+error('Alignment of char misdetected.')
+endif
+
+dbl_alignment = dc.alignment('double')
+
+if dbl_alignment == 8 or dbl_alignment == 4
+message('Alignment of double ok.')
+else
+error('Alignment of double misdetected.')
+endif
+

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/15 compiler run checks/test_sizeof.d Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/16 code generation Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/16 code generation/exe.d Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/16 code generation/generator.d Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/16 code generation/input.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/d/16 code generation/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing build/4 cmake subproject isolation/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/10 out of bounds/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/10 out of bounds/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/100 no glib-compile-resources Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/100 no glib-compile-resources/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/100 no glib-compile-resources/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/100 no glib-compile-resources/trivial.gresource.xml Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/101 number in combo Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/101 number in combo/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/101 number in combo/nativefile.ini Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/101 number in combo/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/102 bool in combo Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/102 bool in combo/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/102 bool in combo/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/102 bool in combo/nativefile.ini Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/102 bool in combo/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/103 compiler no lang Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/103 compiler no lang/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/103 compiler no lang/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/104 no fallback Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/104 no fallback/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/104 no fallback/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/104 no fallback/subprojects/foob Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/104 no fallback/subprojects/foob/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/104 no fallback/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/105 feature require Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/105 feature require/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/105 feature require/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/105 feature require/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/106 feature require.bis Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/106 feature require.bis/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/106 feature require.bis/meson_options.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/106 feature require.bis/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/107 no build get_external_property Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/107 no build get_external_property/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/107 no build get_external_property/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/108 enter subdir twice Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/108 enter subdir twice/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/108 enter subdir twice/sub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/108 enter subdir twice/sub/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/108 enter subdir twice/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/109 invalid fstring Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/109 invalid fstring/109 invalid fstring Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/109 invalid fstring/109 invalid fstring/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/109 invalid fstring/109 invalid fstring/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/109 invalid fstring/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/109 invalid fstring/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/11 object arithmetic/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/11 object arithmetic/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/110 compiler argument checking Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/110 compiler argument checking/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/110 compiler argument checking/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/111 empty fallback Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/111 empty fallback/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/111 empty fallback/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/111 empty fallback/subprojects/foo Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/111 empty fallback/subprojects/foo/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/111 empty fallback/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/112 cmake executable dependency Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/112 cmake executable dependency/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/112 cmake executable dependency/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/112 cmake executable dependency/subprojects/cmlib Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/112 cmake executable dependency/subprojects/cmlib/CMakeLists.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/112 cmake executable dependency/subprojects/cmlib/main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/112 cmake executable dependency/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/113 allow_fallback with fallback Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/113 allow_fallback with fallback/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/113 allow_fallback with fallback/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/114 nonsensical bindgen Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/114 nonsensical bindgen/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/114 nonsensical bindgen/src Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/114 nonsensical bindgen/src/header.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/114 nonsensical bindgen/src/source.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/114 nonsensical bindgen/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/115 run_target in test Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/115 run_target in test/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/115 run_target in test/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/115 run_target in test/trivial.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/116 run_target in add_install_script Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/116 run_target in add_install_script/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/116 run_target in add_install_script/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/116 run_target in add_install_script/trivial.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/117 pathsep in install_symlink Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/117 pathsep in install_symlink/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/117 pathsep in install_symlink/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/118 subproject version conflict Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/118 subproject version conflict/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/118 subproject version conflict/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/118 subproject version conflict/subprojects/A Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/118 subproject version conflict/subprojects/A/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/118 subproject version conflict/subprojects/B Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/118 subproject version conflict/subprojects/B/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/118 subproject version conflict/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/119 structured source empty string Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/119 structured source empty string/main.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/119 structured source empty string/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/119 structured source empty string/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/12 string arithmetic/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/12 string arithmetic/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/120 structured_sources conflicts Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/120 structured_sources conflicts/main.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/120 structured_sources conflicts/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/120 structured_sources conflicts/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/121 missing compiler Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/121 missing compiler/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/121 missing compiler/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/121 missing compiler/subprojects/sub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/121 missing compiler/subprojects/sub/main.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/121 missing compiler/subprojects/sub/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/121 missing compiler/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/122 cmake subproject error Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/122 cmake subproject error/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/122 cmake subproject error/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/122 cmake subproject error/subprojects/cmlib Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/122 cmake subproject error/subprojects/cmlib/CMakeLists.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/122 cmake subproject error/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/123 pkgconfig not relocatable outside prefix Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/123 pkgconfig not relocatable outside prefix/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/123 pkgconfig not relocatable outside prefix/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/meson_options.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj1/file.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj1/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj1/nested Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj1/nested/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj2/file.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj2/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj2/nested Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj2/nested/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj3 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj3/file.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/subprojects/subproj3/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/124 subproject sandbox violation/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/125 override and add_project_dependency Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/125 override and add_project_dependency/inc Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/125 override and add_project_dependency/inc/lib.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/125 override and add_project_dependency/lib.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/125 override and add_project_dependency/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/125 override and add_project_dependency/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/125 override and add_project_dependency/subprojects/a Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/125 override and add_project_dependency/subprojects/a/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/125 override and add_project_dependency/subprojects/a/prog.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/125 override and add_project_dependency/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/126 targets before add_project_dependency Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/126 targets before add_project_dependency/inc Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/126 targets before add_project_dependency/inc/lib.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/126 targets before add_project_dependency/lib.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/126 targets before add_project_dependency/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/126 targets before add_project_dependency/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/127 extract from unity Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/127 extract from unity/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/127 extract from unity/src1.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/127 extract from unity/src2.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/127 extract from unity/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/128 subproject object as a dependency Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/128 subproject object as a dependency/main.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/128 subproject object as a dependency/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/128 subproject object as a dependency/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/128 subproject object as a dependency/subprojects/sub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/128 subproject object as a dependency/subprojects/sub/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/128 subproject object as a dependency/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/129 generator host binary Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/129 generator host binary/exe.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/129 generator host binary/lib.in Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/129 generator host binary/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/129 generator host binary/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/13 array arithmetic/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/13 array arithmetic/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/14 invalid option name/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/14 invalid option name/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/18 wrong plusassign/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/18 wrong plusassign/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/20 version/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/20 version/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/21 subver/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/21 subver/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/21 subver/subprojects/foo/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/21 subver/subprojects/foo/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/21 subver/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/21 subver/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/22 assert/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/22 assert/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/24 int conversion/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/24 int conversion/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/25 badlang/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/25 badlang/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/26 output subdir/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/26 output subdir/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/26 output subdir/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/26 output subdir/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/27 noprog use/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/27 noprog use/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/28 no crossprop/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/28 no crossprop/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/29 nested ternary/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/29 nested ternary/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/3 missing subdir/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/3 missing subdir/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/30 invalid man extension/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/30 invalid man extension/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/31 no man extension/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/31 no man extension/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/33 non-root subproject/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/33 non-root subproject/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/34 dependency not-required then required/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/34 dependency not-required then required/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/38 prefix absolute Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/38 prefix absolute/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/38 prefix absolute/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/39 kwarg assign Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/39 kwarg assign/dummy.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/39 kwarg assign/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/39 kwarg assign/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/39 kwarg assign/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/4 missing meson.build/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/4 missing meson.build/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/40 custom target plainname many inputs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/40 custom target plainname many inputs/1.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/40 custom target plainname many inputs/2.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/40 custom target plainname many inputs/catfiles.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/40 custom target plainname many inputs/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/40 custom target plainname many inputs/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/41 custom target outputs not matching install_dirs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/41 custom target outputs not matching install_dirs/generator.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/41 custom target outputs not matching install_dirs/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/41 custom target outputs not matching install_dirs/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/42 project name colon Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/42 project name colon/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/42 project name colon/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/43 abs subdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/43 abs subdir/bob Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/43 abs subdir/bob/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/43 abs subdir/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/43 abs subdir/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/44 abspath to srcdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/44 abspath to srcdir/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/44 abspath to srcdir/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/45 pkgconfig variables reserved Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/45 pkgconfig variables reserved/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/45 pkgconfig variables reserved/simple.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/45 pkgconfig variables reserved/simple.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/45 pkgconfig variables reserved/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/46 pkgconfig variables zero length Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/46 pkgconfig variables zero length/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/46 pkgconfig variables zero length/simple.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/46 pkgconfig variables zero length/simple.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/46 pkgconfig variables zero length/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/47 pkgconfig variables zero length value Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/47 pkgconfig variables zero length value/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/47 pkgconfig variables zero length value/simple.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/47 pkgconfig variables zero length value/simple.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/47 pkgconfig variables zero length value/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/48 pkgconfig variables not key value Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/48 pkgconfig variables not key value/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/48 pkgconfig variables not key value/simple.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/48 pkgconfig variables not key value/simple.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/48 pkgconfig variables not key value/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/49 executable comparison Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/49 executable comparison/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/49 executable comparison/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/49 executable comparison/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/5 misplaced option/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/5 misplaced option/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/50 inconsistent comparison Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/50 inconsistent comparison/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/50 inconsistent comparison/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/51 slashname Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/51 slashname/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/51 slashname/sub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/51 slashname/sub/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/51 slashname/sub/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/51 slashname/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/52 reserved meson prefix Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/52 reserved meson prefix/meson-foo Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/52 reserved meson prefix/meson-foo/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/52 reserved meson prefix/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/52 reserved meson prefix/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/53 wrong shared crate type Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/53 wrong shared crate type/foo.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/53 wrong shared crate type/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/53 wrong shared crate type/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/54 wrong static crate type Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/54 wrong static crate type/foo.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/54 wrong static crate type/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/54 wrong static crate type/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/55 or on new line Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/55 or on new line/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/55 or on new line/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/55 or on new line/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/56 link with executable Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/56 link with executable/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/56 link with executable/module.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/56 link with executable/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/56 link with executable/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/57 assign custom target index Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/57 assign custom target index/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/57 assign custom target index/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/58 getoption prefix Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/58 getoption prefix/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/58 getoption prefix/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/58 getoption prefix/subprojects/abc Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/58 getoption prefix/subprojects/abc/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/58 getoption prefix/subprojects/abc/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/58 getoption prefix/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/59 bad option argument Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/59 bad option argument/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/59 bad option argument/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/59 bad option argument/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/6 missing incdir/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/6 missing incdir/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/60 subproj filegrab Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/60 subproj filegrab/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/60 subproj filegrab/prog.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/60 subproj filegrab/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/60 subproj filegrab/subprojects/a Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/60 subproj filegrab/subprojects/a/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/60 subproj filegrab/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/61 grab subproj Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/61 grab subproj/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/61 grab subproj/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/61 grab subproj/subprojects/foo Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/61 grab subproj/subprojects/foo/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/61 grab subproj/subprojects/foo/sub.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/61 grab subproj/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/62 grab sibling Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/62 grab sibling/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/62 grab sibling/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/62 grab sibling/subprojects/a Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/62 grab sibling/subprojects/a/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/62 grab sibling/subprojects/b Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/62 grab sibling/subprojects/b/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/62 grab sibling/subprojects/b/sneaky.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/62 grab sibling/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/63 string as link target Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/63 string as link target/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/63 string as link target/prog.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/63 string as link target/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/64 dependency not-found and required Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/64 dependency not-found and required/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/64 dependency not-found and required/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/a Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/a/a.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/a/a.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/a/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/b Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/b/b.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/b/b.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/b/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/c/c.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/subprojects/c/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/65 subproj different versions/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/66 wrong boost module Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/66 wrong boost module/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/66 wrong boost module/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/67 install_data rename bad size Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/67 install_data rename bad size/file1.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/67 install_data rename bad size/file2.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/67 install_data rename bad size/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/67 install_data rename bad size/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/68 skip only subdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/68 skip only subdir/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/68 skip only subdir/subdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/68 skip only subdir/subdir/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/68 skip only subdir/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/69 dual override Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/69 dual override/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/69 dual override/overrides.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/69 dual override/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/7 go to subproject/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/7 go to subproject/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/70 override used Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/70 override used/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/70 override used/other.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/70 override used/something.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/70 override used/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/71 run_command unclean exit Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/71 run_command unclean exit/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/71 run_command unclean exit/returncode.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/71 run_command unclean exit/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/72 int literal leading zero Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/72 int literal leading zero/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/72 int literal leading zero/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/73 configuration immutable Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/73 configuration immutable/input Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/73 configuration immutable/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/73 configuration immutable/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/74 link with shared module on osx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/74 link with shared module on osx/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/74 link with shared module on osx/module.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/74 link with shared module on osx/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/74 link with shared module on osx/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/75 non ascii in ascii encoded configure file Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/75 non ascii in ascii encoded configure file/config9.h.in Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/75 non ascii in ascii encoded configure file/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/75 non ascii in ascii encoded configure file/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/76 subproj dependency not-found and required Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/76 subproj dependency not-found and required/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/76 subproj dependency not-found and required/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/77 unfound run Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/77 unfound run/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/77 unfound run/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/78 framework dependency with version Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/78 framework dependency with version/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/78 framework dependency with version/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/79 override exe config Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/79 override exe config/foo.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/79 override exe config/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/79 override exe config/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/8 recursive/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/8 recursive/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/8 recursive/subprojects/a/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/8 recursive/subprojects/a/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/failing/8 recursive/subprojects/b/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/8 recursive/subprojects/b/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/80 gl dependency with version Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/80 gl dependency with version/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/80 gl dependency with version/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/81 threads dependency with version Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/81 threads dependency with version/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/81 threads dependency with version/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/82 gtest dependency with version Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/82 gtest dependency with version/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/82 gtest dependency with version/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/83 dub libray Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/83 dub libray/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/83 dub libray/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/84 dub executable Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/84 dub executable/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/84 dub executable/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/85 dub compiler Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/85 dub compiler/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/85 dub compiler/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/86 subproj not-found dep Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/86 subproj not-found dep/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/86 subproj not-found dep/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/86 subproj not-found dep/subprojects/somesubproj Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/86 subproj not-found dep/subprojects/somesubproj/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/86 subproj not-found dep/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/87 invalid configure file Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/87 invalid configure file/input Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/87 invalid configure file/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/87 invalid configure file/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/88 kwarg dupe Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/88 kwarg dupe/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/88 kwarg dupe/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/88 kwarg dupe/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/89 missing pch file Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/89 missing pch file/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/89 missing pch file/prog.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/89 missing pch file/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/90 pch source different folder Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/90 pch source different folder/include Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/90 pch source different folder/include/pch.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/90 pch source different folder/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/90 pch source different folder/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/90 pch source different folder/src Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/90 pch source different folder/src/pch.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/90 pch source different folder/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/91 unknown config tool Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/91 unknown config tool/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/91 unknown config tool/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/92 custom target install data Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/92 custom target install data/Info.plist.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/92 custom target install data/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/92 custom target install data/preproc.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/92 custom target install data/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/93 add dict non string key Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/93 add dict non string key/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/93 add dict non string key/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/94 add dict duplicate keys Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/94 add dict duplicate keys/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/94 add dict duplicate keys/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/95 no host get_external_property Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/95 no host get_external_property/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/95 no host get_external_property/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/96 no native compiler Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/96 no native compiler/main.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/96 no native compiler/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/96 no native compiler/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/97 subdir parse error Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/97 subdir parse error/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/97 subdir parse error/subdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/97 subdir parse error/subdir/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/97 subdir parse error/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/98 invalid option file Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/98 invalid option file/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/98 invalid option file/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/98 invalid option file/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/99 no lang Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/99 no lang/main.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/99 no lang/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/failing/99 no lang/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/fortran/14 fortran links c/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/fortran/14 fortran links c/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/fortran/9 cpp/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/fortran/9 cpp/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/fpga/1 simple/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/fpga/1 simple/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/10 gtk-doc/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/10 gtk-doc/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/10 gtk-doc/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/10 gtk-doc/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/11 gir subproject/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/11 gir subproject/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/24 libgcrypt/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/24 libgcrypt/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/27 gpgme/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/27 gpgme/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/28 gir link order 2/samelibname/dummy.c Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/28 gir link order 2/samelibname/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/28 gir link order 2/samelibname/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/4 qt/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/4 qt/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/6 gettext/data/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/data/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/6 gettext/data2/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/data2/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/data3 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/data3/com.mesonbuild.test.intlprog.metainfo.xml Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/data3/meson.build Added

@@ -0,0 +1,33 @@
+
+if itstool.found()
+
+ mi_translated = i18n.itstool_join(
+ input: 'com.mesonbuild.test.intlprog.metainfo.xml',
+ output: 'com.mesonbuild.test.intlprog.metainfo.xml',
+ mo_targets: mo_targets,
+ its_files: 'metainfo.its',
+ install: true,
+ install_dir: get_option('datadir') / 'metainfo',
+ )
+
+ # older versions of itstool have a bug where ITS rules specified on the command-line
+ # are not read when joining files. Since we don't install appstream in the Meson CI
+ # environment, the to-be-tested entry will be untranslated and the test would fail, so
+ # we just skip verification if the installed itstool is too old.
+ r = run_command(itstool, '-v', check: true)
+ itstool_v = r.stdout().strip().split()
+ if itstool_v1.version_compare('>=2.0.6')
+ verify_exe = find_program('verify.py')
+ test('test xml translation',
+ verify_exe,
+ args: mi_translated,
+ 'Dies ist <code>Text</code> mit eingebetteten XML Tags. Toll!'
+ )
+ else
+ message('Skipping translation verification: Itstool too old.')
+ endif
+
+else
+ install_data('com.mesonbuild.test.intlprog.metainfo.xml',
+ install_dir: get_option('datadir') / 'metainfo')
+endif

_service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/data3/metainfo.its Added

@@ -0,0 +1,33 @@
+<?xml version="1.0"?>
+
+<its:rules xmlns:its="http://www.w3.org/2005/11/its"
+ version="2.0">
+
+ <its:withinTextRule withinText="yes" selector="/component//description//em |
+ /component//description//code"/>
+
+ <its:translateRule selector="/component" translate="no"/>
+ <its:translateRule selector="/component/name |
+ /component/summary |
+ /component/description |
+ /component/developer_name |
+ /component/name_variant_suffix |
+ /component/screenshots/screenshot/caption |
+ /component/releases/release/description |
+ /component/agreement/agreement_section/name |
+ /component/agreement/agreement_section/description"
+ translate="yes"/>
+
+ <its:translateRule selector="/component/name@translatable = 'no'"
+ translate="no"/>
+ <its:translateRule selector="/component/developer_name@translatable = 'no'"
+ translate="no"/>
+ <its:translateRule selector="/component/name_variant_suffix@translatable = 'no'"
+ translate="no"/>
+ <its:translateRule selector="/component/releases/release/description@translatable = 'no'"
+ translate="no"/>
+</its:rules>

_service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/data3/verify.py Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/6 gettext/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/6 gettext/po/de.po -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/po/de.po Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/6 gettext/po/intltest.pot -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/po/intltest.pot Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/6 gettext/po/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/po/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/6 gettext/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/6 gettext/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/7 gnome/copyfile.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/7 gnome/gdbus/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/7 gnome/gdbus/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/7 gnome/genmarshal/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/7 gnome/genmarshal/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/7 gnome/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/7 gnome/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/7 gnome/resources/generated Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/7 gnome/resources/generated-main.c -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/7 gnome/resources/generated-main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/7 gnome/resources/generated/meson.build Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/7 gnome/resources/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/7 gnome/resources/meson.build Changed

@@ -1,8 +1,6 @@
 # There are two tests here, because the 2nd one depends on a version of
 # GLib (2.51.1) that is very recent at the time of writing.
 
-copyfile = find_program('copyfile.py')
-
 simple_gresource = configure_file(
   input : 'simple.gresource.xml',
   output : 'simple-gen.gresource.xml',
@@ -30,10 +28,10 @@
 test('simple resource test (gresource)', find_program('resources.py'))
 
 if not pretend_glib_old and glib.version() >= '2.52.0'
-  # This test cannot pass if GLib version is older than 9.99.9.
-  # Meson will raise an error if the user tries to use the 'dependencies'
-  # argument and the version of GLib is too old for generated resource
-  # dependencies to work correctly.
+  # This test cannot pass if GLib version is too old. Generated resource
+  # dependencies do not work correctly and Meson will raise an error if the
+  # user tries to use either the 'dependencies' kwarg or a gresource file that
+  # is itself generated.
   generated_resources = gnome.compile_resources('generated-resources',
     'generated.gresource.xml',
     source_dir : '../resources-data',
@@ -44,6 +42,25 @@
     'generated-main.c', generated_resources,
     dependencies: gio)
   test('generated resource test', generated_res_exe)
+
+  # Test with a CustomTarget
+  subdir('generated')
+
+  ct_resources = gnome.compile_resources(
+    'ct-resources',
+    ct_simple_gresource,
+    install_header : true,
+    export : true,
+    source_dir : '../resources-data',
+    c_name : 'simple_resources')
+
+  cti_resources = gnome.compile_resources(
+    'cti-resources',
+    ct_simple_gresource0,
+    install_header : true,
+    export : true,
+    source_dir : '../resources-data',
+    c_name : 'simple_resources')
 endif
 
 # Test build_by_default

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/7 gnome/resources/simple-main.c -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/7 gnome/resources/simple-main.c Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/frameworks/7 gnome/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/frameworks/7 gnome/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources/src Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources/src/com Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources/src/com/mesonbuild Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources/src/com/mesonbuild/Resources.java Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources/src/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources/src/resources Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources/src/resources/resource1.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources/src/resources/subdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/10 resources/src/resources/subdir/resource2.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/lib Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/lib/com_mesonbuild_JniTest.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/lib/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/lib/native.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/meson.build Added

@@ -0,0 +1,38 @@
+project('jnijava', 'c', 'java')
+
+if build_machine.system() == 'cygwin'
+  error('MESON_SKIP_TEST: cygwin test failures')
+endif
+
+if build_machine.system() == 'windows' and build_machine.cpu_family() == 'x86'
+  error('MESON_SKIP_TEST: failing builds on 32bit Windows because a 32bit JDK is not available in the Azure Pipelines Windows images')
+endif
+
+fs = import('fs')
+javamod = import('java')
+
+cc = meson.get_compiler('c')
+java = find_program('java')
+
+jni_dep = dependency('jni', version : '>=1.8', modules: 'jvm', 'awt')
+
+# Assert that the header can actually be found with the dependency.
+cc.has_header('jni.h', dependencies: jni_dep)
+# Assert that the platform-specific include directory is included in the compiler arguments.
+cc.has_header('jni_md.h', dependencies: jni_dep)
+
+# generate native headers
+subdir('src')
+subdir('lib')
+
+test(
+  'jnitest',
+  java,
+  args: 
+    '-Djava.library.path=@0@'.format(fs.parent(jnijava.full_path())),
+    '-jar',
+    jnijar,
+  ,
+  protocol : 'exitcode',
+  depends : jnijava,
+)

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/src Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/src/com Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/src/com/mesonbuild Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/src/com/mesonbuild/Configured.java.in Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/src/com/mesonbuild/JniTest.java Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/src/com/mesonbuild/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/java/9 jni/src/meson.build Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/keyval/1 basic/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/keyval/1 basic/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/keyval/1 basic/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/keyval/1 basic/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/linuxlike/13 cmake dependency/cmake/FindImportedTarget.cmake -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/linuxlike/13 cmake dependency/cmake/FindImportedTarget.cmake Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/nasm/2 asm language Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/nasm/2 asm language/hello.asm Added

@@ -0,0 +1,31 @@
+;  hello.asm  a first program for nasm for Linux, Intel, gcc
+;
+; assemble:    nasm -f elf -l hello.lst  hello.asm
+; link:        gcc -o hello  hello.o
+; run:            hello
+; output is:    Hello World
+
+%include "config.asm"
+
+%ifdef FOO
+%define RETVAL HELLO
+%endif
+
+    SECTION .data        ; data section
+msg:    db "Hello World",10    ; the string to print, 10=cr
+len:    equ $-msg        ; "$" means "here"
+                ; len is a value, not an address
+
+    SECTION .text        ; code section
+        global main        ; make label available to linker
+main:                ; standard  gcc  entry point
+
+    mov    edx,len        ; arg3, length of string to print
+    mov    ecx,msg        ; arg2, pointer to string
+    mov    ebx,1        ; arg1, where to write, screen
+    mov    eax,4        ; write sysout command to int 80 hex
+    int    0x80        ; interrupt 80 hex, call kernel
+
+    mov    ebx,RETVAL    ; exit code, 0=normal
+    mov    eax,1        ; exit command to kernel
+    int    0x80        ; interrupt 80 hex, call kernel

_service:tar_scm:meson-1.0.1.tar.gz/test cases/nasm/2 asm language/meson.build Added

@@ -0,0 +1,57 @@
+project('test', 'c')
+
+if not host_machine.cpu_family().startswith('x86')
+  assert(not add_languages('nasm', required: false))
+  error('MESON_SKIP_TEST: nasm only supported for x86 and x86_64')
+endif
+
+if not add_languages('nasm', required: false)
+  nasm = find_program('nasm', 'yasm', required: false)
+  assert(not nasm.found())
+  error('MESON_SKIP_TEST: nasm not found')
+endif
+
+nasm = meson.get_compiler('nasm')
+
+code = '''
+SECTION .text
+global main
+main:
+  mov foo,bar ; error: symbol `foo' not defined
+'''
+assert(not nasm.compiles(code, name: 'Invalid NASM code'))
+
+code = '''
+SECTION .text
+global main
+main:
+  mov eax,1
+'''
+assert(nasm.compiles(code, name: 'Valid NASM code'))
+
+config_file = configure_file(
+  output: 'config.asm',
+  configuration: {'HELLO': 0},
+  output_format: 'nasm',
+)
+
+cc = meson.get_compiler('c')
+link_args = cc.get_supported_link_arguments('-no-pie')
+
+exe = executable('hello', 'hello.asm',
+  nasm_args: '-DFOO',
+  link_args: link_args,
+)
+test('hello', exe)
+
+#Test whether pthread dependency gets filtered out
+threads = dependency('threads')
+
+exe2 = executable('hello_w_threads', 'hello.asm',
+  config_file,
+  nasm_args: '-DFOO',
+  link_args: link_args,
+  dependencies: threads
+)
+
+test('hello_w_threads', exe2)

_service:tar_scm:meson-0.61.5.tar.gz/test cases/osx/7 bitcode/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/osx/7 bitcode/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/python/2 extmodule/ext/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/python/2 extmodule/ext/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/python/2 extmodule/ext/nested/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/python/2 extmodule/ext/nested/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/python/2 extmodule/ext/wrongdir/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/python/2 extmodule/ext/wrongdir/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/python/2 extmodule/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/python/2 extmodule/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/python/7 install path/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/structured Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/structured/alpha Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/structured/alpha/one.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/structured/alpha/three.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/structured/alpha/two.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/structured/beta Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/structured/beta/one.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/structured/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/structured/one.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/structured/two.py Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/python/7 install path/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/python/7 install path/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/8 different python versions Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/8 different python versions/blaster.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/8 different python versions/ext Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/8 different python versions/ext/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/8 different python versions/ext/tachyon_module.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/8 different python versions/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/8 different python versions/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/python/8 different python versions/test.json Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/python3/3 cython/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/python3/3 cython/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/12 bindgen/dependencies Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/12 bindgen/dependencies/clib2.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/12 bindgen/dependencies/external_dep.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/12 bindgen/dependencies/internal_dep.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/12 bindgen/dependencies/internal_main.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/12 bindgen/dependencies/meson.build Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/rust/12 bindgen/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/12 bindgen/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/12 bindgen/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/18 proc-macro Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/18 proc-macro/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/18 proc-macro/proc.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/18 proc-macro/use.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/gen.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/main-gen-copy.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/meson.build Added

@@ -0,0 +1,58 @@
+project('structured input', 'rust')
+
+foo_mod_rs = configure_file(
+  input : 'src/foo.rs.in',
+  output : 'mod.rs',
+  configuration : {'message' : 'Hello, World!'},
+)
+
+conf_file = executable(
+  'main_conf_file',
+  structured_sources(
+    'src/main.rs',
+    {'foo' : foo_mod_rs},
+  ),
+)
+
+ct = custom_target(
+  'foo.rs',
+  output : 'foo.rs',
+  command : 'gen.py', '@OUTPUT@',
+)
+
+target = executable(
+  'main_custom_target',
+  structured_sources(
+    'src/main.rs', ct,
+  ),
+)
+
+# Should not be coppied
+executable(
+  'no_copy_target',
+  structured_sources(
+    'src2/main-unique.rs',
+    {'foo': 'src2/foo/mod.rs'},
+  ),
+)
+
+test('no-copy', find_program('no_copy_test.py'), args : meson.current_build_dir())
+
+subdir('src2')
+
+executable('copy-no-gen', srcs2)
+
+m_src = configure_file(
+  input : 'main-gen-copy.rs',
+  output : 'main-gen-copy.rs',
+  configuration : {'dir' : meson.current_build_dir().replace('\\', '/')},
+)
+
+m_src2 = configure_file(
+  input : 'priv.rs',
+  output : 'include.rs',
+  copy : true
+)
+
+executable('gen-no-copy', structured_sources(m_src, m_src2))
+

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/no_copy_test.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/priv.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/src Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/src/foo.rs.in Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/src/main.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/src2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/src2/foo Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/src2/foo/mod.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/src2/main-unique.rs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/19 structured sources/src2/meson.build Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/rust/2 sharedlib/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/2 sharedlib/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/rust/2 sharedlib/stuff.rs -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/2 sharedlib/stuff.rs Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/2 sharedlib/value.c Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/rust/3 staticlib/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/3 staticlib/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/3 staticlib/other.rs Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/rust/3 staticlib/prog.rs -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/3 staticlib/prog.rs Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/rust/3 staticlib/stuff.rs -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/3 staticlib/stuff.rs Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/3 staticlib/value.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/5 polyglot static/clib.c Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/rust/5 polyglot static/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/5 polyglot static/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/rust/5 polyglot static/prog.c -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/5 polyglot static/prog.c Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/rust/5 polyglot static/stuff.rs -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/5 polyglot static/stuff.rs Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/rust/5 polyglot static/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/rust/5 polyglot static/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/100 relative find program Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/100 relative find program/foo.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/100 relative find program/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/100 relative find program/subdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/100 relative find program/subdir/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/101 rlib linkage Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/101 rlib linkage/lib2.rs Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/101 rlib linkage/main.rs Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/101 rlib linkage/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/102 python without pkgconfig Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/102 python without pkgconfig/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/103 strip Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/103 strip/lib.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/103 strip/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/104 debug function Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/104 debug function/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/105 pkgconfig relocatable with absolute path Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/105 pkgconfig relocatable with absolute path/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/106 subproject symlink/cp.py Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/106 subproject symlink/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/106 subproject symlink/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/106 subproject symlink/symlinked_subproject/datadir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/106 subproject symlink/symlinked_subproject/datadir/datafile Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/106 subproject symlink/symlinked_subproject/datadir/meson.build Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/106 subproject symlink/symlinked_subproject/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/106 subproject symlink/symlinked_subproject/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/107 new subproject on reconfigure Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/107 new subproject on reconfigure/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/107 new subproject on reconfigure/meson_options.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/107 new subproject on reconfigure/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/107 new subproject on reconfigure/subprojects/foo Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/107 new subproject on reconfigure/subprojects/foo/foo.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/107 new subproject on reconfigure/subprojects/foo/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/108 configure same noop Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/108 configure same noop/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/108 configure same noop/meson_options.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/109 freeze Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/109 freeze/freeze.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/109 freeze/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/110 classpath Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/110 classpath/com Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/110 classpath/com/mesonbuild Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/110 classpath/com/mesonbuild/Simple.java Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/110 classpath/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/15 prebuilt object/cp.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/15 prebuilt object/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/15 prebuilt object/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/2 testsetups/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/2 testsetups/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/unit/35 dist script/subprojects/sub/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/35 dist script/subprojects/sub/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath/built library Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath/built library/bar.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath/built library/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath/built library/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath/built library/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath/external library Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath/external library/bar.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath/external library/faa.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath/external library/foo.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/39 external, internal library rpath/external library/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/40 featurenew subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/40 featurenew subprojects/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/40 featurenew subprojects/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/40 featurenew subprojects/subprojects/bar Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/40 featurenew subprojects/subprojects/bar/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/40 featurenew subprojects/subprojects/baz Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/40 featurenew subprojects/subprojects/baz/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/40 featurenew subprojects/subprojects/foo Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/40 featurenew subprojects/subprojects/foo/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/41 rpath order Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/41 rpath order/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/41 rpath order/myexe.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/41 rpath order/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/41 rpath order/subprojects/sub1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/41 rpath order/subprojects/sub1/lib.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/41 rpath order/subprojects/sub1/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/41 rpath order/subprojects/sub2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/41 rpath order/subprojects/sub2/lib.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/41 rpath order/subprojects/sub2/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/42 dep order Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/42 dep order/lib1.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/42 dep order/lib2.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/42 dep order/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/42 dep order/myexe.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/subprojects/s1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/subprojects/s1/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/subprojects/s1/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/subprojects/s1/subprojects/ambiguous Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/subprojects/s1/subprojects/ambiguous/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/subprojects/s2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/subprojects/s2/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/subprojects/s2/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/43 promote wrap/subprojects/s2/subprojects/ambiguous.wrap Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/44 vscpp17 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/44 vscpp17/main.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/44 vscpp17/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/45 native dep pkgconfig var Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/45 native dep pkgconfig var/cross_pkgconfig Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/45 native dep pkgconfig var/cross_pkgconfig.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/45 native dep pkgconfig var/cross_pkgconfig/dep_tester.pc Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/45 native dep pkgconfig var/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/45 native dep pkgconfig var/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/45 native dep pkgconfig var/native_pkgconfig Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/45 native dep pkgconfig var/native_pkgconfig/dep_tester.pc Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/46 native file binary Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/46 native file binary/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/46 native file binary/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/47 reconfigure Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/47 reconfigure/main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/47 reconfigure/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/47 reconfigure/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/47 reconfigure/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/47 reconfigure/subprojects/sub1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/47 reconfigure/subprojects/sub1/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/48 testsetup default Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/48 testsetup default/envcheck.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/48 testsetup default/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/49 pkgconfig csharp library Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/49 pkgconfig csharp library/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/49 pkgconfig csharp library/somelib.cs Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/50 noncross options Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/50 noncross options/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/50 noncross options/prog.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/50 noncross options/ylib.pc Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/51 ldflagdedup Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/51 ldflagdedup/bob.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/51 ldflagdedup/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/51 ldflagdedup/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/52 pkgconfig static link order Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/52 pkgconfig static link order/dummy.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/52 pkgconfig static link order/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/53 clang-format Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/53 clang-format/.clang-format Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/53 clang-format/dummydir.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/53 clang-format/dummydir.h/dummy.dat Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/53 clang-format/header_expected_h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/53 clang-format/header_orig_h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/53 clang-format/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/53 clang-format/prog_expected_c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/53 clang-format/prog_orig_c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/54 introspect buildoptions Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/54 introspect buildoptions/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/54 introspect buildoptions/subprojects/projectBad Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/54 introspect buildoptions/subprojects/projectBad/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/54 introspect buildoptions/subprojects/projectBad/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/app Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/app/app.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/app/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/liba Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/liba/liba.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/liba/liba.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/liba/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/libb Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/libb/libb.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/libb/libb.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/libb/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/55 dedup compiler libs/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/cp.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/sharedlib Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/sharedlib/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/sharedlib/shared.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/sharedlib/shared.hpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/staticlib Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/staticlib/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/staticlib/static.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/staticlib/static.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/t1.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/t2.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/56 introspection/t3.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/57 pkg_config_path option Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/57 pkg_config_path option/build_extra_path Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/57 pkg_config_path option/build_extra_path/totally_made_up_dep.pc Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/57 pkg_config_path option/host_extra_path Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/57 pkg_config_path option/host_extra_path/totally_made_up_dep.pc Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/57 pkg_config_path option/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/c_compiler.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/subprojects/evilFile.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/subprojects/projectA Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/subprojects/projectA/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/subprojects/projectA/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/subprojects/projectBad Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/subprojects/projectBad/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/58 introspect buildoptions/subprojects/projectBad/meson_options.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/59 native file override Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/59 native file override/crossfile Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/59 native file override/crossfile2 Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/59 native file override/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/59 native file override/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/59 native file override/nativefile Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/60 identity cross Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/60 identity cross/build_wrapper.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/60 identity cross/host_wrapper.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/60 identity cross/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/60 identity cross/stuff.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/61 pkgconfig relative paths Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/61 pkgconfig relative paths/pkgconfig Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/61 pkgconfig relative paths/pkgconfig/librelativepath.pc Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/62 cmake_prefix_path Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/62 cmake_prefix_path/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/62 cmake_prefix_path/prefix Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/62 cmake_prefix_path/prefix/lib Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/62 cmake_prefix_path/prefix/lib/cmake Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/62 cmake_prefix_path/prefix/lib/cmake/mesontest Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/62 cmake_prefix_path/prefix/lib/cmake/mesontest/mesontest-config.cmake Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/63 cmake parser Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/63 cmake parser/meson.build Added

@@ -0,0 +1,19 @@
+project('61 cmake parser')
+
+dep = dependency('mesontest')
+
+# Test a bunch of variations of the set() command
+assert(dep.get_variable(cmake : 'VAR_WITHOUT_SPACES') == 'NoSpaces', 'set() without spaces incorrect')
+assert(dep.get_variable(cmake : 'VAR_WITH_SPACES') == 'With Spaces', 'set() with spaces incorrect')
+
+assert(dep.get_variable(cmake : 'VAR_WITHOUT_SPACES_PS') == 'NoSpaces', 'set(PARENT_SCOPE) without spaces incorrect')
+assert(dep.get_variable(cmake : 'VAR_WITH_SPACES_PS') == 'With Spaces', 'set(PARENT_SCOPE) with spaces incorrect')
+
+assert(dep.get_variable(cmake : 'VAR_THAT_IS_UNSET', default_value : 'sentinal') == 'sentinal', 'set() to unset is incorrect')
+assert(dep.get_variable(cmake : 'CACHED_STRING_NS') == 'foo', 'set(CACHED) without spaces is incorrect')
+assert(dep.get_variable(cmake : 'CACHED_STRING_WS') == 'foo bar', 'set(CACHED STRING) with spaces is incorrect')
+assert(dep.get_variable(cmake : 'CACHED_STRING_ARRAY_NS') == 'foo;bar', 'set(CACHED STRING) without spaces is incorrect')
+assert(dep.get_variable(cmake : 'CACHED_STRING_ARRAY_WS') == 'foo;foo bar;bar', 'set(CACHED STRING) with spaces is incorrect')
+
+# We don't support this, so it should be unset.
+assert(dep.get_variable(cmake : 'ENV{var}', default_value : 'sentinal') == 'sentinal', 'set(ENV) should be ignored')

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/63 cmake parser/prefix Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/63 cmake parser/prefix/lib Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/63 cmake parser/prefix/lib/cmake Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/63 cmake parser/prefix/lib/cmake/mesontest Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/63 cmake parser/prefix/lib/cmake/mesontest/mesontest-config.cmake Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/64 alias target Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/64 alias target/main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/64 alias target/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/64 alias target/subdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/64 alias target/subdir/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping/app Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping/app/appA.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping/app/appB.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping/app/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping/lib Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping/lib/libA.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping/lib/libA.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping/lib/libB.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping/lib/libB.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/65 static archive stripping/lib/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func1.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func10.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func11.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func12.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func14.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func15.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func16.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func17.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func18.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func19.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func2.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func3.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func4.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func5.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func6.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func7.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func8.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/func9.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/lib/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/test1.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/test2.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/test3.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/test4.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/66 static link/test5.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/67 test env value Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/67 test env value/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/67 test env value/test.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/68 clang-tidy Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/68 clang-tidy/.clang-tidy Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/68 clang-tidy/cttest.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/68 clang-tidy/dummydir.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/68 clang-tidy/dummydir.h/dummy.dat Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/68 clang-tidy/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/69 cross Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/69 cross/crossfile.in Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/69 cross/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/69 cross/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/70 cross test passed Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/70 cross test passed/exewrapper.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/70 cross test passed/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/70 cross test passed/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/70 cross test passed/script.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/70 cross test passed/src Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/70 cross test passed/src/main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary/meson.build Added

@@ -0,0 +1,24 @@
+project('My Project', version : '1.0')
+
+subproject('sub')
+subproject('sub2', required : false)
+
+summary({'Some boolean': false,
+         'Another boolean': true,
+         'Some string': 'Hello World',
+         'A list': 'string', 1, true,
+         'empty list': ,
+         'enabled_opt': get_option('enabled_opt'),
+        }, section: 'Configuration')
+summary({'missing prog': find_program('xyzzy', required: false),
+         'existing prog': import('python').find_installation(),
+         'missing dep': dependency('', required: false),
+         'external dep': dependency('zlib', required: false),
+         'internal dep': declare_dependency(),
+         'disabler': disabler(),
+        }, section: 'Stuff')
+summary('A number', 1, section: 'Configuration')
+summary('yes', true, bool_yn : true, section: 'Configuration')
+summary('no', false, bool_yn : true, section: 'Configuration')
+summary('comma list', 'a', 'b', 'c', list_sep: ', ', section: 'Configuration')
+summary('long comma list', 'alpha', 'alphacolor', 'apetag', 'audiofx', 'audioparsers', 'auparse', 'autodetect', 'avi', list_sep: ', ', section: 'Plugins')

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary/subprojects/sub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary/subprojects/sub/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary/subprojects/sub2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary/subprojects/sub2/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary/subprojects/sub2/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary/subprojects/sub2/subprojects/subsub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/71 summary/subprojects/sub2/subprojects/subsub/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/72 wrap file url Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/72 wrap file url/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/72 wrap file url/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/72 wrap file url/subprojects/foo-patch.tar.xz Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/72 wrap file url/subprojects/foo.tar.xz Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/73 dep files Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/73 dep files/foo.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/73 dep files/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/client Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/client/client.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/client/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/val1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/val1/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/val1/val1.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/val1/val1.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/val2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/val2/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/val2/val2.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/74 pkgconfig prefixes/val2/val2.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/75 subdir libdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/75 subdir libdir/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/75 subdir libdir/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/75 subdir libdir/subprojects/flub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/75 subdir libdir/subprojects/flub/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/76 as link whole Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/76 as link whole/bar.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/76 as link whole/foo.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/76 as link whole/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/77 nostdlib Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/77 nostdlib/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/77 nostdlib/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/77 nostdlib/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/77 nostdlib/subprojects/mylibc Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/77 nostdlib/subprojects/mylibc/libc.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/77 nostdlib/subprojects/mylibc/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/77 nostdlib/subprojects/mylibc/stdio.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/77 nostdlib/subprojects/mylibc/stubstart.s Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/78 user options for subproject Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/78 user options for subproject/75 user options for subproject Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/78 user options for subproject/75 user options for subproject/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/79 global-rpath Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/79 global-rpath/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/79 global-rpath/rpathified.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/79 global-rpath/yonder Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/79 global-rpath/yonder/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/79 global-rpath/yonder/yonder.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/79 global-rpath/yonder/yonder.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/80 wrap-git Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/80 wrap-git/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/80 wrap-git/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/80 wrap-git/subprojects/packagefiles Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/80 wrap-git/subprojects/packagefiles/wrap_git_builddef Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/80 wrap-git/subprojects/packagefiles/wrap_git_builddef/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/80 wrap-git/subprojects/wrap_git_upstream Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/80 wrap-git/subprojects/wrap_git_upstream/main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/81 meson version compare Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/81 meson version compare/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/81 meson version compare/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/81 meson version compare/subprojects/foo Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/81 meson version compare/subprojects/foo/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/82 cross only introspect Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/82 cross only introspect/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/83 change option choices Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/83 change option choices/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/83 change option choices/meson_options.1.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/83 change option choices/meson_options.2.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/84 nested subproject regenerate depends Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/84 nested subproject regenerate depends/main.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/84 nested subproject regenerate depends/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/84 nested subproject regenerate depends/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/84 nested subproject regenerate depends/subprojects/sub1 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/84 nested subproject regenerate depends/subprojects/sub1/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/84 nested subproject regenerate depends/subprojects/sub2 Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/84 nested subproject regenerate depends/subprojects/sub2/CMakeLists.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/main.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/src0.cxx Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/src1.cxx Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/src2.cxx Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/src3.cxx Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/src4.cxx Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/src5.cxx Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/src6.cxx Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/src7.cxx Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/src8.cxx Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/gcc/src9.cxx Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/main.cpp Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/src0.ixx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/src1.ixx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/src2.ixx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/src3.ixx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/src4.ixx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/src5.ixx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/src6.ixx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/src7.ixx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/src8.ixx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/85 cpp modules/vs/src9.ixx Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/86 prelinking Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/86 prelinking/file1.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/86 prelinking/file2.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/86 prelinking/file3.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/86 prelinking/file4.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/86 prelinking/main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/86 prelinking/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/86 prelinking/private_header.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/86 prelinking/public_header.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/87 run native test Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/87 run native test/main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/87 run native test/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/88 multiple envvars Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/88 multiple envvars/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/88 multiple envvars/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/88 multiple envvars/prog.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/89 pkgconfig build rpath order Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/89 pkgconfig build rpath order/dummy.pc Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/89 pkgconfig build rpath order/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/89 pkgconfig build rpath order/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/89 pkgconfig build rpath order/prog.cc Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/89 pkgconfig build rpath order/sub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/89 pkgconfig build rpath order/sub/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/89 pkgconfig build rpath order/sub/stuff.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/90 devenv Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/90 devenv/main.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/90 devenv/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/90 devenv/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/90 devenv/subprojects/sub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/90 devenv/subprojects/sub/foo.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/90 devenv/subprojects/sub/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/90 devenv/test-devenv.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/foo Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/foo.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/foo.dat Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/foo.h Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/foo/foofile Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/subprojects/bar Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/subprojects/bar/bar Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/subprojects/bar/bar.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/subprojects/bar/bar.dat Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/subprojects/bar/bar.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/subprojects/bar/bar/barfile Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/91 install skip subprojects/subprojects/bar/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/92 new subproject in configured project Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/92 new subproject in configured project/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/92 new subproject in configured project/meson_options.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/92 new subproject in configured project/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/92 new subproject in configured project/subprojects/sub Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/92 new subproject in configured project/subprojects/sub/foo.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/92 new subproject in configured project/subprojects/sub/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/93 clangformat Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/93 clangformat/.clang-format Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/93 clangformat/.clang-format-ignore Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/93 clangformat/.clang-format-include Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/93 clangformat/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/93 clangformat/not-included Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/93 clangformat/not-included/badformat.cpp Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/93 clangformat/src Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/93 clangformat/src/badformat.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/93 clangformat/src/badformat.cpp Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/94 custominc Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/94 custominc/easytogrepfor Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/94 custominc/easytogrepfor/genh.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/94 custominc/easytogrepfor/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/94 custominc/helper.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/94 custominc/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/94 custominc/prog.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/94 custominc/prog2.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/95 implicit force fallback Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/95 implicit force fallback/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/95 implicit force fallback/subprojects Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/95 implicit force fallback/subprojects/something Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/95 implicit force fallback/subprojects/something/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/96 compiler.links file arg Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/96 compiler.links file arg/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/96 compiler.links file arg/test.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/97 link full name Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/97 link full name/libtestprovider Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/97 link full name/libtestprovider/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/97 link full name/libtestprovider/provider.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/97 link full name/proguser Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/97 link full name/proguser/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/97 link full name/proguser/receiver.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/bar-custom.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/bar-devel.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/bar-notag.txt Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/custom_files Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/custom_files/data.txt Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/foo.in Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/foo1-devel.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/lib.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/main.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/meson.build Added

@@ -0,0 +1,108 @@
+project('install tag', 'c')
+
+subdir('subdir')
+
+# Those files should not be tagged
+configure_file(input: 'foo.in', output: 'foo-notag.h',
+  configuration: {'foo': 'bar'},
+  install_dir: get_option('datadir'),
+  install: true,
+)
+install_data('bar-notag.txt',
+  install_dir: get_option('datadir')
+)
+custom_target('ct1',
+  output: 'out1-notag.txt', 'out2-notag.txt',
+  command: 'script.py', '@OUTPUT@',
+  install_dir: get_option('datadir'),
+  install: true,
+)
+
+# Those files should be tagged as devel
+install_headers('foo1-devel.h')
+install_data('bar-devel.h',
+  install_dir: get_option('includedir'),
+)
+configure_file(input: 'foo.in', output: 'foo2-devel.h',
+  configuration: {'foo': 'bar'},
+  install_dir: get_option('includedir'),
+  install: true,
+)
+static_library('static', 'lib.c',
+  install: true,
+)
+custom_target('ct-header1',
+  output: 'ct-header1.h',
+  command: 'script.py', '@OUTPUT@',
+  install_dir: get_option('includedir'),
+  install: true,
+)
+custom_target('ct-header2',
+  output: 'ct-header2.h', 'ct-header3.h',
+  command: 'script.py', '@OUTPUT@',
+  install_dir: false, get_option('includedir'),
+  install: true,
+)
+install_emptydir(get_option('includedir') / 'subdir-devel')
+install_subdir('custom_files',
+  install_dir: get_option('includedir'),
+)
+
+# Those files should have 'runtime' tag
+executable('app', 'main.c',
+  install: true,
+)
+executable('app-otherdir', 'main.c',
+  install: true,
+  install_dir: 'otherbin',
+)
+shared_library('shared', 'lib.c',
+  install: true,
+)
+both_libraries('both', 'lib.c',
+  install: true,
+)
+
+# Unversioned .so file should have 'devel' tag, others should have 'runtime' tag
+shared_library('versioned_shared', 'lib.c',
+  install: true,
+  version: '1.2.3',
+)
+
+# Those files should have custom tag
+install_data('bar-custom.txt',
+  install_dir: get_option('datadir'),
+  install_tag: 'custom')
+configure_file(input: 'foo.in', output: 'foo-custom.h',
+  configuration: {'foo': 'bar'},
+  install_dir: get_option('datadir'),
+  install_tag: 'custom',
+  install: true,
+)
+both_libraries('bothcustom', 'lib.c',
+  install_tag: 'custom',
+  install: true,
+)
+custom_target('ct2',
+  output: 'out1-custom.txt', 'out2-custom.txt',
+  command: 'script.py', '@OUTPUT@',
+  install_dir: get_option('datadir'),
+  install_tag: 'custom',
+  install: true,
+)
+install_subdir('custom_files',
+  install_dir: get_option('datadir'),
+  install_tag: 'custom',
+)
+
+# First is custom, 2nd is devel, 3rd has no tag
+custom_target('ct3',
+  output: 'out3-custom.txt', 'out-devel.h', 'out3-notag.txt',
+  command: 'script.py', '@OUTPUT@',
+  install_dir: get_option('datadir'), get_option('includedir'), get_option('datadir'),
+  install_tag: 'custom', 'devel', false,
+  install: true,
+)
+
+meson.add_install_script('script.py', install_tag: 'custom')
+meson.add_install_script('script.py')

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/script.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/subdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/subdir/bar2-devel.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/subdir/foo2.in Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/subdir/foo3-devel.h Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/subdir/lib.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/subdir/main.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/subdir/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/98 install all targets/subdir/script.py Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/99 custom target name Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/99 custom target name/file.txt.in Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/99 custom target name/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/99 custom target name/subdir Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/unit/99 custom target name/subdir/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/vala/14 target glib version and gresources/test.vala -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/vala/14 target glib version and gresources/test.vala Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/vala/5 target glib/GLib.Thread.vala -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/vala/5 target glib/GLib.Thread.vala Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/vala/5 target glib/retcode.c -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/vala/5 target glib/retcode.c Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/warning/1 version for string div/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/1 version for string div/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/warning/3 fallback consistency/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/3 fallback consistency/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/warning/4 fallback consistency/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/4 fallback consistency/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/warning/5 fallback consistency/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/5 fallback consistency/test.json Changed

_service:tar_scm:meson-0.61.5.tar.gz/test cases/warning/6 list add/test.json -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/6 list add/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/7 module without unstable Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/7 module without unstable/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/7 module without unstable/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/8 target with no sources Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/8 target with no sources/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/warning/8 target with no sources/test.json Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland/1 client Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland/1 client/both.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland/1 client/client.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland/1 client/local.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland/1 client/meson.build Added

@@ -0,0 +1,48 @@
+project('wayland-test-client', 'c')
+
+wl_protocols_dep = dependency('wayland-protocols', required : false)
+if not wl_protocols_dep.found()
+  error('MESON_SKIP_TEST: wayland-protocols not installed')
+endif
+
+wl_client_dep = dependency('wayland-client')
+wl_server_dep = dependency('wayland-server')
+wl_mod = import('unstable-wayland')
+fs = import('fs')
+
+# Client side only
+xdg_shell_xml = wl_mod.find_protocol('xdg-shell')
+xdg_shell = wl_mod.scan_xml(xdg_shell_xml)
+assert(xdg_shell.length() == 2)
+assert(fs.name(xdg_shell0.full_path()) == 'xdg-shell-protocol.c')
+assert(fs.name(xdg_shell1.full_path()) == 'xdg-shell-client-protocol.h')
+exe = executable('client', 'client.c', xdg_shell, dependencies : wl_client_dep)
+test('client', exe)
+
+# Server side only
+presentation_time_xml = wl_mod.find_protocol('presentation-time')
+presentation_time = wl_mod.scan_xml(presentation_time_xml, client : false, server : true)
+assert(presentation_time.length() == 2)
+assert(fs.name(presentation_time0.full_path()) == 'presentation-time-protocol.c')
+assert(fs.name(presentation_time1.full_path()) == 'presentation-time-server-protocol.h')
+exe = executable('server', 'server.c', presentation_time, dependencies : wl_server_dep)
+test('server', exe)
+
+# Both sides
+viewporter_xml = wl_mod.find_protocol('viewporter')
+viewporter = wl_mod.scan_xml(viewporter_xml, client : true, server : true)
+assert(viewporter.length() == 3)
+assert(fs.name(viewporter0.full_path()) == 'viewporter-protocol.c')
+assert(fs.name(viewporter1.full_path()) == 'viewporter-client-protocol.h')
+assert(fs.name(viewporter2.full_path()) == 'viewporter-server-protocol.h')
+exe = executable('both', 'both.c', viewporter, dependencies : wl_client_dep, wl_server_dep)
+test('both', exe)
+
+# Local xml
+xmls = files('test.xml')
+gen = wl_mod.scan_xml(xmls)
+assert(gen.length() == 2)
+assert(fs.name(gen0.full_path()) == 'test-protocol.c')
+assert(fs.name(gen1.full_path()) == 'test-client-protocol.h')
+exe = executable('local', 'local.c', gen, dependencies : wl_client_dep)
+test('local', exe)

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland/1 client/server.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland/1 client/test.xml Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland/2 core only Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland/2 core only/core.c Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/wayland/2 core only/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/19 msvc cplusplus define Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/19 msvc cplusplus define/main.cpp Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/19 msvc cplusplus define/meson.build Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/20 vs install static lib with generated obj deps Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/20 vs install static lib with generated obj deps/both_lib_source.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/20 vs install static lib with generated obj deps/copyfile.py Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/20 vs install static lib with generated obj deps/generated_source.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/20 vs install static lib with generated obj deps/meson.build Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/20 vs install static lib with generated obj deps/static_lib_source.c Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/20 vs install static lib with generated obj deps/test.json Changed

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/21 masm Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/21 masm/hello.masm Added

_service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/21 masm/meson.build Added

_service:tar_scm:meson-0.61.5.tar.gz/test cases/windows/3 cpp/meson.build -> _service:tar_scm:meson-1.0.1.tar.gz/test cases/windows/3 cpp/meson.build Changed

_service:tar_scm:meson-0.61.5.tar.gz/tools/ac_converter.py -> _service:tar_scm:meson-1.0.1.tar.gz/tools/ac_converter.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/tools/regenerate_docs.py -> _service:tar_scm:meson-1.0.1.tar.gz/tools/regenerate_docs.py Changed

@@ -37,10 +37,27 @@
 env'COLUMNS' = '80'
 return subprocess.run(str(sys.executable), str(root_dir/'meson.py') + args, check=True, capture_output=True, text=True, env=env).stdout.strip()
 
+def get_commands(help_output: str) -> T.Setstr:
+ # Python's argument parser might put the command list to its own line. Or it might not.
+ assert(help_output.startswith('usage: '))
+ lines = help_output.split('\n')
+ line1 = lines0
+ line2 = lines1
+ if '{' in line1:
+ cmndline = line1
+ else:
+ assert('{' in line2)
+ cmndline = line2
+ cmndstr = cmndline.split('{')1
+ assert('}' in cmndstr)
+ help_commands = set(cmndstr.split('}')0.split(','))
+ assert(len(help_commands) > 0)
+ return {c.strip() for c in help_commands}
+
 def get_commands_data(root_dir: Path) -> T.Dictstr, T.Any:
 usage_start_pattern = re.compile(r'^usage: ', re.MULTILINE)
 positional_start_pattern = re.compile(r'^positional arguments:\t *\r\n+', re.MULTILINE)
- options_start_pattern = re.compile(r'^optional arguments:\t *\r\n+', re.MULTILINE)
+ options_start_pattern = re.compile(r'^(optional arguments|options):\t *\r\n+', re.MULTILINE)
 commands_start_pattern = re.compile(r'^A-Za-z *Ccommands:\t *\r\n+', re.MULTILINE)
 
 def get_next_start(iterators: T.SequenceT.Any, end: T.Optionalint) -> int:
@@ -96,7 +113,7 @@
 return out
 
 output = _get_meson_output(root_dir, '--help')
- commands = {c.strip() for c in re.findall(r'usage:(?:.+)?{((?:a-z+,*)+?)}', output, re.MULTILINE|re.DOTALL)0.split(',')}
+ commands = get_commands(output)
 commands.remove('help')
 
 cmd_data = dict()
@@ -124,7 +141,13 @@
 f.write('| Project | Versions | Provided dependencies | Provided programs |\n')
 f.write('| ------- | -------- | --------------------- | ----------------- |\n')
 for name, info in releases.items():
- versions = f'{v}(https://wrapdb.mesonbuild.com/v2/{name}_{v}/{name}.wrap)' for v in info'versions'
+ versions = 
+ added_tags = set()
+ for v in info'versions':
+ tag, build = v.rsplit('-', 1)
+ if tag not in added_tags:
+ added_tags.add(tag)
+ versions.append(f'{v}(https://wrapdb.mesonbuild.com/v2/{name}_{v}/{name}.wrap)')
 # Highlight latest version.
 versions_str = f'<big>**{versions0}**</big> ' + ', '.join(versions1:)
 dependency_names = info.get('dependency_names', )

_service:tar_scm:meson-0.61.5.tar.gz/unittests/allplatformstests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/allplatformstests.py Changed

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from mesonbuild.mesonlib.universal import windows_proof_rm
 import subprocess
 import re
 import json
@@ -42,12 +41,16 @@
 BuildDirLock, MachineChoice, is_windows, is_osx, is_cygwin, is_dragonflybsd,
 is_sunos, windows_proof_rmtree, python_command, version_compare, split_args, quote_arg,
 relpath, is_linux, git, search_version, do_conf_file, do_conf_str, default_prefix,
- MesonException, EnvironmentException, OptionKey
+ MesonException, EnvironmentException, OptionKey, ExecutableSerialisation, EnvironmentVariables,
+ windows_proof_rm
 )
 
+from mesonbuild.compilers.mixins.clang import ClangCompiler
+from mesonbuild.compilers.mixins.gnu import GnuCompiler
+from mesonbuild.compilers.mixins.intel import IntelGnuLikeCompiler
+from mesonbuild.compilers.c import VisualStudioCCompiler, ClangClCCompiler
+from mesonbuild.compilers.cpp import VisualStudioCPPCompiler, ClangClCPPCompiler
 from mesonbuild.compilers import (
- GnuCompiler, ClangCompiler, IntelGnuLikeCompiler, VisualStudioCCompiler,
- VisualStudioCPPCompiler, ClangClCCompiler, ClangClCPPCompiler,
 detect_static_linker, detect_c_compiler, compiler_from_language,
 detect_compiler_for
 )
@@ -60,7 +63,7 @@
 from mesonbuild.wrap.wrap import PackageDefinition, WrapException
 
 from run_tests import (
- Backend, exe_suffix, get_fake_env
+ Backend, exe_suffix, get_fake_env, get_convincing_fake_env_and_cc
 )
 
 from .baseplatformtests import BasePlatformTests
@@ -213,9 +216,9 @@
 elif opt'name' == 'libdir':
 self.assertEqual(libdir, opt'value')
 
- def test_libdir_must_be_inside_prefix(self):
+ def test_libdir_can_be_outside_prefix(self):
 '''
- Tests that libdir is forced to be inside prefix no matter how it is set.
+ Tests that libdir is allowed to be outside prefix.
 Must be a unit test for obvious reasons.
 '''
 testdir = os.path.join(self.common_test_dir, '1 trivial')
@@ -226,19 +229,19 @@
 args = '--prefix', '/opt', '--libdir', '/opt/lib32'
 self.init(testdir, extra_args=args)
 self.wipe()
- # libdir not being inside prefix is not ok
+ # libdir not being inside prefix is ok too
 if is_windows():
 args = '--prefix', 'x:/usr', '--libdir', 'x:/opt/lib32'
 else:
 args = '--prefix', '/usr', '--libdir', '/opt/lib32'
- self.assertRaises(subprocess.CalledProcessError, self.init, testdir, extra_args=args)
+ self.init(testdir, extra_args=args)
 self.wipe()
- # libdir must be inside prefix even when set via mesonconf
+ # libdir can be outside prefix even when set via mesonconf
 self.init(testdir)
 if is_windows():
- self.assertRaises(subprocess.CalledProcessError, self.setconf, '-Dlibdir=x:/opt', False)
+ self.setconf('-Dlibdir=x:/opt', will_build=False)
 else:
- self.assertRaises(subprocess.CalledProcessError, self.setconf, '-Dlibdir=/opt', False)
+ self.setconf('-Dlibdir=/opt', will_build=False)
 
 def test_prefix_dependent_defaults(self):
 '''
@@ -539,7 +542,7 @@
 self.run_tests()
 
 def test_implicit_forcefallback(self):
- testdir = os.path.join(self.unit_test_dir, '96 implicit force fallback')
+ testdir = os.path.join(self.unit_test_dir, '95 implicit force fallback')
 with self.assertRaises(subprocess.CalledProcessError):
 self.init(testdir)
 self.init(testdir, extra_args='--wrap-mode=forcefallback')
@@ -570,6 +573,75 @@
 self.build()
 self._run(self.mtest_command + '--repeat=2')
 
+ def test_verbose(self):
+ testdir = os.path.join(self.common_test_dir, '206 tap tests')
+ self.init(testdir)
+ self.build()
+ out = self._run(self.mtest_command + '--suite', 'verbose')
+ self.assertIn('1/1 subtest 1', out)
+
+ def test_long_output(self):
+ testdir = os.path.join(self.common_test_dir, '254 long output')
+ self.init(testdir)
+ self.build()
+ self.run_tests()
+
+ # Ensure lines are found from testlog.txt when not being verbose.
+
+ i = 1
+ with open(os.path.join(self.logdir, 'testlog.txt'), encoding='utf-8') as f:
+ line = f.readline()
+ while line and i < 100001:
+ if f'# Iteration {i} to stdout' in line:
+ i += 1
+ line = f.readline()
+ self.assertEqual(i, 100001)
+
+ i = 1
+ while line:
+ if f'# Iteration {i} to stderr' in line:
+ i += 1
+ line = f.readline()
+ self.assertEqual(i, 100001)
+
+ # Ensure lines are found from both testlog.txt and console when being verbose.
+
+ out = self._run(self.mtest_command + '-v')
+ i = 1
+ with open(os.path.join(self.logdir, 'testlog.txt'), encoding='utf-8') as f:
+ line = f.readline()
+ while line and i < 100001:
+ if f'# Iteration {i} to stdout' in line:
+ i += 1
+ line = f.readline()
+ self.assertEqual(i, 100001)
+
+ i = 1
+ while line:
+ if f'# Iteration {i} to stderr' in line:
+ i += 1
+ line = f.readline()
+ self.assertEqual(i, 100001)
+
+ lines = out.split('\n')
+ line_number = 0
+ i = 1
+ while line_number < len(lines) and i < 100001:
+ print('---> %s' % linesline_number)
+ if f'# Iteration {i} to stdout' in linesline_number:
+ i += 1
+ line_number += 1
+ self.assertEqual(i, 100001)
+
+ line_number = 0
+ i = 1
+ while line_number < len(lines):
+ if f'# Iteration {i} to stderr' in linesline_number:
+ i += 1
+ line_number += 1
+ self.assertEqual(i, 100001)
+
+
 def test_testsetups(self):
 if not shutil.which('valgrind'):
 raise SkipTest('Valgrind not installed.')
@@ -638,7 +710,7 @@
 self.mtest_command + '--setup=main:onlyinbar')
 
 def test_testsetup_default(self):
- testdir = os.path.join(self.unit_test_dir, '49 testsetup default')
+ testdir = os.path.join(self.unit_test_dir, '48 testsetup default')
 self.init(testdir)
 self.build()
 
@@ -724,6 +796,26 @@
 
 self.assertFailedTestCount(2, self.mtest_command + '--no-suite', 'subprjfail:fail', '--no-suite', 'subprjmix:fail')
 
+ def test_mtest_reconfigure(self):
+ if self.backend is not Backend.ninja:
+ raise SkipTest(f'mtest can\'t rebuild with {self.backend.name!r}')
+
+ testdir = os.path.join(self.common_test_dir, '206 tap tests')
+ self.init(testdir)
+ self.utime(os.path.join(testdir, 'meson.build'))
+ o = self._run(self.mtest_command + '--list')
+ self.assertIn('Regenerating build files.', o)
+ self.assertIn('test_features / xfail', o)
+ o = self._run(self.mtest_command + '--list')
+ self.assertNotIn('Regenerating build files.', o)
+ # no real targets should have been built
+ tester = os.path.join(self.builddir, 'tester' + exe_suffix)
+ self.assertPathDoesNotExist(tester)
+ # check that we don't reconfigure if --no-rebuild is passed
+ self.utime(os.path.join(testdir, 'meson.build'))
+ o = self._run(self.mtest_command + '--list', '--no-rebuild')
+ self.assertNotIn('Regenerating build files.', o)
+
 def test_build_by_default(self):
 testdir = os.path.join(self.common_test_dir, '129 build by default')
 self.init(testdir)
@@ -741,6 +833,53 @@
 self.build(target=('barprog' + exe_suffix))
 self.assertPathExists(exe2)
 
+ def test_build_generated_pyx_directly(self):
+ # Check that the transpile stage also includes
+ # dependencies for the compilation stage as dependencies
+ testdir = os.path.join("test cases/cython", '2 generated sources')
+ env = get_fake_env(testdir, self.builddir, self.prefix)
+ try:
+ detect_compiler_for(env, "cython", MachineChoice.HOST)
+ except EnvironmentException:
+ raise SkipTest("Cython is not installed")
+ self.init(testdir)
+ # Need to get the full target name of the pyx.c target
+ # (which is unfortunately not provided by introspection :( )
+ # We'll need to dig into the generated sources
+ targets = self.introspect('--targets')
+ name = None
+ for target in targets:
+ for target_sources in target"target_sources":
+ for generated_source in target_sources"generated_sources":
+ if "includestuff.pyx.c" in generated_source:
+ name = generated_source
+ break
+ # Split the path (we only want the includestuff.cpython-blahblahblah)
+ name = os.path.normpath(name).split("/")-2:
+ name = "/".join(name) # Glue list into a string
+ self.build(target=name)
+
+ def test_build_pyx_depfiles(self):
+ # building regularly and then touching a depfile dependency should rebuild
+ testdir = os.path.join("test cases/cython", '2 generated sources')
+ env = get_fake_env(testdir, self.builddir, self.prefix)
+ try:
+ cython = detect_compiler_for(env, "cython", MachineChoice.HOST)
+ if not version_compare(cython.version, '>=0.29.33'):
+ raise SkipTest('Cython is too old')
+ except EnvironmentException:
+ raise SkipTest("Cython is not installed")
+ self.init(testdir)
+
+ targets = self.introspect('--targets')
+ for target in targets:
+ if target'name'.startswith('simpleinclude'):
+ name = target'name'
+ self.build()
+ self.utime(os.path.join(testdir, 'simplestuff.pxi'))
+ self.assertBuildRelinkedOnlyTarget(name)
+
+
 def test_internal_include_order(self):
 if mesonbuild.environment.detect_msys2_arch() and ('MESON_RSP_THRESHOLD' in os.environ):
 raise SkipTest('Test does not yet support gcc rsp files on msys2')
@@ -1443,7 +1582,7 @@
 extra_args = 
 link_cmd = linker.get_exelist()
 link_cmd += linker.get_always_args()
- link_cmd += linker.get_std_link_args(False)
+ link_cmd += linker.get_std_link_args(get_fake_env(), False)
 link_cmd += linker.get_output_args(outfile)
 link_cmd += objectfile
 self.pbcompile(compiler, source, objectfile, extra_args=extra_args)
@@ -1539,6 +1678,32 @@
 self.build()
 self.run_tests()
 
+ def test_underscore_prefix_detection_list(self) -> None:
+ '''
+ Test the underscore detection hardcoded lookup list
+ against what was detected in the binary.
+ '''
+ env, cc = get_convincing_fake_env_and_cc(self.builddir, self.prefix)
+ expected_uscore = cc._symbols_have_underscore_prefix_searchbin(env)
+ list_uscore = cc._symbols_have_underscore_prefix_list(env)
+ if list_uscore is not None:
+ self.assertEqual(list_uscore, expected_uscore)
+ else:
+ raise SkipTest('No match in underscore prefix list for this platform.')
+
+ def test_underscore_prefix_detection_define(self) -> None:
+ '''
+ Test the underscore detection based on compiler-defined preprocessor macro
+ against what was detected in the binary.
+ '''
+ env, cc = get_convincing_fake_env_and_cc(self.builddir, self.prefix)
+ expected_uscore = cc._symbols_have_underscore_prefix_searchbin(env)
+ define_uscore = cc._symbols_have_underscore_prefix_define(env)
+ if define_uscore is not None:
+ self.assertEqual(define_uscore, expected_uscore)
+ else:
+ raise SkipTest('Did not find the underscore prefix define __USER_LABEL_PREFIX__')
+
 @skipIfNoPkgconfig
 def test_pkgconfig_static(self):
 '''
@@ -1603,6 +1768,39 @@
 # pkg-config and pkgconf does not respect the same order
 self.assertEqual(sorted(foo_dep.get_compile_args()), sorted(cargs))
 
+ @skipIfNoPkgconfig
+ def test_pkgconfig_relocatable(self):
+ '''
+ Test that it generates relocatable pkgconfig when module
+ option pkgconfig.relocatable=true.
+ '''
+ testdir_rel = os.path.join(self.common_test_dir, '44 pkgconfig-gen')
+ self.init(testdir_rel, extra_args='-Dpkgconfig.relocatable=true')
+
+ def check_pcfile(name, *, relocatable, levels=2):
+ with open(os.path.join(self.privatedir, name), encoding='utf-8') as f:
+ pcfile = f.read()
+ # The pkgconfig module always uses posix path regardless of platform
+ prefix_rel = PurePath('${pcfiledir}', *('..' * levels)).as_posix()
+ (self.assertIn if relocatable else self.assertNotIn)(
+ f'prefix={prefix_rel}\n',
+ pcfile)
+
+ check_pcfile('libvartest.pc', relocatable=True)
+ check_pcfile('libvartest2.pc', relocatable=True)
+
+ self.wipe()
+ self.init(testdir_rel, extra_args='-Dpkgconfig.relocatable=false')
+
+ check_pcfile('libvartest.pc', relocatable=False)
+ check_pcfile('libvartest2.pc', relocatable=False)
+
+ self.wipe()
+ testdir_abs = os.path.join(self.unit_test_dir, '105 pkgconfig relocatable with absolute path')
+ self.init(testdir_abs)
+
+ check_pcfile('libsimple.pc', relocatable=True, levels=3)
+
 def test_array_option_change(self):
 def get_opt():
 opts = self.introspect('--buildoptions')
@@ -1709,7 +1907,7 @@
 
 def test_options_with_choices_changing(self) -> None:
 """Detect when options like arrays or combos have their choices change."""
- testdir = Path(os.path.join(self.unit_test_dir, '84 change option choices'))
+ testdir = Path(os.path.join(self.unit_test_dir, '83 change option choices'))
 options1 = str(testdir / 'meson_options.1.txt')
 options2 = str(testdir / 'meson_options.2.txt')
 
@@ -1780,7 +1978,7 @@
 self.build()
 
 def test_subproject_promotion_wrap(self):
- testdir = os.path.join(self.unit_test_dir, '44 promote wrap')
+ testdir = os.path.join(self.unit_test_dir, '43 promote wrap')
 workdir = os.path.join(self.builddir, 'work')
 shutil.copytree(testdir, workdir)
 spdir = os.path.join(workdir, 'subprojects')
@@ -1801,24 +1999,26 @@
 r'sub' + os.path.sep + r'meson.build:3: WARNING: Keyword argument "link_with" defined multiple times.',
 r'meson.build:6: WARNING: a warning of some sort',
 r'sub' + os.path.sep + r'meson.build:4: WARNING: subdir warning',
- r'meson.build:7: WARNING: Module unstable-simd has no backwards or forwards compatibility and might not exist in future releases.',
+ r'meson.build:7: WARNING: Module SIMD has no backwards or forwards compatibility and might not exist in future releases.',
 r"meson.build:11: WARNING: The variable(s) 'MISSING' in the input file 'conf.in' are not present in the given configuration data.",
 :
- self.assertRegex(out, re.escape(expected))
+ with self.subTest(expected):
+ self.assertRegex(out, re.escape(expected))
 
 for wd in 
 self.src_root,
 self.builddir,
 os.getcwd(),
 :
- self.new_builddir()
- out = self.init(tdir, workdir=wd)
- expected = os.path.join(relpath(tdir, self.src_root), 'meson.build')
- relwd = relpath(self.src_root, wd)
- if relwd != '.':
- expected = os.path.join(relwd, expected)
- expected = '\n' + expected + ':'
- self.assertIn(expected, out)
+ with self.subTest(wd):
+ self.new_builddir()
+ out = self.init(tdir, workdir=wd)
+ expected = os.path.join(relpath(tdir, self.src_root), 'meson.build')
+ relwd = relpath(self.src_root, wd)
+ if relwd != '.':
+ expected = os.path.join(relwd, expected)
+ expected = '\n' + expected + ':'
+ self.assertIn(expected, out)
 
 def test_error_location_path(self):
 '''Test locations in meson errors contain correct paths'''
@@ -1827,9 +2027,9 @@
 for (t, f) in 
 ('10 out of bounds', 'meson.build'),
 ('18 wrong plusassign', 'meson.build'),
- ('60 bad option argument', 'meson_options.txt'),
- ('98 subdir parse error', os.path.join('subdir', 'meson.build')),
- ('99 invalid option file', 'meson_options.txt'),
+ ('59 bad option argument', 'meson_options.txt'),
+ ('97 subdir parse error', os.path.join('subdir', 'meson.build')),
+ ('98 invalid option file', 'meson_options.txt'),
 :
 tdir = os.path.join(self.src_root, 'test cases', 'failing', t)
 
@@ -1879,6 +2079,12 @@
 
 for lang in langs:
 for target_type in ('executable', 'library'):
+ if is_windows() and lang == 'fortran' and target_type == 'library':
+ # non-Gfortran Windows Fortran compilers do not do shared libraries in a Fortran standard way
+ # see "test cases/fortran/6 dynamic"
+ fc = detect_compiler_for(env, 'fortran', MachineChoice.HOST)
+ if fc.get_id() in {'intel-cl', 'pgi'}:
+ continue
 # test empty directory
 with tempfile.TemporaryDirectory() as tmpdir:
 self._run(self.meson_command + 'init', '--language', lang, '--type', target_type,
@@ -1953,7 +2159,7 @@
 self.assertIn(msg, out)
 
 def test_mixed_language_linker_check(self):
- testdir = os.path.join(self.unit_test_dir, '97 compiler.links file arg')
+ testdir = os.path.join(self.unit_test_dir, '96 compiler.links file arg')
 self.init(testdir)
 cmds = self.get_meson_log_compiler_checks()
 self.assertEqual(len(cmds), 5)
@@ -2120,6 +2326,9 @@
 self.setconf('--warnlevel=3')
 obj = mesonbuild.coredata.load(self.builddir)
 self.assertEqual(obj.optionsOptionKey('warning_level').value, '3')
+ self.setconf('--warnlevel=everything')
+ obj = mesonbuild.coredata.load(self.builddir)
+ self.assertEqual(obj.optionsOptionKey('warning_level').value, 'everything')
 self.wipe()
 
 # But when using -D syntax, it should be 'warning_level'
@@ -2129,6 +2338,9 @@
 self.setconf('-Dwarning_level=3')
 obj = mesonbuild.coredata.load(self.builddir)
 self.assertEqual(obj.optionsOptionKey('warning_level').value, '3')
+ self.setconf('-Dwarning_level=everything')
+ obj = mesonbuild.coredata.load(self.builddir)
+ self.assertEqual(obj.optionsOptionKey('warning_level').value, 'everything')
 self.wipe()
 
 # Mixing --option and -Doption is forbidden
@@ -2271,15 +2483,15 @@
 self.wipe()
 
 def test_feature_check_usage_subprojects(self):
- testdir = os.path.join(self.unit_test_dir, '41 featurenew subprojects')
+ testdir = os.path.join(self.unit_test_dir, '40 featurenew subprojects')
 out = self.init(testdir)
 # Parent project warns correctly
- self.assertRegex(out, "WARNING: Project targeting '>=0.45'.*'0.47.0': dict")
+ self.assertRegex(out, "WARNING: Project targets '>=0.45'.*'0.47.0': dict")
 # Subprojects warn correctly
- self.assertRegex(out, r"foo\| .*WARNING: Project targeting '>=0.40'.*'0.44.0': disabler")
- self.assertRegex(out, r"baz\| .*WARNING: Project targeting '!=0.40'.*'0.44.0': disabler")
+ self.assertRegex(out, r"foo\| .*WARNING: Project targets '>=0.40'.*'0.44.0': disabler")
+ self.assertRegex(out, r"baz\| .*WARNING: Project targets '!=0.40'.*'0.44.0': disabler")
 # Subproject has a new-enough meson_version, no warning
- self.assertNotRegex(out, "WARNING: Project targeting.*Python")
+ self.assertNotRegex(out, "WARNING: Project targets.*Python")
 # Ensure a summary is printed in the subproject and the outer project
 self.assertRegex(out, r"\| WARNING: Project specifies a minimum meson_version '>=0.40'")
 self.assertRegex(out, r"\| \* 0.44.0: {'disabler'}")
@@ -2306,7 +2518,6 @@
 self.assertEqual(f.read().strip(), b'/* #undef FOO_BAR */')
 with open(os.path.join(self.builddir, 'nosubst-nocopy2.txt'), 'rb') as f:
 self.assertEqual(f.read().strip(), b'')
- self.assertRegex(out, r"DEPRECATION:.*\'array'\ is invalid.*dict")
 
 def test_dirs(self):
 with tempfile.TemporaryDirectory() as containing:
@@ -2354,7 +2565,7 @@
 @skipIf(is_windows(), 'Help needed with fixing this test on windows')
 def test_native_dep_pkgconfig(self):
 testdir = os.path.join(self.unit_test_dir,
- '46 native dep pkgconfig var')
+ '45 native dep pkgconfig var')
 with tempfile.NamedTemporaryFile(mode='w', delete=False) as crossfile:
 crossfile.write(textwrap.dedent(
 '''binaries
@@ -2381,7 +2592,7 @@
 @skipIf(is_windows(), 'Help needed with fixing this test on windows')
 def test_pkg_config_libdir(self):
 testdir = os.path.join(self.unit_test_dir,
- '46 native dep pkgconfig var')
+ '45 native dep pkgconfig var')
 with tempfile.NamedTemporaryFile(mode='w', delete=False) as crossfile:
 crossfile.write(textwrap.dedent(
 '''binaries
@@ -2415,7 +2626,7 @@
 pickle.dump(obj, f)
 
 def test_reconfigure(self):
- testdir = os.path.join(self.unit_test_dir, '48 reconfigure')
+ testdir = os.path.join(self.unit_test_dir, '47 reconfigure')
 self.init(testdir, extra_args='-Dopt1=val1', '-Dsub1:werror=true')
 self.setconf('-Dopt2=val2')
 
@@ -2566,7 +2777,7 @@
 def test_clang_format(self):
 if self.backend is not Backend.ninja:
 raise SkipTest(f'Clang-format is for now only supported on Ninja, not {self.backend.name}')
- testdir = os.path.join(self.unit_test_dir, '54 clang-format')
+ testdir = os.path.join(self.unit_test_dir, '53 clang-format')
 
 # Ensure that test project is in git even when running meson from tarball.
 srcdir = os.path.join(self.builddir, 'src')
@@ -2620,7 +2831,7 @@
 raise SkipTest('Clang-tidy breaks when ccache is used and "c++" not in path.')
 if is_osx():
 raise SkipTest('Apple ships a broken clang-tidy that chokes on -pipe.')
- testdir = os.path.join(self.unit_test_dir, '69 clang-tidy')
+ testdir = os.path.join(self.unit_test_dir, '68 clang-tidy')
 dummydir = os.path.join(testdir, 'dummydir.h')
 self.init(testdir, override_envvars={'CXX': 'c++'})
 out = self.run_target('clang-tidy')
@@ -2628,7 +2839,7 @@
 self.assertNotIn(dummydir, out)
 
 def test_identity_cross(self):
- testdir = os.path.join(self.unit_test_dir, '70 cross')
+ testdir = os.path.join(self.unit_test_dir, '69 cross')
 # Do a build to generate a cross file where the host is this target
 self.init(testdir, extra_args='-Dgenerate=true')
 self.meson_cross_files = os.path.join(self.builddir, "crossfile")
@@ -2638,7 +2849,7 @@
 self.init(testdir)
 
 def test_introspect_buildoptions_without_configured_build(self):
- testdir = os.path.join(self.unit_test_dir, '59 introspect buildoptions')
+ testdir = os.path.join(self.unit_test_dir, '58 introspect buildoptions')
 testfile = os.path.join(testdir, 'meson.build')
 res_nb = self.introspect_directory(testfile, '--buildoptions' + self.meson_args)
 self.init(testdir, default_args=False)
@@ -2648,11 +2859,11 @@
 self.assertListEqual(sorted(res_nb, key=lambda x: x'name'), sorted(res_wb, key=lambda x: x'name'))
 
 def test_meson_configure_from_source_does_not_crash(self):
- testdir = os.path.join(self.unit_test_dir, '59 introspect buildoptions')
+ testdir = os.path.join(self.unit_test_dir, '58 introspect buildoptions')
 self._run(self.mconf_command + testdir)
 
 def test_introspect_buildoptions_cross_only(self):
- testdir = os.path.join(self.unit_test_dir, '83 cross only introspect')
+ testdir = os.path.join(self.unit_test_dir, '82 cross only introspect')
 testfile = os.path.join(testdir, 'meson.build')
 res = self.introspect_directory(testfile, '--buildoptions' + self.meson_args)
 optnames = o'name' for o in res
@@ -2660,7 +2871,7 @@
 self.assertNotIn('build.c_args', optnames)
 
 def test_introspect_json_flat(self):
- testdir = os.path.join(self.unit_test_dir, '57 introspection')
+ testdir = os.path.join(self.unit_test_dir, '56 introspection')
 self.init(testdir, extra_args='-Dlayout=flat')
 infodir = os.path.join(self.builddir, 'meson-info')
 self.assertPathExists(infodir)
@@ -2673,7 +2884,7 @@
 assert os.path.relpath(out, self.builddir).startswith('meson-out')
 
 def test_introspect_json_dump(self):
- testdir = os.path.join(self.unit_test_dir, '57 introspection')
+ testdir = os.path.join(self.unit_test_dir, '56 introspection')
 self.init(testdir)
 infodir = os.path.join(self.builddir, 'meson-info')
 self.assertPathExists(infodir)
@@ -2875,7 +3086,7 @@
 self.assertDictEqual(targets_to_find, {})
 
 def test_introspect_file_dump_equals_all(self):
- testdir = os.path.join(self.unit_test_dir, '57 introspection')
+ testdir = os.path.join(self.unit_test_dir, '56 introspection')
 self.init(testdir)
 res_all = self.introspect('--all')
 res_file = {}
@@ -2903,7 +3114,7 @@
 self.assertEqual(res_all, res_file)
 
 def test_introspect_meson_info(self):
- testdir = os.path.join(self.unit_test_dir, '57 introspection')
+ testdir = os.path.join(self.unit_test_dir, '56 introspection')
 introfile = os.path.join(self.builddir, 'meson-info', 'meson-info.json')
 self.init(testdir)
 self.assertPathExists(introfile)
@@ -2917,7 +3128,7 @@
 self.assertEqual(res1'build_files_updated', True)
 
 def test_introspect_config_update(self):
- testdir = os.path.join(self.unit_test_dir, '57 introspection')
+ testdir = os.path.join(self.unit_test_dir, '56 introspection')
 introfile = os.path.join(self.builddir, 'meson-info', 'intro-buildoptions.json')
 self.init(testdir)
 self.assertPathExists(introfile)
@@ -2945,7 +3156,7 @@
 self.assertListEqual(res1, res2)
 
 def test_introspect_targets_from_source(self):
- testdir = os.path.join(self.unit_test_dir, '57 introspection')
+ testdir = os.path.join(self.unit_test_dir, '56 introspection')
 testfile = os.path.join(testdir, 'meson.build')
 introfile = os.path.join(self.builddir, 'meson-info', 'intro-targets.json')
 self.init(testdir)
@@ -2977,7 +3188,7 @@
 self.assertListEqual(res_nb, res_wb)
 
 def test_introspect_ast_source(self):
- testdir = os.path.join(self.unit_test_dir, '57 introspection')
+ testdir = os.path.join(self.unit_test_dir, '56 introspection')
 testfile = os.path.join(testdir, 'meson.build')
 res_nb = self.introspect_directory(testfile, '--ast' + self.meson_args)
 
@@ -3055,7 +3266,7 @@
 self.assertEqual(node_countern, c)
 
 def test_introspect_dependencies_from_source(self):
- testdir = os.path.join(self.unit_test_dir, '57 introspection')
+ testdir = os.path.join(self.unit_test_dir, '56 introspection')
 testfile = os.path.join(testdir, 'meson.build')
 res_nb = self.introspect_directory(testfile, '--scan-dependencies' + self.meson_args)
 expected = 
@@ -3106,16 +3317,16 @@
 
 @skip_if_no_cmake
 def test_cmake_prefix_path(self):
- testdir = os.path.join(self.unit_test_dir, '63 cmake_prefix_path')
+ testdir = os.path.join(self.unit_test_dir, '62 cmake_prefix_path')
 self.init(testdir, extra_args='-Dcmake_prefix_path=' + os.path.join(testdir, 'prefix'))
 
 @skip_if_no_cmake
 def test_cmake_parser(self):
- testdir = os.path.join(self.unit_test_dir, '64 cmake parser')
+ testdir = os.path.join(self.unit_test_dir, '63 cmake parser')
 self.init(testdir, extra_args='-Dcmake_prefix_path=' + os.path.join(testdir, 'prefix'))
 
 def test_alias_target(self):
- testdir = os.path.join(self.unit_test_dir, '65 alias target')
+ testdir = os.path.join(self.unit_test_dir, '64 alias target')
 self.init(testdir)
 self.build()
 self.assertPathDoesNotExist(os.path.join(self.builddir, 'prog' + exe_suffix))
@@ -3132,7 +3343,7 @@
 self._run(self.mconf_command + self.builddir)
 
 def test_summary(self):
- testdir = os.path.join(self.unit_test_dir, '72 summary')
+ testdir = os.path.join(self.unit_test_dir, '71 summary')
 out = self.init(testdir, extra_args='-Denabled_opt=enabled')
 expected = textwrap.dedent(r'''
 Some Subproject 2.0
@@ -3159,7 +3370,7 @@
 A number : 1
 yes : YES
 no : NO
- coma list : a, b, c
+ comma list : a, b, c
 
 Stuff
 missing prog : NO
@@ -3167,9 +3378,10 @@
 missing dep : NO
 external dep : YES 1.2.3
 internal dep : YES
+ disabler : NO
 
 Plugins
- long coma list : alpha, alphacolor, apetag, audiofx, audioparsers, auparse,
+ long comma list: alpha, alphacolor, apetag, audiofx, audioparsers, auparse,
 autodetect, avi
 
 Subprojects
@@ -3186,11 +3398,6 @@
 expected_lines = expected.split('\n')1:
 out_start = out.find(expected_lines0)
 out_lines = outout_start:.split('\n'):len(expected_lines)
- if sys.version_info < (3, 7, 0):
- # Dictionary order is not stable in Python <3.7, so sort the lines
- # while comparing
- expected_lines = sorted(expected_lines)
- out_lines = sorted(out_lines)
 for e, o in zip(expected_lines, out_lines):
 if e.startswith(' external dep'):
 self.assertRegex(o, r'^ external dep : (YES 0-9.*|NO)$')
@@ -3278,7 +3485,7 @@
 self.assertPathDoesNotExist(os.path.join(self.builddir, get_exe_name('trivialprog')))
 
 def test_spurious_reconfigure_built_dep_file(self):
- testdir = os.path.join(self.unit_test_dir, '74 dep files')
+ testdir = os.path.join(self.unit_test_dir, '73 dep files')
 
 # Regression test: Spurious reconfigure was happening when build
 # directory is inside source directory.
@@ -3375,9 +3582,21 @@
 ## Validate commands
 
 md_commands = {k for k,v in md_command_sections.items()}
-
 help_output = self._run(self.meson_command + '--help')
- help_commands = {c.strip() for c in re.findall(r'usage:(?:.+)?{((?:a-z+,*)+?)}', help_output, re.MULTILINE|re.DOTALL)0.split(',')}
+ # Python's argument parser might put the command list to its own line. Or it might not.
+ self.assertTrue(help_output.startswith('usage: '))
+ lines = help_output.split('\n')
+ line1 = lines0
+ line2 = lines1
+ if '{' in line1:
+ cmndline = line1
+ else:
+ self.assertIn('{', line2)
+ cmndline = line2
+ cmndstr = cmndline.split('{')1
+ self.assertIn('}', cmndstr)
+ help_commands = set(cmndstr.split('}')0.split(','))
+ self.assertTrue(len(help_commands) > 0, 'Must detect some command names.')
 
 self.assertEqual(md_commands | {'help'}, help_commands, f'Doc file: `{doc_path}`')
 
@@ -3560,7 +3779,7 @@
 def test_wrap_git(self):
 with tempfile.TemporaryDirectory() as tmpdir:
 srcdir = os.path.join(tmpdir, 'src')
- shutil.copytree(os.path.join(self.unit_test_dir, '81 wrap-git'), srcdir)
+ shutil.copytree(os.path.join(self.unit_test_dir, '80 wrap-git'), srcdir)
 upstream = os.path.join(srcdir, 'subprojects', 'wrap_git_upstream')
 upstream_uri = Path(upstream).as_uri()
 git_init(upstream)
@@ -3571,10 +3790,26 @@
 patch_directory = wrap_git_builddef
 revision = master
 '''.format(upstream_uri)))
- self.init(srcdir)
+ out = self.init(srcdir)
 self.build()
 self.run_tests()
 
+ # Make sure the warning does not occur on the first init.
+ out_of_date_warning = 'revision may be out of date'
+ self.assertNotIn(out_of_date_warning, out)
+
+ # Change the wrap's revisions, reconfigure, and make sure it does
+ # warn on the reconfigure.
+ with open(os.path.join(srcdir, 'subprojects', 'wrap_git.wrap'), 'w', encoding='utf-8') as f:
+ f.write(textwrap.dedent('''
+ wrap-git
+ url = {}
+ patch_directory = wrap_git_builddef
+ revision = not-master
+ '''.format(upstream_uri)))
+ out = self.init(srcdir, extra_args='--reconfigure')
+ self.assertIn(out_of_date_warning, out)
+
 def test_extract_objects_custom_target_no_warning(self):
 testdir = os.path.join(self.common_test_dir, '22 object extraction')
 
@@ -3592,7 +3827,7 @@
 @skipUnless(is_linux() and (re.search('^i.86$|^x86$|^x64$|^x86_64$|^amd64$', platform.processor()) is not None),
 'Requires ASM compiler for x86 or x86_64 platform currently only available on Linux CI runners')
 def test_nostdlib(self):
- testdir = os.path.join(self.unit_test_dir, '78 nostdlib')
+ testdir = os.path.join(self.unit_test_dir, '77 nostdlib')
 machinefile = os.path.join(self.builddir, 'machine.txt')
 with open(machinefile, 'w', encoding='utf-8') as f:
 f.write(textwrap.dedent('''
@@ -3613,7 +3848,7 @@
 self.build()
 
 def test_meson_version_compare(self):
- testdir = os.path.join(self.unit_test_dir, '82 meson version compare')
+ testdir = os.path.join(self.unit_test_dir, '81 meson version compare')
 out = self.init(testdir)
 self.assertNotRegex(out, r'WARNING')
 
@@ -3668,7 +3903,7 @@
 # This checks a bug where if a non-meson project is used as a third
 # level (or deeper) subproject it doesn't cause a rebuild if the build
 # files for that project are changed
- testdir = os.path.join(self.unit_test_dir, '85 nested subproject regenerate depends')
+ testdir = os.path.join(self.unit_test_dir, '84 nested subproject regenerate depends')
 cmakefile = Path(testdir) / 'subprojects' / 'sub2' / 'CMakeLists.txt'
 self.init(testdir)
 self.build()
@@ -3686,7 +3921,7 @@
 envs = {'CPPFLAGS': '-DCPPFLAG',
 'CFLAGS': '-DCFLAG',
 'CXXFLAGS': '-DCXXFLAG'}
- srcdir = os.path.join(self.unit_test_dir, '89 multiple envvars')
+ srcdir = os.path.join(self.unit_test_dir, '88 multiple envvars')
 self.init(srcdir, override_envvars=envs)
 self.build()
 
@@ -3696,7 +3931,7 @@
 self.init(srcdir, extra_args='-Dbuild.b_lto=true')
 
 def test_install_skip_subprojects(self):
- testdir = os.path.join(self.unit_test_dir, '92 install skip subprojects')
+ testdir = os.path.join(self.unit_test_dir, '91 install skip subprojects')
 self.init(testdir)
 self.build()
 
@@ -3742,14 +3977,14 @@
 check_installed_files('--skip-subprojects', 'another', all_expected)
 
 def test_adding_subproject_to_configure_project(self) -> None:
- srcdir = os.path.join(self.unit_test_dir, '93 new subproject in configured project')
+ srcdir = os.path.join(self.unit_test_dir, '92 new subproject in configured project')
 self.init(srcdir)
 self.build()
 self.setconf('-Duse-sub=true')
 self.build()
 
 def test_devenv(self):
- testdir = os.path.join(self.unit_test_dir, '91 devenv')
+ testdir = os.path.join(self.unit_test_dir, '90 devenv')
 self.init(testdir)
 self.build()
 
@@ -3765,7 +4000,7 @@
 if not shutil.which('clang-format'):
 raise SkipTest('clang-format not found')
 
- testdir = os.path.join(self.unit_test_dir, '94 clangformat')
+ testdir = os.path.join(self.unit_test_dir, '93 clangformat')
 newdir = os.path.join(self.builddir, 'testdir')
 shutil.copytree(testdir, newdir)
 self.new_builddir()
@@ -3790,7 +4025,7 @@
 self.build('clang-format-check')
 
 def test_custom_target_implicit_include(self):
- testdir = os.path.join(self.unit_test_dir, '95 custominc')
+ testdir = os.path.join(self.unit_test_dir, '94 custominc')
 self.init(testdir)
 self.build()
 compdb = self.get_compdb()
@@ -3830,7 +4065,7 @@
 self.assertEqual(sorted(link_args), sorted('-flto'))
 
 def test_install_tag(self) -> None:
- testdir = os.path.join(self.unit_test_dir, '99 install all targets')
+ testdir = os.path.join(self.unit_test_dir, '98 install all targets')
 self.init(testdir)
 self.build()
 
@@ -3872,6 +4107,11 @@
 Path(installpath, 'usr/lib/libstatic.a'),
 Path(installpath, 'usr/lib/libboth.a'),
 Path(installpath, 'usr/lib/libboth2.a'),
+ Path(installpath, 'usr/include/ct-header1.h'),
+ Path(installpath, 'usr/include/ct-header3.h'),
+ Path(installpath, 'usr/include/subdir-devel'),
+ Path(installpath, 'usr/include/custom_files'),
+ Path(installpath, 'usr/include/custom_files/data.txt'),
 }
 
 if cc.get_id() in {'msvc', 'clang-cl'}:
@@ -3883,10 +4123,14 @@
 Path(installpath, 'usr/bin/both2.pdb'),
 Path(installpath, 'usr/bin/bothcustom.pdb'),
 Path(installpath, 'usr/bin/shared.pdb'),
+ Path(installpath, 'usr/bin/versioned_shared-1.pdb'),
 Path(installpath, 'usr/lib/both.lib'),
 Path(installpath, 'usr/lib/both2.lib'),
 Path(installpath, 'usr/lib/bothcustom.lib'),
 Path(installpath, 'usr/lib/shared.lib'),
+ Path(installpath, 'usr/lib/versioned_shared.lib'),
+ Path(installpath, 'usr/otherbin'),
+ Path(installpath, 'usr/otherbin/app-otherdir.pdb'),
 }
 elif is_windows() or is_cygwin():
 expected_devel |= {
@@ -3894,17 +4138,38 @@
 Path(installpath, 'usr/lib/libboth2.dll.a'),
 Path(installpath, 'usr/lib/libshared.dll.a'),
 Path(installpath, 'usr/lib/libbothcustom.dll.a'),
+ Path(installpath, 'usr/lib/libversioned_shared.dll.a'),
+ }
+ else:
+ expected_devel |= {
+ Path(installpath, 'usr/' + shared_lib_name('versioned_shared')),
 }
 
 expected_runtime = expected_common | {
 Path(installpath, 'usr/bin'),
 Path(installpath, 'usr/bin/' + exe_name('app')),
+ Path(installpath, 'usr/otherbin'),
+ Path(installpath, 'usr/otherbin/' + exe_name('app-otherdir')),
 Path(installpath, 'usr/bin/' + exe_name('app2')),
 Path(installpath, 'usr/' + shared_lib_name('shared')),
 Path(installpath, 'usr/' + shared_lib_name('both')),
 Path(installpath, 'usr/' + shared_lib_name('both2')),
 }
 
+ if is_windows() or is_cygwin():
+ expected_runtime |= {
+ Path(installpath, 'usr/' + shared_lib_name('versioned_shared-1')),
+ }
+ elif is_osx():
+ expected_runtime |= {
+ Path(installpath, 'usr/' + shared_lib_name('versioned_shared.1')),
+ }
+ else:
+ expected_runtime |= {
+ Path(installpath, 'usr/' + shared_lib_name('versioned_shared') + '.1'),
+ Path(installpath, 'usr/' + shared_lib_name('versioned_shared') + '.1.2.3'),
+ }
+
 expected_custom = expected_common | {
 Path(installpath, 'usr/share'),
 Path(installpath, 'usr/share/bar-custom.txt'),
@@ -3952,7 +4217,7 @@
 do_install(None, expected_all, 2)
 
 def test_introspect_install_plan(self):
- testdir = os.path.join(self.unit_test_dir, '99 install all targets')
+ testdir = os.path.join(self.unit_test_dir, '98 install all targets')
 introfile = os.path.join(self.builddir, 'meson-info', 'intro-install_plan.json')
 self.init(testdir)
 self.assertPathExists(introfile)
@@ -3962,9 +4227,14 @@
 env = get_fake_env(testdir, self.builddir, self.prefix)
 
 def output_name(name, type_):
- return type_(name=name, subdir=None, subproject=None,
- for_machine=MachineChoice.HOST, sources=,
- objects=, environment=env, kwargs={}).filename
+ target = type_(name=name, subdir=None, subproject=None,
+ for_machine=MachineChoice.HOST, sources=,
+ structured_sources=None,
+ objects=, environment=env, compilers=env.coredata.compilersMachineChoice.HOST,
+ kwargs={})
+ target.process_compilers()
+ target.process_compilers_late()
+ return target.filename
 
 shared_lib_name = lambda name: output_name(name, SharedLibrary)
 static_lib_name = lambda name: output_name(name, StaticLibrary)
@@ -3973,11 +4243,11 @@
 expected = {
 'targets': {
 f'{self.builddir}/out1-notag.txt': {
- 'destination': '{prefix}/share/out1-notag.txt',
+ 'destination': '{datadir}/out1-notag.txt',
 'tag': None,
 },
 f'{self.builddir}/out2-notag.txt': {
- 'destination': '{prefix}/share/out2-notag.txt',
+ 'destination': '{datadir}/out2-notag.txt',
 'tag': None,
 },
 f'{self.builddir}/libstatic.a': {
@@ -3988,6 +4258,10 @@
 'destination': '{bindir}/' + exe_name('app'),
 'tag': 'runtime',
 },
+ f'{self.builddir}/' + exe_name('app-otherdir'): {
+ 'destination': '{prefix}/otherbin/' + exe_name('app-otherdir'),
+ 'tag': 'runtime',
+ },
 f'{self.builddir}/subdir/' + exe_name('app2'): {
 'destination': '{bindir}/' + exe_name('app2'),
 'tag': 'runtime',
@@ -4021,67 +4295,67 @@
 'tag': 'devel',
 },
 f'{self.builddir}/out1-custom.txt': {
- 'destination': '{prefix}/share/out1-custom.txt',
+ 'destination': '{datadir}/out1-custom.txt',
 'tag': 'custom',
 },
 f'{self.builddir}/out2-custom.txt': {
- 'destination': '{prefix}/share/out2-custom.txt',
+ 'destination': '{datadir}/out2-custom.txt',
 'tag': 'custom',
 },
 f'{self.builddir}/out3-custom.txt': {
- 'destination': '{prefix}/share/out3-custom.txt',
+ 'destination': '{datadir}/out3-custom.txt',
 'tag': 'custom',
 },
 f'{self.builddir}/subdir/out1.txt': {
- 'destination': '{prefix}/share/out1.txt',
+ 'destination': '{datadir}/out1.txt',
 'tag': None,
 },
 f'{self.builddir}/subdir/out2.txt': {
- 'destination': '{prefix}/share/out2.txt',
+ 'destination': '{datadir}/out2.txt',
 'tag': None,
 },
 f'{self.builddir}/out-devel.h': {
- 'destination': '{prefix}/include/out-devel.h',
+ 'destination': '{includedir}/out-devel.h',
 'tag': 'devel',
 },
 f'{self.builddir}/out3-notag.txt': {
- 'destination': '{prefix}/share/out3-notag.txt',
+ 'destination': '{datadir}/out3-notag.txt',
 'tag': None,
 },
 },
 'configure': {
 f'{self.builddir}/foo-notag.h': {
- 'destination': '{prefix}/share/foo-notag.h',
+ 'destination': '{datadir}/foo-notag.h',
 'tag': None,
 },
 f'{self.builddir}/foo2-devel.h': {
- 'destination': '{prefix}/include/foo2-devel.h',
+ 'destination': '{includedir}/foo2-devel.h',
 'tag': 'devel',
 },
 f'{self.builddir}/foo-custom.h': {
- 'destination': '{prefix}/share/foo-custom.h',
+ 'destination': '{datadir}/foo-custom.h',
 'tag': 'custom',
 },
 f'{self.builddir}/subdir/foo2.h': {
- 'destination': '{prefix}/share/foo2.h',
+ 'destination': '{datadir}/foo2.h',
 'tag': None,
 },
 },
 'data': {
 f'{testdir}/bar-notag.txt': {
- 'destination': '{datadir}/share/bar-notag.txt',
+ 'destination': '{datadir}/bar-notag.txt',
 'tag': None,
 },
 f'{testdir}/bar-devel.h': {
- 'destination': '{datadir}/include/bar-devel.h',
+ 'destination': '{includedir}/bar-devel.h',
 'tag': 'devel',
 },
 f'{testdir}/bar-custom.txt': {
- 'destination': '{datadir}/share/bar-custom.txt',
+ 'destination': '{datadir}/bar-custom.txt',
 'tag': 'custom',
 },
 f'{testdir}/subdir/bar2-devel.h': {
- 'destination': '{datadir}/include/bar2-devel.h',
+ 'destination': '{includedir}/bar2-devel.h',
 'tag': 'devel',
 },
 },
@@ -4094,6 +4368,12 @@
 'destination': '{includedir}/foo3-devel.h',
 'tag': 'devel',
 },
+ },
+ 'install_subdirs': {
+ f'{testdir}/custom_files': {
+ 'destination': '{datadir}/custom_files',
+ 'tag': 'custom'
+ }
 }
 }
 
@@ -4125,7 +4405,8 @@
 self.init(testdir, extra_args='--werror', override_envvars={'RUSTC': 'clippy-driver'})
 with self.assertRaises(subprocess.CalledProcessError) as cm:
 self.build()
- self.assertIn('error: use of a blacklisted/placeholder name `foo`', cm.exception.stdout)
+ self.assertTrue('error: use of a blacklisted/placeholder name `foo`' in cm.exception.stdout or
+ 'error: use of a disallowed/placeholder name `foo`' in cm.exception.stdout)
 
 @skip_if_not_language('rust')
 def test_rust_rlib_linkage(self) -> None:
@@ -4139,7 +4420,7 @@
 }}
 ''')
 
- testdir = os.path.join(self.unit_test_dir, '102 rlib linkage')
+ testdir = os.path.join(self.unit_test_dir, '101 rlib linkage')
 gen_file = os.path.join(testdir, 'lib.rs')
 with open(gen_file, 'w') as f:
 f.write(template.format(0))
@@ -4159,7 +4440,7 @@
 self.assertIn('exit status 39', cm.exception.stdout)
 
 def test_custom_target_name(self):
- testdir = os.path.join(self.unit_test_dir, '100 custom target name')
+ testdir = os.path.join(self.unit_test_dir, '99 custom target name')
 self.init(testdir)
 out = self.build()
 if self.backend is Backend.ninja:
@@ -4178,3 +4459,41 @@
 
 self.init(testdir)
 self.build()
+
+ def test_configure_same_noop(self):
+ testdir = os.path.join(self.unit_test_dir, '108 configure same noop')
+ self.init(testdir, extra_args='-Dopt=val')
+
+ filename = os.path.join(self.privatedir, 'coredata.dat')
+ oldmtime = os.path.getmtime(filename)
+ self.setconf("-Dopt=val")
+ newmtime = os.path.getmtime(filename)
+ self.assertEqual(oldmtime, newmtime)
+
+ def test_scripts_loaded_modules(self):
+ '''
+ Simulate a wrapped command, as done for custom_target() that capture
+ output. The script will print all python modules loaded and we verify
+ that it contains only an acceptable subset. Loading too many modules
+ slows down the build when many custom targets get wrapped.
+ '''
+ es = ExecutableSerialisation(python_command + '-c', 'exit(0)', env=EnvironmentVariables())
+ p = Path(self.builddir, 'exe.dat')
+ with p.open('wb') as f:
+ pickle.dump(es, f)
+ cmd = self.meson_command + '--internal', 'test_loaded_modules', '--unpickle', str(p)
+ p = subprocess.run(cmd, stdout=subprocess.PIPE)
+ all_modules = json.loads(p.stdout.splitlines()0)
+ meson_modules = m for m in all_modules if 'meson' in m
+ expected_meson_modules = 
+ 'mesonbuild',
+ 'mesonbuild._pathlib',
+ 'mesonbuild.utils',
+ 'mesonbuild.utils.core',
+ 'mesonbuild.mesonmain',
+ 'mesonbuild.mlog',
+ 'mesonbuild.scripts',
+ 'mesonbuild.scripts.meson_exe',
+ 'mesonbuild.scripts.test_loaded_modules'
+ 
+ self.assertEqual(sorted(expected_meson_modules), sorted(meson_modules))

_service:tar_scm:meson-0.61.5.tar.gz/unittests/baseplatformtests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/baseplatformtests.py Changed

@@ -15,6 +15,7 @@
 from pathlib import PurePath
 from unittest import mock, TestCase, SkipTest
 import json
+import io
 import os
 import re
 import subprocess
@@ -32,7 +33,7 @@
 import mesonbuild.coredata
 import mesonbuild.modules.gnome
 from mesonbuild.mesonlib import (
-    is_cygwin, windows_proof_rmtree, python_command
+    is_cygwin, join_args, windows_proof_rmtree, python_command
 )
 import mesonbuild.modules.pkgconfig
 
@@ -59,7 +60,7 @@
         self.meson_native_files = 
         self.meson_cross_files = 
         self.meson_command = python_command + get_meson_script()
-        self.setup_command = self.meson_command + self.meson_args
+        self.setup_command = self.meson_command + 'setup' + self.meson_args
         self.mconf_command = self.meson_command + 'configure'
         self.mintro_command = self.meson_command + 'introspect'
         self.wrap_command = self.meson_command + 'wrap'
@@ -120,13 +121,17 @@
         newdir = os.path.realpath(newdir)
         self.change_builddir(newdir)
 
-    def _get_meson_log(self) -> T.Optionalstr:
+    def _open_meson_log(self) -> io.TextIOWrapper:
         log = os.path.join(self.logdir, 'meson-log.txt')
-        if not os.path.isfile(log):
-            print(f"{log!r} doesn't exist", file=sys.stderr)
+        return open(log, encoding='utf-8')
+
+    def _get_meson_log(self) -> T.Optionalstr:
+        try:
+            with self._open_meson_log() as f:
+                return f.read()
+        except FileNotFoundError as e:
+            print(f"{e.filename!r} doesn't exist", file=sys.stderr)
             return None
-        with open(log, encoding='utf-8') as f:
-            return f.read()
 
     def _print_meson_log(self) -> None:
         log = self._get_meson_log()
@@ -143,7 +148,7 @@
         os.environ.update(self.orig_env)
         super().tearDown()
 
-    def _run(self, command, *, workdir=None, override_envvars: T.OptionalT.Mappingstr, str = None):
+    def _run(self, command, *, workdir=None, override_envvars: T.OptionalT.Mappingstr, str = None, stderr=True):
         '''
         Run a command while printing the stdout and stderr to stdout,
         and also return a copy of it
@@ -158,10 +163,16 @@
             env.update(override_envvars)
 
         p = subprocess.run(command, stdout=subprocess.PIPE,
-                           stderr=subprocess.STDOUT, env=env,
+                           stderr=subprocess.STDOUT if stderr else subprocess.PIPE,
+                           env=env,
                            encoding='utf-8',
-                           universal_newlines=True, cwd=workdir, timeout=60 * 5)
+                           text=True, cwd=workdir, timeout=60 * 5)
+        print('$', join_args(command))
+        print('stdout:')
         print(p.stdout)
+        if not stderr:
+            print('stderr:')
+            print(p.stderr)
         if p.returncode != 0:
             if 'MESON_SKIP_TEST' in p.stdout:
                 raise SkipTest('Project requested skipping.')
@@ -199,7 +210,7 @@
         self.privatedir = os.path.join(self.builddir, 'meson-private')
         if inprocess:
             try:
-                returncode, out, err = run_configure_inprocess(self.meson_args + args + extra_args, override_envvars)
+                returncode, out, err = run_configure_inprocess('setup' + self.meson_args + args + extra_args, override_envvars)
             except Exception as e:
                 if not allow_fail:
                     self._print_meson_log()
@@ -235,13 +246,13 @@
                 out = self._get_meson_log()  # best we can do here
         return out
 
-    def build(self, target=None, *, extra_args=None, override_envvars=None):
+    def build(self, target=None, *, extra_args=None, override_envvars=None, stderr=True):
         if extra_args is None:
             extra_args = 
         # Add arguments for building the target (if specified),
         # and using the build dir (if required, with VS)
         args = get_builddir_target_args(self.backend, self.builddir, target)
-        return self._run(self.build_command + args + extra_args, workdir=self.builddir, override_envvars=override_envvars)
+        return self._run(self.build_command + args + extra_args, workdir=self.builddir, override_envvars=override_envvars, stderr=stderr)
 
     def clean(self, *, override_envvars=None):
         dir_args = get_builddir_target_args(self.backend, self.builddir, None)
@@ -311,8 +322,12 @@
                     each'command' = compiler + ' ' + f.read()
         return contents
 
+    def get_meson_log_raw(self):
+        with self._open_meson_log() as f:
+            return f.read()
+
     def get_meson_log(self):
-        with open(os.path.join(self.builddir, 'meson-logs', 'meson-log.txt'), encoding='utf-8') as f:
+        with self._open_meson_log() as f:
             return f.readlines()
 
     def get_meson_log_compiler_checks(self):
@@ -320,19 +335,19 @@
         Fetch a list command-lines run by meson for compiler checks.
         Each command-line is returned as a list of arguments.
         '''
-        log = self.get_meson_log()
         prefix = 'Command line:'
-        cmds = llen(prefix):.split() for l in log if l.startswith(prefix)
-        return cmds
+        with self._open_meson_log() as log:
+            cmds = llen(prefix):.split() for l in log if l.startswith(prefix)
+            return cmds
 
     def get_meson_log_sanitychecks(self):
         '''
         Same as above, but for the sanity checks that were run
         '''
-        log = self.get_meson_log()
         prefix = 'Sanity check compiler command line:'
-        cmds = llen(prefix):.split() for l in log if l.startswith(prefix)
-        return cmds
+        with self._open_meson_log() as log:
+            cmds = llen(prefix):.split() for l in log if l.startswith(prefix)
+            return cmds
 
     def introspect(self, args):
         if isinstance(args, str):
@@ -379,7 +394,7 @@
 
     def assertReconfiguredBuildIsNoop(self):
         'Assert that we reconfigured and then there was nothing to do'
-        ret = self.build()
+        ret = self.build(stderr=False)
         self.assertIn('The Meson build system', ret)
         if self.backend is Backend.ninja:
             for line in ret.split('\n'):
@@ -401,7 +416,7 @@
             raise RuntimeError(f'Invalid backend: {self.backend.name!r}')
 
     def assertBuildIsNoop(self):
-        ret = self.build()
+        ret = self.build(stderr=False)
         if self.backend is Backend.ninja:
             self.assertIn(ret.split('\n')-2, self.no_rebuild_stdout)
         elif self.backend is Backend.vs:

_service:tar_scm:meson-0.61.5.tar.gz/unittests/datatests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/datatests.py Changed

@@ -13,12 +13,9 @@
 # limitations under the License.
 
 import re
-import textwrap
 import unittest
-import hashlib
 from itertools import chain
 from pathlib import Path
-import typing as T
 
 import mesonbuild.mlog
 import mesonbuild.depfile
@@ -122,12 +119,18 @@
         found_entries = set()
         sections = re.finditer(r"^## (.+)$", md, re.MULTILINE)
         # Extract the content for this section
+        u_subcontents = 
         content = self._get_section_content("Universal options", sections, md)
         subsections = tee(re.finditer(r"^### (.+)$", content, re.MULTILINE))
-        subcontent1 = self._get_section_content("Directories", subsections0, content)
-        subcontent2 = self._get_section_content("Core options", subsections1, content)
-        subcontent3 = self._get_section_content("Module options", sections, md)
-        for subcontent in (subcontent1, subcontent2, subcontent3):
+        u_subcontents.append(self._get_section_content("Directories", subsections0, content))
+        u_subcontents.append(self._get_section_content("Core options", subsections1, content))
+
+        mod_subcontents = 
+        content = self._get_section_content("Module options", sections, md)
+        subsections = tee(re.finditer(r"^### (.+)$", content, re.MULTILINE))
+        for idx, mod in enumerate('Pkgconfig', 'Python'):
+            mod_subcontents.append(self._get_section_content(f'{mod} module', subsectionsidx, content))
+        for subcontent in u_subcontents + mod_subcontents:
             # Find the option names
             options = set()
             # Match either a table row or a table heading separator: | ------ |
@@ -154,9 +157,9 @@
         # setting of builtin options behaves
         #
         # Find all tables inside this subsection
-        tables = re.finditer(r"^\| (\w+) .* \|\n\| *-|\s+ *\|$", subcontent2, re.MULTILINE)
+        tables = re.finditer(r"^\| (\w+) .* \|\n\| *-|\s+ *\|$", u_subcontents1, re.MULTILINE)
         # Get the table we want using the header of the first column
-        table = self._get_section_content('buildtype', tables, subcontent2)
+        table = self._get_section_content('buildtype', tables, u_subcontents1)
         # Get table row data
         rows = re.finditer(r"^\|(?: (\w+)\s+\| (\w+)\s+\| (\w+) .* | *-+ *)\|", table, re.MULTILINE)
         env = get_fake_env()
@@ -237,36 +240,3 @@
         interp = Interpreter(FakeBuild(env), mock=True)
         astint = AstInterpreter('.', '', '')
         self.assertEqual(set(interp.funcs.keys()), set(astint.funcs.keys()))
-
-    def test_mesondata_is_up_to_date(self):
-        from mesonbuild.mesondata import mesondata
-        err_msg = textwrap.dedent('''
-
-            ###########################################################
-            ###        mesonbuild.mesondata is not up-to-date       ###
-            ###  Please regenerate it by running tools/gen_data.py  ###
-            ###########################################################
-
-        ''')
-
-        root_dir = Path(__file__).parents1
-
-        mesonbuild_dir = root_dir / 'mesonbuild'
-
-        data_dirs = mesonbuild_dir.glob('**/data')
-        data_files =   # type: T.ListT.Tuple(str, str)
-
-        for i in data_dirs:
-            for p in i.iterdir():
-                data_files += (p.relative_to(mesonbuild_dir).as_posix(), hashlib.sha256(p.read_bytes()).hexdigest())
-
-        current_files = set(mesondata.keys())
-        scanned_files = {x0 for x in data_files}
-
-        self.assertSetEqual(current_files, scanned_files, err_msg + 'Data files were added or removed\n')
-        errors = 
-        for i in data_files:
-            if mesondatai0.sha256sum != i1:
-                errors += i0
-
-        self.assertListEqual(errors, , err_msg + 'Files were changed')

_service:tar_scm:meson-0.61.5.tar.gz/unittests/failuretests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/failuretests.py Changed

@@ -314,18 +314,18 @@
     def test_using_too_recent_feature(self):
         # Here we use a dict, which was introduced in 0.47.0
         self.assertMesonOutputs("dict = {}",
-                                ".*WARNING.*Project targeting.*but.*",
+                                ".*WARNING.*Project targets.*but.*",
                                 meson_version='>= 0.46.0')
 
     def test_using_recent_feature(self):
         # Same as above, except the meson version is now appropriate
         self.assertMesonDoesNotOutput("dict = {}",
-                                      ".*WARNING.*Project targeting.*but.*",
+                                      ".*WARNING.*Project targets.*but.*",
                                       meson_version='>= 0.47')
 
     def test_using_too_recent_feature_dependency(self):
         self.assertMesonOutputs("dependency('pcap', required: false)",
-                                ".*WARNING.*Project targeting.*but.*",
+                                ".*WARNING.*Project targets.*but.*",
                                 meson_version='>= 0.41.0')
 
     def test_vcs_tag_featurenew_build_always_stale(self):

_service:tar_scm:meson-0.61.5.tar.gz/unittests/helpers.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/helpers.py Changed

@@ -5,6 +5,7 @@
 import functools
 import re
 import typing as T
+import zipfile
 from pathlib import Path
 from contextlib import contextmanager
 
@@ -171,8 +172,27 @@
     # nix/nixos adds a bunch of stuff to the rpath out of necessity that we
     # don't check for, so clear those
     final = ':'.join(e for e in raw.split(':') if not e.startswith('/nix'))
+    # If we didn't end up anything but nix paths, return None here
+    if not final:
+        return None
     return final
 
+def get_classpath(fname: str) -> T.Optionalstr:
+    with zipfile.ZipFile(fname) as zip:
+        with zip.open('META-INF/MANIFEST.MF') as member:
+            contents = member.read().decode().strip()
+    lines = 
+    for line in contents.splitlines():
+        if line.startswith(' '):
+            # continuation line
+            lines-1 += line1:
+        else:
+            lines.append(line)
+    manifest = {
+        k.lower(): v.strip() for k, v in l.split(':', 1) for l in lines
+    }
+    return manifest.get('class-path')
+
 def get_path_without_cmd(cmd: str, path: str) -> str:
     pathsep = os.pathsep
     paths = OrderedSet(Path(p).resolve() for p in path.split(pathsep))

_service:tar_scm:meson-0.61.5.tar.gz/unittests/internaltests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/internaltests.py Changed

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 from configparser import ConfigParser
-from mesonbuild.mesonlib.universal import OptionType
 from pathlib import Path
 from unittest import mock
 import contextlib
@@ -32,16 +31,19 @@
 import mesonbuild.depfile
 import mesonbuild.dependencies.base
 import mesonbuild.dependencies.factory
-import mesonbuild.compilers
 import mesonbuild.envconfig
 import mesonbuild.environment
 import mesonbuild.modules.gnome
 from mesonbuild import coredata
+from mesonbuild.compilers.c import ClangCCompiler, GnuCCompiler
+from mesonbuild.compilers.cpp import VisualStudioCPPCompiler
+from mesonbuild.compilers.d import DmdDCompiler
 from mesonbuild.interpreterbase import typed_pos_args, InvalidArguments, ObjectHolder
 from mesonbuild.interpreterbase import typed_pos_args, InvalidArguments, typed_kwargs, ContainerTypeInfo, KwargInfo
 from mesonbuild.mesonlib import (
     LibType, MachineChoice, PerMachine, Version, is_windows, is_osx,
     is_cygwin, is_openbsd, search_version, MesonException, OptionKey,
+    OptionType
 )
 from mesonbuild.interpreter.type_checking import in_set_validator, NoneType
 from mesonbuild.dependencies import PkgConfigDependency
@@ -116,7 +118,7 @@
                          stat.S_IRGRP | stat.S_IXGRP)
 
     def test_compiler_args_class_none_flush(self):
-        cc = mesonbuild.compilers.ClangCCompiler(, 'fake', MachineChoice.HOST, False, mock.Mock())
+        cc = ClangCCompiler(, , 'fake', MachineChoice.HOST, False, mock.Mock())
         a = cc.compiler_args('-I.')
         #first we are checking if the tree construction deduplicates the correct -I argument
         a += '-I..'
@@ -133,14 +135,14 @@
         self.assertEqual(a, '-I.', '-I./tests2/', '-I./tests/', '-I..')
 
     def test_compiler_args_class_d(self):
-        d = mesonbuild.compilers.DmdDCompiler(, 'fake', MachineChoice.HOST, 'info', 'arch')
+        d = DmdDCompiler(, 'fake', MachineChoice.HOST, 'info', '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 = mesonbuild.compilers.ClangCCompiler(, 'fake', MachineChoice.HOST, False, mock.Mock())
+        cc = ClangCCompiler(, , 'fake', MachineChoice.HOST, False, mock.Mock())
         # Test that empty initialization works
         a = cc.compiler_args()
         self.assertEqual(a, )
@@ -219,10 +221,32 @@
         l.append_direct('/libbaz.a')
         self.assertEqual(l, '-Lfoodir', '-lfoo', '-Lbardir', '-lbar', '-lbar', '/libbaz.a')
 
+
+    def test_compiler_args_class_visualstudio(self):
+        linker = mesonbuild.linkers.MSVCDynamicLinker(MachineChoice.HOST, )
+        # Version just needs to be > 19.0.0
+        cc = VisualStudioCPPCompiler(, , '20.00', MachineChoice.HOST, False, mock.Mock(), 'x64', linker=linker)
+
+        a = cc.compiler_args(cc.get_always_args())
+        self.assertEqual(a.to_native(copy=True), '/nologo', '/showIncludes', '/utf-8', '/Zc:__cplusplus')
+
+        # Ensure /source-charset: removes /utf-8
+        a.append('/source-charset:utf-8')
+        self.assertEqual(a.to_native(copy=True), '/nologo', '/showIncludes', '/Zc:__cplusplus', '/source-charset:utf-8')
+
+        # Ensure /execution-charset: removes /utf-8
+        a = cc.compiler_args(cc.get_always_args() + '/execution-charset:utf-8')
+        self.assertEqual(a.to_native(copy=True), '/nologo', '/showIncludes', '/Zc:__cplusplus', '/execution-charset:utf-8')
+
+        # Ensure /validate-charset- removes /utf-8
+        a = cc.compiler_args(cc.get_always_args() + '/validate-charset-')
+        self.assertEqual(a.to_native(copy=True), '/nologo', '/showIncludes', '/Zc:__cplusplus', '/validate-charset-')
+
+
     def test_compiler_args_class_gnuld(self):
         ## Test --start/end-group
         linker = mesonbuild.linkers.GnuBFDDynamicLinker(, MachineChoice.HOST, '-Wl,', )
-        gcc = mesonbuild.compilers.GnuCCompiler(, 'fake', False, MachineChoice.HOST, mock.Mock(), linker=linker)
+        gcc = GnuCCompiler(, , 'fake', False, MachineChoice.HOST, mock.Mock(), 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
@@ -250,7 +274,7 @@
     def test_compiler_args_remove_system(self):
         ## Test --start/end-group
         linker = mesonbuild.linkers.GnuBFDDynamicLinker(, MachineChoice.HOST, '-Wl,', )
-        gcc = mesonbuild.compilers.GnuCCompiler(, 'fake', False, MachineChoice.HOST, mock.Mock(), linker=linker)
+        gcc = GnuCCompiler(, , 'fake', False, MachineChoice.HOST, mock.Mock(), 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
@@ -1387,45 +1411,61 @@
                 validator=in_set_validator({'clean', 'build', 'rebuild', 'deprecated', 'since'}),
                 deprecated_values={'deprecated': '1.0'},
                 since_values={'since': '1.1'}),
+            KwargInfo('dict', (ContainerTypeInfo(list, str), ContainerTypeInfo(dict, str)), default={},
+                      since_values={list: '1.9'}),
+            KwargInfo('new_dict', (ContainerTypeInfo(list, str), ContainerTypeInfo(dict, str)), default={},
+                      since_values={dict: '1.1'}),
         )
         def _(obj, node, args: T.Tuple, kwargs: T.Dictstr, str) -> None:
             pass
 
         with self.subTest('deprecated array string value'), mock.patch('sys.stdout', io.StringIO()) as out:
             _(None, mock.Mock(subproject=''), , {'input': 'foo'})
-            self.assertRegex(out.getvalue(), r"""WARNING:.Project targeting '1.0'.*deprecated since '0.9': "testfunc" keyword argument "input" value "foo".*""")
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*deprecated since '0.9': "testfunc" keyword argument "input" value "foo".*""")
 
         with self.subTest('new array string value'), mock.patch('sys.stdout', io.StringIO()) as out:
             _(None, mock.Mock(subproject=''), , {'input': 'bar'})
-            self.assertRegex(out.getvalue(), r"""WARNING:.Project targeting '1.0'.*introduced in '1.1': "testfunc" keyword argument "input" value "bar".*""")
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*introduced in '1.1': "testfunc" keyword argument "input" value "bar".*""")
 
         with self.subTest('deprecated dict string value'), mock.patch('sys.stdout', io.StringIO()) as out:
             _(None, mock.Mock(subproject=''), , {'output': {'foo': 'a'}})
-            self.assertRegex(out.getvalue(), r"""WARNING:.Project targeting '1.0'.*deprecated since '0.9': "testfunc" keyword argument "output" value "foo".*""")
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*deprecated since '0.9': "testfunc" keyword argument "output" value "foo".*""")
 
         with self.subTest('deprecated dict string value with msg'), mock.patch('sys.stdout', io.StringIO()) as out:
             _(None, mock.Mock(subproject=''), , {'output': {'foo2': 'a'}})
-            self.assertRegex(out.getvalue(), r"""WARNING:.Project targeting '1.0'.*deprecated since '0.9': "testfunc" keyword argument "output" value "foo2". dont use it.*""")
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*deprecated since '0.9': "testfunc" keyword argument "output" value "foo2". dont use it.*""")
 
         with self.subTest('new dict string value'), mock.patch('sys.stdout', io.StringIO()) as out:
             _(None, mock.Mock(subproject=''), , {'output': {'bar': 'b'}})
-            self.assertRegex(out.getvalue(), r"""WARNING:.Project targeting '1.0'.*introduced in '1.1': "testfunc" keyword argument "output" value "bar".*""")
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*introduced in '1.1': "testfunc" keyword argument "output" value "bar".*""")
 
         with self.subTest('new dict string value with msg'), mock.patch('sys.stdout', io.StringIO()) as out:
             _(None, mock.Mock(subproject=''), , {'output': {'bar2': 'a'}})
-            self.assertRegex(out.getvalue(), r"""WARNING:.Project targeting '1.0'.*introduced in '1.1': "testfunc" keyword argument "output" value "bar2". use this.*""")
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*introduced in '1.1': "testfunc" keyword argument "output" value "bar2". use this.*""")
 
         with self.subTest('non string union'), mock.patch('sys.stdout', io.StringIO()) as out:
             _(None, mock.Mock(subproject=''), , {'install_dir': False})
-            self.assertRegex(out.getvalue(), r"""WARNING:.Project targeting '1.0'.*deprecated since '0.9': "testfunc" keyword argument "install_dir" value "False".*""")
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*deprecated since '0.9': "testfunc" keyword argument "install_dir" value "False".*""")
 
         with self.subTest('deprecated string union'), mock.patch('sys.stdout', io.StringIO()) as out:
             _(None, mock.Mock(subproject=''), , {'mode': 'deprecated'})
-            self.assertRegex(out.getvalue(), r"""WARNING:.Project targeting '1.0'.*deprecated since '1.0': "testfunc" keyword argument "mode" value "deprecated".*""")
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*deprecated since '1.0': "testfunc" keyword argument "mode" value "deprecated".*""")
 
         with self.subTest('new string union'), mock.patch('sys.stdout', io.StringIO()) as out:
             _(None, mock.Mock(subproject=''), , {'mode': 'since'})
-            self.assertRegex(out.getvalue(), r"""WARNING:.Project targeting '1.0'.*introduced in '1.1': "testfunc" keyword argument "mode" value "since".*""")
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*introduced in '1.1': "testfunc" keyword argument "mode" value "since".*""")
+
+        with self.subTest('new container'), mock.patch('sys.stdout', io.StringIO()) as out:
+            _(None, mock.Mock(subproject=''), , {'dict': 'a=b'})
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*introduced in '1.9': "testfunc" keyword argument "dict" of type list.*""")
+
+        with self.subTest('new container set to default'), mock.patch('sys.stdout', io.StringIO()) as out:
+            _(None, mock.Mock(subproject=''), , {'new_dict': {}})
+            self.assertRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*introduced in '1.1': "testfunc" keyword argument "new_dict" of type dict.*""")
+
+        with self.subTest('new container default'), mock.patch('sys.stdout', io.StringIO()) as out:
+            _(None, mock.Mock(subproject=''), , {})
+            self.assertNotRegex(out.getvalue(), r"""WARNING:.Project targets '1.0'.*introduced in '1.1': "testfunc" keyword argument "new_dict" of type dict.*""")
 
     def test_typed_kwarg_evolve(self) -> None:
         k = KwargInfo('foo', str, required=True, default='foo')

_service:tar_scm:meson-0.61.5.tar.gz/unittests/linuxcrosstests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/linuxcrosstests.py Changed

@@ -86,7 +86,7 @@
     def test_cross_libdir_subproject(self):
         # Guard against a regression where calling "subproject"
         # would reset the value of libdir to its default value.
-        testdir = os.path.join(self.unit_test_dir, '76 subdir libdir')
+        testdir = os.path.join(self.unit_test_dir, '75 subdir libdir')
         self.init(testdir, extra_args='--libdir=fuf')
         for i in self.introspect('--buildoptions'):
             if i'name' == 'libdir':
@@ -96,7 +96,7 @@
 
     def test_std_remains(self):
         # C_std defined in project options must be in effect also when cross compiling.
-        testdir = os.path.join(self.unit_test_dir, '51 noncross options')
+        testdir = os.path.join(self.unit_test_dir, '50 noncross options')
         self.init(testdir)
         compdb = self.get_compdb()
         self.assertRegex(compdb0'command', '-std=c99')
@@ -106,7 +106,7 @@
     def test_pkg_config_option(self):
         if not shutil.which('arm-linux-gnueabihf-pkg-config'):
             raise unittest.SkipTest('Cross-pkgconfig not found.')
-        testdir = os.path.join(self.unit_test_dir, '58 pkg_config_path option')
+        testdir = os.path.join(self.unit_test_dir, '57 pkg_config_path option')
         self.init(testdir, extra_args=
             '-Dbuild.pkg_config_path=' + os.path.join(testdir, 'build_extra_path'),
             '-Dpkg_config_path=' + os.path.join(testdir, 'host_extra_path'),
@@ -117,7 +117,7 @@
         https://github.com/mesonbuild/meson/issues/7997
         check run native test in crossbuild without exe wrapper
         '''
-        testdir = os.path.join(self.unit_test_dir, '88 run native test')
+        testdir = os.path.join(self.unit_test_dir, '87 run native test')
         stamp_file = os.path.join(self.builddir, 'native_test_has_run.stamp')
         self.init(testdir)
         self.build()
@@ -185,7 +185,7 @@
 
     @skipIfNoPkgconfig
     def test_cross_pkg_config_option(self):
-        testdir = os.path.join(self.unit_test_dir, '58 pkg_config_path option')
+        testdir = os.path.join(self.unit_test_dir, '57 pkg_config_path option')
         self.init(testdir, extra_args=
             '-Dbuild.pkg_config_path=' + os.path.join(testdir, 'build_extra_path'),
             '-Dpkg_config_path=' + os.path.join(testdir, 'host_extra_path'),

_service:tar_scm:meson-0.61.5.tar.gz/unittests/linuxliketests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/linuxliketests.py Changed

@@ -1,4 +1,4 @@
-# Copyright 2016-2021 The Meson development team
+# Copyright 2016-2022 The Meson development team
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -40,12 +40,16 @@
 )
 from mesonbuild.compilers import (
     detect_c_compiler, detect_cpp_compiler, compiler_from_language,
-    AppleClangCCompiler, AppleClangCPPCompiler, AppleClangObjCCompiler,
-    AppleClangObjCPPCompiler
 )
+from mesonbuild.compilers.c import AppleClangCCompiler
+from mesonbuild.compilers.cpp import AppleClangCPPCompiler
+from mesonbuild.compilers.objc import AppleClangObjCCompiler
+from mesonbuild.compilers.objcpp import AppleClangObjCPPCompiler
 from mesonbuild.dependencies import PkgConfigDependency
 import mesonbuild.modules.pkgconfig
 
+PKG_CONFIG = os.environ.get('PKG_CONFIG', 'pkg-config')
+
 
 from run_tests import (
     get_fake_env
@@ -54,6 +58,18 @@
 from .baseplatformtests import BasePlatformTests
 from .helpers import *
 
+def _prepend_pkg_config_path(path: str) -> str:
+    """Prepend a string value to pkg_config_path
+
+    :param path: The path to prepend
+    :return: The path, followed by any PKG_CONFIG_PATH already in the environment
+    """
+    pkgconf = os.environ.get('PKG_CONFIG_PATH')
+    if pkgconf:
+        return f'{path}{os.path.pathsep}{pkgconf}'
+    return path
+
+
 def _clang_at_least(compiler: 'Compiler', minver: str, apple_minver: T.Optionalstr) -> bool:
     """
     check that Clang compiler is at least a specified version, whether AppleClang or regular Clang
@@ -148,25 +164,25 @@
         self.assertTrue(foo_dep.found())
         self.assertEqual(foo_dep.get_version(), '1.0')
         self.assertIn('-lfoo', foo_dep.get_link_args())
-        self.assertEqual(foo_dep.get_pkgconfig_variable('foo', {}), 'bar')
-        self.assertPathEqual(foo_dep.get_pkgconfig_variable('datadir', {}), '/usr/data')
+        self.assertEqual(foo_dep.get_pkgconfig_variable('foo', , None), 'bar')
+        self.assertPathEqual(foo_dep.get_pkgconfig_variable('datadir', , None), '/usr/data')
 
         libhello_nolib = PkgConfigDependency('libhello_nolib', env, kwargs)
         self.assertTrue(libhello_nolib.found())
         self.assertEqual(libhello_nolib.get_link_args(), )
         self.assertEqual(libhello_nolib.get_compile_args(), )
-        self.assertEqual(libhello_nolib.get_pkgconfig_variable('foo', {}), 'bar')
-        self.assertEqual(libhello_nolib.get_pkgconfig_variable('prefix', {}), self.prefix)
-        if version_compare(libhello_nolib.check_pkgconfig(libhello_nolib.pkgbin),">=0.29.1"):
-            self.assertEqual(libhello_nolib.get_pkgconfig_variable('escaped_var', {}), r'hello\ world')
-        self.assertEqual(libhello_nolib.get_pkgconfig_variable('unescaped_var', {}), 'hello world')
+        self.assertEqual(libhello_nolib.get_pkgconfig_variable('foo', , None), 'bar')
+        self.assertEqual(libhello_nolib.get_pkgconfig_variable('prefix', , None), self.prefix)
+        if version_compare(PkgConfigDependency.check_pkgconfig(env, libhello_nolib.pkgbin),">=0.29.1"):
+            self.assertEqual(libhello_nolib.get_pkgconfig_variable('escaped_var', , None), r'hello\ world')
+        self.assertEqual(libhello_nolib.get_pkgconfig_variable('unescaped_var', , None), 'hello world')
 
         cc = detect_c_compiler(env, MachineChoice.HOST)
         if cc.get_id() in {'gcc', 'clang'}:
             for name in {'ct', 'ct0'}:
                 ct_dep = PkgConfigDependency(name, env, kwargs)
                 self.assertTrue(ct_dep.found())
-                self.assertIn('-lct', ct_dep.get_link_args())
+                self.assertIn('-lct', ct_dep.get_link_args(raw=True))
 
     def test_pkgconfig_gen_deps(self):
         '''
@@ -185,7 +201,7 @@
             'PKG_CONFIG_LIBDIR': os.pathsep.join(privatedir1, privatedir2),
             'PKG_CONFIG_SYSTEM_LIBRARY_PATH': '/usr/lib',
         }
-        self._run('pkg-config', 'dependency-test', '--validate', override_envvars=env)
+        self._run(PKG_CONFIG, 'dependency-test', '--validate', override_envvars=env)
 
         # pkg-config strips some duplicated flags so we have to parse the
         # generated file ourself.
@@ -210,21 +226,21 @@
                     matched_lines += 1
             self.assertEqual(len(expected), matched_lines)
 
-        cmd = 'pkg-config', 'requires-test'
+        cmd = PKG_CONFIG, 'requires-test'
         out = self._run(cmd + '--print-requires', override_envvars=env).strip().split('\n')
         if not is_openbsd():
             self.assertEqual(sorted(out), sorted('libexposed', 'libfoo >= 1.0', 'libhello'))
         else:
             self.assertEqual(sorted(out), sorted('libexposed', 'libfoo>=1.0', 'libhello'))
 
-        cmd = 'pkg-config', 'requires-private-test'
+        cmd = PKG_CONFIG, 'requires-private-test'
         out = self._run(cmd + '--print-requires-private', override_envvars=env).strip().split('\n')
         if not is_openbsd():
             self.assertEqual(sorted(out), sorted('libexposed', 'libfoo >= 1.0', 'libhello'))
         else:
             self.assertEqual(sorted(out), sorted('libexposed', 'libfoo>=1.0', 'libhello'))
 
-        cmd = 'pkg-config', 'pub-lib-order'
+        cmd = PKG_CONFIG, 'pub-lib-order'
         out = self._run(cmd + '--libs', override_envvars=env).strip().split()
         self.assertEqual(out, '-llibmain2', '-llibinternal')
 
@@ -324,17 +340,17 @@
         Test that qt4 and qt5 detection with pkgconfig works.
         '''
         # Verify Qt4 or Qt5 can be found with pkg-config
-        qt4 = subprocess.call('pkg-config', '--exists', 'QtCore')
-        qt5 = subprocess.call('pkg-config', '--exists', 'Qt5Core')
+        qt4 = subprocess.call(PKG_CONFIG, '--exists', 'QtCore')
+        qt5 = subprocess.call(PKG_CONFIG, '--exists', 'Qt5Core')
         testdir = os.path.join(self.framework_test_dir, '4 qt')
         self.init(testdir, extra_args='-Dmethod=pkg-config')
         # Confirm that the dependency was found with pkg-config
-        mesonlog = self.get_meson_log()
+        mesonlog = self.get_meson_log_raw()
         if qt4 == 0:
-            self.assertRegex('\n'.join(mesonlog),
+            self.assertRegex(mesonlog,
                              r'Run-time dependency qt4 $modules: Core$ found: YES 4.* $pkg-config$')
         if qt5 == 0:
-            self.assertRegex('\n'.join(mesonlog),
+            self.assertRegex(mesonlog,
                              r'Run-time dependency qt5 $modules: Core$ found: YES 5.* $pkg-config$')
 
     @skip_if_not_base_option('b_sanitize')
@@ -364,8 +380,8 @@
         testdir = os.path.join(self.framework_test_dir, '4 qt')
         self.init(testdir, extra_args='-Dmethod=qmake')
         # Confirm that the dependency was found with qmake
-        mesonlog = self.get_meson_log()
-        self.assertRegex('\n'.join(mesonlog),
+        mesonlog = self.get_meson_log_raw()
+        self.assertRegex(mesonlog,
                          r'Run-time dependency qt5 $modules: Core$ found: YES .* $qmake$\n')
 
     def test_qt6dependency_qmake_detection(self):
@@ -384,8 +400,8 @@
         testdir = os.path.join(self.framework_test_dir, '4 qt')
         self.init(testdir, extra_args='-Dmethod=qmake')
         # Confirm that the dependency was found with qmake
-        mesonlog = self.get_meson_log()
-        self.assertRegex('\n'.join(mesonlog),
+        mesonlog = self.get_meson_log_raw()
+        self.assertRegex(mesonlog,
                          r'Run-time dependency qt6 $modules: Core$ found: YES .* $qmake$\n')
 
     def glob_sofiles_without_privdir(self, g):
@@ -601,7 +617,7 @@
 
         f = os.path.join(self.installdir, 'etc', 'etcfile.dat')
         found_mode = stat.filemode(os.stat(f).st_mode)
-        want_mode = 'rw------T'
+        want_mode = 'rw-------'
         self.assertEqual(want_mode, found_mode1:)
 
         f = os.path.join(self.installdir, 'usr', 'bin', 'runscript.sh')
@@ -636,7 +652,7 @@
         f = os.path.join(self.installdir, 'usr', 'share', 'sub1', 'second.dat')
         statf = os.stat(f)
         found_mode = stat.filemode(statf.st_mode)
-        want_mode = 'rwxr-x--t'
+        want_mode = 'rwxr-x--x'
         self.assertEqual(want_mode, found_mode1:)
         if os.getuid() == 0:
             # The chown failed nonfatally if we're not root
@@ -659,15 +675,15 @@
                 ('bin/trivialprog', '-rwxr-sr-x'),
                 ('include', 'drwxr-x---'),
                 ('include/config.h', '-rw-rwSr--'),
-                ('include/rootdir.h', '-r--r--r-T'),
+                ('include/rootdir.h', '-r--r--r--'),
                 ('lib', 'drwxr-x---'),
                 ('lib/libstat.a', '-rw---Sr--'),
                 ('share', 'drwxr-x---'),
                 ('share/man', 'drwxr-x---'),
                 ('share/man/man1', 'drwxr-x---'),
-                ('share/man/man1/foo.1', '-r--r--r-T'),
+                ('share/man/man1/foo.1', '-r--r--r--'),
                 ('share/sub1', 'drwxr-x---'),
-                ('share/sub1/second.dat', '-rwxr-x--t'),
+                ('share/sub1/second.dat', '-rwxr-x--x'),
                 ('subdir', 'drwxr-x---'),
                 ('subdir/data.dat', '-rw-rwSr--'),
         :
@@ -850,7 +866,7 @@
                 gobject_found = True
         self.assertTrue(glib_found)
         self.assertTrue(gobject_found)
-        if subprocess.call('pkg-config', '--exists', 'glib-2.0 >= 2.56.2') != 0:
+        if subprocess.call(PKG_CONFIG, '--exists', 'glib-2.0 >= 2.56.2') != 0:
             raise SkipTest('glib >= 2.56.2 needed for the rest')
         targets = self.introspect('--targets')
         docbook_target = None
@@ -931,7 +947,7 @@
         '''
         if is_cygwin():
             raise SkipTest('Windows PE/COFF binaries do not use RPATH')
-        testdir = os.path.join(self.unit_test_dir, '90 pkgconfig build rpath order')
+        testdir = os.path.join(self.unit_test_dir, '89 pkgconfig build rpath order')
         self.init(testdir, override_envvars={'PKG_CONFIG_PATH': testdir})
         self.build()
         build_rpath = get_rpath(os.path.join(self.builddir, 'prog'))
@@ -950,7 +966,7 @@
         if is_osx():
             raise SkipTest('Global RPATHs via LDFLAGS not yet supported on MacOS (does anybody need it?)')
 
-        testdir = os.path.join(self.unit_test_dir, '80 global-rpath')
+        testdir = os.path.join(self.unit_test_dir, '79 global-rpath')
         oldinstalldir = self.installdir
 
         # Build and install an external library without DESTDIR.
@@ -1066,21 +1082,18 @@
         also tested.
         '''
         testdir = os.path.join(self.framework_test_dir, '7 gnome')
-        mesonbuild.modules.gnome.native_glib_version = '2.20'
-        env = {'MESON_UNIT_TEST_PRETEND_GLIB_OLD': "1"}
-        try:
+        with mock.patch('mesonbuild.modules.gnome.GnomeModule._get_native_glib_version', mock.Mock(return_value='2.20')):
+            env = {'MESON_UNIT_TEST_PRETEND_GLIB_OLD': "1"}
             self.init(testdir,
                       inprocess=True,
                       override_envvars=env)
             self.build(override_envvars=env)
-        finally:
-            mesonbuild.modules.gnome.native_glib_version = None
 
     @skipIfNoPkgconfig
     def test_pkgconfig_usage(self):
         testdir1 = os.path.join(self.unit_test_dir, '27 pkgconfig usage/dependency')
         testdir2 = os.path.join(self.unit_test_dir, '27 pkgconfig usage/dependee')
-        if subprocess.call('pkg-config', '--cflags', 'glib-2.0',
+        if subprocess.call(PKG_CONFIG, '--cflags', 'glib-2.0',
                            stdout=subprocess.DEVNULL,
                            stderr=subprocess.DEVNULL) != 0:
             raise SkipTest('Glib 2.0 dependency not available.')
@@ -1095,10 +1108,10 @@
             myenv = os.environ.copy()
             myenv'PKG_CONFIG_PATH' = pkg_dir
             # Private internal libraries must not leak out.
-            pkg_out = subprocess.check_output('pkg-config', '--static', '--libs', 'libpkgdep', env=myenv)
+            pkg_out = subprocess.check_output(PKG_CONFIG, '--static', '--libs', 'libpkgdep', env=myenv)
             self.assertNotIn(b'libpkgdep-int', pkg_out, 'Internal library leaked out.')
             # Dependencies must not leak to cflags when building only a shared library.
-            pkg_out = subprocess.check_output('pkg-config', '--cflags', 'libpkgdep', env=myenv)
+            pkg_out = subprocess.check_output(PKG_CONFIG, '--cflags', 'libpkgdep', env=myenv)
             self.assertNotIn(b'glib', pkg_out, 'Internal dependency leaked to headers.')
             # Test that the result is usable.
             self.init(testdir2, override_envvars=myenv)
@@ -1115,7 +1128,7 @@
 
     @skipIfNoPkgconfig
     def test_pkgconfig_relative_paths(self):
-        testdir = os.path.join(self.unit_test_dir, '62 pkgconfig relative paths')
+        testdir = os.path.join(self.unit_test_dir, '61 pkgconfig relative paths')
         pkg_dir = os.path.join(testdir, 'pkgconfig')
         self.assertPathExists(os.path.join(pkg_dir, 'librelativepath.pc'))
 
@@ -1138,9 +1151,12 @@
         env = get_fake_env(testdir, self.builddir, self.prefix)
         env.coredata.set_options({OptionKey('pkg_config_path'): pkg_dir}, subproject='')
 
-        PkgConfigDependency.setup_env({}, env, MachineChoice.HOST, pkg_dir)
+        # Regression test: This used to modify the value of `pkg_config_path`
+        # option, adding the meson-uninstalled directory to it.
+        PkgConfigDependency.setup_env({}, env, MachineChoice.HOST, uninstalled=True)
+
         pkg_config_path = env.coredata.optionsOptionKey('pkg_config_path').value
-        self.assertEqual(len(pkg_config_path), 1)
+        self.assertEqual(pkg_config_path, pkg_dir)
 
     @skipIfNoPkgconfig
     def test_pkgconfig_internal_libraries(self):
@@ -1169,7 +1185,7 @@
         Check that Meson produces valid static archives with --strip enabled
         '''
         with tempfile.TemporaryDirectory() as tempdirname:
-            testdirbase = os.path.join(self.unit_test_dir, '66 static archive stripping')
+            testdirbase = os.path.join(self.unit_test_dir, '65 static archive stripping')
 
             # build lib
             self.new_builddir()
@@ -1195,8 +1211,8 @@
         testdir = os.path.join(self.unit_test_dir, '38 pkgconfig format')
         self.init(testdir)
         myenv = os.environ.copy()
-        myenv'PKG_CONFIG_PATH' = self.privatedir
-        stdo = subprocess.check_output('pkg-config', '--libs-only-l', 'libsomething', env=myenv)
+        myenv'PKG_CONFIG_PATH' = _prepend_pkg_config_path(self.privatedir)
+        stdo = subprocess.check_output(PKG_CONFIG, '--libs-only-l', 'libsomething', env=myenv)
         deps = b'-lgobject-2.0', b'-lgio-2.0', b'-lglib-2.0', b'-lsomething'
         if is_windows() or is_cygwin() or is_osx() or is_openbsd():
             # On Windows, libintl is a separate library
@@ -1206,11 +1222,11 @@
     @skipIfNoPkgconfig
     @skip_if_not_language('cs')
     def test_pkgconfig_csharp_library(self):
-        testdir = os.path.join(self.unit_test_dir, '50 pkgconfig csharp library')
+        testdir = os.path.join(self.unit_test_dir, '49 pkgconfig csharp library')
         self.init(testdir)
         myenv = os.environ.copy()
-        myenv'PKG_CONFIG_PATH' = self.privatedir
-        stdo = subprocess.check_output('pkg-config', '--libs', 'libsomething', env=myenv)
+        myenv'PKG_CONFIG_PATH' = _prepend_pkg_config_path(self.privatedir)
+        stdo = subprocess.check_output(PKG_CONFIG, '--libs', 'libsomething', env=myenv)
 
         self.assertEqual("-r/usr/lib/libsomething.dll", str(stdo.decode('ascii')).strip())
 
@@ -1219,11 +1235,11 @@
         '''
         Test that libraries are listed before their dependencies.
         '''
-        testdir = os.path.join(self.unit_test_dir, '53 pkgconfig static link order')
+        testdir = os.path.join(self.unit_test_dir, '52 pkgconfig static link order')
         self.init(testdir)
         myenv = os.environ.copy()
-        myenv'PKG_CONFIG_PATH' = self.privatedir
-        stdo = subprocess.check_output('pkg-config', '--libs', 'libsomething', env=myenv)
+        myenv'PKG_CONFIG_PATH' = _prepend_pkg_config_path(self.privatedir)
+        stdo = subprocess.check_output(PKG_CONFIG, '--libs', 'libsomething', env=myenv)
         deps = stdo.split()
         self.assertLess(deps.index(b'-lsomething'), deps.index(b'-ldependency'))
 
@@ -1231,7 +1247,7 @@
         '''
         Test that the dependencies are always listed in a deterministic order.
         '''
-        testdir = os.path.join(self.unit_test_dir, '43 dep order')
+        testdir = os.path.join(self.unit_test_dir, '42 dep order')
         self.init(testdir)
         with open(os.path.join(self.builddir, 'build.ninja'), encoding='utf-8') as bfile:
             for line in bfile:
@@ -1246,7 +1262,7 @@
         '''
         if is_cygwin():
             raise SkipTest('rpath are not used on Cygwin')
-        testdir = os.path.join(self.unit_test_dir, '42 rpath order')
+        testdir = os.path.join(self.unit_test_dir, '41 rpath order')
         self.init(testdir)
         if is_osx():
             rpathre = re.compile(r'-rpath,.*/subprojects/sub1.*-rpath,.*/subprojects/sub2')
@@ -1282,7 +1298,7 @@
         '''
         oldprefix = self.prefix
         # Install external library so we can find it
-        testdir = os.path.join(self.unit_test_dir, '40 external, internal library rpath', 'external library')
+        testdir = os.path.join(self.unit_test_dir, '39 external, internal library rpath', 'external library')
         # install into installdir without using DESTDIR
         installdir = self.installdir
         self.prefix = installdir
@@ -1293,8 +1309,8 @@
         ## New builddir for the consumer
         self.new_builddir()
         env = {'LIBRARY_PATH': os.path.join(installdir, self.libdir),
-               'PKG_CONFIG_PATH': os.path.join(installdir, self.libdir, 'pkgconfig')}
-        testdir = os.path.join(self.unit_test_dir, '40 external, internal library rpath', 'built library')
+               'PKG_CONFIG_PATH': _prepend_pkg_config_path(os.path.join(installdir, self.libdir, 'pkgconfig'))}
+        testdir = os.path.join(self.unit_test_dir, '39 external, internal library rpath', 'built library')
         # install into installdir without using DESTDIR
         self.prefix = self.installdir
         self.init(testdir, override_envvars=env)
@@ -1334,7 +1350,7 @@
         see: https://github.com/mesonbuild/meson/issues/9000
              https://stackoverflow.com/questions/48532868/gcc-library-option-with-a-colon-llibevent-a
         '''
-        testdir = os.path.join(self.unit_test_dir, '98 link full name','libtestprovider')
+        testdir = os.path.join(self.unit_test_dir, '97 link full name','libtestprovider')
         oldprefix = self.prefix
         # install into installdir without using DESTDIR
         installdir = self.installdir
@@ -1346,8 +1362,8 @@
 
         self.new_builddir()
         env = {'LIBRARY_PATH': os.path.join(installdir, self.libdir),
-               'PKG_CONFIG_PATH': os.path.join(installdir, self.libdir, 'pkgconfig')}
-        testdir = os.path.join(self.unit_test_dir, '98 link full name','proguser')
+               'PKG_CONFIG_PATH': _prepend_pkg_config_path(os.path.join(installdir, self.libdir, 'pkgconfig'))}
+        testdir = os.path.join(self.unit_test_dir, '97 link full name','proguser')
         self.init(testdir,override_envvars=env)
 
         # test for link with full path
@@ -1365,7 +1381,7 @@
         # skip test if pkg-config is too old.
         #   before v0.28, Libs flags like -Wl will not kept in context order with -l flags.
         #   see https://gitlab.freedesktop.org/pkg-config/pkg-config/-/blob/master/NEWS
-        pkgconfigver = subprocess.check_output('pkg-config', '--version')
+        pkgconfigver = subprocess.check_output(PKG_CONFIG, '--version')
         if b'0.28' > pkgconfigver:
             raise SkipTest('pkg-config is too old to be correctly done this.')
         self.run_tests()
@@ -1380,7 +1396,7 @@
         oldinstalldir = self.installdir
 
         # Build and install both external libraries without DESTDIR
-        val1dir = os.path.join(self.unit_test_dir, '75 pkgconfig prefixes', 'val1')
+        val1dir = os.path.join(self.unit_test_dir, '74 pkgconfig prefixes', 'val1')
         val1prefix = os.path.join(oldinstalldir, 'val1')
         self.prefix = val1prefix
         self.installdir = val1prefix
@@ -1391,7 +1407,7 @@
 
         env1 = {}
         env1'PKG_CONFIG_PATH' = os.path.join(val1prefix, self.libdir, 'pkgconfig')
-        val2dir = os.path.join(self.unit_test_dir, '75 pkgconfig prefixes', 'val2')
+        val2dir = os.path.join(self.unit_test_dir, '74 pkgconfig prefixes', 'val2')
         val2prefix = os.path.join(oldinstalldir, 'val2')
         self.prefix = val2prefix
         self.installdir = val2prefix
@@ -1403,7 +1419,7 @@
         # Build, install, and run the client program
         env2 = {}
         env2'PKG_CONFIG_PATH' = os.path.join(val2prefix, self.libdir, 'pkgconfig')
-        testdir = os.path.join(self.unit_test_dir, '75 pkgconfig prefixes', 'client')
+        testdir = os.path.join(self.unit_test_dir, '74 pkgconfig prefixes', 'client')
         testprefix = os.path.join(oldinstalldir, 'client')
         self.prefix = testprefix
         self.installdir = testprefix
@@ -1457,7 +1473,7 @@
 
     @skipIfNoPkgconfigDep('gmodule-2.0')
     def test_ldflag_dedup(self):
-        testdir = os.path.join(self.unit_test_dir, '52 ldflagdedup')
+        testdir = os.path.join(self.unit_test_dir, '51 ldflagdedup')
         if is_cygwin() or is_osx():
             raise SkipTest('Not applicable on Cygwin or OSX.')
         env = get_fake_env()
@@ -1475,7 +1491,7 @@
         self.assertEqual(max_count, 1, 'Export dynamic incorrectly deduplicated.')
 
     def test_compiler_libs_static_dedup(self):
-        testdir = os.path.join(self.unit_test_dir, '56 dedup compiler libs')
+        testdir = os.path.join(self.unit_test_dir, '55 dedup compiler libs')
         self.init(testdir)
         build_ninja = os.path.join(self.builddir, 'build.ninja')
         with open(build_ninja, encoding='utf-8') as f:
@@ -1490,7 +1506,7 @@
     @skipIfNoPkgconfig
     def test_noncross_options(self):
         # C_std defined in project options must be in effect also when native compiling.
-        testdir = os.path.join(self.unit_test_dir, '51 noncross options')
+        testdir = os.path.join(self.unit_test_dir, '50 noncross options')
         self.init(testdir, extra_args='-Dpkg_config_path=' + testdir)
         compdb = self.get_compdb()
         self.assertEqual(len(compdb), 2)
@@ -1499,7 +1515,7 @@
         self.build()
 
     def test_identity_cross(self):
-        testdir = os.path.join(self.unit_test_dir, '61 identity cross')
+        testdir = os.path.join(self.unit_test_dir, '60 identity cross')
 
         constantsfile = tempfile.NamedTemporaryFile(mode='w')
         constantsfile.write(textwrap.dedent('''\
@@ -1528,15 +1544,13 @@
         self.init(testdir)
 
     def test_identity_cross_env(self):
-        testdir = os.path.join(self.unit_test_dir, '61 identity cross')
+        testdir = os.path.join(self.unit_test_dir, '60 identity cross')
         env = {
             'CC_FOR_BUILD': '"' + os.path.join(testdir, 'build_wrapper.py') + '"',
+            'CC': '"' + os.path.join(testdir, 'host_wrapper.py') + '"',
         }
         crossfile = tempfile.NamedTemporaryFile(mode='w')
-        crossfile.write(textwrap.dedent('''\
-            binaries
-            c = '{}'
-            '''.format(os.path.join(testdir, 'host_wrapper.py'))))
+        crossfile.write('')
         crossfile.flush()
         self.meson_cross_files = crossfile.name
         # TODO should someday be explicit about build platform only here
@@ -1548,7 +1562,7 @@
             raise SkipTest("Cygwin doesn't support LD_LIBRARY_PATH.")
 
         # Build some libraries and install them
-        testdir = os.path.join(self.unit_test_dir, '67 static link/lib')
+        testdir = os.path.join(self.unit_test_dir, '66 static link/lib')
         libdir = os.path.join(self.installdir, self.libdir)
         oldprefix = self.prefix
         self.prefix = self.installdir
@@ -1560,7 +1574,7 @@
         self.prefix = oldprefix
         meson_args = f'-Dc_link_args=-L{libdir}',
                       '--fatal-meson-warnings'
-        testdir = os.path.join(self.unit_test_dir, '67 static link')
+        testdir = os.path.join(self.unit_test_dir, '66 static link')
         env = {'PKG_CONFIG_LIBDIR': os.path.join(libdir, 'pkgconfig')}
         self.init(testdir, extra_args=meson_args, override_envvars=env)
         self.build()
@@ -1585,7 +1599,7 @@
                 if isinstance(comp, (AppleClangCCompiler, AppleClangCPPCompiler,
                                      AppleClangObjCCompiler, AppleClangObjCPPCompiler)):
                     raise SkipTest('AppleClang is currently only supported with ld64')
-                if lang != 'rust' and comp.use_linker_args('bfd') == :
+                if lang != 'rust' and comp.use_linker_args('bfd', '') == :
                     raise SkipTest(
                         f'Compiler {comp.id} does not support using alternative linkers')
                 self.assertEqual(comp.linker.id, expected)
@@ -1634,7 +1648,7 @@
             return hashlib.sha256(f.read()).hexdigest()
 
     def test_wrap_with_file_url(self):
-        testdir = os.path.join(self.unit_test_dir, '73 wrap file url')
+        testdir = os.path.join(self.unit_test_dir, '72 wrap file url')
         source_filename = os.path.join(testdir, 'subprojects', 'foo.tar.xz')
         patch_filename = os.path.join(testdir, 'subprojects', 'foo-patch.tar.xz')
         wrap_filename = os.path.join(testdir, 'subprojects', 'foo.wrap')
@@ -1691,7 +1705,7 @@
             self.init(d, override_envvars={'PKG_CONFIG_LIBDIR': privatedir})
 
     def test_as_link_whole(self):
-        testdir = os.path.join(self.unit_test_dir, '77 as link whole')
+        testdir = os.path.join(self.unit_test_dir, '76 as link whole')
         self.init(testdir)
         with open(os.path.join(self.privatedir, 'bar1.pc'), encoding='utf-8') as f:
             content = f.read()
@@ -1708,13 +1722,11 @@
             raise SkipTest('Prelinking not supported on Darwin.')
         if 'clang' in os.environ.get('CC', 'dummy'):
             raise SkipTest('Prelinking not supported with Clang.')
-        testdir = os.path.join(self.unit_test_dir, '87 prelinking')
+        testdir = os.path.join(self.unit_test_dir, '86 prelinking')
         env = get_fake_env(testdir, self.builddir, self.prefix)
         cc = detect_c_compiler(env, MachineChoice.HOST)
-        if cc.id == "gcc":
-            gccver = subprocess.check_output('gcc', '--version')
-            if b'7.5.0' in gccver:
-                raise SkipTest('GCC on Bionic is too old to be supported.')
+        if cc.id == "gcc" and not version_compare(cc.version, '>=9'):
+            raise SkipTest('Prelinking not supported with gcc 8 or older.')
         self.init(testdir)
         self.build()
         outlib = os.path.join(self.builddir, 'libprelinked.a')
@@ -1724,7 +1736,7 @@
         p = subprocess.run(ar, 't', outlib,
                            stdout=subprocess.PIPE,
                            stderr=subprocess.DEVNULL,
-                           universal_newlines=True, timeout=1)
+                           text=True, timeout=1)
         obj_files = p.stdout.strip().split('\n')
         self.assertEqual(len(obj_files), 1)
         self.assertTrue(obj_files0.endswith('-prelink.o'))
@@ -1760,3 +1772,59 @@
 
         # If so, we can test that cmake works with "gcc -m32"
         self.do_one_test_with_nativefile('../cmake/1 basic', "'gcc', '-m32'")
+
+    @skipUnless(is_linux() or is_osx(), 'Test only applicable to Linux and macOS')
+    def test_install_strip(self):
+        testdir = os.path.join(self.unit_test_dir, '103 strip')
+        self.init(testdir)
+        self.build()
+
+        destdir = self.installdir + self.prefix
+        if is_linux():
+            lib = os.path.join(destdir, self.libdir, 'liba.so')
+        else:
+            lib = os.path.join(destdir, self.libdir, 'liba.dylib')
+        install_cmd = self.meson_command + 'install', '--destdir', self.installdir
+
+        # Check we have debug symbols by default
+        self._run(install_cmd, workdir=self.builddir)
+        if is_linux():
+            # file can detect stripped libraries on linux
+            stdout = self._run('file', '-b', lib)
+            self.assertIn('not stripped', stdout)
+        else:
+            # on macOS we need to query dsymutil instead.
+            # Alternatively, check if __dyld_private is defined
+            # in the output of nm liba.dylib, but that is not
+            # 100% reliable, it needs linking to an external library
+            stdout = self._run('dsymutil', '--dump-debug-map', lib)
+            self.assertIn('symbols:', stdout)
+
+        # Check debug symbols got removed with --strip
+        self._run(install_cmd + '--strip', workdir=self.builddir)
+        if is_linux():
+            stdout = self._run('file', '-b', lib)
+            self.assertNotIn('not stripped', stdout)
+        else:
+            stdout = self._run('dsymutil', '--dump-debug-map', lib)
+            self.assertNotIn('symbols:', stdout)
+
+    def test_isystem_default_removal_with_symlink(self):
+        env = get_fake_env()
+        cpp = detect_cpp_compiler(env, MachineChoice.HOST)
+        default_dirs = cpp.get_default_include_dirs()
+        default_symlinks = 
+        with tempfile.TemporaryDirectory() as tmpdir:
+            for i in range(len(default_dirs)):
+                symlink = f'{tmpdir}/default_dir{i}'
+                default_symlinks.append(symlink)
+                os.symlink(default_dirsi, symlink)
+            self.assertFalse(cpp.compiler_args(f'-isystem{symlink}' for symlink in default_symlinks).to_native())
+
+    def test_freezing(self):
+        testdir = os.path.join(self.unit_test_dir, '109 freeze')
+        self.init(testdir)
+        self.build()
+        with self.assertRaises(subprocess.CalledProcessError) as e:
+            self.run_tests()
+        self.assertNotIn('Traceback', e.exception.output)

_service:tar_scm:meson-0.61.5.tar.gz/unittests/machinefiletests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/machinefiletests.py Changed

@@ -42,6 +42,7 @@
 
 
 from run_tests import (
+    Backend,
     get_fake_env
 )
 
@@ -62,7 +63,7 @@
 
     def setUp(self):
         super().setUp()
-        self.testcase = os.path.join(self.unit_test_dir, '47 native file binary')
+        self.testcase = os.path.join(self.unit_test_dir, '46 native file binary')
         self.current_config = 0
         self.current_wrapper = 0
 
@@ -368,6 +369,23 @@
         self._single_implementation_compiler(
             'java', 'javac', 'javac 9.99.77', '9.99.77')
 
+    @skip_if_not_language('java')
+    def test_java_classpath(self):
+        if self.backend is not Backend.ninja:
+            raise SkipTest('Jar is only supported with Ninja')
+        testdir = os.path.join(self.unit_test_dir, '110 classpath')
+        self.init(testdir)
+        self.build()
+        one_build_path = get_classpath(os.path.join(self.builddir, 'one.jar'))
+        self.assertIsNone(one_build_path)
+        two_build_path = get_classpath(os.path.join(self.builddir, 'two.jar'))
+        self.assertEqual(two_build_path, 'one.jar')
+        self.install()
+        one_install_path = get_classpath(os.path.join(self.installdir, 'usr/bin/one.jar'))
+        self.assertIsNone(one_install_path)
+        two_install_path = get_classpath(os.path.join(self.installdir, 'usr/bin/two.jar'))
+        self.assertIsNone(two_install_path)
+
     @skip_if_not_language('swift')
     def test_swift_compiler(self):
         wrapper = self.helper_create_binary_wrapper(
@@ -379,12 +397,12 @@
         self.assertEqual(compiler.version, '1.2345')
 
     def test_native_file_dirs(self):
-        testcase = os.path.join(self.unit_test_dir, '60 native file override')
+        testcase = os.path.join(self.unit_test_dir, '59 native file override')
         self.init(testcase, default_args=False,
                   extra_args='--native-file', os.path.join(testcase, 'nativefile'))
 
     def test_native_file_dirs_overridden(self):
-        testcase = os.path.join(self.unit_test_dir, '60 native file override')
+        testcase = os.path.join(self.unit_test_dir, '59 native file override')
         self.init(testcase, default_args=False,
                   extra_args='--native-file', os.path.join(testcase, 'nativefile'),
                               '-Ddef_libdir=liblib', '-Dlibdir=liblib')
@@ -422,7 +440,7 @@
         self.init(testcase, extra_args='--native-file', config, '-Dother_one=false')
 
     def test_user_options_subproject(self):
-        testcase = os.path.join(self.unit_test_dir, '79 user options for subproject')
+        testcase = os.path.join(self.unit_test_dir, '78 user options for subproject')
 
         s = os.path.join(testcase, 'subprojects')
         if not os.path.exists(s):
@@ -650,7 +668,7 @@
             ''')
 
     def test_needs_exe_wrapper_true(self):
-        testdir = os.path.join(self.unit_test_dir, '71 cross test passed')
+        testdir = os.path.join(self.unit_test_dir, '70 cross test passed')
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / 'crossfile'
             with p.open('wt', encoding='utf-8') as f:
@@ -660,7 +678,7 @@
             self.assertRegex(out, r'Skipped:\s*1\s*\n')
 
     def test_needs_exe_wrapper_false(self):
-        testdir = os.path.join(self.unit_test_dir, '71 cross test passed')
+        testdir = os.path.join(self.unit_test_dir, '70 cross test passed')
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / 'crossfile'
             with p.open('wt', encoding='utf-8') as f:
@@ -670,7 +688,7 @@
             self.assertNotRegex(out, r'Skipped:\s*1\n')
 
     def test_needs_exe_wrapper_true_wrapper(self):
-        testdir = os.path.join(self.unit_test_dir, '71 cross test passed')
+        testdir = os.path.join(self.unit_test_dir, '70 cross test passed')
         with tempfile.TemporaryDirectory() as d:
             s = Path(d) / 'wrapper.py'
             with s.open('wt', encoding='utf-8') as f:
@@ -687,7 +705,7 @@
             self.assertRegex(out, r'Ok:\s*3\s*\n')
 
     def test_cross_exe_passed_no_wrapper(self):
-        testdir = os.path.join(self.unit_test_dir, '71 cross test passed')
+        testdir = os.path.join(self.unit_test_dir, '70 cross test passed')
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / 'crossfile'
             with p.open('wt', encoding='utf-8') as f:
@@ -756,7 +774,7 @@
         return filename
 
     def test_cross_file_dirs(self):
-        testcase = os.path.join(self.unit_test_dir, '60 native file override')
+        testcase = os.path.join(self.unit_test_dir, '59 native file override')
         self.init(testcase, default_args=False,
                   extra_args='--native-file', os.path.join(testcase, 'nativefile'),
                               '--cross-file', os.path.join(testcase, 'crossfile'),
@@ -774,7 +792,7 @@
                               '-Ddef_sysconfdir=sysconfbar')
 
     def test_cross_file_dirs_overridden(self):
-        testcase = os.path.join(self.unit_test_dir, '60 native file override')
+        testcase = os.path.join(self.unit_test_dir, '59 native file override')
         self.init(testcase, default_args=False,
                   extra_args='--native-file', os.path.join(testcase, 'nativefile'),
                               '--cross-file', os.path.join(testcase, 'crossfile'),
@@ -793,7 +811,7 @@
 
     def test_cross_file_dirs_chain(self):
         # crossfile2 overrides crossfile overrides nativefile
-        testcase = os.path.join(self.unit_test_dir, '60 native file override')
+        testcase = os.path.join(self.unit_test_dir, '59 native file override')
         self.init(testcase, default_args=False,
                   extra_args='--native-file', os.path.join(testcase, 'nativefile'),
                               '--cross-file', os.path.join(testcase, 'crossfile'),

_service:tar_scm:meson-0.61.5.tar.gz/unittests/platformagnostictests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/platformagnostictests.py Changed

@@ -14,7 +14,10 @@
 
 import os
 import tempfile
+import subprocess
+import textwrap
 from unittest import skipIf
+from pathlib import Path
 
 from .baseplatformtests import BasePlatformTests
 from .helpers import is_ci
@@ -32,7 +35,7 @@
         Tests that find_program() with a relative path does not find the program
         in current workdir.
         '''
-        testdir = os.path.join(self.unit_test_dir, '101 relative find program')
+        testdir = os.path.join(self.unit_test_dir, '100 relative find program')
         self.init(testdir, workdir=testdir)
 
     def test_invalid_option_names(self):
@@ -68,5 +71,53 @@
         interp.process(fname)
 
     def test_python_dependency_without_pkgconfig(self):
-        testdir = os.path.join(self.unit_test_dir, '103 python without pkgconfig')
+        testdir = os.path.join(self.unit_test_dir, '102 python without pkgconfig')
         self.init(testdir, override_envvars={'PKG_CONFIG': 'notfound'})
+
+    def test_debug_function_outputs_to_meson_log(self):
+        testdir = os.path.join(self.unit_test_dir, '104 debug function')
+        log_msg = 'This is an example debug output, should only end up in debug log'
+        output = self.init(testdir)
+
+        # Check if message is not printed to stdout while configuring
+        self.assertNotIn(log_msg, output)
+
+        # Check if message is written to the meson log
+        mesonlog = self.get_meson_log_raw()
+        self.assertIn(log_msg, mesonlog)
+
+    def test_new_subproject_reconfigure(self):
+        testdir = os.path.join(self.unit_test_dir, '107 new subproject on reconfigure')
+        self.init(testdir)
+        self.build()
+
+        # Enable the subproject "foo" and reconfigure, this is used to fail
+        # because per-subproject builtin options were not initialized:
+        # https://github.com/mesonbuild/meson/issues/10225.
+        self.setconf('-Dfoo=enabled')
+        self.build('reconfigure')
+
+    def check_connectivity(self):
+        import urllib
+        try:
+            with urllib.request.urlopen('https://wrapdb.mesonbuild.com') as p:
+                pass
+        except urllib.error.URLError as e:
+            self.skipTest('No internet connectivity: ' + str(e))
+
+    def test_update_wrapdb(self):
+        self.check_connectivity()
+        # Write the project into a temporary directory because it will add files
+        # into subprojects/ and we don't want to pollute meson source tree.
+        with tempfile.TemporaryDirectory() as testdir:
+            with Path(testdir, 'meson.build').open('w', encoding='utf-8') as f:
+                f.write(textwrap.dedent(
+                    '''
+                    project('wrap update-db',
+                      default_options: 'wrap_mode=forcefallback')
+
+                    zlib_dep = dependency('zlib')
+                    assert(zlib_dep.type_name() == 'internal')
+                    '''))
+            subprocess.check_call(self.wrap_command + 'update-db', cwd=testdir)
+            self.init(testdir, workdir=testdir)

_service:tar_scm:meson-0.61.5.tar.gz/unittests/pythontests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/pythontests.py Changed

@@ -31,48 +31,11 @@
     Tests that verify compilation of python extension modules
     '''
 
-    def test_versions(self):
+    def test_bad_versions(self):
         if self.backend is not Backend.ninja:
             raise unittest.SkipTest(f'Skipping python tests with {self.backend.name} backend')
 
-        testdir = os.path.join(self.src_root, 'test cases', 'unit', '39 python extmodule')
-
-        # No python version specified, this will use meson's python
-        self.init(testdir)
-        self.build()
-        self.run_tests()
-        self.wipe()
-
-        # When specifying a known name, (python2 / python3) the module
-        # will also try 'python' as a fallback and use it if the major
-        # version matches
-        try:
-            self.init(testdir, extra_args='-Dpython=python2')
-            self.build()
-            self.run_tests()
-        except unittest.SkipTest:
-            # python2 is not necessarily installed on the test machine,
-            # if it is not, or the python headers can't be found, the test
-            # will raise MESON_SKIP_TEST, we could check beforehand what version
-            # of python is available, but it's a bit of a chicken and egg situation,
-            # as that is the job of the module, so we just ask for forgiveness rather
-            # than permission.
-            pass
-
-        self.wipe()
-
-        for py in ('pypy', 'pypy3'):
-            try:
-                self.init(testdir, extra_args='-Dpython=%s' % py)
-            except unittest.SkipTest:
-                # Same as above, pypy2 and pypy3 are not expected to be present
-                # on the test system, the test project only raises in these cases
-                continue
-
-            # We have a pypy, this is expected to work
-            self.build()
-            self.run_tests()
-            self.wipe()
+        testdir = os.path.join(self.src_root, 'test cases', 'python', '8 different python versions')
 
         # The test is configured to error out with MESON_SKIP_TEST
         # in case it could not find python

_service:tar_scm:meson-0.61.5.tar.gz/unittests/rewritetests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/rewritetests.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/unittests/subprojectscommandtests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/subprojectscommandtests.py Changed

@@ -103,15 +103,20 @@
         self._git_remote('commit', '--no-gpg-sign', '--allow-empty', '-m', f'tag {tag} commit', name)
         self._git_remote('tag', '--no-sign', tag, name)
 
-    def _wrap_create_git(self, name, revision='master'):
+    def _wrap_create_git(self, name, revision='master', depth=None):
         path = self.root_dir / name
         with open(str((self.subprojects_dir / name).with_suffix('.wrap')), 'w', encoding='utf-8') as f:
+            if depth is None:
+                depth_line = ''
+            else:
+                depth_line = 'depth = {}'.format(depth)
             f.write(textwrap.dedent(
                 '''
                 wrap-git
                 url={}
                 revision={}
-                '''.format(os.path.abspath(str(path)), revision)))
+                {}
+                '''.format(os.path.abspath(str(path)), revision, depth_line)))
 
     def _wrap_create_file(self, name, tarball='dummy.tar.gz'):
         path = self.root_dir / tarball
@@ -205,6 +210,15 @@
         self._subprojects_cmd('update', '--reset')
         self.assertEqual(self._git_local_commit(subp_name), self._git_remote_commit(subp_name))
 
+        # Create a fake remote git repository and a wrap file targeting
+        # HEAD and depth = 1. Checks that "meson subprojects download" works.
+        subp_name = 'sub3'
+        self._git_create_remote_repo(subp_name)
+        self._wrap_create_git(subp_name, revision='head', depth='1')
+        self._subprojects_cmd('download')
+        self.assertPathExists(str(self.subprojects_dir / subp_name))
+        self._git_config(self.subprojects_dir / subp_name)
+
     @skipIfNoExecutable('true')
     def test_foreach(self):
         self._create_project(self.subprojects_dir / 'sub_file')

_service:tar_scm:meson-0.61.5.tar.gz/unittests/taptests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/taptests.py Changed

_service:tar_scm:meson-0.61.5.tar.gz/unittests/windowstests.py -> _service:tar_scm:meson-1.0.1.tar.gz/unittests/windowstests.py Changed

@@ -32,7 +32,6 @@
 )
 from mesonbuild.compilers import (
 detect_c_compiler, detect_d_compiler, compiler_from_language,
- GnuLikeCompiler
 )
 from mesonbuild.programs import ExternalProgram
 import mesonbuild.dependencies.base
@@ -169,7 +168,7 @@
 self.assertRebuiltTarget('prog_1')
 
 def test_msvc_cpp17(self):
- testdir = os.path.join(self.unit_test_dir, '45 vscpp17')
+ testdir = os.path.join(self.unit_test_dir, '44 vscpp17')
 
 env = get_fake_env(testdir, self.builddir, self.prefix)
 cc = detect_c_compiler(env, MachineChoice.HOST)
@@ -222,21 +221,21 @@
 def test_link_environment_variable_lld_link(self):
 env = get_fake_env()
 comp = detect_c_compiler(env, MachineChoice.HOST)
- if isinstance(comp, GnuLikeCompiler):
+ if comp.get_argument_syntax() == 'gcc':
 raise SkipTest('GCC cannot be used with link compatible linkers.')
 self._check_ld('lld-link', 'c', 'lld-link')
 
 def test_link_environment_variable_link(self):
 env = get_fake_env()
 comp = detect_c_compiler(env, MachineChoice.HOST)
- if isinstance(comp, GnuLikeCompiler):
+ if comp.get_argument_syntax() == 'gcc':
 raise SkipTest('GCC cannot be used with link compatible linkers.')
 self._check_ld('link', 'c', 'link')
 
 def test_link_environment_variable_optlink(self):
 env = get_fake_env()
 comp = detect_c_compiler(env, MachineChoice.HOST)
- if isinstance(comp, GnuLikeCompiler):
+ if comp.get_argument_syntax() == 'gcc':
 raise SkipTest('GCC cannot be used with link compatible linkers.')
 self._check_ld('optlink', 'c', 'optlink')
 
@@ -357,7 +356,7 @@
 raise SkipTest('C++ modules is only supported with Visual Studio.')
 if version_compare(os.environ'VSCMD_VER', '<16.10.0'):
 raise SkipTest('C++ modules are only supported with VS 2019 Preview or newer.')
- self.init(os.path.join(self.unit_test_dir, '86 cpp modules'))
+ self.init(os.path.join(self.unit_test_dir, '85 cpp modules'))
 self.build()
 
 def test_non_utf8_fails(self):

Changes of Revision 2