Update rustc #8

stabilize RangeBounds collections_range rust-lang#30877 The FCP for rust-lang#30877 closed last month, with the decision to: 1. move from `collections::range::RangeArgument` to `ops::RangeBounds`, and 2. rename `start()` and `end()` to `start_bounds()` and `end_bounds()`. Simon Sapin already moved it to `ops::RangeBounds` in rust-lang#49163. I renamed the functions, and removed the old `collections::range::RangeArgument` alias. This is my first Rust PR, please let me know if I can improve anything. This passes all tests for me, except the `clippy` tool (which uses `RangeArgument::start()`). I considered deprecating `start()` and `end()` instead of removing them, but the contribution guidelines indicate we can break `clippy` temporarily. I thought it was best to remove the functions, since we're worried about name collisions with `Range::start` and `end`. Closes rust-lang#30877.

2093 infer outlives requirements Tracking issue: rust-lang#44493 RFC: rust-lang/rfcs#2093 - [x] add `rustc_attrs` flag - [x] use `RequirePredicates` type - [x] handle explicit predicates on `dyn` Trait - [x] handle explicit predicates on projections - [x] more tests - [x] remove `unused`, `dead_code` and etc.. - [x] documentation

Lone breaks outside of loops create errors in the loop check pass but as they are not fatal, compilation continues. MIR building code assumes all HIR break statements to point to valid locations and fires ICEs if this assumption is violated. In normal compilation, this causes no issues, as code apparently prevents MIR from being built if errors are present. However, before that, typecheck runs and with it MIR const eval. Here we operate differently from normal compilation: it doesn't check for any errors except for type checker ones and then directly builds the MIR. This constellation causes an ICE-on-error if bogus break statements are being put into array length expressions. This commit fixes this ICE by letting typecheck fail if bogus break statements are encountered. This way, MIR const eval fails cleanly with a type check error. Fixes rust-lang#50576 Fixes rust-lang#50581

There is no precedent for the `empty` name -- we do not have `Vec::empty` or `HashMap::empty` etc.

Don't ICE if crate has no valid crate types left fixes rust-lang#50993

The `FatalError.raise()` might seem unmotivated (in most places in the compiler, `err.emit()` suffices), but it's actually used to maintain behavior (viz., stop lexing, don't emit potentially spurious errors looking for the next token after the bad Unicodepoint in the exponent): the previous revision's `self.err_span_` ultimately calls `Handler::emit`, which aborts if the `Handler`'s continue_after_error flag is set, which seems to typically be true during lexing (see `phase_1_parse_input` and and how `CompileController::basic` has `continue_parse_after_error: false` in librustc_driver). Also, let's avoid apostrophes in error messages (the present author would argue that users expect a reassuringly detached, formal, above-it-all tone from a Serious tool like a compiler), and use an RLS-friendly structured suggestion. Resolves rust-lang#49746.

…g-impl, r=KodrAus Improve `Debug` impl of `time::Duration` Hi there! For a long time now, I was getting annoyed by the derived `Debug` impl of `Duration`. Usually, I use `Duration` to either do quick'n'dirty benchmarking or measuring the time of some operation in general. The output of the derived Debug impl is hard to parse for humans: is { secs: 0, nanos: 968360102 } or { secs: 0, nanos 98507324 } longer? So after running into the annoyance several times (sometimes building my own function to print the Duration properly), I decided to tackle this. Now the output looks like this: ``` Duration::new(1, 0) => 1s Duration::new(1, 1) => 1.000000001s Duration::new(1, 300) => 1.0000003s Duration::new(1, 4000) => 1.000004s Duration::new(1, 600000) => 1.0006s Duration::new(1, 7000000) => 1.007s Duration::new(0, 0) => 0ns Duration::new(0, 1) => 1ns Duration::new(0, 300) => 300ns Duration::new(0, 4001) => 4.001µs Duration::new(0, 600300) => 600.3µs Duration::new(0, 7000000) => 7ms ``` Note that I implemented the formatting manually and didn't use floats. No information is "lost" when printing. So `Duration::new(123_456_789_000, 900_000_001)` prints as `123456789000.900000001s`. ~~This is not yet finished~~, but I wanted to open the PR now already in order to get some feedback (maybe everyone likes the derived impl). ### Still ToDo: - [x] Respect precision ~~and width~~ parameter of the formatter (see [this comment](rust-lang#50364 (comment))) ### Alternatives/Decisions - Should large durations displayed in minutes, hours, days, ...? For now, I decided not to because the current formatting is close the how a `Duration` is stored. From this new `Debug` output, you can still easily see what the values of `secs` and `nanos` are. A formatting like `3h 27m 12s 9ms` might be more appropriate for a `Display` impl? - Should this rather be a `Display` impl and should `Debug` be derived? Maybe this formatting is too fancy for `Debug`? In my opinion it's not and, as already mentioned, from the current format one can still very easily determine the values for `secs` and `nanos`. - Whitespace between the number and the unit? ### Notes for reviewers - ~~The combined diff sucks. Rather review both commits individually.~~ - ~~In the unit test, I am building my own type implementing `fmt::Write` to test the output. Maybe there is already something like that which I can use?~~ - My `Debug` impl block is marked as `#[stable(...)]`... but that's fine since the derived Debug impl was stable already, right? --- ~~Apart from the main change, I moved all `time` unit tests into the `tests` directory. All other `libcore` tests are there, so I guess it was simply an oversight. Prior to this change, the `time` tests weren't run, so I guess this is kind of a bug fix. If my `Debug` impl is rejected, I can of course just send the fix as PR.~~ (this was already merged in rust-lang#50466)

…sakis std: Ensure OOM is classified as `nounwind` OOM can't unwind today, and historically it's been optimized as if it can't unwind. This accidentally regressed with recent changes to the OOM handler, so this commit adds in a codegen test to assert that everything gets optimized away after the OOM function is approrpiately classified as nounwind Closes rust-lang#50925

…ions, r=petrochencov Underline multiple suggested replacements in the same line <img width="685" alt="screen shot 2018-05-22 at 21 06 48" src="https://user-images.githubusercontent.com/1606434/40403051-174f3180-5e04-11e8-86b6-261630c5ff80.png"> Follow up to rust-lang#50943. Fix rust-lang#50977.

@QuietMisdreavus

…dreavus Add documentation about env! second argument Fixes rust-lang#48044. r? @QuietMisdreavus

@nikomatsakis

Remove unused lowering field and method r? @nikomatsakis So while trying to understand lowering better, I found out that there's something related to creating definitions. Analyzing that further, I realized that it is entirely dead code. The `parent_def` field was only ever used for setting and resetting the field itself. The field was never read anywhere else and thus its value was entirely unused. Maybe the `unused_field` lint should detect when the only use of a field is the field being read without using the read value other than writing back to the field? The diff is best viewed without whitespace changes getting in the way: https://github.com/rust-lang/rust/pull/51034/files?w=1

…s, r=nikomatsakis Use AllFacts from polonius-engine

@QuietMisdreavus

…r=QuietMisdreavus Add more missing examples for Formatter r? @QuietMisdreavus

Mention and use `Once::new` instead of `ONCE_INIT`

@CryZe

What does an expression look like, that consists only of special characters? I had a lot of fun creating this together with @CryZe

Update nomicon link in transmute docs The list of "invalid primitive values" has moved to a different URL within the Rustonomicon.

Add inner links in documentation From [this SO question](https://stackoverflow.com/q/50518757/2733851) it looks like this page isn't really clear. I personally do think this page is quite clear, the only think I could think of was adding some references.

Fail typecheck if we encounter a bogus break Lone breaks outside of loops create errors in the loop check pass but as they are not fatal, compilation continues. MIR building code assumes all HIR break statements to point to valid locations and fires ICEs if this assumption is violated. In normal compilation, this causes no issues, as code apparently prevents MIR from being built if errors are present. However, before that, typecheck runs and with it MIR const eval. Here we operate differently from normal compilation: it doesn't check for any errors except for type checker ones and then directly builds the MIR. This constellation causes an ICE-on-error if bogus break statements are being put into array length expressions. This commit fixes this ICE by letting typecheck fail if bogus break statements are encountered. This way, MIR const eval fails cleanly with a type check error. Fixes rust-lang#50576 Fixes rust-lang#50581

@alexcrichton

Rename TokenStream::empty to TokenStream::new There is no precedent for the `empty` name -- we do not have `Vec::empty` or `HashMap::empty` etc. I would propose landing this but reflecting it in a non-breaking release of proc-macro2 that provides both `new` and a deprecated `empty` constructor. Tracking issue: rust-lang#38356 r? @alexcrichton

Rollup of 11 pull requests Successful merges: - rust-lang#50987 (Underline multiple suggested replacements in the same line) - rust-lang#51014 (Add documentation about env! second argument) - rust-lang#51034 (Remove unused lowering field and method) - rust-lang#51047 (Use AllFacts from polonius-engine) - rust-lang#51048 (Add more missing examples for Formatter) - rust-lang#51056 (Mention and use `Once::new` instead of `ONCE_INIT`) - rust-lang#51059 (What does an expression look like, that consists only of special characters?) - rust-lang#51065 (Update nomicon link in transmute docs) - rust-lang#51067 (Add inner links in documentation) - rust-lang#51070 (Fail typecheck if we encounter a bogus break) - rust-lang#51073 (Rename TokenStream::empty to TokenStream::new) Failed merges:

@petrochenkov

…henkov restore emplacement syntax (obsolete) Fix rust-lang#50832 r? @petrochenkov

Use `Ident`s for fields in HIR Continuation of rust-lang#49718, part of rust-lang#49300

@nikomatsakis

…omatsakis Fix behaviour of divergence in while loop conditions This fixes `'a: while break 'a {};` being treated as diverging, by tracking break expressions in the same way as in `loop` expressions. Fixes rust-lang#50856. r? @nikomatsakis

…robust-wrt-nll, r=nikomatsakis make ui tests robust with respect to NLL This PR revises the `ui` tests that I could quickly identify that: 1. previously had successful compilations under non-lexical lifetimes (NLL) because they assumed lexical lifetimes, but 2. such assumption of lexical lifetimes was actually not necessarily part of the spirit of the original issue/bug we want to witness. In many cases, this is simply a matter of adding a use of a borrow so that it gets extended long enough to observe a conflict. (In some cases the revision was more subtle, such as adding a destructor, or revising the order of declaration of some variables.) ---- With these test revisions in place, I subsequently updated the expected stderr output under the NLL compiletest mode. So now we should get even more testing of NLL than we were before. Fix rust-lang#51025

…r, r=Mark-Simulacrum [master] Release notes for 1.26.1 None

The issue was used for both box syntax as well as placement new. It got closed due to placement new being unapproved. So a new one got created for box syntax, yet neither the unstable book nor feature_gate.rs got updated. We are doing this now.

…crum Rollup of 3 pull requests Successful merges: - rust-lang#51049 (Fix behaviour of divergence in while loop conditions) - rust-lang#51057 (make ui tests robust with respect to NLL) - rust-lang#51092 ([master] Release notes for 1.26.1) Failed merges:

…ved.

@aidanhs

Point to the current box syntax tracking issue The issue was used for both box syntax as well as placement new. It got closed due to placement new being unapproved. So a new one got created for box syntax, yet neither the unstable book nor feature_gate.rs got updated. We are doing this now. r? @aidanhs

…le_float_exponent, r=eddyb Check for confusable Unicode chars in float literal exponent Fixing tests for rust-lang#49989. Resolves rust-lang#49746.

…ssue, r=alexcrichton Ensure every unstable language feature has a tracking issue. Filled in the missing numbers: * `abi_ptx` → rust-lang#38788 * `generators` → rust-lang#43122 * `global_allocator` → rust-lang#27389 Reused existing tracking issues because they were decomposed from a larger feature * `*_target_feature` → rust-lang#44839 (reusing the old `target_feature` number) * `proc_macros_*` → rust-lang#38356 (reusing the to-be-stabilized `proc_macros` number) Filed new issues * `exhaustive_patterns` → rust-lang#51085 * `pattern_parentheses` → rust-lang#51087 * `wasm_custom_section` and `wasm_import_module` → rust-lang#51088

Issue rust-lang#51022: Improve E0131 message when lifetimes are involved. Fixes rust-lang#51022

Fix typo in macro_parser.rs innacurate -> inaccurate

lib.rs don't beautiful

@SimonSapin

…=SimonSapin Stabilize Formatter alignment Fixes rust-lang#27726. cc @SimonSapin

…ebank Address comments in pull request rust-lang#51084. This is a follow-up to rust-lang#51084, that's already been integrated into mainline.

Update cargo There are few nice fixes waiting already.

When encountering an unexisting method for a given trait where an associated function has the same name, suggest using the appropriate syntax, instead of using `help` text. When only one candidate is found, do not call it "candidate #1", just call it "the candidate".

@matklad

Make anon params lint warn-by-default This is intended as a followup on anonymous parameters deprecation. Cross-posting from rust-lang#41686: > After having read a bit more of the discussion that I can find, I propose a more aggressive deprecation strategy: > - We make the lint warn-by-default as soon as possible > - We make anon parameters a hard error at the epoch boundary cc @matklad @est31 @aturon

@alexcrichton

Added rustdoc documentation to compiler docs. Fixes rust-lang#50004. r? @alexcrichton (since you reviewed the last PR about compiler docs)

@michaelwoerister

Make &Slice a thin pointer Split out from rust-lang#50395 r? @michaelwoerister

@Manishearth

…shearth add suggestion applicabilities to librustc and libsyntax A down payment on rust-lang#50723. Interested in feedback on whether my `MaybeIncorrect` vs. `MachineApplicable` judgement calls are well-calibrated (and that we have a consensus on what this means). r? @Manishearth cc @killercup @estebank

@Mark-Simulacrum

Update RLS, Rustfmt, and Cargo r? @Mark-Simulacrum Should fix broken rustfmt and RLS builds - Cargo update is needed for compatibility with RLS

@killercup

Mark .fixed files as Rust syntax for GitHub r? @killercup

branch

Changing the `each_binding` utility method to take the `HirId` of a binding pattern rather than its `NodeId` seems like a modest first step in support of the `HirId`ification initiative rust-lang#50928. (The inspiration for choosing this in particular came from the present author's previous work on diagnostics issued during liveness analysis, which is the most greatly affected module in this change.)

Michael Woerister pointed out that `hir_to_node_id` (introduced in August 2017's 28ddd7a) supersedes the functionality of `find_node_for_hir_id` (just a hash lookup compared to that linear search).

…equirement

Add simd math intrinsics and gather/scatter This PR adds simd math intrinsics for floating-point vectors (sqrt, sin, cos, pow, exp, log, fma, abs, etc.) and the generic simd gather/scatter intrinsics.

Co-authored-by: csmoe <35686186+csmoe@users.noreply.github.com>

@michaelwoerister

… r=michaelwoerister operate on `HirId` instead of `NodeId` in `hir::Pat::each_binding`, and consequences of that See rust-lang#50928 for motivation. Questions— * Is rust-lang#50928 actually a good idea as a plan of record, or is there some reason to keep `NodeId`s? * Are the uses of `find_node_for_hir_id` in this initial submission OK (see the FIXME comments)? * Can we bikeshed a better method names `struct_span_lint_hir` _&c._? (Coined in analogy to the `struct_span_lint_node` and `NodeId`, but it feels kind of semantically clunky.) r? @michaelwoerister

str::from_raw_parts has been removed long ago because it can be obtained via str::from_utf8_unchecked and slice::from_raw_parts. The same goes for str::from_raw_parts_mut.

Add missing Wrapping methods, use doc_comment! Re-opened version of rust-lang#49393 . Finishing touches for rust-lang#32463. Note that this adds `Shl` and `Shr` implementations for `Wrapping<i128>` and `Wrapping<u128>`, which were previously missed. This is technically insta-stable, but I don't know why this would be a problem.

They no longer talk about plain integers. Co-authored-by: csmoe <35686186+csmoe@users.noreply.github.com>

Co-authored-by: csmoe <35686186+csmoe@users.noreply.github.com>

Refactor DebruijnIndex to be 0-based Fixes rust-lang#49813

…mulacrum Stabilize SystemTime::UNIX_EPOCH Fixes rust-lang#49502

Document additional use case for iter::inspect Adds docs for `iter::inspect` showing the non-debug use case Closes rust-lang#49564

@michaelwoerister

Hash up to 8 bytes at once with FxHasher r? @michaelwoerister

This reverts commit aad9840. Level 3 (possibly indirectly, the underlying bug might be in XCode’s linker) causes unit tests to sefault when compiled with some versions of XCode: rust-lang#50867 It also appears to cause some segfaults on Windows: rust-lang#50329 (comment) … and regressions in some rustc performance benchmarks: rust-lang#50329 (comment)

extend from_raw_parts docs for slices and strs to mention alignment requirement The documentation for `str::from_raw_parts_mut` seems to not be visible because that method is private, bit I figured it could still be fixed. I also removed the reference to the no-longer-existing `str::from_raw_parts` while I was at it. Alternatively, should I remove `str::from_raw_parts_mut` completely? it is only used in `str::split_at_mut`, where it might as well be inlined.

…r=nikomatsakis Make borrowck use polonius output

Revert "Set opt-level to 3" This reverts commit aad9840. Level 3 (possibly indirectly, the underlying bug might be in XCode’s linker) causes unit tests to sefault when compiled with some versions of XCode: rust-lang#50867 It also appears to cause some segfaults on Windows: rust-lang#50329 (comment), and regressions in some rustc performance benchmarks: rust-lang#50329 (comment)

…orrow is out of scope at location.

…f a block.

As discussed in rust-lang#49668 (comment) and subsequent, there are use-cases where the OOM handler needs to know the size of the allocation that failed. The alignment might also be a cause for allocation failure, so providing it as well can be useful.

Now, if you pass `-Z disable-ast-check-for-mutation-in-guard`, then we will just allow you to mutably-borrow and assign in guards of `match` arms. This is wildly unsound with AST-borrowck. It is also unsound with MIR-borrowck without further adjustments, which come in later in the commit series on this Pull Request. See also rust-lang#24535 and rust-lang/rfcs#1006.

(This is just the data structure changes and some boilerplate match code that followed from it; the actual emission of these statements comes in a follow-up commit.)

Also, turn on ReadForMatch emission by default (when using NLL).

…to my code. In particular, I am adding an implicit injected borrow on the pattern matches, and when we go around the loop, the compiler is reporting that this injected borrow is conflicting with the move of the original value when the match succeeds.

For some reason, allowing restricted mutation in match arms exposed an obvious case where a unique borrow can indeed fail, namely something like: ```rust match b { ... ref mut r if { (|| { let bar = &mut *r; **bar = false; })(); false } => { &mut *r } // ~~~~~~~ // | // This ends up holding a `&unique` borrow of `r`, but there ends up being an // implicit shared borrow in the guard thanks to rust-lang#49870 ... } ```

```rust fn main() { fn reuse<X>(_: &mut X) {} let mut t = 2f64; match t { ref mut _b if { false } => { reuse(_b); } _ => {} } } ``` Note: The way this is currently written is confusing; when `autoref` is off, then the arm body bindings (introduced by `bind_matched_candidate_for_arm_body`) are *also* used for the guard. (Any attempt to fix this needs to still ensure that the bindings used by the guard are introduced before the guard is evaluated.) (Once we turn NLL on by default, we can presumably simplify all of that.)

…n under NLL.

.

…elsewhere in file.

…post-NLL future. Driveby: just inline the two-line `fn inject_borrow` into its one call site and remove its definition.

- compute bytes_to_copy more elegantly - add assert that written is 0 in fallback case

fs: copy: use copy_file_range on Linux Linux 4.5 introduced a new system call [copy_file_range](http://man7.org/linux/man-pages/man2/copy_file_range.2.html) to copy data from one file to another. This PR uses the new system call (if available). This has several advantages: 1. No need to constantly copy data from userspace to kernel space, if the buffer is small or the file is large 2. On some filesystems, like BTRFS, the kernel can leverage internal fs mechanisms for huge performance gains 3. Filesystems on the network dont need to copy data between the host and the client machine (they have to in the current read/write implementation) I have created a small library that also implements the new system call for some huge performance gains here: https://github.com/nicokoch/fastcopy Benchmark results are in the README

…s-input-take-three, r=nikomatsakis every match arm reads the match's borrowed input This PR changes the `match` codegen under NLL (and just NLL, at least for now) to make the following adjustments: * It adds a `-Z disable-ast-check-for-mutation-in-guard` which, as described, turns off the naive (conservative but also not 100% sound) check for mutation in guards of match arms. * We now borrow the match input at the outset and emit a special `ReadForMatch` statement (that, according to the *static* semantics, reads that borrowed match input) at the start of each match arm. The intent here is to catch cases where the match guard mutates the match input, either via an independent borrow or via `ref mut` borrows in that arm's pattern. * In order to ensure that `ref mut` borrows do not actually conflict with the emitted `ReadForMatch` statements, I expanded the two-phase-borrow system slightly, and also changed the MIR code gen so that under NLL, when there is a guard on a match arm, then each pattern variable ends up having *three* temporaries associated with it: 1. The first temporary will hold the substructure being matched; this is what we will move the (substructural) value into *if* the guard succeeds. 2. The second temporary also corresponds to the same value as the first, but we are just constructing this temporarily for use during the scope of the guard; it is unaliased and its sole referrer is the third temporary. 3. The third temporary is a reference to the second temporary. * (This sounds complicated, I know, but its actually *simpler* than what I was doing before and had checked into the repo, which was to sometimes construct the final value and then take a reference to it before evaluating the guard. See also PR rust-lang#49870.) Fix rust-lang#27282 This also provides a path towards resolving rust-lang#24535 aka rust-lang/rfcs#1006, at least once the `-Z disable-ast-check-for-mutation-in-guard` is just turned on by default (under NLL, that is. It is not sound under AST-borrowck). * But I did not want to make `#![feature(nll)]` imply that as part of this PR; that seemed like too drastic a change to me.

We already got the open file descriptor at this point. Don't make the kernel resolve the path again.

…lwoerister Use crate name for reexported `extern crate` paths Fix rust-lang#43189.

@nikomatsakis

Optimize the way that loans are killed in borrowck dataflow Fixes rust-lang#50934. r? @nikomatsakis

@SimonSapin

OOM handling changes As discussed in rust-lang#49668 (comment) and subsequent. This does have codegen implications. Even without the hooks, and with a handler that ignores the arguments, the compiler doesn't eliminate calling `rust_oom` with the `Layout`. Even if it managed to eliminate that, with the hooks, I don't know if the compiler would be able to figure out it can skip it if the hook is never set. A couple implementation notes: - I went with explicit enums rather than bools because it makes it clearer in callers what is being requested. - I didn't know what `feature` to put the hook setting functions behind. (and surprisingly, the compile went through without any annotation on the functions) - There's probably some bikeshedding to do on the naming. Cc: @SimonSapin, @sfackler

While we're at it update the `backtrace` crate from crates.io. It turns out that the submodule's configure script has gotten a lot more finnicky as of late so also switch over to using the `cc` crate manually which allows to avoid some hacks around the configure script as well

…lexcrichton Update libbacktrace We haven't updated libbacktrace in two years. This is just blindly updating to the latest HEAD; I'd like to see what travis says. It at least builds on my machine, running some tests... This perpetuates the patches from rust-lang#30908

When encountering the following code: ```rust struct Foo; fn takes_ref(_: &Foo) {} let ref opt = Some(Foo); opt.map(|arg| takes_ref(arg)); ``` Suggest using `opt.as_ref().map(|arg| takes_ref(arg));` instead. This is a stop gap solution until we expand typeck to deal with these cases in a more graceful way.

Suggest using `as_ref` on some borrow errors [hack] When encountering the following code: ```rust struct Foo; fn takes_ref(_: &Foo) {} let ref opt = Some(Foo); opt.map(|arg| takes_ref(arg)); ``` Suggest using `opt.as_ref().map(|arg| takes_ref(arg));` instead. This is a stop gap solution until we expand typeck to deal with these cases in a more graceful way. rust-lang#43861

…riate.

Background: The anonymous lifetime mode is used to prohibit elided lifetimes where they didn't used to be permitted, and instead require that `'_` be used. For example: ```rust impl Trait for Ref<T> { .. } // ^^^^^^ ERROR: should be `Ref<'_, T>` ``` When we are parsing the parts of the impl header, we enter into an alternate mode called `CreateParameter`. In this mode, we give an error for things like `Ref<T>`, but for elided lifetimes in a reference type like `&T` we make the elided lifetime into an in-band lifetime: https://github.com/rust-lang/rust/blob/4f99f37b7e213d69a489884f651adfc6d217cef5/src/librustc/hir/lowering.rs#L4017-L4035 This was not intended to change behavior because we only enter into that mode in contexts where elision was not historically permitted. However, the problem is that we fail to reset the mode when we enter into bounds like `Fn(&u32)`, where elision *was* allowed -- the same occurs for fn types like `fn(&u32`). This PR restores the original mode in those contexts.

…lways generate errors

@varkor

…sakis rustc: don't visit lifetime parameters through visit_lifetime. Ideally we'd also not use the `Lifetime` struct for parameters, but I'll leave that to @varkor (rust-lang#48149). Fixes rust-lang#51185 (discovered while auditing all the `visit_lifetime` implementations). r? @nikomatsakis

… r=pnkfelix Add polonius compare mode **This is now ready to review/merge**

It's never used in a meaningful way.

Because they are small and hot.

@cramertj

…ve-lifetime-must-be-declared, r=cramertj reset anonymous-lifetime-mode as we enter `()` scopes Background: The anonymous lifetime mode is used to prohibit elided lifetimes where they didn't used to be permitted, and instead require that `'_` be used. For example: ```rust impl Trait for Ref<T> { .. } // ^^^^^^ ERROR: should be `Ref<'_, T>` ``` When we are parsing the parts of the impl header, we enter into an alternate mode called `CreateParameter`. In this mode, we give an error for things like `Ref<T>`, but for elided lifetimes in a reference type like `&T` we make the elided lifetime into an in-band lifetime: https://github.com/rust-lang/rust/blob/4f99f37b7e213d69a489884f651adfc6d217cef5/src/librustc/hir/lowering.rs#L4017-L4035 This was not intended to change behavior because we only enter into that mode in contexts where elision was not historically permitted. However, the problem is that we fail to reset the mode when we enter into bounds like `Fn(&u32)`, where elision *was* allowed -- the same occurs for fn types like `fn(&u32`). This PR restores the original mode in those contexts. Fixes rust-lang#51008 r? @cramertj

resolve: Make sure indeterminate and inconsistent macro resolutions always generate errors Addresses the issue described in rust-lang#50911 (comment) I haven't come up with a minimized reproduction yet, but confirmed that `npbot` now generates the correct error with `![feature(use_extern_macros)]`.

By calling `bump()` after getting the first char, to avoid a redundant `ident_continue()` test on it.

…llaumeGomez Add doc link from discriminant struct to function. None

@nikomatsakis

…akis [MIR] Change "scopes" from "visibility scopes" to "source scopes". These scopes are already used for source-oriented diagnostics, lint levels and unsafety checks. This PR generalizes the naming around scopes, making the type `SourceScope`, and flips (across several commits) the relationship/priority between `LocalDecl`'s "visibility" and "syntactic" scopes. r? @nikomatsakis

…oerister Two minor `obligation_forest` tweaks. Pretty minimal improvements, but improvements nonetheless.

Fixes rust-lang#50605

`PointerKind` is included in `LoanPath` and hence forms part of the equality check; this led to having two unequal paths that both represent `*x`, depending on whether the `*` was inserted automatically or explicitly. Bad mojo. The `note` field, in contrast, is intended more-or-less primarily for this purpose of adding extra data.

If a struct pattern has a field error return an error.

@eddyb

…licit-deref, r=eddyb remove notion of Implicit derefs from mem-cat `PointerKind` is included in `LoanPath` and hence forms part of the equality check; this led to having two unequal paths that both represent `*x`, depending on whether the `*` was inserted automatically or explicitly. Bad mojo. Fixes rust-lang#51117 r? @eddyb

std::fs::DirEntry.metadata(): use fstatat instead of lstat when possible When reading a directory with `read_dir`, querying metadata for a resulting `DirEntry` is done by building the whole path and then `lstat`ing it, which requires the kernel to resolve the whole path. Instead, one can use the file descriptor to the enumerated directory and use `fstatat`. This make the resolving step unnecessary. This PR implements using `fstatat` on linux, android and emscripten. ## Compatibility across targets `fstatat` is POSIX. * Linux >= 2.6.19 according to https://linux.die.net/man/2/fstatat * android according to https://android.googlesource.com/platform/bionic/+/master/libc/libc.map.txt#392 * emscripten according to https://github.com/kripken/emscripten/blob/7f89560101843198787530731f40a65288f6f15f/system/include/libc/sys/stat.h#L76 The man page says "A similar system call exists on Solaris." but I haven't found it. ## Compatibility with old platforms This was introduced with glibc 2.4 according to the man page. The only information I could find about the minimal version of glibc rust must support is this discussion https://internals.rust-lang.org/t/bumping-glibc-requirements-for-the-rust-toolchain/5111/10 The conclusion, if I understand correctly, is that currently rust supports glibc >= 2.3.4 but the "real" requirement is Centos 5 with glibc 2.5. This PR would make the minimal version 2.4, so this should be fine. ## Benefit I did the following silly benchmark: ```rust use std::io; use std::fs; use std::os::linux::fs::MetadataExt; use std::time::Instant; fn main() -> Result<(), io::Error> { let mut n = 0; let mut size = 0; let start = Instant::now(); for entry in fs::read_dir("/nix/store/.links")? { let entry = entry?; let stat = entry.metadata()?; size += stat.st_size(); n+=1; } println!("{} files, size {}, time {:?}", n, size, Instant::now().duration_since(start)); Ok(()) } ``` On warm cache, with current rust nightly: ``` 1014099 files, size 76895290022, time Duration { secs: 2, nanos: 65832118 } ``` (between 2.1 and 2.9 seconds usually) With this PR: ``` 1014099 files, size 76895290022, time Duration { secs: 1, nanos: 581662953 } ``` (1.5 to 1.6 seconds usually). approximately 40% faster :) On cold cache there is not much to gain because path lookup (which we spare) would have been a cache hit: Before ``` 1014099 files, size 76895290022, time Duration { secs: 391, nanos: 739874992 } ``` After ``` 1014099 files, size 76895290022, time Duration { secs: 388, nanos: 431567396 } ``` ## Testing The tests were run on linux `x86_64` ``` python x.py test src/tools/tidy ./x.py test src/libstd ``` and the above benchmark. I did not test any other target.

@oli-obk

…r-format, r=oli-obk Stabilize short error format r? @oli-obk Added in rust-lang#44636

Update build instructions It get stuck at the cloning step. `./x.py build ` Updating only changed submodules Updating submodule src/llvm Submodule 'src/llvm' (https://github.com/rust-lang/llvm.git) registered for path 'src/llvm' Cloning into '/home/username/rust/src/llvm'...

typeck: Do not pass the field check on field error If a struct pattern has a field error return an error. Fixes: rust-lang#51102

@QuietMisdreavus

…r=QuietMisdreavus Fixes some style issues in rustdoc "implementations on Foreign types" Fixes rust-lang#51113. r? @QuietMisdreavus

fs: copy: Use File::set_permissions instead of fs::set_permissions We already got the open file descriptor at this point. Don't make the kernel resolve the path again.

mod.rs isn't beautiful I hate this spaces.

Two minor parsing tweaks

Implement `is`, `downcast_ref`, `downcast_mut` and `Debug` for `Any + Send + Sync`.

We only need to implement it for `Any + Send + Sync` because in practice that's the only useful combination for `Arc` and `Any`. Implementation for rust-lang#44608 under the `rc_downcast` feature.

This avoids an `unsafe` block in each case.

Make the Any+Send+Sync examples use the right trait bounds, and fix a small whitespace issue.

Rollup of 7 pull requests Successful merges: - rust-lang#49546 (Stabilize short error format) - rust-lang#51123 (Update build instructions) - rust-lang#51146 (typeck: Do not pass the field check on field error) - rust-lang#51193 (Fixes some style issues in rustdoc "implementations on Foreign types") - rust-lang#51213 (fs: copy: Use File::set_permissions instead of fs::set_permissions) - rust-lang#51227 (mod.rs isn't beautiful) - rust-lang#51240 (Two minor parsing tweaks) Failed merges:

@nikomatsakis

…ounds, r=nikomatsakis Register outlives predicates from queries the right way around. Closes rust-lang#49354 The region constraints from queries need to be reversed from sub to outlives. Note: wf checking reports these errors before NLL, so I'm not sure if there's any case when these predicates need to be created at all. cc @nikomatsakis

@alexcrichton

Per discussion in rust-lang#51245 (comment) This allows more flexibility in what can be done with the API. This also splits `rtabort!` into `dumb_print` happening in the default hook and `abort_internal`, happening in the actual oom handler after calling the hook. Registering an empty function thus makes the oom handler not print anything but still abort. Cc: @alexcrichton

@SimonSapin

Arc downcast Implement `downcast` for `Arc<Any + Send + Sync>` as part of rust-lang#44608, and gated by the same `rc_downcast` feature. This PR is mostly lightly-edited cut'n'paste. This has two additional changes: - The `downcast` implementation needs `Any + Send + Sync` implementations for `is` and `Debug`, and I added `downcast_ref` and `downcast_mut` for completeness/consistency. (Can these be insta-stabilized?) - At @SimonSapin's suggestion, I converted `Arc` and `Rc` to use `NonNull::cast` to avoid an `unsafe` block in each which tidied things up nicely.

The old text was: "The precise definition is: a type T is Sync if &T is Send." Since we've also got ``` impl<'a, T> Send for &'a T where T: Sync + ?Sized, ``` I purpose we can change the `if` to `if and only if` to make it more precise.

@oli-obk

…oli-obk Make some std::intrinsics `const fn`s Making some rustc intrinsics (`ctpop`, `cttz`, `ctlz` and `bswap`) `const fn`s. This is a pre-step to being able to make `swap_bytes`, `to_be` and `from_be` constant functions. That in itself could be ergonomic and useful. But even better is that it would allow `Ipv4Addr::new` etc becoming `const fn`s as well. Which might be really useful since I find it quite common to want to define them as constants. r? @oli-obk

@bjorn3

Fix the miri submodule cc @bjorn3 r? @eddyb

Fixes rust-lang#51266

@Zoxc

…r=Zoxc Make const decoding thread-safe. This is an alternative to rust-lang#50957. It's a proof of concept (e.g. it doesn't adapt metadata decoding, just the incr. comp. cache) but I think it turned out nice. It's rather simple and does not require passing around a bunch of weird closures, like we currently do. If you (@Zoxc & @oli-obk) think this approach is good then I'm happy to finish and clean this up. Note: The current version just spins when it encounters an in-progress decoding. I don't have a strong preference for this approach. Decoding concurrently is equally fine by me (or maybe even better because it doesn't require poisoning). r? @Zoxc

Add std/core to prelude if extern_prelude enabled Fixes rust-lang#50605

This is stable, and so no longer needed

@alexcrichton

Make the OOM hook return `()` rather than `!` Per discussion in rust-lang#51245 (comment) This allows more flexibility in what can be done with the API. This also splits `rtabort!` into `dumb_print` happening in the default hook and `abort_internal`, happening in the actual oom handler after calling the hook. Registering an empty function thus makes the oom handler not print anything but still abort. Cc: @alexcrichton

for both Vec<T> and String - eliminates the boolean first flag in fn join() for String only - eliminates repeated bounds checks in join(), concat() - adds fast paths for small string separators up to a len of 4 bytes

old tests cover the new fast path of str joining already this adds tests for joining into Strings with long separators (>4 byte) and for joining into Vec<T>, T: Clone + !Copy. Vec<T: Copy> will be specialised when specialisation type inference bugs are fixed.

further reduce unsafe fn calls reduce right drift assert! sufficient capacity

optimize joining for slices This improves the speed of string joining up to 3x. It removes the boolean flag check every iteration, eliminates repeated bounds checks and adds a fast paths for small separators up to a len of 4 bytes These optimizations gave me ~10%, ~50% and ~80% improvements respectively over the previous speed. Those are multiplicative. 3x improvement happens for the optimal case of joining many small strings together in my microbenchmarks. Improvements flatten out for larger strings of course as more time is spent copying bits around. I've run a few benchmarks [with this code](https://github.com/Emerentius/join_bench). They are pretty noise despite high iteration counts, but in total one can see the trends. ``` len_separator len_string n_strings speedup 4 10 10 2.38 4 10 100 3.41 4 10 1000 3.43 4 10 10000 3.25 4 100 10 2.23 4 100 100 2.73 4 100 1000 1.33 4 100 10000 1.14 4 1000 10 1.33 4 1000 100 1.15 4 1000 1000 1.08 4 1000 10000 1.04 10 10 10 1.61 10 10 100 1.74 10 10 1000 1.77 10 10 10000 1.75 10 100 10 1.58 10 100 100 1.65 10 100 1000 1.24 10 100 10000 1.12 10 1000 10 1.23 10 1000 100 1.11 10 1000 1000 1.05 10 1000 10000 0.997 100 10 10 1.66 100 10 100 1.78 100 10 1000 1.28 100 10 10000 1.16 100 100 10 1.37 100 100 100 1.26 100 100 1000 1.09 100 100 10000 1.0 100 1000 10 1.19 100 1000 100 1.12 100 1000 1000 1.05 100 1000 10000 1.12 ``` The string joining with small or empty separators is now ~50% faster than the old concatenation (small strings). The same approach can also improve the performance of joining into vectors. If this approach is acceptable, I can apply it for concatenation and for vectors as well. Alternatively, concat could just call `.join("")`.

@SimonSapin

Simplify HashMap layout calculation by using Layout `RawTable` uses a single allocation to hold both the array of hashes and the array of key/value pairs. This PR changes `RawTable` to use `Layout` when calculating the amount of memory to allocate instead of performing the calculation manually. r? @SimonSapin

@michaelwoerister

Make GlobalCtxt thread-safe r? @michaelwoerister

Tweak output on E0599 for assoc fn used as method - Use suggestion instead of `help` when possible - Add primary span label - Remove incorrect `help` suggestion using incorrect syntax - Do not refer to only one possible candidate as `candidate #1`, refer to it as `the candidate`

Replace `if` with `if and only if` in the definition dox of `Sync` The old text was: "The precise definition is: a type `T` is `Sync` if `&T` is Send." Since we've also got ``` impl<'a, T> Send for &'a T where T: Sync + ?Sized, ``` I purpose we can change the `if` to `if and only if` to make it more precise.

@QuietMisdreavus

…ce, r=QuietMisdreavus Add missing whitespace in num example r? @QuietMisdreavus

…=QuietMisdreavus Remove feature flag from fs::read_to_string example This is stable, and so no longer needed

…s, r=Mark-Simulacrum Pull 1.26.2 release notes into master None

…crum Rollup of 5 pull requests Successful merges: - rust-lang#51135 (Tweak output on E0599 for assoc fn used as method) - rust-lang#51152 (Replace `if` with `if and only if` in the definition dox of `Sync`) - rust-lang#51262 (Add missing whitespace in num example) - rust-lang#51272 (Remove feature flag from fs::read_to_string example) - rust-lang#51286 (Pull 1.26.2 release notes into master) Failed merges:

fs: copy: Add EPERM to fallback error conditions Fixes rust-lang#51266

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Update rustc #8

Update rustc #8

Commits on May 25, 2018

Commits on May 26, 2018

Commits on May 27, 2018

Commits on May 28, 2018

Commits on May 29, 2018

Commits on May 30, 2018

Commits on May 31, 2018

Commits on Jun 1, 2018

Commits on Jun 2, 2018