log running commands a bit better by doing proper shell quoting

runpython: make it work for -c as well

In commit 4e4f97edb3d475273108b203bc02b04bd6840b06 we added support for
runpython to accept `-c 'code to execute'` in addition to just script
files. However, doing so would mangle the sys.argv in the executed code
-- which assumes, as python itself does, that argv is the stuff after
the code to execute. We correctly handled this for script files, but the
original addition of -c support pushed this handling into a script-file
specific block.

mlog: do not squelch console output for errors

We have functionality to squelch logging, and we use this for situations
where we run a fake interpreter and then emit output. e.g. `introspect`.

It's reasonable to avoid logging your bog-standard noisy `mlog.log()`
here, but unfortunately, we also avoided logging the output of
`mlog.exception()` followed by `sys.exit(2)`, because that went through
mlog! :P Special-case this to keep on printing, even if mlog.disable()
was used -- in such a case, we really do want to emit log output no
matter what. Users need this info to ensure they have any clue why Meson
returned a non-zero exit code.

introspect: avoid crashing when add_languages for an optional language fails

Because that is what the real interpreter does, too. It logs a failure
and carries on.

Users.md: add @dcantrell /bsdutils

tests/llvm: require cmake 3.11

This is a weird but working way to skip this test from running on
bionic (where it should not run).

cmake: allow dynamic linking with LLVM

llvm-config is unsuitable for standard cross-compile,
because we need to build llvm especially for it, which
is not done is almost any distros, so, for example,
standard bootstrap chroot will be unsuitable.

This patch is trying to acheive feature parity between
config-tool searching of LLVM and CMake-based one,
which is arch-agnostic.

Signed-off-by: Konstantin <ria.freelander@gmail.com>

gnome: Deduplicate include dirs to generate gir

Ensuring the order is respected

tests: avoid unexpected failure when cmake is not installed

This test case checks stdout and demands a `dependency()` lookup fail.
The resulting error message can be different depending on whether cmake
is installed, or not. For cmake-specific tests we would simply skip the
test if cmake is not installed, but here we can just fine-tune the
pattern matching we use to determine if the test failed "correctly".

Fixes #11320

mtest: do not warn when the TAP stream version is 12

Partial rollback of commit b7a5c384a1f1ba80c09904e7ef4f5160bdae3345. The
rationale was based on a confusing wording of the TAP14 spec, which is
under discussion for clarification / amendment.

TAP14 doesn't (shouldn't) really say that missing a version line is
potentially an error. Rather, this is the correct way to denote TAP12,
which a TAP14 harness may not understand or try to parse. The intention
was never to suggest that harnesses "should" take exception to the
missing version line on the grounds that one should really add a version
line.

So, stop emitting an annoying warning for something that's valid usage.
Meson understands TAP12 and that's okay.

However, we do need to keep the part of that commit which set the
version to 12 if it was otherwise unspecified. But instead of
distinguishing between None and a version, just default to 12.

Revert "debug cygwin CI"

This reverts commit 79d7891746a7864a1407d48eac8a753b225ec6c3.

This debug print probably should not have ended up live. Moreover, the
function it debugs is, surprisingly, called rather often. Adding I/O to
it causes it to begin to noticeably lag, on the scale of adding actual
*minutes* to a setup run.

Fixes #11322

meson init --build should call meson setup and vsenv

Haiku pkgconfig directory layout support

haiku: set default prefix and library paths

devenv should import env vars from vsenv

docs: Qt compile_moc() parameter error

"extra_arguments" should be "extra_args"

optinterpreter: pass deprecated keyword directly to Option initializer

Deprecate passing strings to non-string options

Currently Meson allow the following (Muon does not):
```meson
option('foo', type : 'boolean', value : 'true')
option('bar', type : 'integer', value : '42')
```

This is possibly a holdover from very old code, but it's a bad idea and
we should stop doing it. This deprecation is the first stop on that
journey.

use typed_kwargs for the various option subparsers

We make use of allow_unknown=True here, which allows us to only look at
the common arguments in the main option parser, and then look at the
specific options in the dispatched parsers. This allows us to do more
specific checking on a per overload basis.

decorators: don't unsort sorted values for printing

Currently in our deprecated/new feature printing we carefully sort all
of the values, then put them in a set to print them. Which unsorts them.
I'm assuming this was done because a set looks nice when printed (which
is true). Let's keep the formatting, but print them in a stable order.

coredata: allow deprecation to be passed to Option initializer

Instead of requiring it to be set outside the initializer

coredata: get rid of UserArrayOption `**kwargs`

Let's just pass the two arguments explicitly.

coredata: use DEFAULT_YIELDING as the default value for Options

Instead of setting it to `Optional[bool] = None`, and then in the
initializer replacing `None` with `DEFAULT_YIELDING`, just set to to
`bool = DEFAULT_YIELDING`

coredata: use a frozenset instead of a dict where values are always None

remove dead code

We shouldn't be hardcoding library dirs anyway. And we usually get this
from the compiler.

This function has been unused since its users were moved to use the
compiler method, in the following commits:
- a1a4f66e6d915c1f6aae2ead02cf5631b10c76f1
- a3856be1d50eaefe32fee5d3347d55d934d15b50
- 08224dafcba1b694fb624553e7d84deb565aae22

dependencies: fix pcap-config which now errors on --version

The latest release of libpcap added argument validation to pcap-config,
but still doesn't support --version. The next version of libpcap will
support --version.

Add support for config-tool dependencies which expect to break on
--version, to fallback to an option that does not error out or print
version info, for sanity checking.

interpreter: use typed_pos_args for build_targets

We have to allow through build.BuildTarget and build.ExtractedObjects,
which is what our previous level of checking did, even though they are
ignored. I've used FeatureDeprecated calls here, so that we have a clear
time of "this was officially deprecated in 1.1.0"

coredata: Make a deepcopy of global state before mutating

When a compiler is initialized, it adds specific options that it
supports, but taking some global UserOption objects and adding them to
itself. When it does so, it mutates then if necessary. This means that
each compiler initialized mutates global state, this is bad. This is
worse because in our test suite we do in process testing, so these
mutations are preserved *between tests*, potentially leading to
incorrect results. The simple fix is to do the right thing, and copy the
UserOption before mutating. A deepcopy is required because the option
might be an ArrayOption, and a shallow copy is not sufficient in that
case.

doc: Fix typo in release notes

Fix typo in doc of sourceset module

devenv: Allow dumping into file and select a format

It is often more useful to generate shell script than dumping to stdout.
It is also important to be able to select the shell format.

Formats currently implemented:
- sh: Basic VAR=prepend_value:$VAR
- export: Same as 'sh', but also export VAR
- vscode: Same as 'sh', but without substitutions because they don't
  seems to work. To be used in launch.json's envFile.

 Fix nasm when target has threads as added dependency

mparser: Use a literal for the ComparisonNode

And fix a bug where `not in` is in the wrong order.

properly type utils/core.py and add it to mypy

EnvironmentVariables was always broken, it used MutableMapping because
everyone <3 abstract interfaces, especially when they are broken and
don't actually do what you want.

This needs a dict interface, exposing `.copy()`. We either use a dict or
os._Environ, and the latter also supports that.

Also fix a broken import, and the fallout from forgetting to update the
signature of self.envvars in commit b926374205bd761085031755c87152d08bc10e9d.

BUG: Fix generated sources not being included as dependencies in cython transpilation

tests: track when an entire category is skipped and be quieter

There is no need to state for every single test that "preconditions were
not met". And logging the skip reason for a single test is easy to read,
but making every second line alternate is less so.

tests: properly log the reason why a test got unexpectedly skipped

remove totally invalid gcc arguments from cross file

Partial revert of commit cf23e341878286790885352fd1d6548be5798391. This
mostly moved existing arguments to the "right" location, but also
introduced new arguments that didn't previously exist -- which was
wrong.

... also, these cross files are used by CI (if they have a corresponding
.json file) and this change broke the CI. Because --target isn't a valid
gcc option, although clang/rustc do accept it. For GCC, the argument
parser decides you wanted --target-help, which prints documentation text
and then quits.

cross: move multilib options to [binaries] section

c_args are meant to be overridden by the user if needed (even via the
environment CFLAGS variables + -Doptimization=plain, for example),
so they should not contain any option that affect the multilib search
path.  For example, a hypothetical native file like this:

   [binaries]
   c = gcc

   [built-in options]
   c_args = ['-m32']

would *not* build 32-bit binaries if -Dc_args is passed to meson.
Such options, instead should be in the [binaries] section.  Adjust
the sample cross files included with meson.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

coredata: Remove dead code

backends: Stop passing generator exes to ExecutableSerialisation as strings

The code below this already handles being passed an Executable or
ExternalProgram, and it does it correctly, since it handles host
binaries that need an exe_wrapper correctly, while the code in the
generator paths doesn't.

The xcode backend is, like always, problematic, it doesn't handle things
the same way as the ninja and vscode backends, and generates a shell
script instead of using meson as a wrapper when needed (it seems likely
that just forcing the meson path for xcode would be better). I don't
have a working mac to develop a fix for, so I've left a todo comment
there.

Fixes: #11264

docs: Add ld64.lld to linker reference table

I forgot to ask the original author to add this to the original MR
(#11243)

linkers: detect ld64 as AppleDynamicLinker

modules: fully type the Qt* modules

The base module is fully typed, but the numbered version are not, though
it's pretty trivial to do so.

modules: add type annotations to the `__init__` module

modules/external_project: `make` should be immutable

In some cases we'll get an `ImmutableListProtocol[str]` anyway (and
actually, we should probably be getting one in call cases), since we
don't mutate it anyway, just store it as immutable.

modules/i18n: fix type annotations

Again, state.find_program is wrong

modules/icestorm: fix type annotations

This is also due to the incorrect annotations of state.find_program()

modules/qt: Fix annotations for state.find_program

Because this too, has the wrong assumptions

modules/rust: Fix annotation for _bindgen_bin

Which suffers from the same issue as the gnome module

modules/gnome: fix type annotations from `__init__`, which are wrong

Mainly thi sis that `state.find_program()` is annotated incorrectly, it
returns `ExternalProgram | Executable | OverrideProgram`, but it's
annotated to return only `ExteranlProgram`, and thus a bunch of the
annotations in the gnome module are wrong.

build: Add a found method to Executable

Again, this is necessary for polymorphism with ExternalProgram

build: Add a get_path method to Executable

This is needed to make Executable Polymorphic with ExternalProgram. This
can happen when a build program overrides a lookup.

linkers: Do not use numeric windows subsystems with lld

Fixes: #11258

linkers: Fix lld detection

This was actually probing bfd without always_args passed.

Fixes: #10763

CI: fix cuda image breakage

From the Zen of Python: "Explicit is better than implicit."

As it turns out, it's no longer a safe assumption that pip uses
setuptools??? Well, anyway, install it properly regardless.

CI: get wxgtk2 via aur_pkgs as it was dropped from the official repos

Note: this does not actually fix the image builder. It just lets us get
far enough to see the testsuite error (the same docker bug that opensuse
has).

avoid detecting masm as a MSVC-like compiler for detecting showincludes

It's msvc-like but, just like Intel Fortran, doesn't support this
argument.

msvc: handle filename extensions for incdetect based on the compiler language

It is possible, albeit possibly inadvisable, for the exact combination
of MSVC and "$CXX has C++ specific flags in it" to occur. When this
happens, and cl.exe is given a filename ending in .c, it complains that
you cannot compile a .c file with that option.

Instead, pick the first filename matching that language and use that as
the temporary filename. This more or less matches what we do in
compiler-time checks. And it's the proper thing to do, rather than
assume that cl.exe, when detected as the current C++ compiler, can
*also* compile C because it's *also* a C compiler.

Fixes #11257

Users.md: add slapt-get

@jaos please review

be more explicit about asyncio usage

`get_event_loop()` would always implicitly create one on demand, but
Python upstream has decided it's a bad/confusing API. Explicitly
starting our own, then setting it, is exactly equivalent other than not
being scheduled for deprecation.

mtest: simplify deprecated access to current loop

These functions constantly want the current asyncio loop, and we run a
function call each time to get it. And the function call is a deprecated
one. Python 3.7 brings the more explicit get_running_loop for use when
we know we're inside one, with the aim of getting rid of get_event_loop
once support for python <3.7 disappears. Meson no longer supports python
<3.7 either.

Switch to the new API, and save the reference for reuse instead of
constantly re-calculating it.

mtest: clean up asyncio event loop instantiation

Fix a TODO comment about moving to asyncio.run, now that we use
sufficiently new python to do it.

Note that we create an event loop for Windows using the new python
defaults, but in a completely different part of the code from where we
need to use it. Since asyncio.run creates the loop on its own, we need
to set the default policy instead -- which we probably should have done
all along.

mtest: delay creation of asyncio lock until event loop exists

In https://bugs.python.org/issue42392 this stopped implicitly creating
an event loop if none exists. We created it before running _run_tests(),
so it would auto-create an event loop and set the default, which means
we cannot create one explicitly on our own schedule or we end up with
two of them.

Delay this until we actually start the logger. This happens inside the
actual testsuite loop, so it finds the running loop and doesn't create a
new one, even on python <3.10.

add a hidden environment variable to make Meson complain hard on deprecations

Useful for running the testsuite with this environment variable and
catching obscure issues. Just like with the encoding warning later down,
we have to do this inside meson itself, not externally injected.

clang-cl: supports /std:c++20 now.

See https://github.com/llvm/llvm-project/commit/a8f75d49

document declare_dependency(object: ...)

forbid using declare_dependency(objects: ...) with pkg-config module

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

add testcase for declare_dependency(objects: ...)

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

add objects keyword argument to declare_dependencies

allow passing generated objects in the "objects" keyword argument

Generated objects can already be passed in the "objects" keyword argument
as long as you go through an extract_objects() indirection.  Allow the
same even directly, since that is more intuitive than having to add them
to "sources".

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

modules/gnome: use `mlog.log(once=True)` in a few more places

It's probably not useful to spam the user with warnings that old
versions of software may not behave correctly when the first warning was
perfectly valid.

Add fatal=False to many mlog.warnings()

There are lots of warnings that become fatal, that are simply unfixable
by the end user. Things like using old versions of software (because
they're using some kind of LTS release), warnings about compilers not
supporting certain kinds of checks, or standards being upgraded due to
skipped implementations (MSVC has c++98 and c++14, but not c++11). None
of these should be fatal, they're informative, and too important to
reduce to notices, but not important enough to stop meson if they're
printed.

wrap: use log once instead of hand rolling

mparser: Don't create an exception to pass to mlog.warning

Just call `mlog.code_line` directly, since the exception is never raised.

mlog: move code for printing code with a caret to the mlog module

We need this outside the constructor for the ParseException class, so
let's pull it out. mlog seemed like a good place since it's a text
formatting function, and has no dependencies.

reformat some warnings for better code readability

backends/backends: Add helpful message for getting rid of warning

mlog: use an enum instead of strings

enum comparisons are ultimately ints, so they're faster, plus they're
exhaustive, so mypy can statically determine that we've passed a valid
value rather than via an assertion at runtime.

mlog: Remove using of `**kwargs: T.Any`

This is annoying because we can't get proper auto-completion of mlog,
and because ultimately it was allowing keyword arguments to be silently
dropped on the floor. This does make the code a little more verbose, but
I think the trade-offs of completion + better safety are worth it.

PEP692, which will be part of python 3.12, provides a more elegant
solution using `TypedDicts` to annotate `**kwargs`, which we should
consider in the future.

msetup: do some stupid casting to make mypy happy

mypy is pretty dumb when it comes to unions of callables (pylance is
also dumb in this regard), and can't figure out that our use of
`mlog.debug | mlog.log` is perfectly safe. We also can't annotate them
properly to cast them to a valid subset of arguments because you can't
have splats in `typing.Callable`, so I've done enough to make it work.

dependencies/dev: refactor some code to make mypy happy

There should be a way to make mypy happy without casting, but I can't
figure it out, since the mlog.error and mlog.debug actually have
different signatures.

mparser: don't pass a SimpleNamespace where a BaseNode is expected

mypy spotted this as well. And it turns out that we're not setting the
column either for the warning, so improvements!

mesonlib: remove filename parameter to mlog.warning

After tracing all the way down to the bottom of this (or really, adding
annotations so mypy can) it turns out that passing file would just be
ignored at the end of the mlog call stack, so it should be removed

CI: bypass the cache and install codeql latest

fixes instability in precise version of tools resulting in some runners
getting a downgraded version and producing spuriously fixed/reintroduced
codeql alerts.

add builtin option to install licenses

Unless `meson.install_dependency_manifest()` is explicitly used, this
will cause a default implied one to be installed.

add license_files kwarg to project

Hook this up to installed dependency manifests. This is often needed
above and beyond just an SPDX string -- e.g. many licenses have custom
copyright lines.

tests: fix test that has source code incompatible with modern C

Delayed until clang 16, -Werror=incompatible-function-pointer-types is
the default. GCC 14 is "likely to do the same".

See https://wiki.gentoo.org/wiki/Modern_C_porting

docs: update IDE-integrations [skip-ci]

- change asabil.meson to vscode-meson
- remove unmaintained Meson-UI and Meson Cmake Wrapper
- remove note that Ecplise CDT support is experimental

docs: add mmeson to IDE integrations [skip-ci]

emscripten: remove no longer relevant comment

This was fixed in Emscripten 1.39.16, see:
https://github.com/emscripten-core/emscripten/commit/d4fabf3da40e7f556700b16950739d5960a91559

emscripten: enforce version 1.39.19 or higher

emscripten: remove redundant `thread_flags` implementation

Since it's the same as the one in `CLikeCompiler`.

emscripten: use single arguments when specifying options

i.e. without a space between the "-s" and option name. See:
https://github.com/emscripten-core/emscripten/issues/11463

This is supported since Emscripten 1.39.19, see:
https://github.com/emscripten-core/emscripten/commit/f45bea21f3a8f74a68ed4e3e3d7e290807ee2aff

emscripten: prefer `-pthread` over `-s USE_PTHREADS=1`

See: https://github.com/emscripten-core/emscripten/issues/12346

This is supported since Emscripten 1.38.33, see:
https://github.com/emscripten-core/emscripten/commit/24350798a8570f567327f873cf1efb0361aec284

dependencies: better logging of pkg-config call outputs

If `pkg-config --modversion foobar` fails, we don't know why. The
general issue here, though, is that call_pkgbin routinely logs stdout
for informational purposes, but not stderr.

Fixes #11076

interpreter: use static_lib's already calculated pic value

Instead of re-calculating it when building both libraries

Bump version number for new development.

This is it. The 1.0.0.

Created release note page for 1.0.0.