title: Release 0.60.0 short-description: Release notes for 0.60.0 ...
run_target can now be used as a dependencyA run_target() can now be saved in a variable and reused as a dependency in an alias_target(). This can be used to create custom alias rules that ensure multiple other targets are run, even if those targets don't produce output files.
For example:
i18n = import('i18n')
all_pot_targets = []
foo_i18n = i18n.gettext('foo')
all_pot_targets += foo_i18n[1]
alias_target('all-pot', all_pot_targets)
Previously these were ignored with a warning, now they're a hard error.
unset_variable()unset_variable() can be used to unset a variable. Reading a variable after calling unset_variable() will raise an exception unless the variable is set again.
# tests/meson.build tests = ['test1', 'test2'] # ... unset_variable('tests') # tests is no longer usable until it is set again
The python module now has options to control where modules are installed:
Those 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 new options can be absolute paths outside of prefix.
subprojects packagefiles subcommandIt is now possible to re-apply meson.build overlays (patch_filename or patch_directory in the wrap ini file) after a subproject was downloaded and set up, via meson subprojects packagefiles --apply <wrap-name>.
It is also possible for patch_directory overlays in a [wrap-file], to copy the packagefiles out of the subproject and back into packagefiles/<patch_directory>/ via meson subprojects packagefiles --save <wrap-name>. This is useful for testing an edit in the subproject and then saving it back to the overlay which is checked into git.
Project options declared in meson_options.txt can now be marked as deprecated and Meson will warn when user sets a value to it. It is also possible to deprecate only some of the choices, and map deprecated values to a new value.
# Option fully deprecated, it warns when any value is set. option('o1', type: 'boolean', deprecated: true) # One of the choices is deprecated, it warns only when 'a' is in the list of values. option('o2', type: 'array', choices: ['a', 'b'], deprecated: ['a']) # One of the choices is deprecated, it warns only when 'a' is in the list of values # and replace it by 'c'. option('o3', type: 'array', choices: ['a', 'b', 'c'], deprecated: {'a': 'c'}) # A boolean option has been replaced by a feature, old true/false values are remapped. option('o4', type: 'feature', deprecated: {'true': 'enabled', 'false': 'disabled'}) # A feature option has been replaced by a boolean, enabled/disabled/auto values are remapped. option('o5', type: 'boolean', deprecated: {'enabled': 'true', 'disabled': 'false', 'auto': 'false'})
Note: This change had to be reverted in 0.60.1 because it caused regressions. New API will likely be introduced in 0.61.0 to have better control whether or not to create thin archive.
A somewhat common use case of [[static_library]] is to create uninstalled internal convenience libraries which are solely meant to be linked to other targets. Some build systems call these “object libraries”. Meson's implementation does always create a static archive.
This will now check to see if the static linker supports “thin archives” (archives which do not contain the actual object code, only references to their location on disk) and if so, use them to minimize space usage and speed up linking.
gnome.yelp previously allowed sources to be passed either as variadic arguments or as a keyword argument. If the keyword argument was given the variadic arguments would be silently ignored. This has changed in 0.60.0, the variadic form has been deprecated, and a warning is printed if both are given.
static keyword argument to meson.override_dependency()It is now possible to override shared and/or static dependencies separately. When the static keyword argument is not specified in dependency(), the first override will be used (static_dep in the example below).
static_lib = static_library() static_dep = declare_dependency(link_with: static_lib) meson.override_dependency('foo', static_dep, static: true) shared_lib = shared_library() shared_dep = declare_dependency(link_with: shared_lib) meson.override_dependency('foo', shared_dep, static: false) # Returns static_dep dependency('foo') # Returns static_dep dependency('foo', static: true) # Returns shared_dep dependency('foo', static: false)
When the static keyword argument is not specified in meson.override_dependency(), the dependency is assumed to follow the value of default_library option.
dep = declare_dependency(...) meson.override_dependency('foo', dep) # Always works dependency('foo') # Works only if default_library is 'static' or 'both' dependency('foo', static: true) # Works only if default_library is 'shared' or 'both' dependency('foo', static: false)
dependency() sets default_library on fallback subprojectWhen the static keyword argument is set but default_library is missing in default_options, dependency() will set it when configuring fallback subproject. dependency('foo', static: true) is now equivalent to dependency('foo', static: true, default_options: ['default_library=static']).
It is now possible to define a directory which will be created during installation, without creating it as a side effect of installing files into it. This replaces custom meson.add_install_script() routines. For example:
meson.add_install_script('sh', '-c', 'mkdir -p "$DESTDIR/@0@"'.format(path))
can be replaced by:
install_emptydir(path)
and as a bonus this works reliably on Windows, prints a sensible progress message, will be uninstalled by ninja uninstall, etc.
Built-in cython support currently only allows C as an intermediate language, now C++ is also allowed. This can be set via the cython_language option, either on the command line, or in the meson.build files.
project( 'myproject', 'cython', default_options : ['cython_language=cpp'], )
or on a per target basis with:
python.extension_module( 'mod', 'mod.pyx', override_options : ['cython_language=cpp'], )
dependency('iconv')
will now check for the functionality of libiconv.so, but first check if it is provided in the libc (for example in glibc or musl libc on Linux).
Passing unknown options to “meson setup” or “meson configure” is now always fatal. That is, Meson will exit with an error code if this happens. Previous Meson versions only showed a warning message.
When DESTDIR environment or meson install --destdir option is a relative path, it is now assumed to be relative to the build directory. An absolute path will be set into environment when executing scripts. It was undefined behavior in prior Meson versions but was working as relative to build directory most of the time.
The Java module has been added to Meson. The Java module allows users to generate native header files without needing to use a custom_target().
jmod = import('java') native_header = jmod.generate_native_header('File.java', package: 'com.mesonbuild') native_header_includes = include_directories('.') jdkjava = shared_module( 'jdkjava', [native_header_includes, other_sources], dependencies : [jdk], include_directories : [native_header_includes] )
Usually, the links method of the compiler object uses a single program invocation to do both compilation and linking. Starting with this version, whenever the argument to links is a file, Meson will check if the file suffix matches the compiler object's language. If they do not match, as in the following case:
cxx = meson.get_compiler('cpp')
cxx.links(files('test.c'))
then Meson will separate compilation and linking. In the above example test.c will be compiled with a C compiler and the resulting object file will be linked with a C++ compiler. This makes it possible to detect misconfigurations of the compilation environment, for example when the C++ runtime is not compatible with the one expected by the C compiler.
For this reason, passing file arguments with an unrecognized suffix to links will cause a warning.
str.join()Since 0.60.0, the [[str.join]] method can take an arbitrary number of arguments instead of just one list. Additionally, all lists past to [[str.join]] will now be flattened.
-D warnings, which will cause rustc to error for every warning not explicitly disabledThis means you can use custom_target, custom_target indices (custom_target[0], for example), or the output of generator.process as inputs to the various qt.compile_* methods.
qt = import('qt5') ct = custom_target(...) out = qt.compile_ui(sources : ct)
If the first argument is 'waf', special treatment is done for the waf build system. The waf executable must be found either in the current directory, or in system PATH.
Using the == and != operators to compare objects of different (for instance [1] == 1) types was deprecated and undefined behavior since 0.45.0 and is now a hard error.
It is now possible to install only a subset of the installable files using meson install --tags tag1,tag2 command line.
See documentation for more details.
It‘s never been documented, and it’s been marked deprecated for a long time, so let's remove it.
More than one name can now be passed to dependency(), they will be tried in order and the first name to be found will 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 are added into the cache so subsequent calls for any of those name will return the same value. This is useful in case a dependency could have different names, such as png and libpng.
r = i18n.gettext('mydomain') will now provide access to:
Support for CLA sources has been added for cross-compilation with the C2000 toolchain.
Clippy is a popular linting tool for Rust, and is invoked in place of rustc as a wrapper. Unfortunately it doesn‘t proxy rustc’s output, so we need to have a small wrapper around it so that Meson can correctly detect the underlying rustc, but still display clippy
Since 0.59.0, meson automatically activates Visual Studio environment on Windows for all its subcommands, but only if no other compilers (e.g. gcc or clang) are found, and silently continue if Visual Studio activation fails.
meson setup --vsenv command line argument can now be used to force Visual Studio activation even when other compilers are found. It also make Meson abort with an error message when activation fails. This is especially useful for GitHub Actions because their Windows images have gcc in their PATH by default.
--vsenv is set by default when using vs backend.
Only setup, compile, dist and devenv subcommands now activate Visual Studio.
Every project that uses UTF-8 source files had to add manually /utf-8 C/C++ compiler argument for MSVC otherwise they wouldn't work on non-English locale. Meson now switched the default to UTF-8 to be more consistent with all other compilers.
This can be overridden but using /source-charset:
if cc.get_id() == 'msvc' add_project_arguments('/source-charset:.XYZ', language: ['c', 'cpp']) endif
See Microsoft documentation for details: https://docs.microsoft.com/en-us/cpp/build/reference/source-charset-set-source-character-set.
find_library in EmscriptenThe find_library method can be used to find your own JavaScript libraries. The limitation is that they must have the file extension .js. Other library lookups will look up “native” libraries from the system like currently. A typical usage would look like this:
glue_lib = cc.find_library('gluefuncs.js', dirs: meson.current_source_dir()) executable('prog', 'prog.c', dependencies: glue_lib)
custom_target() nameThe name argument is now optional and defaults to the basename of the first output.