1. 17 9月, 2018 6 次提交
  2. 16 9月, 2018 18 次提交
  3. 15 9月, 2018 11 次提交
    • P
      Improve output if no_lookup_host_duplicates fails · 0e9d260e
      Philip Munksgaard 提交于
      If the test fails, output the offending addresses and a helpful error message.
      Also slightly improve legibility of the preceding line that puts the addresses
      into a HashMap.
      0e9d260e
    • B
      Auto merge of #53527 - Emerentius:test_all, r=nrc · 9f53c87b
      bors 提交于
      Add option to run all tests
      
      This adds the "--include-ignored" flag to libtest, which allows running ignored and unignored tests in one go.
      
      Closes #50363
      9f53c87b
    • B
      Auto merge of #52896 - SergioBenitez:master, r=alexcrichton · cba0fdf4
      bors 提交于
      Add inspection and setter methods to proc_macro::Diagnostic.
      
      A few useful methods for `proc_macro::Diagnostic`.
      
      r? @alexcrichton
      cba0fdf4
    • B
      Auto merge of #54227 - flip1995:clippyup, r=kennytm · d92b0661
      bors 提交于
      Update Clippy
      
      Clippy one commit behind #54226. This should work
      
      r? @Manishearth
      d92b0661
    • B
      Auto merge of #54177 - nnethercote:streamline-bit-stuff, r=Mark-Simulacrum · 7896af95
      bors 提交于
      Remove bitslice.rs
      
      As the comment in `bitslice.rs` says:
      
      > FIXME: merge with `bitvec`
      7896af95
    • K
      Add a small search box to seach Rust's standary library · d63fd469
      Kazuyoshi Kato 提交于
      This change partially addresses #14572. No CSS doesn't look fancy
      but at least it is functional.
      d63fd469
    • K
      Add a test to prevent regression · bbcb6339
      Kazuyoshi Kato 提交于
      The way it defines implementations is unrealistic though.
      bbcb6339
    • B
      Auto merge of #54151 - ljedrz:cleanup_hir, r=michaelwoerister · ed45f9cb
      bors 提交于
      A few cleanups for hir
      
      - prefer `if let` to `match` when only 1 branch matters
      - `chain` iterable items that are looped over in sequence
      - `sort_by_key` instead of `sort_by` when possible
      - change cloning `map`s to `cloned()`
      - use `unwrap_or_else` and `ok` when applicable
      - a few other minor readability improvements
      - whitespace fixes
      ed45f9cb
    • V
      issue 54109: use short suggestions · bc63a4a1
      Vitaly _Vi Shukela 提交于
      bc63a4a1
    • B
      Auto merge of #54069 - petrochenkov:subns, r=aturon · f789b6bd
      bors 提交于
      resolve: Introduce two sub-namespaces in macro namespace
      
      Two sub-namespaces are introduced in the macro namespace - one for bang macros and one for attribute-like macros (attributes, derives).
      
      "Sub-namespace" means this is not a newly introduced full namespace, the single macro namespace is still in place.
      I.e. you still can't define/import two macros with the same name in a single module, `use` imports still import only one name in macro namespace (from any sub-namespace) and not possibly two.
      
      However, when we are searching for a name used in a `!` macro call context (`my_macro!()`) we skip attribute names in scope, and when we are searching for a name used in attribute context (`#[my_macro]`/`#[derive(my_macro)]`) we are skipping bang macro names in scope.
      In other words, bang macros cannot shadow attribute macros and vice versa.
      
      For a non-macro analogy, we could e.g. skip non-traits when searching for `MyTrait` in `impl MyTrait for Type { ... }`.
      However we do not do it in non-macro namespaces because we don't have practical issues with e.g. non-traits shadowing traits with the same name, but with macros we do, especially after macro modularization.
      
      For `#[test]` and `#[bench]` we have a hack in the compiler right now preventing their shadowing by `macro_rules! test` and similar things. This hack was introduced after making `#[test]`/`#[bench]` built-in macros instead of built-in attributes (https://github.com/rust-lang/rust/pull/53410), something that needed to be done from the start since they are "active" attributes transforming their inputs.
      Now they are passed through normal name resolution and can be shadowed, but that's a breaking change, so we have  a special hack basically applying this PR for `#[test]` and `#[bench]` only.
      
      Soon all potentially built-in attributes will be passed through normal name resolution (https://github.com/rust-lang/rust/pull/53913) and that uncovers even more cases where the strict "macro namespace is a single namespace" rule needs to be broken.
      For example, with strict rules, built-in macro `cfg!(...)` would shadow built-in attribute `#[cfg]` (they are different things), standard library macro `thread_local!(...)` would shadow built-in attribute `#[thread_local]` - both of these cases are covered by special hacks in https://github.com/rust-lang/rust/pull/53913 as well.
      Crater run uncovered more cases of attributes being shadowed by user-defined macros (`warn`, `doc`, `main`, even `deprecated`), we cannot add exceptions in the compiler for all of them.
      
      Regressions with user-defined attributes like https://github.com/rust-lang/rust/issues/53583 and https://github.com/rust-lang/rust/issues/53898 also appeared after enabling macro modularization.
      
      People are also usually confused (https://github.com/rust-lang/rust/issues/53205#issuecomment-411552763, https://github.com/rust-lang/rust/issues/53583#issuecomment-415447800) when they see conflicts between attributes and non-attribute macros for the first time.
      
      So my proposed solution is to solve this issue by introducing two sub-namespaces and thus skipping resolutions of the wrong kind and preventing more error-causing cases of shadowing.
      
      Fixes https://github.com/rust-lang/rust/issues/53583
      f789b6bd
    • B
      Auto merge of #54201 - eddyb:reflexive-disambiguation, r=petrochenkov · 2ab3eba3
      bors 提交于
      rustc_resolve: don't treat uniform_paths canaries as ambiguities unless they resolve to distinct Def's.
      
      In particular, this allows this pattern that @cramertj mentioned in https://github.com/rust-lang/rust/issues/53130#issuecomment-420848814:
      ```rust
      use log::{debug, log};
      fn main() {
          use log::{debug, log};
          debug!(...);
      }
      ```
      The canaries for the inner `use log::...;`, *in the macro namespace*, see the `log` macro imported at the module scope, and the (same) `log` macro, imported in the block scope inside `main`.
      
      Previously, these two possible (macro namspace) `log` resolutions would be considered ambiguous (from a forwards-compat standpoint, where we might make imports aware of block scopes).
      
      With this PR, such a case is allowed *if and only if* all the possible resolutions refer to the same definition (more specifically, because the *same* `log` macro is being imported twice).
      This condition subsumes previous (weaker) checks like #54005 and the second commit of #54011.
      
      Only the last commit is the main change, the other two are cleanups.
      
      r? @petrochenkov cc @Centril @joshtriplett
      2ab3eba3
  4. 14 9月, 2018 5 次提交