Chiebot-Mirror
/
meson
mirror of https://github.com/mesonbuild/meson.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
The Meson Build System http://mesonbuild.com/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
14448 Commits
76 Branches
171 Tags
72 MiB
Tag: Branch: Tree: 9752b89100
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '9752b89100'
${ noResults }
meson/mesonbuild/modules/rust.py

330 lines
13 KiB
Raw Normal View History Unescape

Use SPDX-License-Identifier consistently This replaces all of the Apache blurbs at the start of each file with an `# SPDX-License-Identifier: Apache-2.0` string. It also fixes existing uses to be consistent in capitalization, and to be placed above any copyright notices. This removes nearly 3000 lines of boilerplate from the project (only python files), which no developer cares to look at. SPDX is in common use, particularly in the Linux kernel, and is the recommended format for Meson's own `project(license: )` field
11 months ago
# SPDX-License-Identifier: Apache-2.0
rust: Add `--extern proc_macro` in `rust.proc_macro() not in cargo translation Cargo does this by default, so it's reasonable that we do the same. Fixes: #12758
10 months ago
# Copyright © 2020-2024 Intel Corporation
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
modules/rust: Use `__future__.annotations`
2 years ago
from __future__ import annotations
modules/rust: only use include and define args from global/project args
1 year ago
import itertools
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
import os
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
import typing as T
modules/rust: only use include and define args from global/project args
1 year ago
Rust: Add a rust.proc_macro() method
1 year ago
from mesonbuild.interpreterbase.decorators import FeatureNew
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
modules: use module level information about new and deprecation Instead of using FeatureNew/FeatureDeprecated in the module. The goal here is to be able to handle information about modules in a single place, instead of having to handle it separately. Each module simply defines some metadata, and then the interpreter handles the rest.
2 years ago
from . import ExtensionModule, ModuleReturnValue, ModuleInfo
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
from .. import mlog
Rust: Add a rust.proc_macro() method
1 year ago
from ..build import (BothLibraries, BuildTarget, CustomTargetIndex, Executable, ExtractedObjects, GeneratedList,
CustomTarget, InvalidArguments, Jar, StructuredSources, SharedLibrary)
rust/bindgen: Use Meson rules for C++ headers Bindgen natively only considers .hpp to be C++ headers, but Meson considers some additional extensions including .hh and .hxx to be C++.
1 year ago
from ..compilers.compilers import are_asserts_disabled, lang_suffixes
modules/rust: Allow explicitly setting the language to bind This may be of particular use when a header is .h but should be treated as a C++ header instead of a C header.
1 year ago
from ..interpreter.type_checking import (
DEPENDENCIES_KW, LINK_WITH_KW, SHARED_LIB_KWS, TEST_KWS, OUTPUT_KW,
INCLUDE_DIRECTORIES, SOURCES_VARARGS, NoneType, in_set_validator
)
Rust: Add a rust.proc_macro() method
1 year ago
from ..interpreterbase import ContainerTypeInfo, InterpreterException, KwargInfo, typed_kwargs, typed_pos_args, noPosargs, permittedKwargs
modules/rust: use typed_kwargs for bindgen This was the only function left in here that wasn't fully typed, so let's fix that
3 years ago
from ..mesonlib import File
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
if T.TYPE_CHECKING:
Simplify module API - ModuleState is now a real class that will have methods in the future for actions modules needs, instead of using interpreter internal API. - New ModuleObject base class, similar to InterpreterObject, that should be used by all objects returned by modules. Its methods gets the ModuleState passed as first argument. It has a `methods` dictionary to define what is public API that can be called from build definition. - Method return value is not required to be a ModuleReturnValue any more, it can be any type that interpreter can holderify, including ModuleObject. - Legacy module API is maintained until we port all modules. In the future modules should be updated: - Use methods dict. - Remove snippets. - Custom objects returned by modules should all be subclass of ModuleObject to get the state iface in their methods. - Modules should never call into interpreter directly and instead state object should have wrapper API. - Stop using ModuleReturnValue in methods that just return simple objects like strings. Possibly remove ModuleReturnValue completely since all objects that needs to be processed by interpreter (e.g. CustomTarget) should be created through ModuleState API.
4 years ago
from . import ModuleState
move various bits of type-checking only code to TYPE_CHECKING blocks Mostly detected with flake8-type-checking. Also quote T.cast() first arguments, since those are not affected by future annotations.
1 year ago
from ..build import IncludeDirs, LibTypes
from ..dependencies import Dependency, ExternalLibrary
Simplify module API - ModuleState is now a real class that will have methods in the future for actions modules needs, instead of using interpreter internal API. - New ModuleObject base class, similar to InterpreterObject, that should be used by all objects returned by modules. Its methods gets the ModuleState passed as first argument. It has a `methods` dictionary to define what is public API that can be called from build definition. - Method return value is not required to be a ModuleReturnValue any more, it can be any type that interpreter can holderify, including ModuleObject. - Legacy module API is maintained until we port all modules. In the future modules should be updated: - Use methods dict. - Remove snippets. - Custom objects returned by modules should all be subclass of ModuleObject to get the state iface in their methods. - Modules should never call into interpreter directly and instead state object should have wrapper API. - Stop using ModuleReturnValue in methods that just return simple objects like strings. Possibly remove ModuleReturnValue completely since all objects that needs to be processed by interpreter (e.g. CustomTarget) should be created through ModuleState API.
4 years ago
from ..interpreter import Interpreter
interpreter: use typed_*args for test and benchmark this also requires some changes to the Rust module, as it calls into the test code.
3 years ago
from ..interpreter import kwargs as _kwargs
rust: clean up inputs and outputs to bindgen Make the handling of bindgen inputs consistent with the inputs and outputs of source_strings_to_files. However, for the first source argument reject anything that cannot possibly be an header file. This also fixes a mypy failure from the next patch, since ExtractedObjects does not have a zero-argument get_outputs method. Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
3 years ago
from ..interpreter.interpreter import SourceInputs, SourceOutputs
modules/rust: Fix annotation for _bindgen_bin Which suffers from the same issue as the gnome module
2 years ago
from ..programs import ExternalProgram, OverrideProgram
Rust: Add a rust.proc_macro() method
1 year ago
from ..interpreter.type_checking import SourcesVarargsType
interpreter: use typed_*args for test and benchmark this also requires some changes to the Rust module, as it calls into the test code.
3 years ago
modules/rust: Allow explicitly setting the language to bind This may be of particular use when a header is .h but should be treated as a C++ header instead of a C header.
1 year ago
from typing_extensions import TypedDict, Literal
modules/rust: use typed_kwargs for bindgen This was the only function left in here that wasn't fully typed, so let's fix that
3 years ago
interpreter: use typed_*args for test and benchmark this also requires some changes to the Rust module, as it calls into the test code.
3 years ago
class FuncTest(_kwargs.BaseTest):
holders: Fix the remaining code to respect the holder changes
3 years ago
dependencies: T.List[T.Union[Dependency, ExternalLibrary]]
interpreter: use typed_*args for test and benchmark this also requires some changes to the Rust module, as it calls into the test code.
3 years ago
is_parallel: bool
modules/rust: Add a `link_with` kwarg to the test method This was requested by Mesa, where a bunch of `declare_dependency` objects are being created as a workaround for the lack of this keyword
1 year ago
link_with: T.List[LibTypes]
modules/rust: Add a keyword argument to pass extra args to the rust compiler This may be necessary to, for example, stop rustc complaining about unused functions
1 year ago
rust_args: T.List[str]
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
modules/rust: use typed_kwargs for bindgen This was the only function left in here that wasn't fully typed, so let's fix that
3 years ago
class FuncBindgen(TypedDict):
args: T.List[str]
c_args: T.List[str]
include_directories: T.List[IncludeDirs]
input: T.List[SourceInputs]
output: str
modules/rust: Add support for dependencies in bindgen This is needed for cases where we need external C headers, which are passed to clang.
2 years ago
dependencies: T.List[T.Union[Dependency, ExternalLibrary]]
modules/rust: Allow explicitly setting the language to bind This may be of particular use when a header is .h but should be treated as a C++ header instead of a C header.
1 year ago
language: T.Optional[Literal['c', 'cpp']]
modules/rust: use typed_kwargs for bindgen This was the only function left in here that wasn't fully typed, so let's fix that
3 years ago
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
class RustModule(ExtensionModule):
"""A module that holds helper functions for rust."""
modules/rust: stabilize Mesa is using the rust module in production, so we should stabilize it.
2 years ago
INFO = ModuleInfo('rust', '0.57.0', stabilized='1.0.0')
modules: use module level information about new and deprecation Instead of using FeatureNew/FeatureDeprecated in the module. The goal here is to be able to handle information about modules in a single place, instead of having to handle it separately. Each module simply defines some metadata, and then the interpreter handles the rest.
2 years ago
modules/rust: Use `__future__.annotations`
2 years ago
def __init__(self, interpreter: Interpreter) -> None:
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
super().__init__(interpreter)
modules/rust: Fix annotation for _bindgen_bin Which suffers from the same issue as the gnome module
2 years ago
self._bindgen_bin: T.Optional[T.Union[ExternalProgram, Executable, OverrideProgram]] = None
modules: Add methods dict everywhere This fix calling random internal methods from meson.build as long as they were not prefixed by underscore.
4 years ago
self.methods.update({
'test': self.test,
'bindgen': self.bindgen,
Rust: Add a rust.proc_macro() method
1 year ago
'proc_macro': self.proc_macro,
modules: Add methods dict everywhere This fix calling random internal methods from meson.build as long as they were not prefixed by underscore.
4 years ago
})
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
holders: Fix the remaining code to respect the holder changes
3 years ago
@typed_pos_args('rust.test', str, BuildTarget)
interpreter: use typed_*args for test and benchmark this also requires some changes to the Rust module, as it calls into the test code.
3 years ago
@typed_kwargs(
'rust.test',
interpreter: move TEST_KW from interpreter.py to type_checking.py Since it's also used in the rust module, it should be in a common place. Also rename from `TEST_KWARGS` to `TEST_KWS`, which is more in line with the `*_KW` naming scheme used in the type_checking module.
2 years ago
*TEST_KWS,
modules/rust: use the shared DEPENDENCIES_KW
2 years ago
DEPENDENCIES_KW,
modules/rust: Add a `link_with` kwarg to the test method This was requested by Mesa, where a bunch of `declare_dependency` objects are being created as a workaround for the lack of this keyword
1 year ago
LINK_WITH_KW.evolve(since='1.2.0'),
modules/rust: Add a keyword argument to pass extra args to the rust compiler This may be necessary to, for example, stop rustc complaining about unused functions
1 year ago
KwargInfo(
'rust_args',
ContainerTypeInfo(list, str),
listify=True,
default=[],
since='1.2.0',
),
interpreter: use typed_*args for test and benchmark this also requires some changes to the Rust module, as it calls into the test code.
3 years ago
KwargInfo('is_parallel', bool, default=False),
)
modules/rust: Use `__future__.annotations`
2 years ago
def test(self, state: ModuleState, args: T.Tuple[str, BuildTarget], kwargs: FuncTest) -> ModuleReturnValue:
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
"""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
Fix misspells Signed-off-by: Antonin Décimo <antonin.decimo@gmail.com>
4 years ago
you have to define two separate targets with basically the same
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
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)
```
"""
modules/rust: Add a `link_with` kwarg to the test method This was requested by Mesa, where a bunch of `declare_dependency` objects are being created as a workaround for the lack of this keyword
1 year ago
if any(isinstance(t, Jar) for t in kwargs.get('link_with', [])):
raise InvalidArguments('Rust tests cannot link with Jar targets')
modules/rust: use typed_pos_args
4 years ago
name = args[0]
holders: remove unholder
3 years ago
base_target: BuildTarget = args[1]
Replace NinjaBackend is_rust_target with build.uses_rust we have two functions to do the exact same thing, and they're basically implemented the same way. Instead, let's just use the BuildTarget one, as it's more generally available.
4 years ago
if not base_target.uses_rust():
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
raise InterpreterException('Second positional argument to rustmod.test() must be a rust based target')
interpreter: use typed_*args for test and benchmark this also requires some changes to the Rust module, as it calls into the test code.
3 years ago
extra_args = kwargs['args']
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
# 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_args[i + 1]
del extra_args[i]
for i, a in enumerate(extra_args):
interpreter: use typed_*args for test and benchmark this also requires some changes to the Rust module, as it calls into the test code.
3 years ago
if isinstance(a, str) and a.startswith('--format='):
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
del extra_args[i]
break
interpreter: use typed_*args for test and benchmark this also requires some changes to the Rust module, as it calls into the test code.
3 years ago
# 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())
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
interpreter: use typed_*args for test and benchmark this also requires some changes to the Rust module, as it calls into the test code.
3 years ago
tkwargs['args'] = extra_args + ['--test', '--format', 'pretty']
tkwargs['protocol'] = 'rust'
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
build: Don't do a deep copy of kwargs It seems to only be used by the Rust module now, and it already does a copy.
2 years ago
new_target_kwargs = base_target.original_kwargs.copy()
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
# Don't mutate the shallow copied list, instead replace it with a new
# one
new_target_kwargs['install'] = False
pylint: enable unnecessary-comprehension
2 years ago
new_target_kwargs['dependencies'] = new_target_kwargs.get('dependencies', []) + kwargs['dependencies']
modules/rust: Add a `link_with` kwarg to the test method This was requested by Mesa, where a bunch of `declare_dependency` objects are being created as a workaround for the lack of this keyword
1 year ago
new_target_kwargs['link_with'] = new_target_kwargs.get('link_with', []) + kwargs['link_with']
modules/rust: remove rust_crate_type for test() method This is required to test non-executable targets when they set an explicit type.
1 year ago
del new_target_kwargs['rust_crate_type']
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
build: Use typed_kwargs for language args This also moves the repacking into the interpreter, making the build implementation simpler and removing a layering violation. This also makes use a defaultdict to remove the need to call `.get()`
2 years ago
lang_args = base_target.extra_args.copy()
lang_args['rust'] = base_target.extra_args['rust'] + kwargs['rust_args'] + ['--test']
new_target_kwargs['language_args'] = lang_args
modules/rust: Also include generated sources for tests When we create a test from a non-executable, we weren't copying the generated sources, just the static ones.
2 years ago
sources = T.cast('T.List[SourceOutputs]', base_target.sources.copy())
sources.extend(base_target.generated)
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
new_target = Executable(
build: plumb structured sources into BuildTargets
3 years ago
name, base_target.subdir, state.subproject, base_target.for_machine,
modules/rust: Also include generated sources for tests When we create a test from a non-executable, we weren't copying the generated sources, just the static ones.
2 years ago
sources, base_target.structured_sources,
Make compilers list per subproject Previously subprojects inherited languages already added by main project, or any previous subproject. This change to have a list of compilers per interpreters, which means that if a subproject does not add 'c' language it won't be able to compile .c files any more, even if main project added the 'c' language. This delays processing list of compilers until the interpreter adds the BuildTarget into its list of targets. That way the interpreter can add missing languages instead of duplicating that logic into BuildTarget for the cython case.
3 years ago
base_target.objects, base_target.environment, base_target.compilers,
new_target_kwargs
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
)
test = self.interpreter.make_test(
holders: Fix the remaining code to respect the holder changes
3 years ago
self.interpreter.current_node, (name, new_target), tkwargs)
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
holders: Fix the remaining code to respect the holder changes
3 years ago
return ModuleReturnValue(None, [new_target, test])
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
@noPosargs
modules/rust: use typed_kwargs for bindgen This was the only function left in here that wasn't fully typed, so let's fix that
3 years ago
@typed_kwargs(
'rust.bindgen',
KwargInfo('c_args', ContainerTypeInfo(list, str), default=[], listify=True),
KwargInfo('args', ContainerTypeInfo(list, str), default=[], listify=True),
KwargInfo(
'input',
rust: clean up inputs and outputs to bindgen Make the handling of bindgen inputs consistent with the inputs and outputs of source_strings_to_files. However, for the first source argument reject anything that cannot possibly be an header file. This also fixes a mypy failure from the next patch, since ExtractedObjects does not have a zero-argument get_outputs method. Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
3 years ago
ContainerTypeInfo(list, (File, GeneratedList, BuildTarget, BothLibraries, ExtractedObjects, CustomTargetIndex, CustomTarget, str), allow_empty=False),
modules/rust: use typed_kwargs for bindgen This was the only function left in here that wasn't fully typed, so let's fix that
3 years ago
default=[],
listify=True,
required=True,
),
modules/rust: Allow explicitly setting the language to bind This may be of particular use when a header is .h but should be treated as a C++ header instead of a C header.
1 year ago
KwargInfo('language', (str, NoneType), since='1.4.0', validator=in_set_validator({'c', 'cpp'})),
typed_kwargs: Extend since_values and deprecated_values for types
2 years ago
INCLUDE_DIRECTORIES.evolve(since_values={ContainerTypeInfo(list, str): '1.0.0'}),
fix regression that broke type checking of CustomTarget outputs We validate a few things here, such as the non-presence of '@INPUT' in an output name. These got moved out of the CustomTarget constructor in commit 11f96380351a88059ec55f1070fdebc1b1033117 and into KwargInfo, but only for kwargs that took multiple values. This caused configure_file() and unstable_rust.bindgen() to stop checking for this. Add a shared single-output KW and use it in both places. This now dispatches to _output_validator. configure_file now validates subdirectories in output names the same way we do elsewhere, directly in the typed_kwargs and by specifying the erroring kwarg.
3 years ago
OUTPUT_KW,
modules/rust: Add support for dependencies in bindgen This is needed for cases where we need external C headers, which are passed to clang.
2 years ago
DEPENDENCIES_KW.evolve(since='1.0.0'),
modules/rust: use typed_kwargs for bindgen This was the only function left in here that wasn't fully typed, so let's fix that
3 years ago
)
modules/rust: Use `__future__.annotations`
2 years ago
def bindgen(self, state: ModuleState, args: T.List, kwargs: FuncBindgen) -> ModuleReturnValue:
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
"""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.
"""
modules/rust: use typed_kwargs for bindgen This was the only function left in here that wasn't fully typed, so let's fix that
3 years ago
header, *_deps = self.interpreter.source_strings_to_files(kwargs['input'])
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
# Split File and Target dependencies to add pass to CustomTarget
modules/rust: Use `__future__.annotations`
2 years ago
depends: T.List[SourceOutputs] = []
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
depend_files: T.List[File] = []
for d in _deps:
if isinstance(d, File):
depend_files.append(d)
else:
depends.append(d)
modules/rust: Add a machine file property for extra clang args with bindgen It's currently impossible to inject extra clang arguments when using bindgen, which is problematic when cross compiling since you may need critical arguments like `--target=...`. Because such arguments must be passed after the `--` it's impossible to inject them currently without going to something like a wrapper script. Fixes: #11805
1 year ago
# Copy to avoid subsequent calls mutating the original
# TODO: if we want this to be per-machine we'll need a native kwarg
clang_args = state.environment.properties.host.get_bindgen_clang_args().copy()
modules/rust: Add support for string include_directories Which we support for basically every other case, but not this one.
2 years ago
for i in state.process_include_dirs(kwargs['include_directories']):
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
# bindgen always uses clang, so it's safe to hardcode -I here
modules/rust: Add support for dependencies in bindgen This is needed for cases where we need external C headers, which are passed to clang.
2 years ago
clang_args.extend([f'-I{x}' for x in i.to_string_list(
modules/rust: set bindgen include_dirs for both build and source dir Which we pretty obviously need if any of our headers are generated
3 years ago
state.environment.get_source_dir(), state.environment.get_build_dir())])
modules/rust: Add -DNDEBUG to bindgen if b_ndebug is false Otherwise bindgen may generate different behavior than the compiled C code actually has.
2 years ago
if are_asserts_disabled(state.environment.coredata.options):
clang_args.append('-DNDEBUG')
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
modules/rust: Add support for dependencies in bindgen This is needed for cases where we need external C headers, which are passed to clang.
2 years ago
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)
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
if self._bindgen_bin is None:
holders: remove unholder
3 years ago
self._bindgen_bin = state.find_program('bindgen')
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
name: str
if isinstance(header, File):
name = header.fname
build: plumb structured sources into BuildTargets
3 years ago
elif isinstance(header, (BuildTarget, BothLibraries, ExtractedObjects, StructuredSources)):
rust: clean up inputs and outputs to bindgen Make the handling of bindgen inputs consistent with the inputs and outputs of source_strings_to_files. However, for the first source argument reject anything that cannot possibly be an header file. This also fixes a mypy failure from the next patch, since ExtractedObjects does not have a zero-argument get_outputs method. Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
3 years ago
raise InterpreterException('bindgen source file must be a C header, not an object or build target')
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
else:
name = header.get_outputs()[0]
rust/bindgen: Use Meson rules for C++ headers Bindgen natively only considers .hpp to be C++ headers, but Meson considers some additional extensions including .hh and .hxx to be C++.
1 year ago
# bindgen assumes that C++ headers will be called .hpp. We want to
# ensure that anything Meson considers a C++ header is treated as one.
modules/rust: Allow explicitly setting the language to bind This may be of particular use when a header is .h but should be treated as a C++ header instead of a C header.
1 year ago
language = kwargs['language']
if language is None:
ext = os.path.splitext(name)[1][1:]
if ext in lang_suffixes['cpp']:
language = 'cpp'
elif ext == 'h':
language = 'c'
else:
raise InterpreterException(f'Unknown file type extension for: {name}')
rust/bindgen: Use Meson rules for C++ headers Bindgen natively only considers .hpp to be C++ headers, but Meson considers some additional extensions including .hh and .hxx to be C++.
1 year ago
# We only want include directories and defines, other things may not be valid
cargs = state.get_option('args', state.subproject, lang=language)
assert isinstance(cargs, list), 'for mypy'
for a in itertools.chain(state.global_args.get(language, []), state.project_args.get(language, []), cargs):
if a.startswith(('-I', '/I', '-D', '/D', '-U', '/U')):
clang_args.append(a)
if language == 'cpp':
clang_args.extend(['-x', 'c++'])
modules/rust: inject a C/C++ standard for bindgen Especially for C++ this is very important.
1 year ago
# Add the C++ standard to the clang arguments. Attempt to translate VS
# extension versions into the nearest standard version
std = state.get_option('std', lang=language)
assert isinstance(std, str), 'for mypy'
if std.startswith('vc++'):
if std.endswith('latest'):
mlog.warning('Attempting to translate vc++latest into a clang compatible version.',
'Currently this is hardcoded for c++20', once=True, fatal=False)
std = 'c++20'
else:
mlog.debug('The current C++ standard is a Visual Studio extension version.',
'bindgen will use a the nearest C++ standard instead')
std = std[1:]
if std != 'none':
clang_args.append(f'-std={std}')
Fix indentation issues reported by flake8, requiring code restructuring Strictly speaking code restructuring isn't needed, but making this PEP8 compliant results in indentation of the code that reduces the readability. By moving the offending code on the outside of the method call, the readability is maintained.
2 years ago
cmd = self._bindgen_bin.get_command() + \
[
'@INPUT@', '--output',
os.path.join(state.environment.build_dir, '@OUTPUT@')
] + \
modules/rust: Add support for dependencies in bindgen This is needed for cases where we need external C headers, which are passed to clang.
2 years ago
kwargs['args'] + ['--'] + kwargs['c_args'] + clang_args + \
Fix indentation issues reported by flake8, requiring code restructuring Strictly speaking code restructuring isn't needed, but making this PEP8 compliant results in indentation of the code that reduces the readability. By moving the offending code on the outside of the method call, the readability is maintained.
2 years ago
['-MD', '-MQ', '@INPUT@', '-MF', '@DEPFILE@']
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
target = CustomTarget(
f'rustmod-bindgen-{name}'.replace('/', '_'),
state.subdir,
state.subproject,
Pass environment down to base Target class
3 years ago
state.environment,
Fix indentation issues reported by flake8, requiring code restructuring Strictly speaking code restructuring isn't needed, but making this PEP8 compliant results in indentation of the code that reduces the readability. By moving the offending code on the outside of the method call, the readability is maintained.
2 years ago
cmd,
build: replace kwargs in CustomTarget initializer Because we don't want to pass the Interpreter kwargs into the build layer. This turned out to be a mega commit, as there's really on elegant way to make this change in an incremental way. On the nice side, mypy made this change super easy, as nearly all of the calls to `CustomTarget` are fully type checked! It also turns out that we're not handling install_tags in custom_target correctly, since we're not converting the boolean values into Optional values!
3 years ago
[header],
[kwargs['output']],
depfile='@PLAINNAME@.d',
extra_depends=depends,
depend_files=depend_files,
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
backend=state.backend,
Add more descriptive description to CustomTarget Allow modules using CustomTarget to modify the command description used by ninja backend. This result in more precise logs when building a project.
1 year ago
description='Generating bindings for Rust {}',
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
)
holders: Fix the remaining code to respect the holder changes
3 years ago
return ModuleReturnValue([target], [target])
rust: Add a module wrapper for bindgen This has a couple of advantages over rolling it by hand: 1. it correctly handles include_directories objects, which is always handy 2. it correctly generates a depfile for you, which makes it more reliable 3. it requires less typing
4 years ago
Rust: Add a rust.proc_macro() method
1 year ago
# Allow a limited set of kwargs, but still use the full set of typed_kwargs()
# because it could be setting required default values.
@FeatureNew('rust.proc_macro', '1.3.0')
@permittedKwargs({'rust_args', 'rust_dependency_map', 'sources', 'dependencies', 'extra_files',
'link_args', 'link_depends', 'link_with', 'override_options'})
@typed_pos_args('rust.proc_macro', str, varargs=SOURCES_VARARGS)
@typed_kwargs('rust.proc_macro', *SHARED_LIB_KWS, allow_unknown=True)
interpreter: annotate build_target function This uses an overload to try to get more accurate information from the function.
1 year ago
def proc_macro(self, state: ModuleState, args: T.Tuple[str, SourcesVarargsType], kwargs: _kwargs.SharedLibrary) -> SharedLibrary:
kwargs['native'] = True # type: ignore
kwargs['rust_crate_type'] = 'proc-macro' # type: ignore
rust: Add `--extern proc_macro` in `rust.proc_macro() not in cargo translation Cargo does this by default, so it's reasonable that we do the same. Fixes: #12758
10 months ago
kwargs['rust_args'] = kwargs['rust_args'] + ['--extern', 'proc_macro']
Rust: Add a rust.proc_macro() method
1 year ago
target = state._interpreter.build_target(state.current_node, args, kwargs, SharedLibrary)
interpreter: annotate build_target function This uses an overload to try to get more accurate information from the function.
1 year ago
return target
Rust: Add a rust.proc_macro() method
1 year ago
modules: Add an unstable-rust module Like other language specific modules this module is module for holding rust specific helpers. This commit adds a test() function, which simplifies using rust's internal unittest mechanism. Rust tests are generally placed in the same code files as they are testing, in contrast to languages like C/C++ and python which generally place the tests in separate translation units. For meson this is somewhat problematic from a repetition point of view, as the only changes are generally adding --test, and possibly some dependencies. The rustmod.test() method provides a mechanism to remove the repatition: it takes a rust target, copies it, and then addes the `--test` option, then creates a Test() target with the `rust` protocol. You can pass additional dependencies via the `dependencies` keyword. This all makes for a nice, DRY, test definition.
4 years ago
modules/rust: Use `__future__.annotations`
2 years ago
def initialize(interp: Interpreter) -> RustModule:
modules/rust: fix initialize signature So that it's accurate, and we don't need to use to use `#type: ignore` declaration
3 years ago
return RustModule(interp)