bors [Sat, 21 Dec 2019 14:30:26 +0000 (14:30 +0000)]
Auto merge of #67485 - Centril:rollup-gt0opvr, r=Centril
Rollup of 7 pull requests
Successful merges:
- #67059 (Fix too restrictive checks on Drop impls)
- #67355 (Merge `ast::Mutability` and `mir::Mutability`)
- #67393 (Enable opting out of specific default LLVM arguments.)
- #67422 (Cleanup err codes)
- #67462 (Make ptr::slice_from_raw_parts a const fn available under a feature flag)
- #67467 (Test slice patterns more)
- #67478 (Fix src/libcore/str/mod.rs doc comments)
Rollup merge of #67462 - DutchGhost:const_slice_from_raw_parts, r=dtolnay
Make ptr::slice_from_raw_parts a const fn available under a feature flag
A first step in the direction of https://github.com/rust-lang/rust/issues/67456 .
This makes `ptr::slice_from_raw_parts` and `ptr::slice_from_raw_parts_mut` available as a const fn under a feature flag.
Rollup merge of #67393 - michaelwoerister:llvm-args-override, r=varkor
Enable opting out of specific default LLVM arguments.
`rustc` by default adds a few arguments to LLVM (like `-mergefunc-use-aliases` for example). With this PR `rustc` will only emit these arguments if the same argument has not already been specified by the user via `-Cllvm-args`. This enables opting out of these defaults.
The PR also removes a PGO specific `-Z` flag the effect of which can also be easily achieved by `-Cllvm-args`.
Rollup merge of #67059 - TommasoBianchi:dropck_fix_pr, r=pnkfelix
Fix too restrictive checks on Drop impls
Fixes #34426. Fixes #58311.
This PR completes and extends #59497 (which has been inactive for a while now).
The problem generating both issues was that when checking that the `Predicate`s of the `Drop` impl are exactly the same as the ones of the struct definition, the check was essentially performed by a simple `==` operator, which was not handling correctly HRTBs and involved `Fn` types.
The implemented solution relies on the `relate` machinery to more correctly equate `Predicate`s, and on `anonymize_late_bound_regions` to handle HRTB in a more general way. As the `Relate` trait currently is implemented only for `TraitPredicate` and `ProjectionPredicate` (and as they were the ones generating problems), `relate` is used only for them while for other `Predicate`s the equality check is kept. I'm currently considering whether it would make sense to implement the `Relate` trait also for all other `Predicate`s to render the proposed solution more general.
Matthew Jasper [Sun, 8 Dec 2019 17:22:35 +0000 (17:22 +0000)]
Update tests for GATs
* Make some run-pass or check-pass
* Use `#![allow(incomplete_features)]`
* Update FIXMEs now that some of the issues have been addressed
* Add regression tests
bors [Sat, 21 Dec 2019 11:05:03 +0000 (11:05 +0000)]
Auto merge of #66994 - Centril:stmt-polish, r=estebank
refactor expr & stmt parsing + improve recovery
Summary of important changes (best read commit-by-commit, ignoring whitespace changes):
- `AttrVec` is introduces as an alias for `ThinVec<Attribute>`
- `parse_expr_bottom` and `parse_stmt` are thoroughly refactored.
- Extract diagnostics logic for `vec![...]` in a pattern context.
- Recovery is added for `do catch { ... }`
- Recovery is added for `'label: non_block_expr`
- Recovery is added for `var $local`, `auto $local`, and `mut $local`. Fixes #65257.
- Recovery is added for `e1 and e2` and `e1 or e2`.
- ~~`macro_legacy_warnings` is turned into an error (has been a warning for 3 years!)~~
- Fixes #63396 by forward-porting #64105 which now works thanks to added recovery.
- `ui-fulldeps/ast_stmt_expr_attr.rs` is turned into UI and pretty tests.
- Recovery is fixed for `#[attr] if expr {}`
bors [Sat, 21 Dec 2019 01:02:54 +0000 (01:02 +0000)]
Auto merge of #67464 - Centril:rollup-j3mkl1m, r=Centril
Rollup of 6 pull requests
Successful merges:
- #67130 (Const prop should finish propagation into user defined variables)
- #67163 (Split up ptr/mod.rs in libcore...)
- #67314 (Don't suppress move errors for union fields)
- #67392 (Fix unresolved type span inside async object)
- #67404 (Separate region inference logic from error handling better)
- #67428 (`is_binding_pat`: use explicit match & include or-pats in grammar)
Josh Stone [Fri, 20 Dec 2019 23:45:03 +0000 (15:45 -0800)]
Remove rustc-dev from the default nightly components
It was already filtered from other branches, but we only kept it in
nightly's default to ease the transition. Now that the separation of
rust-std/rustc-dev has reached the 1.40 release, it seems like a good
time for that transition to end.
Rollup merge of #67392 - csmoe:async-typeinfo, r=estebank
Fix unresolved type span inside async object
Closes #65180
r? @estebank
It's hard to create a minimal repro for that issue, [decided](https://rust-lang.zulipchat.com/#narrow/stream/187312-wg-async-foundations/topic/meeting.202019.2E12.2E17/near/183675659) to give up finding mcve.
cc [previous take](https://github.com/rust-lang/rust/pull/65668)
Rollup merge of #67163 - TheSamsa:split-up-ptr-mod, r=Mark-Simulacrum
Split up ptr/mod.rs in libcore...
...one with implementation detail for const ptr and the other with mut ptr
I am not sure if the "stable since 1.0.0" flags are the correct choice for the two additional mods.
Also, is it necessary for them to be "pub"? If so, there should be a good description for them.
bors [Fri, 20 Dec 2019 20:56:09 +0000 (20:56 +0000)]
Auto merge of #67020 - pnkfelix:issue-59535-accumulate-past-lto-imports, r=mw
save LTO import info and check it when trying to reuse build products
Fix #59535
Previous runs of LTO optimization on the previous incremental build can import larger portions of the dependence graph into a codegen unit than the current compilation run is choosing to import. We need to take that into account when we choose to reuse PostLTO-optimization object files from previous compiler invocations.
This PR accomplishes that by serializing the LTO import information on each incremental build. We load up the previous LTO import data as well as the current LTO import data. Then as we decide whether to reuse previous PostLTO objects or redo LTO optimization, we check whether the LTO import data matches. After we finish with this decision process for every object, we write the LTO import data back to disk.
----
What is the scenario where comparing against past LTO import information is necessary?
I've tried to capture it in the comments in the regression test, but here's yet another attempt from me to summarize the situation:
1. Consider a call-graph like `[A] -> [B -> D] <- [C]` (where the letters are functions and the modules are enclosed in `[]`)
2. In our specific instance, the earlier compilations were inlining the call to`B` into `A`; thus `A` ended up with a external reference to the symbol `D` in its object code, to be resolved at subsequent link time. The LTO import information provided by LLVM for those runs reflected that information: it explicitly says during those runs, `B` definition and `D` declaration were imported into `[A]`.
3. The change between incremental builds was that the call `D <- C` was removed.
4. That change, coupled with other decisions within `rustc`, made the compiler decide to make `D` an internal symbol (since it was no longer accessed from other codegen units, this makes sense locally). And then the definition of `D` was inlined into `B` and `D` itself was eliminated entirely.
5. The current LTO import information reported that `B` alone is imported into `[A]` for the *current compilation*. So when the Rust compiler surveyed the dependence graph, it determined that nothing `[A]` imports changed since the last build (and `[A]` itself has not changed either), so it chooses to reuse the object code generated during the previous compilation.
6. But that previous object code has an unresolved reference to `D`, and that causes a link time failure!
----
The interesting thing is that its quite hard to actually observe the above scenario arising, which is probably why no one has noticed this bug in the year or so since incremental LTO support landed (PR #53673).
I've literally spent days trying to observe the bug on my local machine, but haven't managed to find the magic combination of factors to get LLVM and `rustc` to do just the right set of the inlining and `internal`-reclassification choices that cause this particular problem to arise.
----
Also, I have tried to be careful about injecting new bugs with this PR. Specifically, I was/am worried that we could get into a scenario where overwriting the current LTO import data with past LTO import data would cause us to "forget" a current import. ~~To guard against this, the PR as currently written always asserts, at overwrite time, that the past LTO import-set is a *superset* of the current LTO import-set. This way, the overwriting process should always be safe to run.~~
* The previous note was written based on the first version of this PR. It has since been revised to use a simpler strategy, where we never attempt to merge the past LTO import information into the current one. We just *compare* them, and act accordingly.
* Also, as you can see from the comments on the PR itself, I was quite right to be worried about forgetting past imports; that scenario was observable via a trivial transformation of the regression test I had devised.
bors [Fri, 20 Dec 2019 16:24:12 +0000 (16:24 +0000)]
Auto merge of #67455 - Centril:rollup-mf0yc81, r=Centril
Rollup of 5 pull requests
Successful merges:
- #64588 (Add a raw "address of" operator)
- #67031 (Update tokio crates to latest versions)
- #67131 (Merge `TraitItem` & `ImplItem into `AssocItem`)
- #67354 (Fix pointing at arg when cause is outside of call)
- #67363 (Fix handling of wasm import modules and names)
Rollup merge of #67363 - alexcrichton:wasm-import-modules, r=eddyb
Fix handling of wasm import modules and names
The WebAssembly targets of rustc have weird issues around name mangling
and import the same name from different modules. This all largely stems
from the fact that we're using literal symbol names in LLVM IR to
represent what a function is called when it's imported, and we're not
using the wasm-specific `wasm-import-name` attribute. This in turn leads
to two issues:
* If, in the same codegen unit, the same FFI symbol is referenced twice
then rustc, when translating to LLVM IR, will only reference one
symbol from the first wasm module referenced.
* There's also a bug in LLD [1] where even if two codegen units
reference different modules, having the same symbol names means that
LLD coalesces the symbols and only refers to one wasm module.
Put another way, all our imported wasm symbols from the environment are
keyed off their LLVM IR symbol name, which has lots of collisions today.
This commit fixes the issue by implementing two changes:
1. All wasm symbols with `#[link(wasm_import_module = "...")]` are
mangled by default in LLVM IR. This means they're all given unique names.
2. Symbols then use the `wasm-import-name` attribute to ensure that the
WebAssembly file uses the correct import name.
When put together this should ensure we don't trip over the LLD bug [1]
and we also codegen IR correctly always referencing the right symbols
with the right import module/name pairs.
Rollup merge of #67031 - mati865:tokio-update, r=nikomatsakis
Update tokio crates to latest versions
Drops few old crates from the workspace (they are only used during tests, not in Rust itself) and allows to remove even more crates during next `rustc-ap-*` update.
Rollup merge of #64588 - matthewjasper:mir-address-of, r=oli-obk
Add a raw "address of" operator
* Parse and feature gate `&raw [const | mut] expr` (feature gate name is `raw_address_of`)
* Add `mir::Rvalue::AddressOf`
* Use the new `Rvalue` for:
* the new syntax
* reference to pointer casts
* drop shims for slices and arrays
* Stop using `mir::Rvalue::Cast` with a reference as the operand
* Correctly evaluate `mir::Rvalue::{Ref, AddressOf}` in constant propagation
bors [Fri, 20 Dec 2019 11:17:47 +0000 (11:17 +0000)]
Auto merge of #67449 - Centril:rollup-04hvg57, r=Centril
Rollup of 7 pull requests
Successful merges:
- #66755 (Remove a const-if-hack in RawVec)
- #67127 (Use structured suggestion for disambiguating method calls)
- #67219 (Fix up Command Debug output when arg0 is specified.)
- #67285 (Indicate origin of where type parameter for uninferred types )
- #67328 (Remove now-redundant range check on u128 -> f32 casts)
- #67367 (Move command line option definitions into a dedicated file)
- #67442 (Remove `SOCK_CLOEXEC` dummy variable on platforms that don't use it.)
Rollup merge of #67367 - 0dvictor:options, r=Centril
Move command line option definitions into a dedicated file
config.rs has reached the 3000 line tidy limit, this commit moves command line option definitions into a new file - options.rs, and leaves the rest of configuration infrastructure in config.rs.
Rollup merge of #67328 - rkruppe:simplify-u128-f32-cast, r=matthewjasper
Remove now-redundant range check on u128 -> f32 casts
This code was added to avoid UB in LLVM 6 and earlier, but we no longer support those LLVM versions.
Since https://reviews.llvm.org/D47807 (released in LLVM 7), uitofp does exactly what we need.
Rollup merge of #67285 - ohadravid:indicate-origin-of-where-type-parameter, r=estebank
Indicate origin of where type parameter for uninferred types
Based on #65951 (which is not merge yet), fixes #67277.
This PR improves a little the diagnostic for code like:
```
async fn foo() {
bar().await;
}
async fn bar<T>() -> () {}
```
by showing:
```
error[E0698]: type inside `async fn` body must be known in this context
--> unresolved_type_param.rs:9:5
|
9 | bar().await;
| ^^^ cannot infer type for type parameter `T` declared on the function `bar`
|
...
```
(The
```
declared on the function `bar`
```
part is new)
A small side note: `Vec` and `slice` seem to resist this change, because querying `item_name()` panics, and `get_opt_name()` returns `None`.
Rollup merge of #67219 - jsgf:command-argv0-debug, r=joshtriplett
Fix up Command Debug output when arg0 is specified.
PR https://github.com/rust-lang/rust/pull/66512 added the ability to set argv[0] on
Command. As a side effect, it changed the Debug output to print both the program and
argv[0], which in practice results in stuttery output (`"echo" "echo" "foo"`).
This PR reverts the behaviour to the the old one, so that the command is only printed
once - unless arg0 has been set. In that case it emits `"[command]" "arg0" "arg1" ...`.
Victor Ding [Tue, 17 Dec 2019 12:22:55 +0000 (23:22 +1100)]
Move command line option definitions into a dedicated file
config.rs has reached the 3000 line tidy limit, this commit moves
command line option definitions into a new file - options.rs, and
leaves the rest of configuration infrastructure in config.rs.
save LTO import information and check it when trying to reuse build products.
adopts simple strategy devised with assistance from mw: Instead of accumulating
(and acting upon) LTO import information over an unbounded number of prior
compilations, just see if the current import set matches the previous import set.
if they don't match, then you cannot reuse the PostLTO build product for that
module.
In either case (of a match or a non-match), we can (and must) unconditionally
emit the current import set as the recorded information in the incremental
compilation cache, ready to be loaded during the next compiler run for use in
the same check described above.
projects / rust.git / log