It's not necessary; cycles (which are rare) can be detected by looking
at the node stack.
This change speeds things up slightly, as well as simplifying the code a
little.
panic=abort support in libtest
Add experimental support for tests compiled with panic=abort. Enabled with `-Z panic_abort_tests`.
r? @alexcrichton
cc @cramertj
Rollup of 5 pull requests
Successful merges:
- #63492 (Remove redundancy from the implementation of C variadics.)
- #64589 (Differentiate AArch64 bare-metal targets between hf and non-hf.)
- #64799 (Fix double panic when printing query stack during an ICE)
- #64824 (No StableHasherResult everywhere)
- #64884 (Add pkg-config to dependency list if building for Linux on Linux)
Failed merges:
r? @ghost
Add pkg-config to dependency list if building for Linux on Linux
I got this message when building from source on Ubuntu:
```
It looks like you're compiling on Linux and also targeting Linux. Currently this
requires the `pkg-config` utility to find OpenSSL but unfortunately `pkg-config`
could not be found. If you have OpenSSL installed you can likely fix this by
installing `pkg-config`.
```
I feel like it would be a better experience to show this in the dependencies instead of having to run into this issue.
No StableHasherResult everywhere
This removes the generic parameter on `StableHasher`, instead moving it to the call to `finish`. This has the side-effect of making all `HashStable` impls nicer, since we no longer need the verbose `<W: StableHasherResult>` that previously existed -- often forcing line wrapping.
This is done for two reasons:
* we should avoid false "generic" dependency on the result of StableHasher
* we don't need to codegen two/three copies of all the HashStable impls when they're transitively used to produce a fingerprint, u64, or u128. I haven't measured, but this might actually make our artifacts somewhat smaller too.
* Easier to understand/read/write code -- the result of the stable hasher is irrelevant when writing a hash impl.
Fix double panic when printing query stack during an ICE
On the latest nightly, any call to `bug` or `span_bug` will result in two panics - the first one as a normal result of calling `bug` / `span_bug`, and the second as a result of trying to print the query stack from the panic handler. This is caused by the query-printing code attempting to acquire a lock on `HandlerInnder`, which is still being held by `bug`.
This PR moves the actual panic out of `HandlerInner`, into `Handler`. This allows us to release the lock on `HandlerInner` before triggering the panic, ensuring that the panic handler will be able to acquire the lock if necessary.
Differentiate AArch64 bare-metal targets between hf and non-hf.
CC @parched, kindly request you to review.
~~Note: This change breaks code that uses the target `aarch64-unknown-none` for the sake of clearer naming as discussed in the links posted below. A search on github reveals that code using `aarch64-unknown-none` is almost exclusively forked from our embedded WG's OS tutorials repo at https://github.com/rust-embedded/rust-raspi3-OS-tutorials, for which the target was originally created.~~
~~I will adapt this repo to the new target name asap once this PR would go upstream. The minor annoyance for the forks to break temporarily should be acceptable for the sake of introducing a better differentiation now before it is too late.
Also, the break would only happen upon updating the toolchain, giving the user a good hint at what has happened.~~
---------- Patch commit message:
Following up on [1] and [2], this PR adds differntiation for aarch64 bare-metal
targets between versions with and without floating point enabled.
This streamlines the target naming with other existing ARM targets and provides
the user clear indication if he is getting float or non-float for his bare-metal
target.
[1] https://github.com/rust-lang/rust/pull/60135#issuecomment-485851356
[2] https://github.com/rust-embedded/wg/issues/230Closes: rust-embedded/wg#230
Remove redundancy from the implementation of C variadics.
This cleanup was first described in https://github.com/rust-lang/rust/issues/44930#issuecomment-497163539:
* AST doesn't track `c_variadic: bool` anymore, relying solely on a trailing `CVarArgs` type in fn signatures
* HIR doesn't have a `CVarArgs` anymore, relying solely on `c_variadic: bool`
* same for `ty::FnSig` (see tests for diagnostics improvements from that)
* `{hir,mir}::Body` have one extra argument than the signature when `c_variadic == true`
* `rustc_typeck` and `rustc_mir::{build,borrowck}` need to give that argument the right type (which no longer uses a lifetime parameter, but a function-internal scope)
* `rustc_target::abi::call` doesn't need special hacks anymore (since it never sees the `VaListImpl` now, it's all inside the body)
r? @nagisa / @rkruppe cc @dlrobertson @oli-obk
Rollup of 10 pull requests
Successful merges:
- #64131 (data_structures: Add deterministic FxHashMap and FxHashSet wrappers)
- #64387 (Fix redundant semicolon lint interaction with proc macro attributes)
- #64678 (added more context for duplicate lang item errors (fixes#60561))
- #64763 (Add E0734 and its long explanation)
- #64793 (Fix format macro expansions spans to be macro-generated)
- #64837 (Improve wording in documentation of MaybeUninit)
- #64852 (Print ParamTy span when accessing a field (#52082))
- #64875 (Upgrade async/await to "used" keywords.)
- #64876 (Fix typo in intrinsics op safety)
- #64880 (Slice docs: fix typo)
Failed merges:
r? @ghost
Improve wording in documentation of MaybeUninit
Changes
> variables are properly initialized **at** their respective type
into
> variables are properly initialized **as** their respective type
Fix format macro expansions spans to be macro-generated
New Exprs generated as part of the format macro expansion should get the macro
expansion span with an expansion context, rather than the span of the format string
which does not.
added more context for duplicate lang item errors (fixes#60561)
Some more information about #60561 -- these errors are pretty common when one works in restrictive environments with `no_std` or customized `std`, but they don't provide much context for debugging, as any transitive dependency could have brought in `std` crate. With that, currently, one needs to use something like `cargo tree` and investigate transitive dependencies one by one.
It'll be more helpful to know at least the crate that uses `std` (which `cargo tree` doesn't show) to pin down this investigation when debugging.
I'm not sure what the best way to get this context is inside rustc internals (I'm new to them). I found that `all_crate_nums` query returns the crates in some dependency order, so printing out the name of the preceding crate seems to do the trick. But I welcome suggestions if this can be done in a better way.
Fix redundant semicolon lint interaction with proc macro attributes
Fixes#63967 and fixes#63947, both of which were caused by the lint's changes to the parser interacting poorly with proc macro attributes and causing span information to be lost
r? @varkor
data_structures: Add deterministic FxHashMap and FxHashSet wrappers
StableMap
A wrapper for FxHashMap that allows to `insert`, `remove`, `get`, `get_mut` and convert a hashmap into a sorted vector using the method `into_sorted_vector` but no iteration support.
StableSet
A wrapper for FxHashSet that allows to `insert`, `remove`, `get` and convert a hashset into a sorted vector using the method `into_sorted_vector` but no iteration support.
Addresses issue #63713
We relied previously on the caller (e.g. `Q::in_operand`) to ignore
`Local`s that were indirectly mutable (and thus assumed to be
qualified). However, it's much clearer (and more efficient) to do this
in the resolver itself.
This does not yet remove the masking done in `Q::in_operand` and others
for safety's sake, although I believe that should now be possible.
