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.
15098 Commits
76 Branches
171 Tags
74 MiB
Tag: Branch: Tree: 6091ef0f5a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '6091ef0f5a'
${ noResults }
meson/docs/markdown/Rust-module.md

142 lines
4.7 KiB
Raw Normal View History Unescape

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
---
short-description: Rust language integration module
authors:
- name: Dylan Baker
email: dylan@pnwbakers.com
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
years: [2020, 2021, 2022, 2024]
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: stabilize Mesa is using the rust module in production, so we should stabilize it.
2 years ago
# Rust module
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 in 0.57.0)*
modules/rust: stabilize Mesa is using the rust module in production, so we should stabilize it.
2 years ago
*(Stable since 1.0.0)*
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
Capitalize "Meson" consistently as it is a proper name. [skip ci]
4 years ago
The rust module provides helper to integrate rust code into Meson. The
goal is to make using rust in Meson more pleasant, while still
remaining mesonic, this means that it attempts to make Rust work more
like Meson, rather than Meson work more like 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
## Functions
docs: improve formatting of the Rust module This brings the formatting more in line with other modules, in particular the headers do not include the full function signature for readability, keyword arguments are listed one-by-one, etc.
1 year ago
### test()
```meson
rustmod.test(name, target, ...)
```
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
Rewrap long text lines in docs. [skip ci]
4 years ago
This function creates a new rust unittest target from an existing rust
based target, which may be a library or executable. It does this by
copying the sources and arguments passed to the original target and
adding the `--test` argument to the compilation, then creates a new
test target which calls that executable, using the rust test protocol.
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
docs: improve formatting of the Rust module This brings the formatting more in line with other modules, in particular the headers do not include the full function signature for readability, keyword arguments are listed one-by-one, etc.
1 year ago
This function takes two positional arguments, the first is the name of the
test and the second is the library or executable that is the rust based target.
It also takes the following keyword arguments:
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
docs: improve formatting of the Rust module This brings the formatting more in line with other modules, in particular the headers do not include the full function signature for readability, keyword arguments are listed one-by-one, etc.
1 year ago
- `dependencies`: a list of test-only Dependencies
- `link_with`: a list of additional build Targets to link with (*since 1.2.0*)
- `rust_args`: a list of extra arguments passed to the Rust compiler (*since 1.2.0*)
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
docs: improve formatting of the Rust module This brings the formatting more in line with other modules, in particular the headers do not include the full function signature for readability, keyword arguments are listed one-by-one, etc.
1 year ago
This function also accepts all of the keyword arguments accepted by the
[[test]] function except `protocol`, it will set that automatically.
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
docs: improve formatting of the Rust module This brings the formatting more in line with other modules, in particular the headers do not include the full function signature for readability, keyword arguments are listed one-by-one, etc.
1 year ago
### 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
This function wraps bindgen to simplify creating rust bindings around C
docs: fix typos and keyword markdown for the Rust module page Two typos and mark the keyword arguments with backticks so they render nicely.
1 year ago
libraries. This has two advantages over invoking bindgen with a
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
`generator` or `custom_target`:
- It handles `include_directories`, so one doesn't have to manually convert them to `-I...`
- It automatically sets up a depfile, making the results more reliable
docs: update the Rust bindgen docs to talk about assertions Since we now guarantee that Rust and C/C++ will have assertions both on or both off, we can give guidance about using `cfg(debug_assertions)` to wrap code using `#ifdef NDEBUG`.
2 years ago
- It automatically handles assertions, synchronizing Rust and C/C++ to have the same behavior
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
It takes the following keyword arguments
docs: improve formatting of the Rust module This brings the formatting more in line with other modules, in particular the headers do not include the full function signature for readability, keyword arguments are listed one-by-one, etc.
1 year ago
- `input`: a list of Files, Strings, or CustomTargets. The first element is
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
the header bindgen will parse, additional elements are dependencies.
docs: improve formatting of the Rust module This brings the formatting more in line with other modules, in particular the headers do not include the full function signature for readability, keyword arguments are listed one-by-one, etc.
1 year ago
- `output`: the name of the output rust file
meson/rust: wrap `bindgen`s `wrap-static-fns` functionality This way the `rust.bindgen` can generate a second output being a C file, which contains wrapper functions for static inline ones. This output file can then be compiled via C targets.
1 year ago
- `output_inline_wrapper`: the name of the optional output c file containing
wrappers for static inline function. This requires `bindgen-0.65` or
newer (*since 1.3.0*).
docs: improve formatting of the Rust module This brings the formatting more in line with other modules, in particular the headers do not include the full function signature for readability, keyword arguments are listed one-by-one, etc.
1 year ago
- `include_directories`: A list of `include_directories` or `string` objects,
modules/rust: Add support for string include_directories Which we support for basically every other case, but not this one.
2 years ago
these are passed to clang as `-I` arguments *(string since 1.0.0)*
docs: improve formatting of the Rust module This brings the formatting more in line with other modules, in particular the headers do not include the full function signature for readability, keyword arguments are listed one-by-one, etc.
1 year ago
- `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*)
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`: A literal string value of `c` or `cpp`. When set this will force bindgen to treat a source as the given language. Defaults to checking based on the input file extension. *(since 1.4.0)*
modules/rust: allow setting a version constraint on bindgen This allows us to ensure that the bindgen we're using is suitable for our purpose.
1 year ago
- `bindgen_version`: a list of string version values. When set the found bindgen binary must conform to these constraints. *(since 1.4.0)*
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
```meson
rust = import('unstable-rust')
inc = include_directories('..'¸ '../../foo')
generated = rust.bindgen(
docs: fix rust module bindgen arguments Fixes: 9795
3 years ago
input : 'myheader.h',
output : 'generated.rs',
doc: Fix array syntax [skip ci] Adds a square bracket to create a valid array.
4 years ago
include_directories : [inc, include_directories('foo')],
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
args : ['--no-rustfmt-bindings'],
c_args : ['-DFOO=1'],
)
```
fix various spelling issues Signed-off-by: Josh Soref <2119212+jsoref@users.noreply.github.com>
2 years ago
If the header depends on generated headers, those headers must be passed to
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` as well to ensure proper dependency ordering, static headers do not
need to be passed, as a proper depfile is generated:
```meson
h1 = custom_target(...)
h2 = custom_target(...)
r1 = rust.bindgen(
docs: fix rust module bindgen arguments Fixes: 9795
3 years ago
input : [h1, h2], # h1 includes h2,
output : 'out.rs',
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
)
```
docs: update the Rust bindgen docs to talk about assertions Since we now guarantee that Rust and C/C++ will have assertions both on or both off, we can give guidance about using `cfg(debug_assertions)` to wrap code using `#ifdef NDEBUG`.
2 years ago
*Since 1.1.0* Meson will synchronize assertions for Rust and C/C++ when the
`b_ndebug` option is set (via `-DNDEBUG` for C/C++, and `-C
debug-assertions=on` for Rust), and will pass `-DNDEBUG` as an extra argument
to clang. This allows for reliable wrapping of `-DNDEBUG` controlled behavior
with `#[cfg(debug_asserions)]` and or `cfg!()`. Before 1.1.0, assertions for Rust
were never turned on by Meson.
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
*Since 1.2.0* Additional arguments to pass to clang may be specified in a
*machine file in the properties section:
```ini
[properties]
docs: fix bindgen_clang_arguments example > error: unsupported option '--target'; did you mean '-target'?
1 year ago
bindgen_clang_arguments = ['-target', 'x86_64-linux-gnu']
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
```
Rust: Add a rust.proc_macro() method
1 year ago
### proc_macro()
```meson
rustmod.proc_macro(name, sources, ...)
```
*Since 1.3.0*
This function creates a Rust `proc-macro` crate, similar to:
```meson
[[shared_library]](name, sources,
rust_crate_type: 'proc-macro',
native: true)
```
`proc-macro` targets can be passed to `link_with` keyword argument of other Rust
targets.
Only a subset of [[shared_library]] keyword arguments are allowed:
- rust_args
- rust_dependency_map
- sources
- dependencies
- extra_files
- link_args
- link_depends
- link_with
- override_options