Changes:
````
rustup https://github.com/rust-lang/rust/pull/69968/
Fix documentation generation for configurable lints
Fix single binding in closure
Improvement: Don't show function body in needless_lifetimes
````
Without Boats [Fri, 31 Jan 2020 13:26:24 +0000 (14:26 +0100)]
Add Wake trait for safe construction of Wakers.
Currently, constructing a waker requires calling the unsafe
`Waker::from_raw` API. This API requires the user to manually construct
a vtable for the waker themself - which is both cumbersome and very
error prone. This API would provide an ergonomic, straightforward and
guaranteed memory-safe way of constructing a waker.
It has been our longstanding intention that the `Waker` type essentially
function as an `Arc<dyn Wake>`, with a `Wake` trait as defined here. Two
considerations prevented the original API from being shipped as simply
an `Arc<dyn Wake>`:
- We want to support futures on embedded systems, which may not have an
allocator, and in optimized executors for which this API may not be
best-suited. Therefore, we have always explicitly supported the
maximally-flexible (but also memory-unsafe) `RawWaker` API, and
`Waker` has always lived in libcore.
- Because `Waker` lives in libcore and `Arc` lives in liballoc, it has
not been feasible to provide a constructor for `Waker` from `Arc<dyn
Wake>`.
Therefore, the Wake trait was left out of the initial version of the
task waker API.
However, as Rust 1.41, it is possible under the more flexible orphan
rules to implement `From<Arc<W>> for Waker where W: Wake` in liballoc.
Therefore, we can now define this constructor even though `Waker` lives
in libcore.
This PR adds these APIs:
- A `Wake` trait, which contains two methods
- A required method `wake`, which is called by `Waker::wake`
- A provided method `wake_by_ref`, which is called by
`Waker::wake_by_ref` and which implementors can override if they
can optimize this use case.
- An implementation of `From<Arc<W>> for Waker where W: Wake + Send +
Sync + 'static`
- A similar implementation of `From<Arc<W>> for RawWaker`.
bors [Mon, 23 Mar 2020 12:40:36 +0000 (12:40 +0000)]
Auto merge of #69649 - estebank:negative-impl-span, r=Centril
Tweak output for invalid negative impl errors
Follow up to #69722. Tweak negative impl errors emitted in the HIR:
```
error[E0192]: invalid negative impl
--> $DIR/E0192.rs:9:6
|
LL | impl !Trait for Foo { }
| ^^^^^^
|
= note: negative impls are only allowed for auto traits, like `Send` and `Sync`
```
bors [Mon, 23 Mar 2020 09:30:00 +0000 (09:30 +0000)]
Auto merge of #70305 - Centril:rollup-zi13fz4, r=Centril
Rollup of 8 pull requests
Successful merges:
- #69080 (rustc_codegen_llvm: don't generate any type debuginfo for -Cdebuginfo=1.)
- #69940 (librustc_codegen_llvm: Replace deprecated API usage)
- #69942 (Increase verbosity when suggesting subtle code changes)
- #69968 (rustc: keep upvars tupled in {Closure,Generator}Substs.)
- #70123 (Ensure LLVM is in the link path for rustc tools)
- #70159 (Update the bundled wasi-libc with libstd)
- #70233 (resolve: Do not resolve visibilities on proc macro definitions twice)
- #70286 (Miri error type: remove UbExperimental variant)
Rollup merge of #70123 - cuviper:library-path, r=Mark-Simulacrum
Ensure LLVM is in the link path for rustc tools
The build script for `rustc_llvm` outputs LLVM information in `cargo:rustc-link-lib` and `cargo:rustc-link-search` so the compiler can be linked correctly. However, while the lib is carried along in metadata, the search paths are not. So when cargo is invoked again later for rustc _tools_, they'll also try to link with LLVM, but the necessary paths may be left out.
Rustbuild can use the environment to set the LLVM link path for tools -- `LIB` for MSVC toolchains and `LIBRARY_PATH` for everyone else.
Rollup merge of #69968 - eddyb:tupled-closure-captures, r=nikomatsakis
rustc: keep upvars tupled in {Closure,Generator}Substs.
Previously, each closure/generator capture's (aka "upvar") type was tracked as one "synthetic" type parameter in the closure/generator substs, and figuring out where the parent `fn`'s generics end and the synthetics start involved slicing at `tcx.generics_of(def_id).parent_count`.
Needing to query `generics_of` limited @davidtwco (who wants to compute some `TypeFlags` differently for parent generics vs upvars, and `TyCtxt` is not available there), which is how I got started on this, but it's also possible that the `generics_of` queries are slowing down `{Closure,Generator}Substs` methods.
To give an example, for a `foo::<T, U>::{closure#0}` with captures `x: X` and `y: Y`, substs are:
* before this PR: `[T, U, /*kind*/, /*signature*/, X, Y]`
* after this PR: `[T, U, /*kind*/, /*signature*/, (X, Y)]`
You can see that, with this PR, no matter how many captures, the last 3 entries in the substs (or 5 for a generator) are always the "synthetic" ones, with the last one being the tuple of capture types.
Rollup merge of #69080 - eddyb:one-billion-dwarves-walk-into-a-bar, r=michaelwoerister
rustc_codegen_llvm: don't generate any type debuginfo for -Cdebuginfo=1.
Works towards #69074 by adding more checks for `DebugInfo::Full` in a few places in `rustc_codegen_llvm`, bringing us in line with what `clang -g1` generates (no debuginfo types, nor debuginfo for `static`s).
<hr/>
My local build's (`debuginfo-level=1`, `debug-assertions=1`) `librustc_driver-*.so` went from just over 1GiB (1019MiB) down to 402MiB.
It's still bad, but the `.debug_*` sections themselves (as reported by `objdump`) went from something like 853MiB down to 236MiB, i.e. roughly a 3.6x reduction.
<hr/>
Sadly, I don't think this is enough to justify *shipping* all of this debuginfo, but now it's more plausible that we could at least *build* with `debuginfo-level=1` *then* strip it.
That would give us real backtraces for e.g. ICEs during builds, but I don't know how often that's relevant.
We could also look into split DWARF, and maybe have a `rustc-debuginfo` component in `rustup`.
There's also the possibility of making it slimmer by omitting parameters to functions, or perhaps some deduplication (I think right now there is no DWARF reuse across CGUs? maybe ThinLTO helps?).
r? @michaelwoerister cc @rust-lang/wg-codegen @alexcrichton @Mark-Simulacrum
Aaron Hill [Tue, 17 Mar 2020 15:45:02 +0000 (11:45 -0400)]
Store idents for `DefPathData` into crate metadata
Previously, we threw away the `Span` associated with a definition's
identifier when we encoded crate metadata, causing us to lose location
and hygiene information.
We now store the identifier's `Span` in the crate metadata.
When we decode items from the metadata, we combine
the name and span back into an `Ident`.
This improves the output of several tests, which previously had messages
suppressed due to dummy spans.
This is a prerequisite for #68686, since throwing away a `Span` means
that we lose hygiene information.
Rollup merge of #70236 - petrochenkov:globimpice, r=ecstatic-morse
resolve: Avoid "self-confirming" import resolutions in one more case
So the idea behind "blacklisted bindings" is that we must ignore some name definitions during resolution because otherwise they cause infinite cycles.
E.g. import
```rust
use my_crate;
```
would refer to itself (on 2018 edition) without this blacklisting, because `use my_crate;` is the first name in scope when we are resolving `my_crate` here.
In this PR we are doing this blacklisting for the case
```rust
use same::same;
```
, namely blacklisting the second `same` when resolving the first `same`.
This was previously forgotten.
Rollup merge of #69880 - RalfJung:miri-assert-error-sanity, r=oli-obk
miri engine: turn error sanity checks into assertions
We had these as debug assertions so far to make sure our test suite is clean, but really these are conditions that should never arise and also @eddyb told me to turn non-performance-critical debug assertions into full assertions so here we go. ;)
I propose that we do a check-only crater run to make sure this does not actually happen in practice.
Rollup merge of #69251 - anp:track-caller-in-traits, r=eddyb
#[track_caller] in traits
Per https://github.com/rust-lang/rust/issues/47809#issuecomment-572791760, this allows the `#[track_caller]` attribute on trait methods.
Includes tests for `#[track_caller]` with:
* "regular" trait impls
* default trait impls
* "blanket-tracked" trait impls, where the annotation is in the trait definition and is inherited by "regular" impls of the trait
bors [Mon, 23 Mar 2020 03:10:48 +0000 (03:10 +0000)]
Auto merge of #70204 - Centril:unshackled-lowering, r=Zoxc
Liberate `rustc_ast_lowering` from `rustc`
The whole point of this PR is the very last commit, in which we remove `rustc` as one of `rustc_ast_lowering`'s dependencies, thereby improving `./x.py` parallelism and working towards https://github.com/rust-lang/rust/issues/65031.
Noteworthy:
- From `rustc::arena` we move logic into `arena`, in particular `declare_arena!`. This is then used in `rustc_ast_lowering` so that lowering has its own separate arena.
- Some linting code is unfortunately moved to `rustc_session::lint` cause its used both in `rustc_lint` and `rustc_ast_lowering`, and this is their common dependency.
- `rustc_session::CrateDisambiguator` is moved into `rustc_ast` so that `rustc::hir::map::definitions` can be moved into `rustc_hir`, so that `rustc_ast_lowering` can stop referring to `rustc::hir`.
Introduce a local variable `config_emit_normal_obj`.
This adds a missing `!config.obj_is_bitcode` condition to two places
that should have it.
As a result, when `obj_is_bitcode` and `no_integrated_as` are both true,
the compiler will no longer unnecessarily emit asm, convert it to an
object file, and then overwrite that object file with bitcode.
I find the code easier to read if the values in `config` are all used
directly, rather than a mix of `config` values and local variables. It
will also faciliate some of the following commits.
bors [Sun, 22 Mar 2020 22:36:44 +0000 (22:36 +0000)]
Auto merge of #69778 - Marwes:dep_graph, r=davidtwco
perf(dep_graph): Avoid allocating a set on when the number reads are …
…small
`reserve_and_rehash` takes up 1.4% of the runtime on the `packed-simd`
benchmark which I believe is due to the number of reads are very low in
many cases (see https://github.com/rust-lang/rust/pull/50565 for
instance).
This avoids allocating the set until we start allocating the `reads`
`SmallVec` but it is possible that a lower limit might be better (not
tested since the improvement will be hard to spot either way).
CDirkx [Sun, 22 Mar 2020 21:04:05 +0000 (22:04 +0100)]
Add regression test for #70155.
With #70166 merged, `RangeInclusive` now derives `PartialEq` and `Eq`, implementing structural equality and as a side effect the range is now usable with const generics, closing #70155.
A test is added to avoid a change to the private fields or the equality implementation of the range from subtly reverting #70155.
bors [Sun, 22 Mar 2020 18:37:19 +0000 (18:37 +0000)]
Auto merge of #69079 - CAD97:layout-of-ptr, r=RalfJung
Allow calculating the layout behind a pointer
There was some discussion around allowing this previously.
This does make the requirement for raw pointers to have valid metadata exposed as part of the std API (as a safety invariant, not validity invariant), though I think this is not strictly necessarily required as of current. cc @rust-lang/wg-unsafe-code-guidelines
Naming is hard; I picked the best "obvious" name I could come up with.
If it's agreed that this is actually a desired API surface, I'll file a tracking issue and update the attributes.
Dylan DPC [Sun, 22 Mar 2020 14:48:41 +0000 (15:48 +0100)]
Rollup merge of #70254 - matthiaskrgr:cl4ppy, r=Centril
couple more clippy fixes (let_and_return, if_same_then_else)
* summarize if-else-code with identical blocks (clippy::if_same_then_else)
* don't create variable bindings just to return the bound value immediately (clippy::let_and_return)
Dylan DPC [Sun, 22 Mar 2020 14:48:40 +0000 (15:48 +0100)]
Rollup merge of #70253 - jplatte:patch-2, r=Mark-Simulacrum
Remove another wrong entry from RELEASES.md
The entry is under 1.11.0, but the feature is only available since 1.12.0 (for which an identical entry exists).
![Screenshot_2020-03-22 Support `cfg_attr` on `path` attributes by jseyfried · Pull Request #34546 · rust-lang rust](https://user-images.githubusercontent.com/951129/77238862-85c8f580-6bd4-11ea-8d31-77e2994a4b5a.png)
Dylan DPC [Sun, 22 Mar 2020 14:48:35 +0000 (15:48 +0100)]
Rollup merge of #70229 - matthiaskrgr:cl3ppy, r=Mark-Simulacrum
more clippy fixes
* remove unused unit values (clippy::unused_unit)
* make some let-if-bindings more idiomatic (clippy::useless_let_if_seq)
* clarify when we pass () to functions (clippy::unit_arg)
* don't redundantly repeat field names (clippy::redundant_field_names)
* remove redundant returns (clippy::needless_return)
* use let instead of match for matches with single bindings (clippy::match_single_binding)
* don't convert results to options just for matching (clippy::if_let_some_result)
Dylan DPC [Sun, 22 Mar 2020 14:48:32 +0000 (15:48 +0100)]
Rollup merge of #70209 - Centril:recover-quant-closure, r=petrochenkov
parser: recover on `for<'a> |...| body` closures
When encountering `for` and `<` is 1 token ahead, interpret this as an explicitly quantified generic closure and recover, rather than attempting to parse a `for` loop. This provides both improved diagnostics as well as an insurance policy for the ability to use this as the syntax for generic closures in the future.
Dylan DPC [Sun, 22 Mar 2020 14:48:30 +0000 (15:48 +0100)]
Rollup merge of #70172 - eddyb:retokenize-external-src, r=petrochenkov
parse/lexer: support `StringReader::retokenize` called on external files.
This ~~should theoretically~~ fixes #69933, ~~but I'm not sure what the best way to test it is~~.
**EDIT**: see https://github.com/rust-lang/rust/issues/69933#issuecomment-602019598.
Dylan DPC [Sun, 22 Mar 2020 14:48:28 +0000 (15:48 +0100)]
Rollup merge of #68099 - lukaslueg:into_raw_unsafe, r=LukasKalbertodt
Amend Rc/Arc::from_raw() docs regarding unsafety
[This](https://stackoverflow.com/questions/59671647/is-it-safe-to-clone-a-type-erased-arc-via-raw-pointer) question on SO boils down to "is it safe to `::from_raw()` a `Rc<T>`/`Arc<T>` using a dummy `T` even if `T` is never dereferenced via the new `Rc`/`Arc`?". It almost never is.
This PR amends the docs of `from_raw()` regarding this point.
bors [Sun, 22 Mar 2020 11:57:58 +0000 (11:57 +0000)]
Auto merge of #68820 - WaffleLapkin:remove_finished_from_map_while, r=LukasKalbertodt
Remove `finished` flag from `MapWhile`
This PR removes `finished` flag from `MapWhile` as been proposed in https://github.com/rust-lang/rust/pull/66577#discussion_r370958025.
This also resolves open questions of the tracking issue (#68537):
- `MapWhile` can't implement both
+ `DoubleEndedIterator` (discussed in https://github.com/rust-lang/rust/pull/66577#discussion_r370947990 and following comments)
+ `FusedIterator` (this pr removes `finished` flag, so `MapWhile` isn't fused anymore)
- Debug output (this pr removes `finished` flag, so there is no question in including it in debug output)