From 7cdcdb5dc0b282d5926f0edd7f05b13fbf239197 Mon Sep 17 00:00:00 2001 From: king6cong Date: Wed, 2 Jan 2019 15:18:13 +0800 Subject: [PATCH 001/278] Update reference of rlibc crate to compiler-builtins crate --- src/libcore/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index b2cafc4cede2e..c94f0ab03014d 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -24,7 +24,7 @@ //! often generated by LLVM. Additionally, this library can make explicit //! calls to these functions. Their signatures are the same as found in C. //! These functions are often provided by the system libc, but can also be -//! provided by the [rlibc crate](https://crates.io/crates/rlibc). +//! provided by the [compiler-builtins crate](https://crates.io/crates/compiler_builtins). //! //! * `rust_begin_panic` - This function takes four arguments, a //! `fmt::Arguments`, a `&'static str`, and two `u32`'s. These four arguments From 5581207182d69a03f09d48c38e279cd7b99e422b Mon Sep 17 00:00:00 2001 From: king6cong Date: Wed, 9 Jan 2019 19:42:25 +0800 Subject: [PATCH 002/278] Remove outdated comment --- config.toml.example | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config.toml.example b/config.toml.example index c68d358b6a67e..23943d34b7ca8 100644 --- a/config.toml.example +++ b/config.toml.example @@ -288,7 +288,7 @@ #codegen-units-std = 1 # Whether or not debug assertions are enabled for the compiler and standard -# library. Also enables compilation of debug! and trace! logging macros. +# library. #debug-assertions = false # Whether or not debuginfo is emitted From 830b3b8c75a5b7476de7ce07ee53c590f09f82f1 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Thu, 10 Jan 2019 23:59:42 +0100 Subject: [PATCH 003/278] Re-enable history api on file:// protocol --- src/librustdoc/html/static/main.js | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js index 75b0f5df0d8b3..250e4a466fc96 100644 --- a/src/librustdoc/html/static/main.js +++ b/src/librustdoc/html/static/main.js @@ -150,8 +150,7 @@ if (!DOMTokenList.prototype.remove) { } function browserSupportsHistoryApi() { - return document.location.protocol != "file:" && - window.history && typeof window.history.pushState === "function"; + return window.history && typeof window.history.pushState === "function"; } var main = document.getElementById("main"); From 87f5a98a5d8f29d1a631cd06a39863a1e494b4d7 Mon Sep 17 00:00:00 2001 From: Jakub Onderka Date: Fri, 18 Jan 2019 19:08:31 +0100 Subject: [PATCH 004/278] Use `to_ne_bytes` for converting IPv4Address to octets It is easier and it should be also faster, because `to_ne_bytes` just calls `mem::transmute`. --- src/libstd/net/ip.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/libstd/net/ip.rs b/src/libstd/net/ip.rs index f98113e0896f7..29f635919cb90 100644 --- a/src/libstd/net/ip.rs +++ b/src/libstd/net/ip.rs @@ -393,8 +393,7 @@ impl Ipv4Addr { /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn octets(&self) -> [u8; 4] { - let bits = u32::from_be(self.inner.s_addr); - [(bits >> 24) as u8, (bits >> 16) as u8, (bits >> 8) as u8, bits as u8] + self.inner.s_addr.to_ne_bytes() } /// Returns [`true`] for the special 'unspecified' address (0.0.0.0). From 0c54d2d12ee21f53657e76bf7d2ace9445520ff5 Mon Sep 17 00:00:00 2001 From: Johnathan Van Why Date: Tue, 22 Jan 2019 15:02:57 -0800 Subject: [PATCH 005/278] Mention that core::intrinsics::transmute is available at core::mem::transmute. In #[no_std] environments, std::mem::transmute is unavailable. Searching for transmute in libcore only pulls up core::intrinsics::transmute, which is behind the (unstable) core_intrinsics feature flag. Users wishing to use transmute in #[no_std] environments typically should use core::mem::transmute instead, as it is stable. This documentation makes core::mem::transmute discoverable. --- src/libcore/intrinsics.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index db19baf7a2c64..74c0eae939cb4 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -729,6 +729,10 @@ extern "rust-intrinsic" { /// cause [undefined behavior][ub] with this function. `transmute` should be /// the absolute last resort. /// + /// `transmute` is re-exported by [core::mem](../mem/index.html) as + /// `core::mem::transmute`, which may be used without the `core_intrinsics` + /// feature flag. + /// /// The [nomicon](../../nomicon/transmutes.html) has additional /// documentation. /// From e4fedf4be4c0cf735787bc81ff5ea0d7086fe6cd Mon Sep 17 00:00:00 2001 From: Aaron Hill Date: Tue, 22 Jan 2019 19:54:30 -0500 Subject: [PATCH 006/278] Don't try to clean predicates involving ReErased There's nothing to render when we have a bound involving ReErased (either a type or region outliving it), so we don't attempt to generate a clean WherePredicate Fixes #57806 --- src/librustdoc/clean/auto_trait.rs | 4 +++ src/librustdoc/clean/mod.rs | 48 ++++++++++++++++++++---------- 2 files changed, 37 insertions(+), 15 deletions(-) diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs index 27ca205720d6a..b99181c0d4f9e 100644 --- a/src/librustdoc/clean/auto_trait.rs +++ b/src/librustdoc/clean/auto_trait.rs @@ -574,6 +574,10 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> { let mut ty_to_fn: FxHashMap, Option)> = Default::default(); for (orig_p, p) in clean_where_predicates { + if p.is_none() { + continue; + } + let p = p.unwrap(); match p { WherePredicate::BoundPredicate { ty, mut bounds } => { // Writing a projection trait bound of the form diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 6eea95b61c990..a7ce0520b6d3d 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1271,7 +1271,10 @@ impl Clean> for ty::RegionKind { ty::RePlaceholder(..) | ty::ReEmpty | ty::ReClosureBound(_) | - ty::ReErased => None + ty::ReErased => { + debug!("Cannot clean region {:?}", self); + None + } } } } @@ -1310,16 +1313,16 @@ impl Clean for hir::WherePredicate { } } -impl<'a> Clean for ty::Predicate<'a> { - fn clean(&self, cx: &DocContext) -> WherePredicate { +impl<'a> Clean> for ty::Predicate<'a> { + fn clean(&self, cx: &DocContext) -> Option { use rustc::ty::Predicate; match *self { - Predicate::Trait(ref pred) => pred.clean(cx), - Predicate::Subtype(ref pred) => pred.clean(cx), + Predicate::Trait(ref pred) => Some(pred.clean(cx)), + Predicate::Subtype(ref pred) => Some(pred.clean(cx)), Predicate::RegionOutlives(ref pred) => pred.clean(cx), Predicate::TypeOutlives(ref pred) => pred.clean(cx), - Predicate::Projection(ref pred) => pred.clean(cx), + Predicate::Projection(ref pred) => Some(pred.clean(cx)), Predicate::WellFormed(..) | Predicate::ObjectSafe(..) | @@ -1345,24 +1348,39 @@ impl<'tcx> Clean for ty::SubtypePredicate<'tcx> { } } -impl<'tcx> Clean for ty::OutlivesPredicate, ty::Region<'tcx>> { - fn clean(&self, cx: &DocContext) -> WherePredicate { +impl<'tcx> Clean> for + ty::OutlivesPredicate,ty::Region<'tcx>> { + + fn clean(&self, cx: &DocContext) -> Option { let ty::OutlivesPredicate(ref a, ref b) = *self; - WherePredicate::RegionPredicate { + + match (a, b) { + (ty::ReEmpty, ty::ReEmpty) => { + return None; + }, + _ => {} + } + + Some(WherePredicate::RegionPredicate { lifetime: a.clean(cx).expect("failed to clean lifetime"), bounds: vec![GenericBound::Outlives(b.clean(cx).expect("failed to clean bounds"))] - } + }) } } -impl<'tcx> Clean for ty::OutlivesPredicate, ty::Region<'tcx>> { - fn clean(&self, cx: &DocContext) -> WherePredicate { +impl<'tcx> Clean> for ty::OutlivesPredicate, ty::Region<'tcx>> { + fn clean(&self, cx: &DocContext) -> Option { let ty::OutlivesPredicate(ref ty, ref lt) = *self; - WherePredicate::BoundPredicate { + match lt { + ty::ReEmpty => return None, + _ => {} + } + + Some(WherePredicate::BoundPredicate { ty: ty.clean(cx), bounds: vec![GenericBound::Outlives(lt.clean(cx).expect("failed to clean lifetimes"))] - } + }) } } @@ -1579,7 +1597,7 @@ impl<'a, 'tcx> Clean for (&'a ty::Generics, }).collect::>(); let mut where_predicates = preds.predicates.iter() - .map(|(p, _)| p.clean(cx)) + .flat_map(|(p, _)| p.clean(cx)) .collect::>(); // Type parameters and have a Sized bound by default unless removed with From f97856350cb3d390b23f30b7804f3fc6126740ac Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Fri, 25 Jan 2019 00:07:08 +0100 Subject: [PATCH 007/278] Update minifier version --- Cargo.lock | 6 +++--- src/librustdoc/Cargo.toml | 2 +- src/librustdoc/html/render.rs | 5 +++-- 3 files changed, 7 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 01216deabba31..e20289e458fda 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1407,7 +1407,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "minifier" -version = "0.0.26" +version = "0.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "macro-utils 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", @@ -2853,7 +2853,7 @@ dependencies = [ name = "rustdoc" version = "0.0.0" dependencies = [ - "minifier 0.0.26 (registry+https://github.com/rust-lang/crates.io-index)", + "minifier 0.0.28 (registry+https://github.com/rust-lang/crates.io-index)", "parking_lot 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)", "pulldown-cmark 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", "tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)", @@ -3890,7 +3890,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum memchr 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0a3eb002f0535929f1199681417029ebea04aadc0c7a4224b46be99c7f5d6a16" "checksum memmap 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e2ffa2c986de11a9df78620c01eeaaf27d94d3ff02bf81bfcca953102dd0c6ff" "checksum memoffset 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "0f9dc261e2b62d7a622bf416ea3c5245cdd5d9a7fcc428c0d06804dfce1775b3" -"checksum minifier 0.0.26 (registry+https://github.com/rust-lang/crates.io-index)" = "f299df45afd73332044ea9f717c816a84fc90c8b631409abf339ba93642a7985" +"checksum minifier 0.0.28 (registry+https://github.com/rust-lang/crates.io-index)" = "3a2898502751dcc9d66b6fff57f3cf63cc91605e83e1a33515396f5027f8e4ca" "checksum miniz-sys 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "0300eafb20369952951699b68243ab4334f4b10a88f411c221d444b36c40e649" "checksum miniz_oxide 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5ad30a47319c16cde58d0314f5d98202a80c9083b5f61178457403dfb14e509c" "checksum miniz_oxide_c_api 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "28edaef377517fd9fe3e085c37d892ce7acd1fbeab9239c5a36eec352d8a8b7e" diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml index 4b421881db48d..20d5e672a8368 100644 --- a/src/librustdoc/Cargo.toml +++ b/src/librustdoc/Cargo.toml @@ -9,6 +9,6 @@ path = "lib.rs" [dependencies] pulldown-cmark = { version = "0.1.2", default-features = false } -minifier = "0.0.26" +minifier = "0.0.28" tempfile = "3" parking_lot = "0.6.4" diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 86fb51419c270..0b2e27eccff1b 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -939,7 +939,7 @@ themePicker.onblur = handleThemeButtonsBlur; if path.exists() { for line in BufReader::new(File::open(path)?).lines() { let line = line?; - if for_search_index && line.starts_with("var r_") { + if for_search_index && line.starts_with("var R") { variables.push(line.clone()); // We need to check if the crate name has been put into a variable as well. let tokens = js::simple_minify(&line).apply(js::clean_tokens); @@ -1299,8 +1299,9 @@ fn write_minify_replacer( }) .apply(|f| { // We add a backline after the newly created variables. - minifier::js::aggregate_strings_with_separation( + minifier::js::aggregate_strings_into_array_with_separation( f, + "R", Token::Char(ReservedChar::Backline), ) }) From 1c8c94af51e10e0593163d6a8ff41513271d7eab Mon Sep 17 00:00:00 2001 From: Johnathan Van Why Date: Thu, 24 Jan 2019 16:06:35 -0800 Subject: [PATCH 008/278] Instead of adding a paragraph mentioning std::mem::transmute and core::mem::transmute, create documentation pages for them. This renders them discoverable via search. I removed the mention of the exports in the transmute documentation, but can re-add it if desired. --- src/libcore/intrinsics.rs | 4 ---- src/libcore/mem.rs | 1 + 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 74c0eae939cb4..db19baf7a2c64 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -729,10 +729,6 @@ extern "rust-intrinsic" { /// cause [undefined behavior][ub] with this function. `transmute` should be /// the absolute last resort. /// - /// `transmute` is re-exported by [core::mem](../mem/index.html) as - /// `core::mem::transmute`, which may be used without the `core_intrinsics` - /// feature flag. - /// /// The [nomicon](../../nomicon/transmutes.html) has additional /// documentation. /// diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index 8fcbb73d9ce46..4a9e0bb54cc08 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -15,6 +15,7 @@ use ptr; use ops::{Deref, DerefMut}; #[stable(feature = "rust1", since = "1.0.0")] +#[doc(inline)] pub use intrinsics::transmute; /// Takes ownership and "forgets" about the value **without running its destructor**. From b4d3c87ebc32ed4b96dc64cc9b45758e356df17a Mon Sep 17 00:00:00 2001 From: Simon Heath Date: Sat, 26 Jan 2019 16:46:15 -0500 Subject: [PATCH 009/278] Tiny improvement to docs for `core::convert`. This is not really significant, accept or reject as you wish. I just want to make sure I understand how the PR process works and I'm doing it right before doing a bigger one for #33417. --- src/libcore/convert.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/libcore/convert.rs b/src/libcore/convert.rs index 203be541e492f..d4a1d15e4e7e1 100644 --- a/src/libcore/convert.rs +++ b/src/libcore/convert.rs @@ -17,7 +17,10 @@ //! [`TryFrom`][`TryFrom`] rather than [`Into`][`Into`] or [`TryInto`][`TryInto`], //! as [`From`] and [`TryFrom`] provide greater flexibility and offer //! equivalent [`Into`] or [`TryInto`] implementations for free, thanks to a -//! blanket implementation in the standard library. +//! blanket implementation in the standard library. However, there are some cases +//! where this is not possible, such as creating conversions into a type defined +//! outside your library, so implementing [`Into`] instead of [`From`] is +//! sometimes necessary. //! //! # Generic Implementations //! From 30b1c35f030ae746bf08784dea65fc20f47dc9f8 Mon Sep 17 00:00:00 2001 From: Andy Russell Date: Mon, 28 Jan 2019 13:04:05 -0500 Subject: [PATCH 010/278] rustdoc: remove blank unstable spans --- src/librustdoc/html/render.rs | 4 ---- src/test/rustdoc/stability.rs | 12 ++++++++++++ 2 files changed, 12 insertions(+), 4 deletions(-) create mode 100644 src/test/rustdoc/stability.rs diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 86fb51419c270..83302892c1c96 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -3483,10 +3483,6 @@ fn item_struct(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, ns_id = ns_id, name = field.name.as_ref().unwrap(), ty = ty)?; - if let Some(stability_class) = field.stability_class() { - write!(w, "", - stab = stability_class)?; - } document(w, cx, field)?; } } diff --git a/src/test/rustdoc/stability.rs b/src/test/rustdoc/stability.rs new file mode 100644 index 0000000000000..18a21603493c2 --- /dev/null +++ b/src/test/rustdoc/stability.rs @@ -0,0 +1,12 @@ +#![feature(staged_api)] + +#![unstable(feature = "test", issue = "0")] + +pub struct Unstable { + // @has stability/struct.Unstable.html \ + // '//div[@class="stability"]//div[@class="stab unstable"]' \ + // 'This is a nightly-only experimental API' + // @count stability/struct.Unstable.html '//span[@class="stab unstable"]' 0 + pub foo: u32, + pub bar: u32, +} From 8d26c7504365127c143d540094516f0a2dd67442 Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Tue, 29 Jan 2019 00:59:13 +0200 Subject: [PATCH 011/278] add some comments to method::probe::Candidate --- src/librustc_typeck/check/method/probe.rs | 31 +++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index b849be52a9223..03a0f6233a75e 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -85,6 +85,37 @@ impl<'a, 'gcx, 'tcx> Deref for ProbeContext<'a, 'gcx, 'tcx> { #[derive(Debug)] struct Candidate<'tcx> { + // Candidates are (I'm not quite sure, but they are mostly) basically + // some metadata on top of a `ty::AssociatedItem` (without substs). + // + // However, method probing wants to be able to evaluate the predicates + // for a function with the substs applied - for example, if a function + // has `where Self: Sized`, we don't want to consider it unless `Self` + // is actually `Sized`, and similarly, return-type suggestions want + // to consider the "actual" return type. + // + // The way this is handled is through `xform_self_ty`. It contains + // the receiver type of this candidate, but `xform_self_ty`, + // `xform_ret_ty` and `kind` (which contains the predicates) have the + // generic parameters of this candidate substituted with the *same set* + // of inference variables, which acts as some weird sort of "query". + // + // When we check out a candidate, we require `xform_self_ty` to be + // a subtype of the passed-in self-type, and this equates the type + // variables in the rest of the fields. + // + // For example, if we have this candidate: + // ``` + // trait Foo { + // fn foo(&self) where Self: Sized; + // } + // ``` + // + // Then `xform_self_ty` will be `&'erased ?X` and `kind` will contain + // the predicate `?X: Sized`, so if we are evaluating `Foo` for a + // the receiver `&T`, we'll do the subtyping which will make `?X` + // get the right value, then when we evaluate the predicate we'll check + // if `T: Sized`. xform_self_ty: Ty<'tcx>, xform_ret_ty: Option>, item: ty::AssociatedItem, From 0ceb30de6d5bb82b14159f37dd66a3fd6bcd756c Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Tue, 29 Jan 2019 00:59:30 +0200 Subject: [PATCH 012/278] add tests to a few edge cases in method lookup These aren't fixed by this PR, but were broken in a few older attempts at it. Make sure they don't regress. --- ...-same-trait-object-with-separate-params.rs | 177 ++++++++++++++++++ ...e-trait-object-with-separate-params.stderr | 72 +++++++ .../methods/method-trait-object-with-hrtb.rs | 41 ++++ 3 files changed, 290 insertions(+) create mode 100644 src/test/ui/methods/method-deref-to-same-trait-object-with-separate-params.rs create mode 100644 src/test/ui/methods/method-deref-to-same-trait-object-with-separate-params.stderr create mode 100644 src/test/ui/methods/method-trait-object-with-hrtb.rs diff --git a/src/test/ui/methods/method-deref-to-same-trait-object-with-separate-params.rs b/src/test/ui/methods/method-deref-to-same-trait-object-with-separate-params.rs new file mode 100644 index 0000000000000..a5dae1c71cdaa --- /dev/null +++ b/src/test/ui/methods/method-deref-to-same-trait-object-with-separate-params.rs @@ -0,0 +1,177 @@ +#![feature(arbitrary_self_types, coerce_unsized, dispatch_from_dyn, unsize, unsized_locals)] + +// This tests a few edge-cases around `arbitrary_self_types`. Most specifically, +// it checks that the `ObjectCandidate` you get from method matching can't +// match a trait with the same DefId as a supertrait but a bad type parameter. + +use std::marker::PhantomData; + +mod internal { + use std::ops::{CoerceUnsized, Deref, DispatchFromDyn}; + use std::marker::{PhantomData, Unsize}; + + pub struct Smaht(pub Box, pub PhantomData); + + impl Deref for Smaht { + type Target = T; + + fn deref(&self) -> &Self::Target { + &self.0 + } + } + impl, U: ?Sized, MISC> CoerceUnsized> + for Smaht + {} + impl, U: ?Sized, MISC> DispatchFromDyn> + for Smaht + {} + + pub trait Foo: X {} + pub trait X { + fn foo(self: Smaht) -> T; + } + + impl X for () { + fn foo(self: Smaht) -> u32 { + 0 + } + } + + pub trait Marker {} + impl Marker for dyn Foo {} + impl X for T { + fn foo(self: Smaht) -> u64 { + 1 + } + } + + impl Deref for dyn Foo { + type Target = (); + fn deref(&self) -> &() { &() } + } + + impl Foo for () {} +} + +pub trait FinalFoo { + fn foo(&self) -> u8; +} + +impl FinalFoo for () { + fn foo(&self) -> u8 { 0 } +} + +mod nuisance_foo { + pub trait NuisanceFoo { + fn foo(self); + } + + impl NuisanceFoo for T { + fn foo(self) {} + } +} + + +fn objectcandidate_impl() { + let x: internal::Smaht<(), u32> = internal::Smaht(Box::new(()), PhantomData); + let x: internal::Smaht = x; + + // This picks `>::foo` via `ObjectCandidate`. + // + // The `TraitCandidate` is not relevant because `X` is not in scope. + let z = x.foo(); + + // Observe the type of `z` is `u32` + let _seetype: () = z; //~ ERROR mismatched types + //~| expected (), found u32 +} + +fn traitcandidate_impl() { + use internal::X; + + let x: internal::Smaht<(), u64> = internal::Smaht(Box::new(()), PhantomData); + let x: internal::Smaht = x; + + // This picks `>::foo` via `TraitCandidate`. + // + // The `ObjectCandidate` does not apply, as it only applies to + // `X` (and not `X`). + let z = x.foo(); + + // Observe the type of `z` is `u64` + let _seetype: () = z; //~ ERROR mismatched types + //~| expected (), found u64 +} + +fn traitcandidate_impl_with_nuisance() { + use internal::X; + use nuisance_foo::NuisanceFoo; + + let x: internal::Smaht<(), u64> = internal::Smaht(Box::new(()), PhantomData); + let x: internal::Smaht = x; + + // This picks `>::foo` via `TraitCandidate`. + // + // The `ObjectCandidate` does not apply, as it only applies to + // `X` (and not `X`). + // + // The NuisanceFoo impl has the same priority as the `X` impl, + // so we get a conflict. + let z = x.foo(); //~ ERROR multiple applicable items in scope +} + + +fn neither_impl() { + let x: internal::Smaht<(), u64> = internal::Smaht(Box::new(()), PhantomData); + let x: internal::Smaht = x; + + // This can't pick the `TraitCandidate` impl, because `Foo` is not + // imported. However, this also can't pick the `ObjectCandidate` + // impl, because it only applies to `X` (and not `X`). + // + // Therefore, neither of the candidates is applicable, and we pick + // the `FinalFoo` impl after another deref, which will return `u8`. + let z = x.foo(); + + // Observe the type of `z` is `u8` + let _seetype: () = z; //~ ERROR mismatched types + //~| expected (), found u8 +} + +fn both_impls() { + use internal::X; + + let x: internal::Smaht<(), u32> = internal::Smaht(Box::new(()), PhantomData); + let x: internal::Smaht = x; + + // This can pick both the `TraitCandidate` and the `ObjectCandidate` impl. + // + // However, the `ObjectCandidate` is considered an "inherent candidate", + // and therefore has priority over both the `TraitCandidate` as well as + // any other "nuisance" candidate" (if present). + let z = x.foo(); + + // Observe the type of `z` is `u32` + let _seetype: () = z; //~ ERROR mismatched types + //~| expected (), found u32 +} + + +fn both_impls_with_nuisance() { + // Similar to the `both_impls` example, except with a nuisance impl to + // make sure the `ObjectCandidate` indeed has a higher priority. + + use internal::X; + use nuisance_foo::NuisanceFoo; + + let x: internal::Smaht<(), u32> = internal::Smaht(Box::new(()), PhantomData); + let x: internal::Smaht = x; + let z = x.foo(); + + // Observe the type of `z` is `u32` + let _seetype: () = z; //~ ERROR mismatched types + //~| expected (), found u32 +} + +fn main() { +} diff --git a/src/test/ui/methods/method-deref-to-same-trait-object-with-separate-params.stderr b/src/test/ui/methods/method-deref-to-same-trait-object-with-separate-params.stderr new file mode 100644 index 0000000000000..2d8449b96de41 --- /dev/null +++ b/src/test/ui/methods/method-deref-to-same-trait-object-with-separate-params.stderr @@ -0,0 +1,72 @@ +error[E0308]: mismatched types + --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:85:24 + | +LL | let _seetype: () = z; //~ ERROR mismatched types + | ^ expected (), found u32 + | + = note: expected type `()` + found type `u32` + +error[E0308]: mismatched types + --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:102:24 + | +LL | let _seetype: () = z; //~ ERROR mismatched types + | ^ expected (), found u64 + | + = note: expected type `()` + found type `u64` + +error[E0034]: multiple applicable items in scope + --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:120:15 + | +LL | let z = x.foo(); //~ ERROR multiple applicable items in scope + | ^^^ multiple `foo` found + | +note: candidate #1 is defined in an impl of the trait `internal::X` for the type `_` + --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:43:9 + | +LL | fn foo(self: Smaht) -> u64 { + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +note: candidate #2 is defined in an impl of the trait `nuisance_foo::NuisanceFoo` for the type `_` + --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:70:9 + | +LL | fn foo(self) {} + | ^^^^^^^^^^^^ +note: candidate #3 is defined in the trait `FinalFoo` + --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:57:5 + | +LL | fn foo(&self) -> u8; + | ^^^^^^^^^^^^^^^^^^^^ + = help: to disambiguate the method call, write `FinalFoo::foo(x)` instead + +error[E0308]: mismatched types + --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:137:24 + | +LL | let _seetype: () = z; //~ ERROR mismatched types + | ^ expected (), found u8 + | + = note: expected type `()` + found type `u8` + +error[E0308]: mismatched types + --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:155:24 + | +LL | let _seetype: () = z; //~ ERROR mismatched types + | ^ expected (), found u32 + | + = note: expected type `()` + found type `u32` + +error[E0308]: mismatched types + --> $DIR/method-deref-to-same-trait-object-with-separate-params.rs:172:24 + | +LL | let _seetype: () = z; //~ ERROR mismatched types + | ^ expected (), found u32 + | + = note: expected type `()` + found type `u32` + +error: aborting due to 6 previous errors + +Some errors occurred: E0034, E0308. +For more information about an error, try `rustc --explain E0034`. diff --git a/src/test/ui/methods/method-trait-object-with-hrtb.rs b/src/test/ui/methods/method-trait-object-with-hrtb.rs new file mode 100644 index 0000000000000..da2f13f5a2f8a --- /dev/null +++ b/src/test/ui/methods/method-trait-object-with-hrtb.rs @@ -0,0 +1,41 @@ +// compile-pass + +// Check that method probing ObjectCandidate works in the presence of +// auto traits and/or HRTBs. + +mod internal { + pub trait MyObject<'a> { + type Output; + + fn foo(&self) -> Self::Output; + } + + impl<'a> MyObject<'a> for () { + type Output = &'a u32; + + fn foo(&self) -> Self::Output { &4 } + } +} + +fn t1(d: &dyn for<'a> internal::MyObject<'a, Output=&'a u32>) { + d.foo(); +} + +fn t2(d: &dyn internal::MyObject<'static, Output=&'static u32>) { + d.foo(); +} + +fn t3(d: &(dyn for<'a> internal::MyObject<'a, Output=&'a u32> + Sync)) { + d.foo(); +} + +fn t4(d: &(dyn internal::MyObject<'static, Output=&'static u32> + Sync)) { + d.foo(); +} + +fn main() { + t1(&()); + t2(&()); + t3(&()); + t4(&()); +} From 927d01fdb9adb7ee716af987f7074d5af5426a5d Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Tue, 29 Jan 2019 01:00:42 +0200 Subject: [PATCH 013/278] avoid committing to autoderef in object method probing --- src/librustc_typeck/check/method/probe.rs | 29 ++++++--- .../method-probe-no-guessing-dyn-trait.rs | 59 +++++++++++++++++++ 2 files changed, 81 insertions(+), 7 deletions(-) create mode 100644 src/test/run-pass/methods/method-probe-no-guessing-dyn-trait.rs diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 03a0f6233a75e..be6a2ffa3eb7f 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -537,13 +537,28 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> { match self_ty.value.value.sty { ty::Dynamic(ref data, ..) => { if let Some(p) = data.principal() { - let InferOk { value: instantiated_self_ty, obligations: _ } = - self.fcx.probe_instantiate_query_response( - self.span, &self.orig_steps_var_values, self_ty) - .unwrap_or_else(|_| { - span_bug!(self.span, "{:?} was applicable but now isn't?", self_ty) - }); - self.assemble_inherent_candidates_from_object(instantiated_self_ty); + // Subtle: we can't use `instantiate_query_response` here: using it will + // commit to all of the type equalities assumed by inference going through + // autoderef (see the `method-probe-no-guessing` test). + // + // However, in this code, it is OK if we end up with an object type that is + // "more general" than the object type that we are evaluating. For *every* + // object type `MY_OBJECT`, a function call that goes through a trait-ref + // of the form `::func` is a valid + // `ObjectCandidate`, and it should be discoverable "exactly" through one + // of the iterations in the autoderef loop, so there is no problem with it + // being discoverable in another one of these iterations. + // + // Using `instantiate_canonical_with_fresh_inference_vars` on our + // `Canonical>>` and then *throwing away* the + // `CanonicalVarValues` will exactly give us such a generalization - it + // will still match the original object type, but it won't pollute our + // type variables in any form, so just do that! + let (QueryResponse { value: generalized_self_ty, .. }, _ignored_var_values) = + self.fcx.instantiate_canonical_with_fresh_inference_vars( + self.span, &self_ty); + + self.assemble_inherent_candidates_from_object(generalized_self_ty); self.assemble_inherent_impl_candidates_for_type(p.def_id()); } } diff --git a/src/test/run-pass/methods/method-probe-no-guessing-dyn-trait.rs b/src/test/run-pass/methods/method-probe-no-guessing-dyn-trait.rs new file mode 100644 index 0000000000000..8c8165a100449 --- /dev/null +++ b/src/test/run-pass/methods/method-probe-no-guessing-dyn-trait.rs @@ -0,0 +1,59 @@ +// Check that method matching does not make "guesses" depending on +// Deref impls that don't eventually end up being picked. + +use std::ops::Deref; + +// An impl with less derefs will get called over an impl with more derefs, +// so `(t: Foo<_>).my_fn()` will use ` as MyTrait1>::my_fn(t)`, +// and does *not* force the `_` to equal `()`, because the Deref impl +// was *not* used. + +trait MyTrait1 { + fn my_fn(&self) {} +} + +impl MyTrait1 for Foo {} + +struct Foo(T); + +impl Deref for Foo<()> { + type Target = dyn MyTrait1 + 'static; + fn deref(&self) -> &(dyn MyTrait1 + 'static) { + panic!() + } +} + +// ...but if there is no impl with less derefs, the "guess" will be +// forced, so `(t: Bar<_>).my_fn2()` is `::my_fn2(*t)`, +// and because the deref impl is used, the `_` is forced to equal `u8`. + +trait MyTrait2 { + fn my_fn2(&self) {} +} + +impl MyTrait2 for u32 {} +struct Bar(T, u32); +impl Deref for Bar { + type Target = dyn MyTrait2 + 'static; + fn deref(&self) -> &(dyn MyTrait2 + 'static) { + &self.1 + } +} + +// actually invoke things + +fn main() { + let mut foo: Option> = None; + let mut bar: Option> = None; + let mut first_iter = true; + loop { + if !first_iter { + foo.as_ref().unwrap().my_fn(); + bar.as_ref().unwrap().my_fn2(); + break; + } + foo = Some(Foo(0)); + bar = Some(Bar(Default::default(), 0)); + first_iter = false; + } +} From c6f6101180f8f18008b819b4e438824048b90925 Mon Sep 17 00:00:00 2001 From: Niklas Fiekas Date: Wed, 30 Jan 2019 14:14:16 +0100 Subject: [PATCH 014/278] Allow #[repr(align(x))] on enums (#57996) --- .../src/language-features/repr-align-enum.md | 26 +++++++++++++++++++ src/librustc/hir/check_attr.rs | 12 ++------- src/libsyntax/feature_gate.rs | 14 ++++++++++ src/test/run-pass/structs-enums/align-enum.rs | 17 ++++++++++++ src/test/ui/attr-usage-repr.rs | 3 ++- src/test/ui/attr-usage-repr.stderr | 18 ++++--------- .../feature-gate-repr_align_enum.rs | 10 +++++++ .../feature-gate-repr_align_enum.stderr | 11 ++++++++ 8 files changed, 87 insertions(+), 24 deletions(-) create mode 100644 src/doc/unstable-book/src/language-features/repr-align-enum.md create mode 100644 src/test/run-pass/structs-enums/align-enum.rs create mode 100644 src/test/ui/feature-gates/feature-gate-repr_align_enum.rs create mode 100644 src/test/ui/feature-gates/feature-gate-repr_align_enum.stderr diff --git a/src/doc/unstable-book/src/language-features/repr-align-enum.md b/src/doc/unstable-book/src/language-features/repr-align-enum.md new file mode 100644 index 0000000000000..1fd9bd20f3f0d --- /dev/null +++ b/src/doc/unstable-book/src/language-features/repr-align-enum.md @@ -0,0 +1,26 @@ +# `repr_align_enum` + +The tracking issue for this feature is: [#57996] + +[#57996]: https://github.com/rust-lang/rust/issues/57996 + +------------------------ + +The `repr_align_enum` feature allows using the `#[repr(align(x))]` attribute +on enums, similarly to structs. + +# Examples + +```rust +#![feature(repr_align_enum)] + +#[repr(align(8))] +enum Aligned { + Foo, + Bar { value: u32 }, +} + +fn main() { + assert_eq!(std::mem::align_of::(), 8); +} +``` diff --git a/src/librustc/hir/check_attr.rs b/src/librustc/hir/check_attr.rs index df111b2be319f..9fac88fbbe9ab 100644 --- a/src/librustc/hir/check_attr.rs +++ b/src/librustc/hir/check_attr.rs @@ -187,8 +187,8 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> { }; let (article, allowed_targets) = match &*name.as_str() { - "C" => { - is_c = true; + "C" | "align" => { + is_c |= name == "C"; if target != Target::Struct && target != Target::Union && target != Target::Enum { @@ -213,14 +213,6 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> { continue } } - "align" => { - if target != Target::Struct && - target != Target::Union { - ("a", "struct or union") - } else { - continue - } - } "transparent" => { is_transparent = true; if target != Target::Struct { diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 2820924824697..218a3f52ee0b2 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -461,6 +461,9 @@ declare_features! ( // #[optimize(X)] (active, optimize_attribute, "1.34.0", Some(54882), None), + + // #[repr(align(X))] on enums + (active, repr_align_enum, "1.34.0", Some(57996), None), ); declare_features! ( @@ -1697,6 +1700,17 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { } } + ast::ItemKind::Enum(..) => { + for attr in attr::filter_by_name(&i.attrs[..], "repr") { + for item in attr.meta_item_list().unwrap_or_else(Vec::new) { + if item.check_name("align") { + gate_feature_post!(&self, repr_align_enum, attr.span, + "`#[repr(align(x))]` on enums is experimental"); + } + } + } + } + ast::ItemKind::Impl(_, polarity, defaultness, _, _, _, _) => { if polarity == ast::ImplPolarity::Negative { gate_feature_post!(&self, optin_builtin_traits, diff --git a/src/test/run-pass/structs-enums/align-enum.rs b/src/test/run-pass/structs-enums/align-enum.rs new file mode 100644 index 0000000000000..265bae89b80c9 --- /dev/null +++ b/src/test/run-pass/structs-enums/align-enum.rs @@ -0,0 +1,17 @@ +// run-pass +#![allow(dead_code)] +#![feature(repr_align_enum)] + +use std::mem; + +// Raising alignment +#[repr(align(8))] +enum Align8 { + Foo { foo: u32 }, + Bar { bar: u32 }, +} + +fn main() { + assert_eq!(mem::align_of::(), 8); + assert_eq!(mem::size_of::(), 8); +} diff --git a/src/test/ui/attr-usage-repr.rs b/src/test/ui/attr-usage-repr.rs index 498bf4d284a73..1df2947cbe2dd 100644 --- a/src/test/ui/attr-usage-repr.rs +++ b/src/test/ui/attr-usage-repr.rs @@ -1,4 +1,5 @@ #![feature(repr_simd)] +#![feature(repr_align_enum)] #[repr(C)] //~ ERROR: attribute should be applied to struct, enum or union fn f() {} @@ -18,7 +19,7 @@ struct SInt(f64, f64); #[repr(C)] enum EExtern { A, B } -#[repr(align(8))] //~ ERROR: attribute should be applied to struct +#[repr(align(8))] enum EAlign { A, B } #[repr(packed)] //~ ERROR: attribute should be applied to struct diff --git a/src/test/ui/attr-usage-repr.stderr b/src/test/ui/attr-usage-repr.stderr index 990984bbb2b3d..abb8685e4cef0 100644 --- a/src/test/ui/attr-usage-repr.stderr +++ b/src/test/ui/attr-usage-repr.stderr @@ -1,5 +1,5 @@ error[E0517]: attribute should be applied to struct, enum or union - --> $DIR/attr-usage-repr.rs:3:8 + --> $DIR/attr-usage-repr.rs:4:8 | LL | #[repr(C)] //~ ERROR: attribute should be applied to struct, enum or union | ^ @@ -7,7 +7,7 @@ LL | fn f() {} | --------- not a struct, enum or union error[E0517]: attribute should be applied to enum - --> $DIR/attr-usage-repr.rs:15:8 + --> $DIR/attr-usage-repr.rs:16:8 | LL | #[repr(i8)] //~ ERROR: attribute should be applied to enum | ^^ @@ -15,15 +15,7 @@ LL | struct SInt(f64, f64); | ---------------------- not an enum error[E0517]: attribute should be applied to struct or union - --> $DIR/attr-usage-repr.rs:21:8 - | -LL | #[repr(align(8))] //~ ERROR: attribute should be applied to struct - | ^^^^^^^^ -LL | enum EAlign { A, B } - | -------------------- not a struct or union - -error[E0517]: attribute should be applied to struct or union - --> $DIR/attr-usage-repr.rs:24:8 + --> $DIR/attr-usage-repr.rs:25:8 | LL | #[repr(packed)] //~ ERROR: attribute should be applied to struct | ^^^^^^ @@ -31,13 +23,13 @@ LL | enum EPacked { A, B } | --------------------- not a struct or union error[E0517]: attribute should be applied to struct - --> $DIR/attr-usage-repr.rs:27:8 + --> $DIR/attr-usage-repr.rs:28:8 | LL | #[repr(simd)] //~ ERROR: attribute should be applied to struct | ^^^^ LL | enum ESimd { A, B } | ------------------- not a struct -error: aborting due to 5 previous errors +error: aborting due to 4 previous errors For more information about this error, try `rustc --explain E0517`. diff --git a/src/test/ui/feature-gates/feature-gate-repr_align_enum.rs b/src/test/ui/feature-gates/feature-gate-repr_align_enum.rs new file mode 100644 index 0000000000000..f8e68a9de015b --- /dev/null +++ b/src/test/ui/feature-gates/feature-gate-repr_align_enum.rs @@ -0,0 +1,10 @@ +#[repr(align(16))] +struct Foo(u64); + +#[repr(align(8))] //~ ERROR `#[repr(align(x))]` on enums is experimental (see issue #57996) +enum Bar { + Foo { foo: Foo }, + Baz, +} + +fn main() { } diff --git a/src/test/ui/feature-gates/feature-gate-repr_align_enum.stderr b/src/test/ui/feature-gates/feature-gate-repr_align_enum.stderr new file mode 100644 index 0000000000000..6def25f965118 --- /dev/null +++ b/src/test/ui/feature-gates/feature-gate-repr_align_enum.stderr @@ -0,0 +1,11 @@ +error[E0658]: `#[repr(align(x))]` on enums is experimental (see issue #57996) + --> $DIR/feature-gate-repr_align_enum.rs:4:1 + | +LL | #[repr(align(8))] //~ ERROR `#[repr(align(x))]` on enums is experimental (see issue #57996) + | ^^^^^^^^^^^^^^^^^ + | + = help: add #![feature(repr_align_enum)] to the crate attributes to enable + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0658`. From 1a183368082ad357b1fef0f55038becc9ac14b7b Mon Sep 17 00:00:00 2001 From: "Felix S. Klock II" Date: Wed, 30 Jan 2019 15:12:41 +0100 Subject: [PATCH 015/278] proc_macro: make `TokenStream::from_streams` pre-allocate its vector. This requires a pre-pass over the input streams. But that is cheap compared to the quadratic blowup associated with reallocating the accumulating vector on-the-fly. --- src/libsyntax/tokenstream.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/libsyntax/tokenstream.rs b/src/libsyntax/tokenstream.rs index f5d2d6f18ee87..7d6ffceb2c0d4 100644 --- a/src/libsyntax/tokenstream.rs +++ b/src/libsyntax/tokenstream.rs @@ -255,7 +255,13 @@ impl TokenStream { 0 => TokenStream::empty(), 1 => streams.pop().unwrap(), _ => { - let mut vec = vec![]; + // rust-lang/rust#57735: pre-allocate vector to avoid + // quadratic blow-up due to on-the-fly reallocations. + let tree_count = streams.iter() + .map(|ts| match &ts.0 { None => 0, Some(s) => s.len() }) + .sum(); + let mut vec = Vec::with_capacity(tree_count); + for stream in streams { match stream.0 { None => {}, From 38bcd4b42a1d0a5546122e78efb266161aa4c731 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Tue, 29 Jan 2019 16:47:30 +0100 Subject: [PATCH 016/278] Move privacy checking later in the pipeline and make some passes run in parallel --- src/librustc/hir/mod.rs | 26 ++--- src/librustc/middle/liveness.rs | 1 - src/librustc/session/mod.rs | 4 +- src/librustc_data_structures/sync.rs | 27 +++++ src/librustc_driver/driver.rs | 102 ++++++++++-------- src/librustc_driver/lib.rs | 1 + src/librustc_passes/rvalue_promotion.rs | 1 - src/test/ui/error-codes/E0446.rs | 2 +- src/test/ui/error-codes/E0446.stderr | 4 +- src/test/ui/error-codes/E0451.rs | 8 +- src/test/ui/error-codes/E0451.stderr | 12 +-- ...nctional-struct-update-respects-privacy.rs | 4 +- src/test/ui/privacy/private-in-public-warn.rs | 2 + .../ui/privacy/private-in-public-warn.stderr | 65 ++++++----- src/test/ui/privacy/private-inferred-type.rs | 2 +- 15 files changed, 157 insertions(+), 104 deletions(-) diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 657e6e5dcde35..841124bb4a60a 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -30,7 +30,7 @@ use syntax::util::parser::ExprPrecedence; use ty::AdtKind; use ty::query::Providers; -use rustc_data_structures::sync::{ParallelIterator, par_iter, Send, Sync, scope}; +use rustc_data_structures::sync::{ParallelIterator, par_iter, Send, Sync}; use rustc_data_structures::thin_vec::ThinVec; use serialize::{self, Encoder, Encodable, Decoder, Decodable}; @@ -754,23 +754,17 @@ impl Crate { pub fn par_visit_all_item_likes<'hir, V>(&'hir self, visitor: &V) where V: itemlikevisit::ParItemLikeVisitor<'hir> + Sync + Send { - scope(|s| { - s.spawn(|_| { - par_iter(&self.items).for_each(|(_, item)| { - visitor.visit_item(item); - }); + parallel!({ + par_iter(&self.items).for_each(|(_, item)| { + visitor.visit_item(item); }); - - s.spawn(|_| { - par_iter(&self.trait_items).for_each(|(_, trait_item)| { - visitor.visit_trait_item(trait_item); - }); + }, { + par_iter(&self.trait_items).for_each(|(_, trait_item)| { + visitor.visit_trait_item(trait_item); }); - - s.spawn(|_| { - par_iter(&self.impl_items).for_each(|(_, impl_item)| { - visitor.visit_impl_item(impl_item); - }); + }, { + par_iter(&self.impl_items).for_each(|(_, impl_item)| { + visitor.visit_impl_item(impl_item); }); }); } diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 4ef8e1a0cf95b..841a93cae1b62 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -189,7 +189,6 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { for &module in tcx.hir().krate().modules.keys() { queries::check_mod_liveness::ensure(tcx, tcx.hir().local_def_id(module)); } - tcx.sess.abort_if_errors(); } pub fn provide(providers: &mut Providers<'_>) { diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index c5034415d6ffb..b273c73332c67 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -85,7 +85,7 @@ pub struct Session { /// in order to avoid redundantly verbose output (Issue #24690, #44953). pub one_time_diagnostics: Lock, String)>>, pub plugin_llvm_passes: OneThread>>, - pub plugin_attributes: OneThread>>, + pub plugin_attributes: Lock>, pub crate_types: Once>, pub dependency_formats: Once, /// The crate_disambiguator is constructed out of all the `-C metadata` @@ -1178,7 +1178,7 @@ pub fn build_session_( buffered_lints: Lock::new(Some(Default::default())), one_time_diagnostics: Default::default(), plugin_llvm_passes: OneThread::new(RefCell::new(Vec::new())), - plugin_attributes: OneThread::new(RefCell::new(Vec::new())), + plugin_attributes: Lock::new(Vec::new()), crate_types: Once::new(), dependency_formats: Once::new(), crate_disambiguator: Once::new(), diff --git a/src/librustc_data_structures/sync.rs b/src/librustc_data_structures/sync.rs index cae3087fe586c..7fef1f374d6fd 100644 --- a/src/librustc_data_structures/sync.rs +++ b/src/librustc_data_structures/sync.rs @@ -127,6 +127,13 @@ cfg_if! { pub use self::serial_join as join; pub use self::serial_scope as scope; + #[macro_export] + macro_rules! parallel { + ($($blocks:tt),*) => { + $($blocks)*; + } + } + pub use std::iter::Iterator as ParallelIterator; pub fn par_iter(t: T) -> T::IntoIter { @@ -271,6 +278,26 @@ cfg_if! { use std::thread; pub use rayon::{join, scope}; + #[macro_export] + macro_rules! parallel { + (impl [$($c:tt,)*] [$block:tt $(, $rest:tt)*]) => { + parallel!(impl [$block, $($c,)*] [$($rest),*]) + }; + (impl [$($blocks:tt,)*] []) => { + ::rustc_data_structures::sync::scope(|s| { + $( + s.spawn(|_| $blocks); + )* + }) + }; + ($($blocks:tt),*) => { + // Reverse the order of the blocks since Rayon executes them in reverse order + // when using a single thread. This ensures the execution order matches that + // of a single threaded rustc + parallel!(impl [] [$($blocks),*]); + }; + } + pub use rayon_core::WorkerLocal; pub use rayon::iter::ParallelIterator; diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index c586c705676f4..a3fa55931f02e 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -1222,26 +1222,28 @@ where // tcx available. time(sess, "dep graph tcx init", || rustc_incremental::dep_graph_tcx_init(tcx)); - time(sess, "looking for entry point", || { - middle::entry::find_entry_point(tcx) - }); - - time(sess, "looking for plugin registrar", || { - plugin::build::find_plugin_registrar(tcx) - }); - - time(sess, "looking for derive registrar", || { - proc_macro_decls::find(tcx) - }); - - time(sess, "loop checking", || loops::check_crate(tcx)); + parallel!({ + time(sess, "looking for entry point", || { + middle::entry::find_entry_point(tcx) + }); - time(sess, "attribute checking", || { - hir::check_attr::check_crate(tcx) - }); + time(sess, "looking for plugin registrar", || { + plugin::build::find_plugin_registrar(tcx) + }); - time(sess, "stability checking", || { - stability::check_unstable_api_usage(tcx) + time(sess, "looking for derive registrar", || { + proc_macro_decls::find(tcx) + }); + }, { + time(sess, "loop checking", || loops::check_crate(tcx)); + }, { + time(sess, "attribute checking", || { + hir::check_attr::check_crate(tcx) + }); + }, { + time(sess, "stability checking", || { + stability::check_unstable_api_usage(tcx) + }); }); // passes are timed inside typeck @@ -1253,27 +1255,31 @@ where } } - time(sess, "rvalue promotion", || { - rvalue_promotion::check_crate(tcx) - }); - - time(sess, "privacy checking", || { - rustc_privacy::check_crate(tcx) - }); - - time(sess, "intrinsic checking", || { - middle::intrinsicck::check_crate(tcx) + time(sess, "misc checking", || { + parallel!({ + time(sess, "rvalue promotion", || { + rvalue_promotion::check_crate(tcx) + }); + }, { + time(sess, "intrinsic checking", || { + middle::intrinsicck::check_crate(tcx) + }); + }, { + time(sess, "match checking", || mir::matchck_crate(tcx)); + }, { + // this must run before MIR dump, because + // "not all control paths return a value" is reported here. + // + // maybe move the check to a MIR pass? + time(sess, "liveness checking", || { + middle::liveness::check_crate(tcx) + }); + }); }); - time(sess, "match checking", || mir::matchck_crate(tcx)); - - // this must run before MIR dump, because - // "not all control paths return a value" is reported here. - // - // maybe move the check to a MIR pass? - time(sess, "liveness checking", || { - middle::liveness::check_crate(tcx) - }); + // Abort so we don't try to construct MIR with liveness errors. + // We also won't want to continue with errors from rvalue promotion + tcx.sess.abort_if_errors(); time(sess, "borrow checking", || { if tcx.use_ast_borrowck() { @@ -1297,7 +1303,7 @@ where time(sess, "layout testing", || layout_test::test_layout(tcx)); - // Avoid overwhelming user with errors if type checking failed. + // Avoid overwhelming user with errors if borrow checking failed. // I'm not sure how helpful this is, to be honest, but it avoids // a // lot of annoying errors in the compile-fail tests (basically, @@ -1307,14 +1313,22 @@ where return Ok(f(tcx, rx, sess.compile_status())); } - time(sess, "death checking", || middle::dead::check_crate(tcx)); - - time(sess, "unused lib feature checking", || { - stability::check_unused_or_stable_features(tcx) + time(sess, "misc checking", || { + parallel!({ + time(sess, "privacy checking", || { + rustc_privacy::check_crate(tcx) + }); + }, { + time(sess, "death checking", || middle::dead::check_crate(tcx)); + }, { + time(sess, "unused lib feature checking", || { + stability::check_unused_or_stable_features(tcx) + }); + }, { + time(sess, "lint checking", || lint::check_crate(tcx)); + }); }); - time(sess, "lint checking", || lint::check_crate(tcx)); - return Ok(f(tcx, rx, tcx.sess.compile_status())); }, ) diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index a95ce810ffaeb..5f98ea29d2e76 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -30,6 +30,7 @@ extern crate rustc; extern crate rustc_allocator; extern crate rustc_target; extern crate rustc_borrowck; +#[macro_use] extern crate rustc_data_structures; extern crate rustc_errors as errors; extern crate rustc_passes; diff --git a/src/librustc_passes/rvalue_promotion.rs b/src/librustc_passes/rvalue_promotion.rs index c11b1af97766d..739c96934e6ab 100644 --- a/src/librustc_passes/rvalue_promotion.rs +++ b/src/librustc_passes/rvalue_promotion.rs @@ -44,7 +44,6 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { let def_id = tcx.hir().body_owner_def_id(body_id); tcx.const_is_rvalue_promotable_to_static(def_id); } - tcx.sess.abort_if_errors(); } fn const_is_rvalue_promotable_to_static<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, diff --git a/src/test/ui/error-codes/E0446.rs b/src/test/ui/error-codes/E0446.rs index 33bd6144716c8..f61c7e5461662 100644 --- a/src/test/ui/error-codes/E0446.rs +++ b/src/test/ui/error-codes/E0446.rs @@ -1,4 +1,4 @@ -mod Foo { +mod foo { struct Bar(u32); pub fn bar() -> Bar { //~ ERROR E0446 diff --git a/src/test/ui/error-codes/E0446.stderr b/src/test/ui/error-codes/E0446.stderr index 8f381320cf99e..9c7399515f439 100644 --- a/src/test/ui/error-codes/E0446.stderr +++ b/src/test/ui/error-codes/E0446.stderr @@ -1,8 +1,8 @@ -error[E0446]: private type `Foo::Bar` in public interface +error[E0446]: private type `foo::Bar` in public interface --> $DIR/E0446.rs:4:5 | LL | struct Bar(u32); - | - `Foo::Bar` declared as private + | - `foo::Bar` declared as private LL | LL | / pub fn bar() -> Bar { //~ ERROR E0446 LL | | Bar(0) diff --git a/src/test/ui/error-codes/E0451.rs b/src/test/ui/error-codes/E0451.rs index 7c1c326fb5bec..aa8f051afa777 100644 --- a/src/test/ui/error-codes/E0451.rs +++ b/src/test/ui/error-codes/E0451.rs @@ -1,4 +1,4 @@ -mod Bar { +mod bar { pub struct Foo { pub a: isize, b: isize, @@ -10,10 +10,10 @@ mod Bar { ); } -fn pat_match(foo: Bar::Foo) { - let Bar::Foo{a:a, b:b} = foo; //~ ERROR E0451 +fn pat_match(foo: bar::Foo) { + let bar::Foo{a, b} = foo; //~ ERROR E0451 } fn main() { - let f = Bar::Foo{ a: 0, b: 0 }; //~ ERROR E0451 + let f = bar::Foo{ a: 0, b: 0 }; //~ ERROR E0451 } diff --git a/src/test/ui/error-codes/E0451.stderr b/src/test/ui/error-codes/E0451.stderr index 11bc7e31803a7..11f0867724627 100644 --- a/src/test/ui/error-codes/E0451.stderr +++ b/src/test/ui/error-codes/E0451.stderr @@ -1,13 +1,13 @@ -error[E0451]: field `b` of struct `Bar::Foo` is private - --> $DIR/E0451.rs:14:23 +error[E0451]: field `b` of struct `bar::Foo` is private + --> $DIR/E0451.rs:14:21 | -LL | let Bar::Foo{a:a, b:b} = foo; //~ ERROR E0451 - | ^^^ field `b` is private +LL | let bar::Foo{a, b} = foo; //~ ERROR E0451 + | ^ field `b` is private -error[E0451]: field `b` of struct `Bar::Foo` is private +error[E0451]: field `b` of struct `bar::Foo` is private --> $DIR/E0451.rs:18:29 | -LL | let f = Bar::Foo{ a: 0, b: 0 }; //~ ERROR E0451 +LL | let f = bar::Foo{ a: 0, b: 0 }; //~ ERROR E0451 | ^^^^ field `b` is private error: aborting due to 2 previous errors diff --git a/src/test/ui/functional-struct-update/functional-struct-update-respects-privacy.rs b/src/test/ui/functional-struct-update/functional-struct-update-respects-privacy.rs index 00606af904835..7ae53020fe011 100644 --- a/src/test/ui/functional-struct-update/functional-struct-update-respects-privacy.rs +++ b/src/test/ui/functional-struct-update/functional-struct-update-respects-privacy.rs @@ -6,12 +6,12 @@ use self::foo::S; mod foo { use std::cell::{UnsafeCell}; - static mut count : UnsafeCell = UnsafeCell::new(1); + static mut COUNT : UnsafeCell = UnsafeCell::new(1); pub struct S { pub a: u8, pub b: String, secret_uid: u64 } pub fn make_secrets(a: u8, b: String) -> S { - let val = unsafe { let p = count.get(); let val = *p; *p = val + 1; val }; + let val = unsafe { let p = COUNT.get(); let val = *p; *p = val + 1; val }; println!("creating {}, uid {}", b, val); S { a: a, b: b, secret_uid: val } } diff --git a/src/test/ui/privacy/private-in-public-warn.rs b/src/test/ui/privacy/private-in-public-warn.rs index 29f365b69be4d..467b83746702b 100644 --- a/src/test/ui/privacy/private-in-public-warn.rs +++ b/src/test/ui/privacy/private-in-public-warn.rs @@ -49,6 +49,7 @@ mod traits { pub type Alias = T; //~ ERROR private trait `traits::PrivTr` in public interface //~| WARNING hard error + //~| WARNING bounds on generic parameters are not enforced in type aliases pub trait Tr1: PrivTr {} //~ ERROR private trait `traits::PrivTr` in public interface //~^ WARNING hard error pub trait Tr2 {} //~ ERROR private trait `traits::PrivTr` in public interface @@ -74,6 +75,7 @@ mod traits_where { pub type Alias where T: PrivTr = T; //~^ ERROR private trait `traits_where::PrivTr` in public interface //~| WARNING hard error + //~| WARNING where clauses are not enforced in type aliases pub trait Tr2 where T: PrivTr {} //~^ ERROR private trait `traits_where::PrivTr` in public interface //~| WARNING hard error diff --git a/src/test/ui/privacy/private-in-public-warn.stderr b/src/test/ui/privacy/private-in-public-warn.stderr index 8f9e7cd74f992..621d9a57fa076 100644 --- a/src/test/ui/privacy/private-in-public-warn.stderr +++ b/src/test/ui/privacy/private-in-public-warn.stderr @@ -112,7 +112,7 @@ LL | pub type Alias = T; //~ ERROR private trait `traits::PrivTr` = note: for more information, see issue #34537 error: private trait `traits::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:52:5 + --> $DIR/private-in-public-warn.rs:53:5 | LL | pub trait Tr1: PrivTr {} //~ ERROR private trait `traits::PrivTr` in public interface | ^^^^^^^^^^^^^^^^^^^^^^^^ @@ -121,7 +121,7 @@ LL | pub trait Tr1: PrivTr {} //~ ERROR private trait `traits::PrivTr` in pu = note: for more information, see issue #34537 error: private trait `traits::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:54:5 + --> $DIR/private-in-public-warn.rs:55:5 | LL | pub trait Tr2 {} //~ ERROR private trait `traits::PrivTr` in public interface | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -130,7 +130,7 @@ LL | pub trait Tr2 {} //~ ERROR private trait `traits::PrivTr` in = note: for more information, see issue #34537 error: private trait `traits::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:56:5 + --> $DIR/private-in-public-warn.rs:57:5 | LL | / pub trait Tr3 { LL | | //~^ ERROR private trait `traits::PrivTr` in public interface @@ -145,7 +145,7 @@ LL | | } = note: for more information, see issue #34537 error: private trait `traits::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:60:9 + --> $DIR/private-in-public-warn.rs:61:9 | LL | fn f(arg: T) {} //~ ERROR private trait `traits::PrivTr` in public interface | ^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -154,7 +154,7 @@ LL | fn f(arg: T) {} //~ ERROR private trait `traits::PrivTr` = note: for more information, see issue #34537 error: private trait `traits::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:63:5 + --> $DIR/private-in-public-warn.rs:64:5 | LL | impl Pub {} //~ ERROR private trait `traits::PrivTr` in public interface | ^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -163,7 +163,7 @@ LL | impl Pub {} //~ ERROR private trait `traits::PrivTr` in p = note: for more information, see issue #34537 error: private trait `traits::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:65:5 + --> $DIR/private-in-public-warn.rs:66:5 | LL | impl PubTr for Pub {} //~ ERROR private trait `traits::PrivTr` in public interface | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -172,7 +172,7 @@ LL | impl PubTr for Pub {} //~ ERROR private trait `traits::Pr = note: for more information, see issue #34537 error: private trait `traits_where::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:74:5 + --> $DIR/private-in-public-warn.rs:75:5 | LL | pub type Alias where T: PrivTr = T; | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -181,7 +181,7 @@ LL | pub type Alias where T: PrivTr = T; = note: for more information, see issue #34537 error: private trait `traits_where::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:77:5 + --> $DIR/private-in-public-warn.rs:79:5 | LL | pub trait Tr2 where T: PrivTr {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -190,7 +190,7 @@ LL | pub trait Tr2 where T: PrivTr {} = note: for more information, see issue #34537 error: private trait `traits_where::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:81:9 + --> $DIR/private-in-public-warn.rs:83:9 | LL | fn f(arg: T) where T: PrivTr {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -199,7 +199,7 @@ LL | fn f(arg: T) where T: PrivTr {} = note: for more information, see issue #34537 error: private trait `traits_where::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:85:5 + --> $DIR/private-in-public-warn.rs:87:5 | LL | impl Pub where T: PrivTr {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -208,7 +208,7 @@ LL | impl Pub where T: PrivTr {} = note: for more information, see issue #34537 error: private trait `traits_where::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:88:5 + --> $DIR/private-in-public-warn.rs:90:5 | LL | impl PubTr for Pub where T: PrivTr {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -217,7 +217,7 @@ LL | impl PubTr for Pub where T: PrivTr {} = note: for more information, see issue #34537 error: private trait `generics::PrivTr` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:99:5 + --> $DIR/private-in-public-warn.rs:101:5 | LL | pub trait Tr1: PrivTr {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -226,7 +226,7 @@ LL | pub trait Tr1: PrivTr {} = note: for more information, see issue #34537 error: private type `generics::Priv` in public interface (error E0446) - --> $DIR/private-in-public-warn.rs:102:5 + --> $DIR/private-in-public-warn.rs:104:5 | LL | pub trait Tr2: PubTr {} //~ ERROR private type `generics::Priv` in public interface | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -235,7 +235,7 @@ LL | pub trait Tr2: PubTr {} //~ ERROR private type `generics::Priv` i = note: for more information, see issue #34537 error: private type `generics::Priv` in public interface (error E0446) - --> $DIR/private-in-public-warn.rs:104:5 + --> $DIR/private-in-public-warn.rs:106:5 | LL | pub trait Tr3: PubTr<[Priv; 1]> {} //~ ERROR private type `generics::Priv` in public interface | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -244,7 +244,7 @@ LL | pub trait Tr3: PubTr<[Priv; 1]> {} //~ ERROR private type `generics::Pr = note: for more information, see issue #34537 error: private type `generics::Priv` in public interface (error E0446) - --> $DIR/private-in-public-warn.rs:106:5 + --> $DIR/private-in-public-warn.rs:108:5 | LL | pub trait Tr4: PubTr> {} //~ ERROR private type `generics::Priv` in public interface | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -253,7 +253,7 @@ LL | pub trait Tr4: PubTr> {} //~ ERROR private type `generics::Pr = note: for more information, see issue #34537 error[E0446]: private type `impls::Priv` in public interface - --> $DIR/private-in-public-warn.rs:133:9 + --> $DIR/private-in-public-warn.rs:135:9 | LL | struct Priv; | - `impls::Priv` declared as private @@ -262,7 +262,7 @@ LL | type Alias = Priv; //~ ERROR private type `impls::Priv` in public i | ^^^^^^^^^^^^^^^^^^ can't leak private type error: private type `aliases_pub::Priv` in public interface (error E0446) - --> $DIR/private-in-public-warn.rs:204:9 + --> $DIR/private-in-public-warn.rs:206:9 | LL | pub fn f(arg: Priv) {} //~ ERROR private type `aliases_pub::Priv` in public interface | ^^^^^^^^^^^^^^^^^^^^^^ @@ -271,7 +271,7 @@ LL | pub fn f(arg: Priv) {} //~ ERROR private type `aliases_pub::Priv` i = note: for more information, see issue #34537 error[E0446]: private type `aliases_pub::Priv` in public interface - --> $DIR/private-in-public-warn.rs:208:9 + --> $DIR/private-in-public-warn.rs:210:9 | LL | struct Priv; | - `aliases_pub::Priv` declared as private @@ -280,7 +280,7 @@ LL | type Check = Priv; //~ ERROR private type `aliases_pub::Priv` in pu | ^^^^^^^^^^^^^^^^^^ can't leak private type error[E0446]: private type `aliases_pub::Priv` in public interface - --> $DIR/private-in-public-warn.rs:211:9 + --> $DIR/private-in-public-warn.rs:213:9 | LL | struct Priv; | - `aliases_pub::Priv` declared as private @@ -289,7 +289,7 @@ LL | type Check = Priv; //~ ERROR private type `aliases_pub::Priv` in pu | ^^^^^^^^^^^^^^^^^^ can't leak private type error[E0446]: private type `aliases_pub::Priv` in public interface - --> $DIR/private-in-public-warn.rs:214:9 + --> $DIR/private-in-public-warn.rs:216:9 | LL | struct Priv; | - `aliases_pub::Priv` declared as private @@ -298,7 +298,7 @@ LL | type Check = Priv; //~ ERROR private type `aliases_pub::Priv` in pu | ^^^^^^^^^^^^^^^^^^ can't leak private type error[E0446]: private type `aliases_pub::Priv` in public interface - --> $DIR/private-in-public-warn.rs:217:9 + --> $DIR/private-in-public-warn.rs:219:9 | LL | struct Priv; | - `aliases_pub::Priv` declared as private @@ -307,7 +307,7 @@ LL | type Check = Priv; //~ ERROR private type `aliases_pub::Priv` in pu | ^^^^^^^^^^^^^^^^^^ can't leak private type error: private trait `aliases_priv::PrivTr1` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:247:5 + --> $DIR/private-in-public-warn.rs:249:5 | LL | pub trait Tr1: PrivUseAliasTr {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -316,7 +316,7 @@ LL | pub trait Tr1: PrivUseAliasTr {} = note: for more information, see issue #34537 error: private trait `aliases_priv::PrivTr1` in public interface (error E0445) - --> $DIR/private-in-public-warn.rs:250:5 + --> $DIR/private-in-public-warn.rs:252:5 | LL | pub trait Tr2: PrivUseAliasTr {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -325,7 +325,7 @@ LL | pub trait Tr2: PrivUseAliasTr {} = note: for more information, see issue #34537 error: private type `aliases_priv::Priv2` in public interface (error E0446) - --> $DIR/private-in-public-warn.rs:250:5 + --> $DIR/private-in-public-warn.rs:252:5 | LL | pub trait Tr2: PrivUseAliasTr {} | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -333,6 +333,23 @@ LL | pub trait Tr2: PrivUseAliasTr {} = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: for more information, see issue #34537 +warning: bounds on generic parameters are not enforced in type aliases + --> $DIR/private-in-public-warn.rs:50:23 + | +LL | pub type Alias = T; //~ ERROR private trait `traits::PrivTr` in public interface + | ^^^^^^ + | + = note: #[warn(type_alias_bounds)] on by default + = help: the bound will not be checked when the type alias is used, and should be removed + +warning: where clauses are not enforced in type aliases + --> $DIR/private-in-public-warn.rs:75:29 + | +LL | pub type Alias where T: PrivTr = T; + | ^^^^^^^^^ + | + = help: the clause will not be checked when the type alias is used, and should be removed + error: aborting due to 36 previous errors For more information about this error, try `rustc --explain E0446`. diff --git a/src/test/ui/privacy/private-inferred-type.rs b/src/test/ui/privacy/private-inferred-type.rs index 69b60a56c67f1..d98cf5991efeb 100644 --- a/src/test/ui/privacy/private-inferred-type.rs +++ b/src/test/ui/privacy/private-inferred-type.rs @@ -1,4 +1,3 @@ -#![feature(associated_consts)] #![feature(decl_macro)] #![allow(private_in_public)] @@ -15,6 +14,7 @@ mod m { pub struct PubTupleStruct(u8); impl PubTupleStruct { fn method() {} } + #[derive(Clone, Copy)] struct Priv; pub type Alias = Priv; pub struct Pub(pub T); From 1595163356546e8a4db55784bcc591e2c5cea26c Mon Sep 17 00:00:00 2001 From: David Wood Date: Tue, 29 Jan 2019 13:34:40 +0100 Subject: [PATCH 017/278] Add suggestion for duplicated import. This commit adds a suggestion when a import is duplicated (ie. the same name is used twice trying to import the same thing) to remove the second import. --- src/librustc_resolve/build_reduced_graph.rs | 9 + src/librustc_resolve/lib.rs | 275 +++++++++++++++--- src/librustc_resolve/resolve_imports.rs | 28 +- src/libsyntax/ast.rs | 7 + src/test/ui/double-type-import.stderr | 9 +- src/test/ui/error-codes/E0430.stderr | 10 +- src/test/ui/imports/duplicate.stderr | 9 +- src/test/ui/issues/auxiliary/issue-52891.rs | 33 +++ src/test/ui/issues/issue-26886.stderr | 18 +- .../ui/issues/issue-45829/import-twice.stderr | 10 +- src/test/ui/issues/issue-52891.fixed | 37 +++ src/test/ui/issues/issue-52891.rs | 38 +++ src/test/ui/issues/issue-52891.stderr | 145 +++++++++ src/test/ui/proc-macro/shadow.stderr | 17 +- .../resolve-conflict-import-vs-import.stderr | 9 +- .../unresolved-extern-mod-suggestion.stderr | 9 +- src/test/ui/use/use-mod.stderr | 9 +- src/test/ui/use/use-paths-as-items.stderr | 9 +- 18 files changed, 570 insertions(+), 111 deletions(-) create mode 100644 src/test/ui/issues/auxiliary/issue-52891.rs create mode 100644 src/test/ui/issues/issue-52891.fixed create mode 100644 src/test/ui/issues/issue-52891.rs create mode 100644 src/test/ui/issues/issue-52891.stderr diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 3752d953f8afa..c5401ac3f5560 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -238,12 +238,14 @@ impl<'a> Resolver<'a> { macro_ns: Cell::new(None), }, type_ns_only, + nested, }; self.add_import_directive( module_path, subclass, use_tree.span, id, + item, root_span, item.id, vis, @@ -260,6 +262,7 @@ impl<'a> Resolver<'a> { subclass, use_tree.span, id, + item, root_span, item.id, vis, @@ -379,6 +382,9 @@ impl<'a> Resolver<'a> { source: orig_name, target: ident, }, + has_attributes: !item.attrs.is_empty(), + use_span_with_attributes: item.span_with_attributes(), + use_span: item.span, root_span: item.span, span: item.span, module_path: Vec::new(), @@ -824,6 +830,9 @@ impl<'a> Resolver<'a> { parent_scope: parent_scope.clone(), imported_module: Cell::new(Some(ModuleOrUniformRoot::Module(module))), subclass: ImportDirectiveSubclass::MacroUse, + use_span_with_attributes: item.span_with_attributes(), + has_attributes: !item.attrs.is_empty(), + use_span: item.span, root_span: span, span, module_path: Vec::new(), diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 55d5cdedd6ddd..3973bc2ad62de 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -63,7 +63,7 @@ use syntax::ast::{Label, Local, Mutability, Pat, PatKind, Path}; use syntax::ast::{QSelf, TraitItemKind, TraitRef, Ty, TyKind}; use syntax::ptr::P; -use syntax_pos::{Span, DUMMY_SP, MultiSpan}; +use syntax_pos::{BytePos, Span, DUMMY_SP, MultiSpan}; use errors::{Applicability, DiagnosticBuilder, DiagnosticId}; use std::cell::{Cell, RefCell}; @@ -1228,6 +1228,16 @@ enum NameBindingKind<'a> { }, } +impl<'a> NameBindingKind<'a> { + /// Is this a name binding of a import? + fn is_import(&self) -> bool { + match *self { + NameBindingKind::Import { .. } => true, + _ => false, + } + } +} + struct PrivacyError<'a>(Span, Ident, &'a NameBinding<'a>); struct UseError<'a> { @@ -5134,64 +5144,235 @@ impl<'a> Resolver<'a> { ); // See https://github.com/rust-lang/rust/issues/32354 + use NameBindingKind::Import; let directive = match (&new_binding.kind, &old_binding.kind) { - (NameBindingKind::Import { directive, .. }, _) if !new_binding.span.is_dummy() => - Some((directive, new_binding.span)), - (_, NameBindingKind::Import { directive, .. }) if !old_binding.span.is_dummy() => - Some((directive, old_binding.span)), + // If there are two imports where one or both have attributes then prefer removing the + // import without attributes. + (Import { directive: new, .. }, Import { directive: old, .. }) if { + !new_binding.span.is_dummy() && !old_binding.span.is_dummy() && + (new.has_attributes || old.has_attributes) + } => { + if old.has_attributes { + Some((new, new_binding.span, true)) + } else { + Some((old, old_binding.span, true)) + } + }, + // Otherwise prioritize the new binding. + (Import { directive, .. }, other) if !new_binding.span.is_dummy() => + Some((directive, new_binding.span, other.is_import())), + (other, Import { directive, .. }) if !old_binding.span.is_dummy() => + Some((directive, old_binding.span, other.is_import())), _ => None, }; - if let Some((directive, binding_span)) = directive { - let suggested_name = if name.as_str().chars().next().unwrap().is_uppercase() { - format!("Other{}", name) - } else { - format!("other_{}", name) - }; - let mut suggestion = None; - match directive.subclass { - ImportDirectiveSubclass::SingleImport { type_ns_only: true, .. } => - suggestion = Some(format!("self as {}", suggested_name)), - ImportDirectiveSubclass::SingleImport { source, .. } => { - if let Some(pos) = source.span.hi().0.checked_sub(binding_span.lo().0) - .map(|pos| pos as usize) { - if let Ok(snippet) = self.session.source_map() - .span_to_snippet(binding_span) { - if pos <= snippet.len() { - suggestion = Some(format!( - "{} as {}{}", - &snippet[..pos], - suggested_name, - if snippet.ends_with(";") { ";" } else { "" } - )) - } + // Check if the target of the use for both bindings is the same. + let duplicate = new_binding.def().opt_def_id() == old_binding.def().opt_def_id(); + let has_dummy_span = new_binding.span.is_dummy() || old_binding.span.is_dummy(); + let from_item = self.extern_prelude.get(&ident) + .map(|entry| entry.introduced_by_item) + .unwrap_or(true); + // Only suggest removing an import if both bindings are to the same def, if both spans + // aren't dummy spans. Further, if both bindings are imports, then the ident must have + // been introduced by a item. + let should_remove_import = duplicate && !has_dummy_span && + ((new_binding.is_extern_crate() || old_binding.is_extern_crate()) || from_item); + + match directive { + Some((directive, span, true)) if should_remove_import && directive.is_nested() => + self.add_suggestion_for_duplicate_nested_use(&mut err, directive, span), + Some((directive, _, true)) if should_remove_import && !directive.is_glob() => { + // Simple case - remove the entire import. Due to the above match arm, this can + // only be a single use so just remove it entirely. + err.span_suggestion( + directive.use_span_with_attributes, + "remove unnecessary import", + String::new(), + Applicability::MaybeIncorrect, + ); + }, + Some((directive, span, _)) => + self.add_suggestion_for_rename_of_use(&mut err, name, directive, span), + _ => {}, + } + + err.emit(); + self.name_already_seen.insert(name, span); + } + + /// This function adds a suggestion to change the binding name of a new import that conflicts + /// with an existing import. + /// + /// ```ignore (diagnostic) + /// help: you can use `as` to change the binding name of the import + /// | + /// LL | use foo::bar as other_bar; + /// | ^^^^^^^^^^^^^^^^^^^^^ + /// ``` + fn add_suggestion_for_rename_of_use( + &self, + err: &mut DiagnosticBuilder<'_>, + name: Symbol, + directive: &ImportDirective<'_>, + binding_span: Span, + ) { + let suggested_name = if name.as_str().chars().next().unwrap().is_uppercase() { + format!("Other{}", name) + } else { + format!("other_{}", name) + }; + + let mut suggestion = None; + match directive.subclass { + ImportDirectiveSubclass::SingleImport { type_ns_only: true, .. } => + suggestion = Some(format!("self as {}", suggested_name)), + ImportDirectiveSubclass::SingleImport { source, .. } => { + if let Some(pos) = source.span.hi().0.checked_sub(binding_span.lo().0) + .map(|pos| pos as usize) { + if let Ok(snippet) = self.session.source_map() + .span_to_snippet(binding_span) { + if pos <= snippet.len() { + suggestion = Some(format!( + "{} as {}{}", + &snippet[..pos], + suggested_name, + if snippet.ends_with(";") { ";" } else { "" } + )) } } } - ImportDirectiveSubclass::ExternCrate { source, target, .. } => - suggestion = Some(format!( - "extern crate {} as {};", - source.unwrap_or(target.name), - suggested_name, - )), - _ => unreachable!(), } + ImportDirectiveSubclass::ExternCrate { source, target, .. } => + suggestion = Some(format!( + "extern crate {} as {};", + source.unwrap_or(target.name), + suggested_name, + )), + _ => unreachable!(), + } + + let rename_msg = "you can use `as` to change the binding name of the import"; + if let Some(suggestion) = suggestion { + err.span_suggestion( + binding_span, + rename_msg, + suggestion, + Applicability::MaybeIncorrect, + ); + } else { + err.span_label(binding_span, rename_msg); + } + } - let rename_msg = "you can use `as` to change the binding name of the import"; - if let Some(suggestion) = suggestion { - err.span_suggestion( - binding_span, - rename_msg, - suggestion, - Applicability::MaybeIncorrect, - ); - } else { - err.span_label(binding_span, rename_msg); + /// This function adds a suggestion to remove a unnecessary binding from an import that is + /// nested. In the following example, this function will be invoked to remove the `a` binding + /// in the second use statement: + /// + /// ```ignore (diagnostic) + /// use issue_52891::a; + /// use issue_52891::{d, a, e}; + /// ``` + /// + /// The following suggestion will be added: + /// + /// ```ignore (diagnostic) + /// use issue_52891::{d, a, e}; + /// ^-- help: remove unnecessary import + /// ``` + /// + /// If the nested use contains only one import then the suggestion will remove the entire + /// line. + /// + /// It is expected that the directive provided is a nested import - this isn't checked by the + /// function. If this invariant is not upheld, this function's behaviour will be unexpected + /// as characters expected by span manipulations won't be present. + fn add_suggestion_for_duplicate_nested_use( + &self, + err: &mut DiagnosticBuilder<'_>, + directive: &ImportDirective<'_>, + binding_span: Span, + ) { + assert!(directive.is_nested()); + let message = "remove unnecessary import"; + let source_map = self.session.source_map(); + + // Two examples will be used to illustrate the span manipulations we're doing: + // + // - Given `use issue_52891::{d, a, e};` where `a` is a duplicate then `binding_span` is + // `a` and `directive.use_span` is `issue_52891::{d, a, e};`. + // - Given `use issue_52891::{d, e, a};` where `a` is a duplicate then `binding_span` is + // `a` and `directive.use_span` is `issue_52891::{d, e, a};`. + + // Find the span of everything after the binding. + // ie. `a, e};` or `a};` + let binding_until_end = binding_span.with_hi(directive.use_span.hi()); + + // Find everything after the binding but not including the binding. + // ie. `, e};` or `};` + let after_binding_until_end = binding_until_end.with_lo(binding_span.hi()); + + // Keep characters in the span until we encounter something that isn't a comma or + // whitespace. + // ie. `, ` or ``. + // + // Also note whether a closing brace character was encountered. If there + // was, then later go backwards to remove any trailing commas that are left. + let mut found_closing_brace = false; + let after_binding_until_next_binding = source_map.span_take_while( + after_binding_until_end, + |&ch| { + if ch == '}' { found_closing_brace = true; } + ch == ' ' || ch == ',' + } + ); + + // Combine the two spans. + // ie. `a, ` or `a`. + // + // Removing these would leave `issue_52891::{d, e};` or `issue_52891::{d, e, };` + let span = binding_span.with_hi(after_binding_until_next_binding.hi()); + + // If there was a closing brace then identify the span to remove any trailing commas from + // previous imports. + if found_closing_brace { + if let Ok(prev_source) = source_map.span_to_prev_source(span) { + // `prev_source` will contain all of the source that came before the span. + // Then split based on a command and take the first (ie. closest to our span) + // snippet. In the example, this is a space. + let prev_comma = prev_source.rsplit(',').collect::>(); + let prev_starting_brace = prev_source.rsplit('{').collect::>(); + if prev_comma.len() > 1 && prev_starting_brace.len() > 1 { + let prev_comma = prev_comma.first().unwrap(); + let prev_starting_brace = prev_starting_brace.first().unwrap(); + + // If the amount of source code before the comma is greater than + // the amount of source code before the starting brace then we've only + // got one item in the nested item (eg. `issue_52891::{self}`). + if prev_comma.len() > prev_starting_brace.len() { + // So just remove the entire line... + err.span_suggestion( + directive.use_span_with_attributes, + message, + String::new(), + Applicability::MaybeIncorrect, + ); + return; + } + + let span = span.with_lo(BytePos( + // Take away the number of bytes for the characters we've found and an + // extra for the comma. + span.lo().0 - (prev_comma.as_bytes().len() as u32) - 1 + )); + err.span_suggestion( + span, message, String::new(), Applicability::MaybeIncorrect, + ); + return; + } } } - err.emit(); - self.name_already_seen.insert(name, span); + err.span_suggestion(span, message, String::new(), Applicability::MachineApplicable); } fn extern_prelude_get(&mut self, ident: Ident, speculative: bool) diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index fd55897522bf7..5105c80fcbc87 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -18,7 +18,7 @@ use rustc::hir::def::*; use rustc::session::DiagnosticMessageId; use rustc::util::nodemap::FxHashSet; -use syntax::ast::{Ident, Name, NodeId, CRATE_NODE_ID}; +use syntax::ast::{self, Ident, Name, NodeId, CRATE_NODE_ID}; use syntax::ext::base::Determinacy::{self, Determined, Undetermined}; use syntax::ext::hygiene::Mark; use syntax::symbol::keywords; @@ -42,6 +42,8 @@ pub enum ImportDirectiveSubclass<'a> { target_bindings: PerNS>>>, /// `true` for `...::{self [as target]}` imports, `false` otherwise. type_ns_only: bool, + /// Did this import result from a nested import? ie. `use foo::{bar, baz};` + nested: bool, }, GlobImport { is_prelude: bool, @@ -78,6 +80,15 @@ crate struct ImportDirective<'a> { /// `UseTree` node. pub root_id: NodeId, + /// Span of the entire use statement. + pub use_span: Span, + + /// Span of the entire use statement with attributes. + pub use_span_with_attributes: Span, + + /// Did the use statement have any attributes? + pub has_attributes: bool, + /// Span of this use tree. pub span: Span, @@ -98,6 +109,13 @@ impl<'a> ImportDirective<'a> { match self.subclass { ImportDirectiveSubclass::GlobImport { .. } => true, _ => false } } + pub fn is_nested(&self) -> bool { + match self.subclass { + ImportDirectiveSubclass::SingleImport { nested, .. } => nested, + _ => false + } + } + crate fn crate_lint(&self) -> CrateLint { CrateLint::UsePath { root_id: self.root_id, root_span: self.root_span } } @@ -390,6 +408,7 @@ impl<'a> Resolver<'a> { subclass: ImportDirectiveSubclass<'a>, span: Span, id: NodeId, + item: &ast::Item, root_span: Span, root_id: NodeId, vis: ty::Visibility, @@ -402,6 +421,9 @@ impl<'a> Resolver<'a> { subclass, span, id, + use_span: item.span, + use_span_with_attributes: item.span_with_attributes(), + has_attributes: !item.attrs.is_empty(), root_span, root_id, vis: Cell::new(vis), @@ -787,7 +809,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { let (source, target, source_bindings, target_bindings, type_ns_only) = match directive.subclass { SingleImport { source, target, ref source_bindings, - ref target_bindings, type_ns_only } => + ref target_bindings, type_ns_only, .. } => (source, target, source_bindings, target_bindings, type_ns_only), GlobImport { .. } => { self.resolve_glob_import(directive); @@ -908,7 +930,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { let (ident, target, source_bindings, target_bindings, type_ns_only) = match directive.subclass { SingleImport { source, target, ref source_bindings, - ref target_bindings, type_ns_only } => + ref target_bindings, type_ns_only, .. } => (source, target, source_bindings, target_bindings, type_ns_only), GlobImport { is_prelude, ref max_vis } => { if directive.module_path.len() <= 1 { diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index af521848e9057..4f3f5631cc39c 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -2164,6 +2164,13 @@ pub struct Item { pub tokens: Option, } +impl Item { + /// Return the span that encompasses the attributes. + pub fn span_with_attributes(&self) -> Span { + self.attrs.iter().fold(self.span, |acc, attr| acc.to(attr.span())) + } +} + /// A function header. /// /// All the information between the visibility and the name of the function is diff --git a/src/test/ui/double-type-import.stderr b/src/test/ui/double-type-import.stderr index 4bdee0c4c9f6c..c7288af13c278 100644 --- a/src/test/ui/double-type-import.stderr +++ b/src/test/ui/double-type-import.stderr @@ -4,13 +4,12 @@ error[E0252]: the name `X` is defined multiple times LL | pub use self::bar::X; | ------------ previous import of the type `X` here LL | use self::bar::X; - | ^^^^^^^^^^^^ `X` reimported here + | ----^^^^^^^^^^^^- + | | | + | | `X` reimported here + | help: remove unnecessary import | = note: `X` must be defined only once in the type namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | use self::bar::X as OtherX; - | ^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/error-codes/E0430.stderr b/src/test/ui/error-codes/E0430.stderr index 0151cde887f1d..78e4e43ac2f3d 100644 --- a/src/test/ui/error-codes/E0430.stderr +++ b/src/test/ui/error-codes/E0430.stderr @@ -10,15 +10,13 @@ error[E0252]: the name `fmt` is defined multiple times --> $DIR/E0430.rs:1:22 | LL | use std::fmt::{self, self}; //~ ERROR E0430 - | ---- ^^^^ `fmt` reimported here - | | + | ------^^^^ + | | | | + | | | `fmt` reimported here + | | help: remove unnecessary import | previous import of the module `fmt` here | = note: `fmt` must be defined only once in the type namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | use std::fmt::{self, self as other_fmt}; //~ ERROR E0430 - | ^^^^^^^^^^^^^^^^^ error: aborting due to 2 previous errors diff --git a/src/test/ui/imports/duplicate.stderr b/src/test/ui/imports/duplicate.stderr index acd66826fdfb7..29660d908e485 100644 --- a/src/test/ui/imports/duplicate.stderr +++ b/src/test/ui/imports/duplicate.stderr @@ -4,13 +4,12 @@ error[E0252]: the name `foo` is defined multiple times LL | use a::foo; | ------ previous import of the value `foo` here LL | use a::foo; //~ ERROR the name `foo` is defined multiple times - | ^^^^^^ `foo` reimported here + | ----^^^^^^- + | | | + | | `foo` reimported here + | help: remove unnecessary import | = note: `foo` must be defined only once in the value namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | use a::foo as other_foo; //~ ERROR the name `foo` is defined multiple times - | ^^^^^^^^^^^^^^^^^^^ error[E0659]: `foo` is ambiguous (glob import vs glob import in the same module) --> $DIR/duplicate.rs:46:15 diff --git a/src/test/ui/issues/auxiliary/issue-52891.rs b/src/test/ui/issues/auxiliary/issue-52891.rs new file mode 100644 index 0000000000000..0759811832242 --- /dev/null +++ b/src/test/ui/issues/auxiliary/issue-52891.rs @@ -0,0 +1,33 @@ +pub mod a { + pub mod inner { + } +} + +pub mod b { + pub mod inner { + } +} + +pub mod c {} + +pub mod d {} + +pub mod e {} + +pub mod f {} + +pub mod g {} + +pub mod h {} + +pub mod i {} + +pub mod j {} + +pub mod k {} + +pub mod l {} + +pub mod m {} + +pub mod n {} diff --git a/src/test/ui/issues/issue-26886.stderr b/src/test/ui/issues/issue-26886.stderr index 08faa9c9ca2c2..70dacb353fe07 100644 --- a/src/test/ui/issues/issue-26886.stderr +++ b/src/test/ui/issues/issue-26886.stderr @@ -4,13 +4,12 @@ error[E0252]: the name `Arc` is defined multiple times LL | use std::sync::{self, Arc}; | --- previous import of the type `Arc` here LL | use std::sync::Arc; //~ ERROR the name `Arc` is defined multiple times - | ^^^^^^^^^^^^^^ `Arc` reimported here + | ----^^^^^^^^^^^^^^- + | | | + | | `Arc` reimported here + | help: remove unnecessary import | = note: `Arc` must be defined only once in the type namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | use std::sync::Arc as OtherArc; //~ ERROR the name `Arc` is defined multiple times - | ^^^^^^^^^^^^^^^^^^^^^^^^^^ error[E0252]: the name `sync` is defined multiple times --> $DIR/issue-26886.rs:4:5 @@ -19,13 +18,12 @@ LL | use std::sync::{self, Arc}; | ---- previous import of the module `sync` here ... LL | use std::sync; //~ ERROR the name `sync` is defined multiple times - | ^^^^^^^^^ `sync` reimported here + | ----^^^^^^^^^- + | | | + | | `sync` reimported here + | help: remove unnecessary import | = note: `sync` must be defined only once in the type namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | use std::sync as other_sync; //~ ERROR the name `sync` is defined multiple times - | ^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to 2 previous errors diff --git a/src/test/ui/issues/issue-45829/import-twice.stderr b/src/test/ui/issues/issue-45829/import-twice.stderr index 374b809647e7a..2a1ac57651138 100644 --- a/src/test/ui/issues/issue-45829/import-twice.stderr +++ b/src/test/ui/issues/issue-45829/import-twice.stderr @@ -2,15 +2,13 @@ error[E0252]: the name `A` is defined multiple times --> $DIR/import-twice.rs:6:14 | LL | use foo::{A, A}; - | - ^ `A` reimported here - | | + | ---^ + | || | + | || `A` reimported here + | |help: remove unnecessary import | previous import of the type `A` here | = note: `A` must be defined only once in the type namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | use foo::{A, A as OtherA}; - | ^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/issues/issue-52891.fixed b/src/test/ui/issues/issue-52891.fixed new file mode 100644 index 0000000000000..e694b5c9b154f --- /dev/null +++ b/src/test/ui/issues/issue-52891.fixed @@ -0,0 +1,37 @@ +// aux-build:issue-52891.rs +// run-rustfix + +#![allow(warnings)] + +extern crate issue_52891; + +// Check that we don't suggest renaming duplicate imports but instead +// suggest removing one. + +use issue_52891::a; + //~ ERROR `a` is defined multiple times + +use issue_52891::{b, c}; //~ ERROR `a` is defined multiple times +use issue_52891::{d, e}; //~ ERROR `a` is defined multiple times +use issue_52891::{f, g}; //~ ERROR `a` is defined multiple times + +use issue_52891::{//~ ERROR `a` is defined multiple times + h, + i}; +use issue_52891::{j, + //~ ERROR `a` is defined multiple times + k}; +use issue_52891::{l, + m}; //~ ERROR `a` is defined multiple times + +use issue_52891::a::inner; +use issue_52891::b::inner as other_inner; //~ ERROR `inner` is defined multiple times + + +//~^ ERROR `issue_52891` is defined multiple times + + +#[macro_use] +use issue_52891::n; //~ ERROR `n` is defined multiple times + +fn main() {} diff --git a/src/test/ui/issues/issue-52891.rs b/src/test/ui/issues/issue-52891.rs new file mode 100644 index 0000000000000..cd4b40629ab7f --- /dev/null +++ b/src/test/ui/issues/issue-52891.rs @@ -0,0 +1,38 @@ +// aux-build:issue-52891.rs +// run-rustfix + +#![allow(warnings)] + +extern crate issue_52891; + +// Check that we don't suggest renaming duplicate imports but instead +// suggest removing one. + +use issue_52891::a; +use issue_52891::a; //~ ERROR `a` is defined multiple times + +use issue_52891::{a, b, c}; //~ ERROR `a` is defined multiple times +use issue_52891::{d, a, e}; //~ ERROR `a` is defined multiple times +use issue_52891::{f, g, a}; //~ ERROR `a` is defined multiple times + +use issue_52891::{a, //~ ERROR `a` is defined multiple times + h, + i}; +use issue_52891::{j, + a, //~ ERROR `a` is defined multiple times + k}; +use issue_52891::{l, + m, + a}; //~ ERROR `a` is defined multiple times + +use issue_52891::a::inner; +use issue_52891::b::inner; //~ ERROR `inner` is defined multiple times + +use issue_52891::{self}; +//~^ ERROR `issue_52891` is defined multiple times + +use issue_52891::n; +#[macro_use] +use issue_52891::n; //~ ERROR `n` is defined multiple times + +fn main() {} diff --git a/src/test/ui/issues/issue-52891.stderr b/src/test/ui/issues/issue-52891.stderr new file mode 100644 index 0000000000000..55d611070d9dc --- /dev/null +++ b/src/test/ui/issues/issue-52891.stderr @@ -0,0 +1,145 @@ +error[E0252]: the name `a` is defined multiple times + --> $DIR/issue-52891.rs:12:5 + | +LL | use issue_52891::a; + | -------------- previous import of the module `a` here +LL | use issue_52891::a; //~ ERROR `a` is defined multiple times + | ----^^^^^^^^^^^^^^- + | | | + | | `a` reimported here + | help: remove unnecessary import + | + = note: `a` must be defined only once in the type namespace of this module + +error[E0252]: the name `a` is defined multiple times + --> $DIR/issue-52891.rs:14:19 + | +LL | use issue_52891::a; + | -------------- previous import of the module `a` here +... +LL | use issue_52891::{a, b, c}; //~ ERROR `a` is defined multiple times + | ^-- + | | + | `a` reimported here + | help: remove unnecessary import + | + = note: `a` must be defined only once in the type namespace of this module + +error[E0252]: the name `a` is defined multiple times + --> $DIR/issue-52891.rs:15:22 + | +LL | use issue_52891::a; + | -------------- previous import of the module `a` here +... +LL | use issue_52891::{d, a, e}; //~ ERROR `a` is defined multiple times + | ^-- + | | + | `a` reimported here + | help: remove unnecessary import + | + = note: `a` must be defined only once in the type namespace of this module + +error[E0252]: the name `a` is defined multiple times + --> $DIR/issue-52891.rs:16:25 + | +LL | use issue_52891::a; + | -------------- previous import of the module `a` here +... +LL | use issue_52891::{f, g, a}; //~ ERROR `a` is defined multiple times + | --^ + | | | + | | `a` reimported here + | help: remove unnecessary import + | + = note: `a` must be defined only once in the type namespace of this module + +error[E0252]: the name `a` is defined multiple times + --> $DIR/issue-52891.rs:18:19 + | +LL | use issue_52891::a; + | -------------- previous import of the module `a` here +... +LL | use issue_52891::{a, //~ ERROR `a` is defined multiple times + | ^-- + | | + | `a` reimported here + | help: remove unnecessary import + | + = note: `a` must be defined only once in the type namespace of this module + +error[E0252]: the name `a` is defined multiple times + --> $DIR/issue-52891.rs:22:5 + | +LL | use issue_52891::a; + | -------------- previous import of the module `a` here +... +LL | a, //~ ERROR `a` is defined multiple times + | ^-- + | | + | `a` reimported here + | help: remove unnecessary import + | + = note: `a` must be defined only once in the type namespace of this module + +error[E0252]: the name `a` is defined multiple times + --> $DIR/issue-52891.rs:26:5 + | +LL | use issue_52891::a; + | -------------- previous import of the module `a` here +... +LL | m, + | ______- +LL | | a}; //~ ERROR `a` is defined multiple times + | | - + | | | + | |_____`a` reimported here + | help: remove unnecessary import + | + = note: `a` must be defined only once in the type namespace of this module + +error[E0252]: the name `inner` is defined multiple times + --> $DIR/issue-52891.rs:29:5 + | +LL | use issue_52891::a::inner; + | --------------------- previous import of the module `inner` here +LL | use issue_52891::b::inner; //~ ERROR `inner` is defined multiple times + | ^^^^^^^^^^^^^^^^^^^^^ `inner` reimported here + | + = note: `inner` must be defined only once in the type namespace of this module +help: you can use `as` to change the binding name of the import + | +LL | use issue_52891::b::inner as other_inner; //~ ERROR `inner` is defined multiple times + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +error[E0254]: the name `issue_52891` is defined multiple times + --> $DIR/issue-52891.rs:31:19 + | +LL | extern crate issue_52891; + | ------------------------- previous import of the extern crate `issue_52891` here +... +LL | use issue_52891::{self}; + | ------------------^^^^-- + | | | + | | `issue_52891` reimported here + | help: remove unnecessary import + | + = note: `issue_52891` must be defined only once in the type namespace of this module + +error[E0252]: the name `n` is defined multiple times + --> $DIR/issue-52891.rs:36:5 + | +LL | use issue_52891::n; + | ------------------- + | | | + | | previous import of the module `n` here + | help: remove unnecessary import +LL | #[macro_use] +LL | use issue_52891::n; //~ ERROR `n` is defined multiple times + | ^^^^^^^^^^^^^^ `n` reimported here + | + = note: `n` must be defined only once in the type namespace of this module + +error: aborting due to 10 previous errors + +Some errors occurred: E0252, E0254. +For more information about an error, try `rustc --explain E0252`. diff --git a/src/test/ui/proc-macro/shadow.stderr b/src/test/ui/proc-macro/shadow.stderr index 103c78126a838..2dfe2a94c88e1 100644 --- a/src/test/ui/proc-macro/shadow.stderr +++ b/src/test/ui/proc-macro/shadow.stderr @@ -1,17 +1,16 @@ error[E0259]: the name `derive_a` is defined multiple times --> $DIR/shadow.rs:6:1 | -LL | extern crate derive_a; - | ---------------------- previous import of the extern crate `derive_a` here -LL | #[macro_use] -LL | extern crate derive_a; //~ ERROR the name `derive_a` is defined multiple times - | ^^^^^^^^^^^^^^^^^^^^^^ `derive_a` reimported here +LL | extern crate derive_a; + | ---------------------- previous import of the extern crate `derive_a` here +LL | / #[macro_use] +LL | | extern crate derive_a; //~ ERROR the name `derive_a` is defined multiple times + | | ^^^^^^^^^^^^^^^^^^^^^- + | |_|____________________| + | | help: remove unnecessary import + | `derive_a` reimported here | = note: `derive_a` must be defined only once in the type namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | extern crate derive_a as other_derive_a; //~ ERROR the name `derive_a` is defined multiple times - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/resolve/resolve-conflict-import-vs-import.stderr b/src/test/ui/resolve/resolve-conflict-import-vs-import.stderr index 2852d122e5e4a..1b4b058b783ad 100644 --- a/src/test/ui/resolve/resolve-conflict-import-vs-import.stderr +++ b/src/test/ui/resolve/resolve-conflict-import-vs-import.stderr @@ -4,13 +4,12 @@ error[E0252]: the name `transmute` is defined multiple times LL | use std::mem::transmute; | ------------------- previous import of the value `transmute` here LL | use std::mem::transmute; - | ^^^^^^^^^^^^^^^^^^^ `transmute` reimported here + | ----^^^^^^^^^^^^^^^^^^^- + | | | + | | `transmute` reimported here + | help: remove unnecessary import | = note: `transmute` must be defined only once in the value namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | use std::mem::transmute as other_transmute; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/unresolved/unresolved-extern-mod-suggestion.stderr b/src/test/ui/unresolved/unresolved-extern-mod-suggestion.stderr index 012d3c3a7510f..e8679a3726d30 100644 --- a/src/test/ui/unresolved/unresolved-extern-mod-suggestion.stderr +++ b/src/test/ui/unresolved/unresolved-extern-mod-suggestion.stderr @@ -4,13 +4,12 @@ error[E0254]: the name `core` is defined multiple times LL | extern crate core; | ------------------ previous import of the extern crate `core` here LL | use core; - | ^^^^ `core` reimported here + | ----^^^^- + | | | + | | `core` reimported here + | help: remove unnecessary import | = note: `core` must be defined only once in the type namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | use core as other_core; - | ^^^^^^^^^^^^^^^^^^ error: aborting due to previous error diff --git a/src/test/ui/use/use-mod.stderr b/src/test/ui/use/use-mod.stderr index 9ab873b35989c..c23ab34eae678 100644 --- a/src/test/ui/use/use-mod.stderr +++ b/src/test/ui/use/use-mod.stderr @@ -20,13 +20,12 @@ LL | self, | ---- previous import of the module `bar` here ... LL | self - | ^^^^ `bar` reimported here + | ^^^^ + | | + | `bar` reimported here + | help: remove unnecessary import | = note: `bar` must be defined only once in the type namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | self as other_bar - | error: aborting due to 3 previous errors diff --git a/src/test/ui/use/use-paths-as-items.stderr b/src/test/ui/use/use-paths-as-items.stderr index 5bcdf937d5698..00f468cdf316b 100644 --- a/src/test/ui/use/use-paths-as-items.stderr +++ b/src/test/ui/use/use-paths-as-items.stderr @@ -4,13 +4,12 @@ error[E0252]: the name `mem` is defined multiple times LL | use std::{mem, ptr}; | --- previous import of the module `mem` here LL | use std::mem; //~ ERROR the name `mem` is defined multiple times - | ^^^^^^^^ `mem` reimported here + | ----^^^^^^^^- + | | | + | | `mem` reimported here + | help: remove unnecessary import | = note: `mem` must be defined only once in the type namespace of this module -help: you can use `as` to change the binding name of the import - | -LL | use std::mem as other_mem; //~ ERROR the name `mem` is defined multiple times - | ^^^^^^^^^^^^^^^^^^^^^ error: aborting due to previous error From d0129a613c3bd4581826bb838eea1ab96c2cd5c7 Mon Sep 17 00:00:00 2001 From: Oliver Scherer Date: Wed, 21 Nov 2018 10:54:46 +0100 Subject: [PATCH 018/278] Add a forever unstable opt-out of const qualification checks --- src/librustc/session/config.rs | 2 ++ src/librustc_mir/transform/qualify_consts.rs | 29 ++++++++++++++++-- .../ui/consts/miri_unleashed/assoc_const.rs | 30 +++++++++++++++++++ .../consts/miri_unleashed/assoc_const.stderr | 15 ++++++++++ .../ui/consts/miri_unleashed/assoc_const_2.rs | 28 +++++++++++++++++ .../miri_unleashed/assoc_const_2.stderr | 9 ++++++ ...ure-gate-unleash_the_miri_inside_of_you.rs | 27 +++++++++++++++++ ...gate-unleash_the_miri_inside_of_you.stderr | 17 +++++++++++ 8 files changed, 155 insertions(+), 2 deletions(-) create mode 100644 src/test/ui/consts/miri_unleashed/assoc_const.rs create mode 100644 src/test/ui/consts/miri_unleashed/assoc_const.stderr create mode 100644 src/test/ui/consts/miri_unleashed/assoc_const_2.rs create mode 100644 src/test/ui/consts/miri_unleashed/assoc_const_2.stderr create mode 100644 src/test/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.rs create mode 100644 src/test/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.stderr diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 4b1aefb2216fb..577246783a178 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1300,6 +1300,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options, "print some statistics about AST and HIR"), always_encode_mir: bool = (false, parse_bool, [TRACKED], "encode MIR of all functions into the crate metadata"), + unleash_the_miri_inside_of_you: bool = (false, parse_bool, [TRACKED], + "take the breaks off const evaluation. NOTE: this is unsound"), osx_rpath_install_name: bool = (false, parse_bool, [TRACKED], "pass `-install_name @rpath/...` to the macOS linker"), sanitizer: Option = (None, parse_sanitizer, [TRACKED], diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs index 2d941902debc3..7d1943e21b90d 100644 --- a/src/librustc_mir/transform/qualify_consts.rs +++ b/src/librustc_mir/transform/qualify_consts.rs @@ -108,6 +108,15 @@ struct Qualifier<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { promotion_candidates: Vec } +macro_rules! unleash_miri { + ($this:expr) => {{ + if $this.tcx.sess.opts.debugging_opts.unleash_the_miri_inside_of_you { + $this.tcx.sess.span_warn($this.span, "skipping const checks"); + return; + } + }} +} + impl<'a, 'tcx> Qualifier<'a, 'tcx, 'tcx> { fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId, @@ -147,6 +156,7 @@ impl<'a, 'tcx> Qualifier<'a, 'tcx, 'tcx> { // categories, but enabling full miri would make that // slightly pointless (even with feature-gating). fn not_const(&mut self) { + unleash_miri!(self); self.add(Qualif::NOT_CONST); if self.mode != Mode::Fn { let mut err = struct_span_err!( @@ -419,6 +429,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> { } return; } + unleash_miri!(self); self.add(Qualif::NOT_CONST); if self.mode != Mode::Fn { @@ -618,6 +629,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> { } if forbidden_mut { + unleash_miri!(self); self.add(Qualif::NOT_CONST); if self.mode != Mode::Fn { let mut err = struct_span_err!(self.tcx.sess, self.span, E0017, @@ -660,6 +672,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> { debug!("visit_rvalue: forbidden_mut={:?}", forbidden_mut); if forbidden_mut { + unleash_miri!(self); self.add(Qualif::NOT_CONST); } else { // We might have a candidate for promotion. @@ -700,6 +713,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> { match (cast_in, cast_out) { (CastTy::Ptr(_), CastTy::Int(_)) | (CastTy::FnPtr, CastTy::Int(_)) => { + unleash_miri!(self); if let Mode::Fn = self.mode { // in normal functions, mark such casts as not promotable self.add(Qualif::NOT_CONST); @@ -727,6 +741,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> { op == BinOp::Ge || op == BinOp::Gt || op == BinOp::Offset); + unleash_miri!(self); if let Mode::Fn = self.mode { // raw pointer operations are not allowed inside promoteds self.add(Qualif::NOT_CONST); @@ -745,6 +760,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> { } Rvalue::NullaryOp(NullOp::Box, _) => { + unleash_miri!(self); self.add(Qualif::NOT_CONST); if self.mode != Mode::Fn { let mut err = struct_span_err!(self.tcx.sess, self.span, E0010, @@ -861,7 +877,13 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> { } else { // stable const fns or unstable const fns with their feature gate // active - if self.tcx.is_const_fn(def_id) { + let unleash_miri = self + .tcx + .sess + .opts + .debugging_opts + .unleash_the_miri_inside_of_you; + if self.tcx.is_const_fn(def_id) || unleash_miri { is_const_fn = true; } else if self.is_const_panic_fn(def_id) { // Check the const_panic feature gate. @@ -1030,6 +1052,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> { // Deny *any* live drops anywhere other than functions. if self.mode != Mode::Fn { + unleash_miri!(self); // HACK(eddyb): emulate a bit of dataflow analysis, // conservatively, that drop elaboration will do. let needs_drop = if let Place::Local(local) = *place { @@ -1175,7 +1198,9 @@ impl MirPass for QualifyAndPromoteConstants { let (temps, candidates) = { let mut qualifier = Qualifier::new(tcx, def_id, mir, mode); if mode == Mode::ConstFn { - if tcx.is_min_const_fn(def_id) { + if tcx.sess.opts.debugging_opts.unleash_the_miri_inside_of_you { + qualifier.qualify_const(); + } else if tcx.is_min_const_fn(def_id) { // enforce `min_const_fn` for stable const fns use super::qualify_min_const_fn::is_min_const_fn; if let Err((span, err)) = is_min_const_fn(tcx, def_id, mir) { diff --git a/src/test/ui/consts/miri_unleashed/assoc_const.rs b/src/test/ui/consts/miri_unleashed/assoc_const.rs new file mode 100644 index 0000000000000..b8959667cc215 --- /dev/null +++ b/src/test/ui/consts/miri_unleashed/assoc_const.rs @@ -0,0 +1,30 @@ +// compile-flags: -Zunleash-the-miri-inside-of-you +#![allow(const_err)] + +// a test demonstrating why we do need to run static const qualification on associated constants +// instead of just checking the final constant + +trait Foo { + const X: T; +} + +trait Bar> { + const F: u32 = (U::X, 42).1; //~ WARN skipping const checks +} + +impl Foo for () { + const X: u32 = 42; +} +impl Foo> for String { + const X: Vec = Vec::new(); +} + +impl Bar for () {} +impl Bar, String> for String {} + +fn main() { + // this is fine, but would have been forbidden by the static checks on `F` + let x = <() as Bar>::F; + // this test only causes errors due to the line below, so post-monomorphization + let y = , String>>::F; //~ ERROR erroneous constant +} diff --git a/src/test/ui/consts/miri_unleashed/assoc_const.stderr b/src/test/ui/consts/miri_unleashed/assoc_const.stderr new file mode 100644 index 0000000000000..a40f8d46d0aa7 --- /dev/null +++ b/src/test/ui/consts/miri_unleashed/assoc_const.stderr @@ -0,0 +1,15 @@ +warning: skipping const checks + --> $DIR/assoc_const.rs:12:31 + | +LL | const F: u32 = (U::X, 42).1; //~ WARN skipping const checks + | ^ + +error[E0080]: erroneous constant used + --> $DIR/assoc_const.rs:29:13 + | +LL | let y = , String>>::F; //~ ERROR erroneous constant + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/consts/miri_unleashed/assoc_const_2.rs b/src/test/ui/consts/miri_unleashed/assoc_const_2.rs new file mode 100644 index 0000000000000..c87b6389848f4 --- /dev/null +++ b/src/test/ui/consts/miri_unleashed/assoc_const_2.rs @@ -0,0 +1,28 @@ +#![allow(const_err)] + +// a test demonstrating that const qualification cannot prevent monomorphization time errors + +trait Foo { + const X: u32; +} + +trait Bar { + const F: u32 = 100 / U::X; +} + +impl Foo for () { + const X: u32 = 42; +} + +impl Foo for String { + const X: u32 = 0; +} + +impl Bar<()> for () {} +impl Bar for String {} + +fn main() { + let x = <() as Bar<()>>::F; + // this test only causes errors due to the line below, so post-monomorphization + let y = >::F; //~ ERROR erroneous constant +} diff --git a/src/test/ui/consts/miri_unleashed/assoc_const_2.stderr b/src/test/ui/consts/miri_unleashed/assoc_const_2.stderr new file mode 100644 index 0000000000000..77aab31d26ec3 --- /dev/null +++ b/src/test/ui/consts/miri_unleashed/assoc_const_2.stderr @@ -0,0 +1,9 @@ +error[E0080]: erroneous constant used + --> $DIR/assoc_const_2.rs:27:13 + | +LL | let y = >::F; //~ ERROR erroneous constant + | ^^^^^^^^^^^^^^^^^^^^^^^^^^ referenced constant has errors + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0080`. diff --git a/src/test/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.rs b/src/test/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.rs new file mode 100644 index 0000000000000..5fb92535502a5 --- /dev/null +++ b/src/test/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.rs @@ -0,0 +1,27 @@ +#![allow(const_err)] + +// a test demonstrating why we do need to run static const qualification on associated constants +// instead of just checking the final constant + +trait Foo { + const X: T; +} + +trait Bar> { + const F: u32 = (U::X, 42).1; //~ ERROR destructors cannot be evaluated at compile-time +} + +impl Foo for () { + const X: u32 = 42; +} +impl Foo> for String { + const X: Vec = Vec::new(); //~ ERROR not yet stable as a const fn +} + +impl Bar for () {} +impl Bar, String> for String {} + +fn main() { + let x = <() as Bar>::F; + let y = , String>>::F; +} diff --git a/src/test/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.stderr b/src/test/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.stderr new file mode 100644 index 0000000000000..e23ed1c620639 --- /dev/null +++ b/src/test/ui/consts/miri_unleashed/feature-gate-unleash_the_miri_inside_of_you.stderr @@ -0,0 +1,17 @@ +error[E0493]: destructors cannot be evaluated at compile-time + --> $DIR/feature-gate-unleash_the_miri_inside_of_you.rs:11:20 + | +LL | const F: u32 = (U::X, 42).1; //~ ERROR destructors cannot be evaluated at compile-time + | ^^^^^^^^^^ constants cannot evaluate destructors + +error: `>::new` is not yet stable as a const fn + --> $DIR/feature-gate-unleash_the_miri_inside_of_you.rs:18:25 + | +LL | const X: Vec = Vec::new(); //~ ERROR not yet stable as a const fn + | ^^^^^^^^^^ + | + = help: add `#![feature(const_vec_new)]` to the crate attributes to enable + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0493`. From 73bf0703a70098cdeebfb29709f74f101ab3e6b1 Mon Sep 17 00:00:00 2001 From: Niklas Fiekas Date: Thu, 31 Jan 2019 14:18:31 +0100 Subject: [PATCH 019/278] Add more tests for #[repr(align(x))] on enums --- src/test/run-pass/structs-enums/align-enum.rs | 46 +++++++++++++++++-- src/test/ui/repr/repr-align.rs | 4 ++ src/test/ui/repr/repr-align.stderr | 14 ++++-- 3 files changed, 56 insertions(+), 8 deletions(-) diff --git a/src/test/run-pass/structs-enums/align-enum.rs b/src/test/run-pass/structs-enums/align-enum.rs index 265bae89b80c9..8d72b1f6f0d24 100644 --- a/src/test/run-pass/structs-enums/align-enum.rs +++ b/src/test/run-pass/structs-enums/align-enum.rs @@ -5,13 +5,51 @@ use std::mem; // Raising alignment -#[repr(align(8))] -enum Align8 { +#[repr(align(16))] +enum Align16 { Foo { foo: u32 }, Bar { bar: u32 }, } +// Raise alignment by maximum +#[repr(align(1), align(16))] +#[repr(align(32))] +#[repr(align(4))] +enum Align32 { + Foo, + Bar, +} + +// Not reducing alignment +#[repr(align(4))] +enum AlsoAlign16 { + Foo { limb_with_align16: Align16 }, + Bar, +} + +// No niche for discriminant when used as limb +#[repr(align(16))] +struct NoNiche16(u64, u64); + +// Discriminant will require extra space, but enum needs to stay compatible +// with alignment 16 +#[repr(align(1))] +enum AnotherAlign16 { + Foo { limb_with_noniche16: NoNiche16 }, + Bar, + Baz, +} + fn main() { - assert_eq!(mem::align_of::(), 8); - assert_eq!(mem::size_of::(), 8); + assert_eq!(mem::align_of::(), 16); + assert_eq!(mem::size_of::(), 16); + + assert_eq!(mem::align_of::(), 32); + assert_eq!(mem::size_of::(), 32); + + assert_eq!(mem::align_of::(), 16); + assert_eq!(mem::size_of::(), 16); + + assert_eq!(mem::align_of::(), 16); + assert_eq!(mem::size_of::(), 32); } diff --git a/src/test/ui/repr/repr-align.rs b/src/test/ui/repr/repr-align.rs index 78ed6c7e1c417..9ce89e82ca225 100644 --- a/src/test/ui/repr/repr-align.rs +++ b/src/test/ui/repr/repr-align.rs @@ -1,3 +1,4 @@ +#![feature(repr_align_enum)] #![allow(dead_code)] #[repr(align(16.0))] //~ ERROR: invalid `repr(align)` attribute: not an unsuffixed integer @@ -12,4 +13,7 @@ struct C(i32); #[repr(align(536870912))] // ok: this is the largest accepted alignment struct D(i32); +#[repr(align(15))] //~ ERROR: invalid `repr(align)` attribute: not a power of two +enum E { Left, Right } + fn main() {} diff --git a/src/test/ui/repr/repr-align.stderr b/src/test/ui/repr/repr-align.stderr index e8dbf74232bfa..f1a5d88ace1fd 100644 --- a/src/test/ui/repr/repr-align.stderr +++ b/src/test/ui/repr/repr-align.stderr @@ -1,21 +1,27 @@ error[E0589]: invalid `repr(align)` attribute: not an unsuffixed integer - --> $DIR/repr-align.rs:3:8 + --> $DIR/repr-align.rs:4:8 | LL | #[repr(align(16.0))] //~ ERROR: invalid `repr(align)` attribute: not an unsuffixed integer | ^^^^^^^^^^^ error[E0589]: invalid `repr(align)` attribute: not a power of two - --> $DIR/repr-align.rs:6:8 + --> $DIR/repr-align.rs:7:8 | LL | #[repr(align(15))] //~ ERROR: invalid `repr(align)` attribute: not a power of two | ^^^^^^^^^ error[E0589]: invalid `repr(align)` attribute: larger than 2^29 - --> $DIR/repr-align.rs:9:8 + --> $DIR/repr-align.rs:10:8 | LL | #[repr(align(4294967296))] //~ ERROR: invalid `repr(align)` attribute: larger than 2^29 | ^^^^^^^^^^^^^^^^^ -error: aborting due to 3 previous errors +error[E0589]: invalid `repr(align)` attribute: not a power of two + --> $DIR/repr-align.rs:16:8 + | +LL | #[repr(align(15))] //~ ERROR: invalid `repr(align)` attribute: not a power of two + | ^^^^^^^^^ + +error: aborting due to 4 previous errors For more information about this error, try `rustc --explain E0589`. From ea2b1b035b3aa2e0e464dabb0e46f6c2092d357f Mon Sep 17 00:00:00 2001 From: Andy Russell Date: Mon, 14 Jan 2019 10:02:27 -0500 Subject: [PATCH 020/278] rustdoc: wrap stability tags in colored spans --- src/librustdoc/html/render.rs | 15 ++++++++------- src/librustdoc/html/static/rustdoc.css | 13 ++++++++----- src/test/rustdoc/deprecated.rs | 6 ++++-- src/test/rustdoc/inline_cross/macros.rs | 3 ++- src/test/rustdoc/internal.rs | 6 ++++-- src/test/rustdoc/issue-32374.rs | 7 +++++-- 6 files changed, 31 insertions(+), 19 deletions(-) diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 86fb51419c270..c74e4647cdbde 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -2798,9 +2798,13 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context, fn stability_tags(item: &clean::Item) -> String { let mut tags = String::new(); + fn tag_html(class: &str, contents: &str) -> String { + format!(r#"{}"#, class, contents) + } + // The trailing space after each tag is to space it properly against the rest of the docs. if item.deprecation().is_some() { - tags.push_str("[
Deprecated
] "); + tags += &tag_html("deprecated", "Deprecated"); } if let Some(stab) = item @@ -2809,17 +2813,14 @@ fn stability_tags(item: &clean::Item) -> String { .filter(|s| s.level == stability::Unstable) { if stab.feature.as_ref().map(|s| &**s) == Some("rustc_private") { - tags.push_str("[
Internal
] "); + tags += &tag_html("internal", "Internal"); } else { - tags.push_str("[
Experimental
] "); + tags += &tag_html("unstable", "Experimental"); } } if let Some(ref cfg) = item.attrs.cfg { - tags.push_str(&format!( - "[
{}
] ", - cfg.render_short_html() - )); + tags += &tag_html("portability", &cfg.render_short_html()); } tags diff --git a/src/librustdoc/html/static/rustdoc.css b/src/librustdoc/html/static/rustdoc.css index 36765496ff4e9..b210586006702 100644 --- a/src/librustdoc/html/static/rustdoc.css +++ b/src/librustdoc/html/static/rustdoc.css @@ -767,11 +767,14 @@ body.blur > :not(#help) { } .module-item .stab { - display: inline; - border-width: 0; - padding: 0; - margin: 0; - background: inherit !important; + border-radius: 3px; + display: inline-block; + font-size: 80%; + line-height: 1.2; + margin-bottom: 0; + margin-right: .3em; + padding: 2px; + vertical-align: text-bottom; } .module-item.unstable { diff --git a/src/test/rustdoc/deprecated.rs b/src/test/rustdoc/deprecated.rs index ca3f380ed2825..74bd94548e036 100644 --- a/src/test/rustdoc/deprecated.rs +++ b/src/test/rustdoc/deprecated.rs @@ -1,7 +1,9 @@ #![feature(deprecated)] -// @matches deprecated/index.html '//*[@class="docblock-short"]' \ -// '^\[Deprecated\] Deprecated docs' +// @has deprecated/index.html '//*[@class="docblock-short"]/span[@class="stab deprecated"]' \ +// 'Deprecated' +// @has - '//*[@class="docblock-short"]' 'Deprecated docs' + // @has deprecated/struct.S.html '//*[@class="stab deprecated"]' \ // 'Deprecated since 1.0.0: text' /// Deprecated docs diff --git a/src/test/rustdoc/inline_cross/macros.rs b/src/test/rustdoc/inline_cross/macros.rs index 4e370062385d0..f9bf982659e02 100644 --- a/src/test/rustdoc/inline_cross/macros.rs +++ b/src/test/rustdoc/inline_cross/macros.rs @@ -7,7 +7,8 @@ extern crate macros; -// @has foo/index.html '//*[@class="docblock-short"]' '[Deprecated] [Experimental]' +// @has foo/index.html '//*[@class="docblock-short"]/span[@class="stab deprecated"]' Deprecated +// @has - '//*[@class="docblock-short"]/span[@class="stab unstable"]' Experimental // @has foo/macro.my_macro.html // @has - '//*[@class="docblock"]' 'docs for my_macro' diff --git a/src/test/rustdoc/internal.rs b/src/test/rustdoc/internal.rs index ba58da138a8c0..2cb7c472cc84b 100644 --- a/src/test/rustdoc/internal.rs +++ b/src/test/rustdoc/internal.rs @@ -1,7 +1,9 @@ // compile-flags: -Z force-unstable-if-unmarked -// @matches internal/index.html '//*[@class="docblock-short"]' \ -// '^\[Internal\] Docs' +// @matches internal/index.html '//*[@class="docblock-short"]/span[@class="stab internal"]' \ +// 'Internal' +// @matches - '//*[@class="docblock-short"]' 'Docs' + // @has internal/struct.S.html '//*[@class="stab internal"]' \ // 'This is an internal compiler API. (rustc_private)' /// Docs diff --git a/src/test/rustdoc/issue-32374.rs b/src/test/rustdoc/issue-32374.rs index 58876a1aa1162..7babfaf6060f4 100644 --- a/src/test/rustdoc/issue-32374.rs +++ b/src/test/rustdoc/issue-32374.rs @@ -3,8 +3,11 @@ #![unstable(feature="test", issue = "32374")] -// @matches issue_32374/index.html '//*[@class="docblock-short"]' \ -// '^\[Deprecated\] \[Experimental\] Docs' +// @matches issue_32374/index.html '//*[@class="docblock-short"]/span[@class="stab deprecated"]' \ +// 'Deprecated' +// @matches issue_32374/index.html '//*[@class="docblock-short"]/span[@class="stab unstable"]' \ +// 'Experimental' +// @matches issue_32374/index.html '//*[@class="docblock-short"]/text()' 'Docs' // @has issue_32374/struct.T.html '//*[@class="stab deprecated"]' \ // 'Deprecated since 1.0.0: text' From 20b55b7e2cb345e92ed024f9fef46ca4a83cd0a0 Mon Sep 17 00:00:00 2001 From: Niklas Fiekas Date: Thu, 31 Jan 2019 21:24:23 +0100 Subject: [PATCH 021/278] Clarify semantics of #[repr(align(x))] on enums --- .../src/language-features/repr-align-enum.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/doc/unstable-book/src/language-features/repr-align-enum.md b/src/doc/unstable-book/src/language-features/repr-align-enum.md index 1fd9bd20f3f0d..415c6ebe8b4bc 100644 --- a/src/doc/unstable-book/src/language-features/repr-align-enum.md +++ b/src/doc/unstable-book/src/language-features/repr-align-enum.md @@ -24,3 +24,19 @@ fn main() { assert_eq!(std::mem::align_of::(), 8); } ``` + +This is equivalent to using an aligned wrapper struct everywhere: + +```rust +#[repr(align(8))] +struct Aligned(Unaligned); + +enum Unaligned { + Foo, + Bar { value: u32 }, +} + +fn main() { + assert_eq!(std::mem::align_of::(), 8); +} +``` From 5cf20ca3c539d8d2e2560055f516ef95251837c1 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Thu, 31 Jan 2019 15:42:45 +0100 Subject: [PATCH 022/278] Fix image link in the settings menu --- src/librustdoc/html/layout.rs | 28 ++++++++++++++++++---------- src/librustdoc/html/render.rs | 20 ++++++++++++++++---- src/test/rustdoc/keyword.rs | 2 +- 3 files changed, 35 insertions(+), 15 deletions(-) diff --git a/src/librustdoc/html/layout.rs b/src/librustdoc/html/layout.rs index c34dcbbb672e9..b444993c1b5ec 100644 --- a/src/librustdoc/html/layout.rs +++ b/src/librustdoc/html/layout.rs @@ -4,6 +4,8 @@ use std::path::PathBuf; use externalfiles::ExternalHtml; +use html::render::SlashChecker; + #[derive(Clone)] pub struct Layout { pub logo: String, @@ -176,16 +178,22 @@ pub fn render( static_root_path = static_root_path, root_path = page.root_path, css_class = page.css_class, - logo = if layout.logo.is_empty() { - format!("\ - logo", - static_root_path=static_root_path, - suffix=page.resource_suffix) - } else { - format!("\ - logo", - page.root_path, layout.krate, - layout.logo) + logo = { + let p = format!("{}{}", page.root_path, layout.krate); + let p = SlashChecker(&p); + if layout.logo.is_empty() { + format!("\ + logo", + path=p, + static_root_path=static_root_path, + suffix=page.resource_suffix) + } else { + format!("\ + logo", + p, + layout.logo) + } }, title = page.title, description = page.description, diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 86fb51419c270..f2bd56978c287 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -73,6 +73,18 @@ use minifier; /// A pair of name and its optional document. pub type NameDoc = (String, Option); +pub struct SlashChecker<'a>(pub &'a str); + +impl<'a> Display for SlashChecker<'a> { + fn fmt(&self, f: &mut Formatter) -> fmt::Result { + if !self.0.ends_with("/") && !self.0.is_empty() { + write!(f, "{}/", self.0) + } else { + write!(f, "{}", self.0) + } + } +} + /// Major driving force in all rustdoc rendering. This contains information /// about where in the tree-like hierarchy rendering is occurring and controls /// how the current page is being rendered. @@ -1140,7 +1152,8 @@ themePicker.onblur = handleThemeButtonsBlur; krates .iter() .map(|s| { - format!("
  • {}
    • ", s, s) + format!("
  • {}
    • ", + SlashChecker(s), s) }) .collect::()); try_err!(layout::render(&mut w, &cx.shared.layout, @@ -2074,8 +2087,7 @@ impl Context { let mut themes = self.shared.themes.clone(); let sidebar = "

    Settings

    "; themes.push(PathBuf::from("settings.css")); - let mut layout = self.shared.layout.clone(); - layout.krate = String::new(); + let layout = self.shared.layout.clone(); try_err!(layout::render(&mut w, &layout, &page, &sidebar, &settings, self.shared.css_file_extension.is_some(), @@ -2454,7 +2466,7 @@ impl<'a> fmt::Display for Item<'a> { fn item_path(ty: ItemType, name: &str) -> String { match ty { - ItemType::Module => format!("{}/index.html", name), + ItemType::Module => format!("{}index.html", SlashChecker(name)), _ => format!("{}.{}.html", ty.css_class(), name), } } diff --git a/src/test/rustdoc/keyword.rs b/src/test/rustdoc/keyword.rs index d3327ae7ae117..c721c024468dd 100644 --- a/src/test/rustdoc/keyword.rs +++ b/src/test/rustdoc/keyword.rs @@ -7,7 +7,7 @@ // @has foo/keyword.match.html '//a[@class="keyword"]' 'match' // @has foo/keyword.match.html '//span[@class="in-band"]' 'Keyword match' // @has foo/keyword.match.html '//section[@id="main"]//div[@class="docblock"]//p' 'this is a test!' -// @!has foo/index.html '//a/@href' 'foo/index.html' +// @has foo/index.html '//a/@href' '../foo/index.html' // @!has foo/foo/index.html // @!has-dir foo/foo #[doc(keyword = "match")] From c955f172b2f09f28d187ed7634e18861258833e5 Mon Sep 17 00:00:00 2001 From: QuietMisdreavus Date: Fri, 1 Feb 2019 11:17:33 -0600 Subject: [PATCH 023/278] don't try to get a DefId for a Def that doesn't have one --- src/librustdoc/clean/inline.rs | 7 +++++-- src/librustdoc/clean/mod.rs | 2 +- src/librustdoc/visit_ast.rs | 7 ++++--- src/test/rustdoc/use-attr.rs | 8 ++++++++ 4 files changed, 18 insertions(+), 6 deletions(-) create mode 100644 src/test/rustdoc/use-attr.rs diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 9cb21df713e5b..8c8151e1e9509 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -37,8 +37,11 @@ use super::Clean; /// and `Some` of a vector of items if it was successfully expanded. pub fn try_inline(cx: &DocContext, def: Def, name: ast::Name, visited: &mut FxHashSet) -> Option> { - if def == Def::Err { return None } - let did = def.def_id(); + let did = if let Some(did) = def.opt_def_id() { + did + } else { + return None; + }; if did.is_local() { return None } let mut ret = Vec::new(); let inner = match def { diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 6eea95b61c990..7d736d40b2547 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -3818,7 +3818,7 @@ pub fn register_def(cx: &DocContext, def: Def) -> DefId { fn resolve_use_source(cx: &DocContext, path: Path) -> ImportSource { ImportSource { - did: if path.def == Def::Err { + did: if path.def.opt_def_id().is_none() { None } else { Some(register_def(cx, path.def)) diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 953ab7c2565bf..b8eb777a54ba4 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -284,10 +284,11 @@ impl<'a, 'tcx, 'rcx> RustdocVisitor<'a, 'tcx, 'rcx> { debug!("maybe_inline_local def: {:?}", def); let tcx = self.cx.tcx; - if def == Def::Err { + let def_did = if let Some(did) = def.opt_def_id() { + did + } else { return false; - } - let def_did = def.def_id(); + }; let use_attrs = tcx.hir().attrs(id); // Don't inline `doc(hidden)` imports so they can be stripped at a later stage. diff --git a/src/test/rustdoc/use-attr.rs b/src/test/rustdoc/use-attr.rs new file mode 100644 index 0000000000000..996b7bba62181 --- /dev/null +++ b/src/test/rustdoc/use-attr.rs @@ -0,0 +1,8 @@ +// edition:2018 + +// ICE when rustdoc encountered a use statement of a non-macro attribute (see #58054) + +// @has use_attr/index.html +// @has - '//code' 'pub use proc_macro_attribute' +pub use proc_macro_attribute; +use proc_macro_derive; From a6fd6eccda42f86e40b73d788e8099adeb66e37b Mon Sep 17 00:00:00 2001 From: Niklas Fiekas Date: Sat, 2 Feb 2019 00:52:38 +0100 Subject: [PATCH 024/278] Test alloca with #[repr(align(x))] on enum --- src/test/codegen/align-enum.rs | 36 ++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 src/test/codegen/align-enum.rs diff --git a/src/test/codegen/align-enum.rs b/src/test/codegen/align-enum.rs new file mode 100644 index 0000000000000..2251c54229ee0 --- /dev/null +++ b/src/test/codegen/align-enum.rs @@ -0,0 +1,36 @@ +// compile-flags: -C no-prepopulate-passes +// ignore-tidy-linelength +// min-llvm-version 7.0 + +#![crate_type = "lib"] +#![feature(repr_align_enum)] + +#[repr(align(64))] +pub enum Align64 { + A(u32), + B(u32), +} +// CHECK: %Align64 = type { [0 x i32], i32, [15 x i32] } + +pub struct Nested64 { + a: u8, + b: Align64, + c: u16, +} + +// CHECK-LABEL: @align64 +#[no_mangle] +pub fn align64(a: u32) -> Align64 { +// CHECK: %a64 = alloca %Align64, align 64 +// CHECK: call void @llvm.memcpy.{{.*}}(i8* align 64 %{{.*}}, i8* align 64 %{{.*}}, i{{[0-9]+}} 64, i1 false) + let a64 = Align64::A(a); + a64 +} + +// CHECK-LABEL: @nested64 +#[no_mangle] +pub fn nested64(a: u8, b: u32, c: u16) -> Nested64 { +// CHECK: %n64 = alloca %Nested64, align 64 + let n64 = Nested64 { a, b: Align64::B(b), c }; + n64 +} From d80a558e4a50d0a89a753c903bd7f7d0d25e7ab4 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Sun, 3 Feb 2019 00:14:32 +0100 Subject: [PATCH 025/278] Improve file list display --- src/librustdoc/html/static/rustdoc.css | 3 ++- src/librustdoc/html/static/source-script.js | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/librustdoc/html/static/rustdoc.css b/src/librustdoc/html/static/rustdoc.css index 36765496ff4e9..2e77ce2b0fd72 100644 --- a/src/librustdoc/html/static/rustdoc.css +++ b/src/librustdoc/html/static/rustdoc.css @@ -1570,5 +1570,6 @@ div.name::before { } div.name.expand::before { transform: rotate(90deg); - left: -14px; + left: -15px; + top: 2px; } diff --git a/src/librustdoc/html/static/source-script.js b/src/librustdoc/html/static/source-script.js index c5d6fa16f550e..509c628ce5a46 100644 --- a/src/librustdoc/html/static/source-script.js +++ b/src/librustdoc/html/static/source-script.js @@ -94,7 +94,7 @@ function createSidebarToggle() { inner1.style.position = "relative"; var inner2 = document.createElement("div"); - inner2.style.marginTop = "-2px"; + inner2.style.paddingTop = "3px"; if (getCurrentValue("rustdoc-source-sidebar-show") === "true") { inner2.innerText = "<"; } else { From 6e72077b3b01aa33accf4925bd6faf701e322194 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Sun, 3 Feb 2019 09:48:18 +0900 Subject: [PATCH 026/278] submodule: update rls from c9d25b667a to f331ff7 --- Cargo.lock | 28 ++++++++++++++-------------- src/tools/rls | 2 +- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1ac2dfe25c395..b52f2094584ce 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1232,7 +1232,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] name = "jsonrpc-core" -version = "9.0.0" +version = "10.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1352,7 +1352,7 @@ dependencies = [ [[package]] name = "lsp-codec" -version = "0.1.0" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "bytes 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1362,7 +1362,7 @@ dependencies = [ [[package]] name = "lsp-types" -version = "0.54.0" +version = "0.55.1" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", @@ -2045,7 +2045,7 @@ dependencies = [ [[package]] name = "racer" -version = "2.1.16" +version = "2.1.17" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", @@ -2246,10 +2246,10 @@ dependencies = [ [[package]] name = "rls" -version = "1.31.6" +version = "1.34.0" dependencies = [ "cargo 0.35.0", - "cargo_metadata 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)", + "cargo_metadata 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)", "clippy_lints 0.0.212", "crossbeam-channel 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)", "difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -2258,14 +2258,14 @@ dependencies = [ "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)", "home 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)", "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", - "jsonrpc-core 9.0.0 (registry+https://github.com/rust-lang/crates.io-index)", + "jsonrpc-core 10.0.1 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)", - "lsp-codec 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", - "lsp-types 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)", + "lsp-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", + "lsp-types 0.55.1 (registry+https://github.com/rust-lang/crates.io-index)", "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)", "ordslice 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", - "racer 2.1.16 (registry+https://github.com/rust-lang/crates.io-index)", + "racer 2.1.17 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)", "rayon 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -4040,7 +4040,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum jemalloc-sys 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "bfc62c8e50e381768ce8ee0428ee53741929f7ebd73e4d83f669bcf7693e00ae" "checksum jobserver 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "dd80e58f77e0cdea53ba96acc5e04479e5ffc5d869626a6beafe50fed867eace" "checksum json 0.11.13 (registry+https://github.com/rust-lang/crates.io-index)" = "9ad0485404155f45cce53a40d4b2d6ac356418300daed05273d9e26f91c390be" -"checksum jsonrpc-core 9.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4e9cbeda300803d381390fb65e8158437728c39e6987ed23bee82728b73511a7" +"checksum jsonrpc-core 10.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a5152c3fda235dfd68341b3edf4121bc4428642c93acbd6de88c26bf95fc5d7" "checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d" "checksum lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73" "checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1" @@ -4053,8 +4053,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum lock_api 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "949826a5ccf18c1b3a7c3d57692778d21768b79e46eb9dd07bfc4c2160036c54" "checksum log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c84ec4b527950aa83a329754b01dbe3f58361d1c5efacd1f6d68c494d08a17c6" "checksum log_settings 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "19af41f0565d7c19b2058153ad0b42d4d5ce89ec4dbf06ed6741114a8b63e7cd" -"checksum lsp-codec 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9b29e3d1632fef13c1286b0b2f8545a7d894ae565a7fac013b90a17ee5bfbc91" -"checksum lsp-types 0.54.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a252cc2be87d9329dd91c505a951996b3263582ba304870960faaae77b642183" +"checksum lsp-codec 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f3570f641b984e3e4613a1ca34db2ea72549bbc3c0316d33f5af91ab514dcbff" +"checksum lsp-types 0.55.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3ca49aeb430780992121d582520170411658b1e41bf968b917d85fd0fb6da3c5" "checksum lzma-sys 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "d1eaa027402541975218bb0eec67d6b0412f6233af96e0d096d31dbdfd22e614" "checksum mac 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4" "checksum macro-utils 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f2c4deaccc2ead6a28c16c0ba82f07d52b6475397415ce40876e559b0b0ea510" @@ -4123,7 +4123,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a" "checksum quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9949cfe66888ffe1d53e6ec9d9f3b70714083854be20fd5e271b232a017401e8" "checksum quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)" = "53fa22a1994bd0f9372d7a816207d8a2677ad0325b073f5c5332760f0fb62b5c" -"checksum racer 2.1.16 (registry+https://github.com/rust-lang/crates.io-index)" = "fbfcf2686b50f75a279cb42d9c6d253a1e68a475b415ea4baf7fb177ce94839a" +"checksum racer 2.1.17 (registry+https://github.com/rust-lang/crates.io-index)" = "11db0de64c3eed7ee25f7b0af2109d296a67efa1efe7566ed17cc01115f961c8" "checksum rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8356f47b32624fef5b3301c1be97e5944ecdd595409cc5da11d05f211db6cfbd" "checksum rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e464cd887e869cddcae8792a4ee31d23c7edd516700695608f5b98c67ee0131c" "checksum rand 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9d223d52ae411a33cf7e54ec6034ec165df296ccd23533d671a28252b6f66a" diff --git a/src/tools/rls b/src/tools/rls index c9d25b667af76..f331ff713917f 160000 --- a/src/tools/rls +++ b/src/tools/rls @@ -1 +1 @@ -Subproject commit c9d25b667af766e8fe6d3b6168a5f99a0e4d722a +Subproject commit f331ff713917f6edb044c7e5c6c28c3845afebe7 From 28fec683f552cb2bc20644f06895232c574751ab Mon Sep 17 00:00:00 2001 From: ljedrz Date: Sun, 3 Feb 2019 08:51:50 +0100 Subject: [PATCH 027/278] cleanup: don't use node_to_hir_id where unneeded --- src/librustc/cfg/construct.rs | 3 +-- .../error_reporting/nice_region_error/find_anon_type.rs | 5 ++--- src/librustc/middle/region.rs | 2 +- src/librustc_mir/hair/cx/block.rs | 2 +- src/librustc_typeck/astconv.rs | 6 ++---- src/librustc_typeck/collect.rs | 6 ++---- src/librustdoc/clean/mod.rs | 3 +-- 7 files changed, 10 insertions(+), 17 deletions(-) diff --git a/src/librustc/cfg/construct.rs b/src/librustc/cfg/construct.rs index 6122fe6370940..669c2998d1cb2 100644 --- a/src/librustc/cfg/construct.rs +++ b/src/librustc/cfg/construct.rs @@ -99,7 +99,6 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { } fn stmt(&mut self, stmt: &hir::Stmt, pred: CFGIndex) -> CFGIndex { - let hir_id = self.tcx.hir().node_to_hir_id(stmt.id); let exit = match stmt.node { hir::StmtKind::Local(ref local) => { let init_exit = self.opt_expr(&local.init, pred); @@ -113,7 +112,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { self.expr(&expr, pred) } }; - self.add_ast_node(hir_id.local_id, &[exit]) + self.add_ast_node(stmt.hir_id.local_id, &[exit]) } fn pat(&mut self, pat: &hir::Pat, pred: CFGIndex) -> CFGIndex { diff --git a/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs b/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs index eeaa01375ed4d..ebaef4977f400 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs @@ -114,7 +114,7 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for FindNestedTypeVisitor<'a, 'gcx, 'tcx> { hir::TyKind::Rptr(ref lifetime, _) => { // the lifetime of the TyRptr - let hir_id = self.tcx.hir().node_to_hir_id(lifetime.id); + let hir_id = lifetime.hir_id; match (self.tcx.named_region(hir_id), self.bound_region) { // Find the index of the anonymous region that was part of the // error. We will then search the function parameters for a bound @@ -221,8 +221,7 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for TyPathVisitor<'a, 'gcx, 'tcx> { } fn visit_lifetime(&mut self, lifetime: &hir::Lifetime) { - let hir_id = self.tcx.hir().node_to_hir_id(lifetime.id); - match (self.tcx.named_region(hir_id), self.bound_region) { + match (self.tcx.named_region(lifetime.hir_id), self.bound_region) { // the lifetime of the TyPath! (Some(rl::Region::LateBoundAnon(debruijn_index, anon_index)), ty::BrAnon(br_index)) => { if debruijn_index == self.current_index && anon_index == br_index { diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 31f91a1bae57f..db52cc3074b9a 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -840,7 +840,7 @@ fn resolve_pat<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'a, 'tcx>, pat: & } fn resolve_stmt<'a, 'tcx>(visitor: &mut RegionResolutionVisitor<'a, 'tcx>, stmt: &'tcx hir::Stmt) { - let stmt_id = visitor.tcx.hir().node_to_hir_id(stmt.id).local_id; + let stmt_id = stmt.hir_id.local_id; debug!("resolve_stmt(stmt.id={:?})", stmt_id); // Every statement will clean up the temporaries created during diff --git a/src/librustc_mir/hair/cx/block.rs b/src/librustc_mir/hair/cx/block.rs index c50d9ddcb152e..518ae978ae17a 100644 --- a/src/librustc_mir/hair/cx/block.rs +++ b/src/librustc_mir/hair/cx/block.rs @@ -46,7 +46,7 @@ fn mirror_stmts<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>, -> Vec> { let mut result = vec![]; for (index, stmt) in stmts.iter().enumerate() { - let hir_id = cx.tcx.hir().node_to_hir_id(stmt.id); + let hir_id = stmt.hir_id; let opt_dxn_ext = cx.region_scope_tree.opt_destruction_scope(hir_id.local_id); let stmt_span = StatementSpan(cx.tcx.hir().span(stmt.id)); match stmt.node { diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 61674070fbcb2..8da0b6dcbeac3 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -114,8 +114,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o { tcx.hir().name(tcx.hir().as_local_node_id(def_id).unwrap()).as_interned_str() }; - let hir_id = tcx.hir().node_to_hir_id(lifetime.id); - let r = match tcx.named_region(hir_id) { + let r = match tcx.named_region(lifetime.hir_id) { Some(rl::Region::Static) => { tcx.types.re_static } @@ -1145,8 +1144,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o { self.ast_region_to_region(lifetime, None) } else { self.compute_object_lifetime_bound(span, existential_predicates).unwrap_or_else(|| { - let hir_id = tcx.hir().node_to_hir_id(lifetime.id); - if tcx.named_region(hir_id).is_some() { + if tcx.named_region(lifetime.hir_id).is_some() { self.ast_region_to_region(lifetime, None) } else { self.re_infer(span, None).unwrap_or_else(|| { diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 1c8dffaf628c4..9dc74c5d63a4e 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -814,8 +814,7 @@ fn has_late_bound_regions<'a, 'tcx>( return; } - let hir_id = self.tcx.hir().node_to_hir_id(lt.id); - match self.tcx.named_region(hir_id) { + match self.tcx.named_region(lt.hir_id) { Some(rl::Region::Static) | Some(rl::Region::EarlyBound(..)) => {} Some(rl::Region::LateBound(debruijn, _, _)) | Some(rl::Region::LateBoundAnon(debruijn, _)) if debruijn < self.outer_index => {} @@ -841,8 +840,7 @@ fn has_late_bound_regions<'a, 'tcx>( }; for param in &generics.params { if let GenericParamKind::Lifetime { .. } = param.kind { - let hir_id = tcx.hir().node_to_hir_id(param.id); - if tcx.is_late_bound(hir_id) { + if tcx.is_late_bound(param.hir_id) { return Some(param.span); } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index c328dbe82e4b1..116e46df3c10a 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1210,8 +1210,7 @@ impl Lifetime { impl Clean for hir::Lifetime { fn clean(&self, cx: &DocContext) -> Lifetime { if self.id != ast::DUMMY_NODE_ID { - let hir_id = cx.tcx.hir().node_to_hir_id(self.id); - let def = cx.tcx.named_region(hir_id); + let def = cx.tcx.named_region(self.hir_id); match def { Some(rl::Region::EarlyBound(_, node_id, _)) | Some(rl::Region::LateBound(_, node_id, _)) | From f832a809bbb08bc2bb08b012cee8ee6b2178d26d Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Sun, 3 Feb 2019 21:43:09 +0900 Subject: [PATCH 028/278] Transition remote-test-client to 2018 edition --- src/tools/remote-test-client/Cargo.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tools/remote-test-client/Cargo.toml b/src/tools/remote-test-client/Cargo.toml index 54739101f1eff..1a4b24bd5b34c 100644 --- a/src/tools/remote-test-client/Cargo.toml +++ b/src/tools/remote-test-client/Cargo.toml @@ -2,5 +2,6 @@ name = "remote-test-client" version = "0.1.0" authors = ["The Rust Project Developers"] +edition = "2018" [dependencies] From d17b2ec0e3830a5b673907aa2e9f8347df4c4cf4 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Sun, 3 Feb 2019 21:44:21 +0900 Subject: [PATCH 029/278] Transition remote-test-server to 2018 edition --- src/tools/remote-test-server/Cargo.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tools/remote-test-server/Cargo.toml b/src/tools/remote-test-server/Cargo.toml index 8704296289e83..5906c76c01d9f 100644 --- a/src/tools/remote-test-server/Cargo.toml +++ b/src/tools/remote-test-server/Cargo.toml @@ -2,5 +2,6 @@ name = "remote-test-server" version = "0.1.0" authors = ["The Rust Project Developers"] +edition = "2018" [dependencies] From 9f34d4b3572f7db45cbe7108f392280ebc18b301 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Sun, 3 Feb 2019 21:32:59 +0900 Subject: [PATCH 030/278] Use 2018 edition for cargotest --- src/tools/cargotest/Cargo.toml | 1 + src/tools/cargotest/main.rs | 2 ++ 2 files changed, 3 insertions(+) diff --git a/src/tools/cargotest/Cargo.toml b/src/tools/cargotest/Cargo.toml index f4163a6f1170a..3811fee39368f 100644 --- a/src/tools/cargotest/Cargo.toml +++ b/src/tools/cargotest/Cargo.toml @@ -2,6 +2,7 @@ name = "cargotest2" version = "0.1.0" authors = ["Brian Anderson "] +edition = "2018" [[bin]] name = "cargotest" diff --git a/src/tools/cargotest/main.rs b/src/tools/cargotest/main.rs index 120f238eb45c5..7f3c159075b97 100644 --- a/src/tools/cargotest/main.rs +++ b/src/tools/cargotest/main.rs @@ -1,3 +1,5 @@ +#![deny(rust_2018_idioms)] + use std::env; use std::process::Command; use std::path::{Path, PathBuf}; From 3a133f20887b9a9677ac9af8fa56d75e4d3b6e89 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Sun, 3 Feb 2019 21:37:08 +0900 Subject: [PATCH 031/278] Transition linkchecker to 2018 edition --- src/tools/linkchecker/Cargo.toml | 1 + src/tools/linkchecker/main.rs | 4 +++- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/tools/linkchecker/Cargo.toml b/src/tools/linkchecker/Cargo.toml index d6b7dafea40e0..0994cd2066246 100644 --- a/src/tools/linkchecker/Cargo.toml +++ b/src/tools/linkchecker/Cargo.toml @@ -2,6 +2,7 @@ name = "linkchecker" version = "0.1.0" authors = ["Alex Crichton "] +edition = "2018" [[bin]] name = "linkchecker" diff --git a/src/tools/linkchecker/main.rs b/src/tools/linkchecker/main.rs index 2cf0fcfd34cd6..af704ce260dc4 100644 --- a/src/tools/linkchecker/main.rs +++ b/src/tools/linkchecker/main.rs @@ -14,6 +14,8 @@ //! A few whitelisted exceptions are allowed as there's known bugs in rustdoc, //! but this should catch the majority of "broken link" cases. +#![deny(rust_2018_idioms)] + use std::collections::hash_map::Entry; use std::collections::{HashMap, HashSet}; use std::env; @@ -21,7 +23,7 @@ use std::fs; use std::path::{Path, PathBuf, Component}; use std::rc::Rc; -use Redirect::*; +use crate::Redirect::*; macro_rules! t { ($e:expr) => (match $e { From 39394c8126dcea8570dc2108f0918478bfb6962e Mon Sep 17 00:00:00 2001 From: Mazdak Farrokhzad Date: Sat, 2 Feb 2019 18:18:39 +0100 Subject: [PATCH 032/278] libfmt_macros => 2018 --- src/libfmt_macros/Cargo.toml | 1 + src/libfmt_macros/lib.rs | 13 +++++++------ 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/libfmt_macros/Cargo.toml b/src/libfmt_macros/Cargo.toml index b3f4d2deae2fc..50779a2d9ad08 100644 --- a/src/libfmt_macros/Cargo.toml +++ b/src/libfmt_macros/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "fmt_macros" version = "0.0.0" +edition = "2018" [lib] name = "fmt_macros" diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index 4f516f18bbfdd..7bfe2377cea9e 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -10,14 +10,15 @@ html_playground_url = "https://play.rust-lang.org/", test(attr(deny(warnings))))] -#![feature(nll)] +#![deny(rust_2018_idioms)] + #![feature(rustc_private)] -pub use self::Piece::*; -pub use self::Position::*; -pub use self::Alignment::*; -pub use self::Flag::*; -pub use self::Count::*; +pub use Piece::*; +pub use Position::*; +pub use Alignment::*; +pub use Flag::*; +pub use Count::*; use std::str; use std::string; From 7f41ed62e5cb9a5af7f742f9c4515a6d3a9530c0 Mon Sep 17 00:00:00 2001 From: Mazdak Farrokhzad Date: Sat, 2 Feb 2019 18:29:08 +0100 Subject: [PATCH 033/278] libgraphviz => 2018 --- src/libgraphviz/Cargo.toml | 1 + src/libgraphviz/lib.rs | 11 ++++++----- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/src/libgraphviz/Cargo.toml b/src/libgraphviz/Cargo.toml index 76ef3a1d188ce..a6a3c1a249d64 100644 --- a/src/libgraphviz/Cargo.toml +++ b/src/libgraphviz/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "graphviz" version = "0.0.0" +edition = "2018" [lib] name = "graphviz" diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 164dec97b8fdb..f05f6e6651f83 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -276,10 +276,11 @@ html_root_url = "https://doc.rust-lang.org/nightly/", test(attr(allow(unused_variables), deny(warnings))))] -#![feature(nll)] +#![deny(rust_2018_idioms)] + #![feature(str_escape)] -use self::LabelText::*; +use LabelText::*; use std::borrow::Cow; use std::io::prelude::*; @@ -548,12 +549,12 @@ impl<'a> LabelText<'a> { } /// Puts `prefix` on a line above this label, with a blank line separator. - pub fn prefix_line(self, prefix: LabelText) -> LabelText<'static> { + pub fn prefix_line(self, prefix: LabelText<'_>) -> LabelText<'static> { prefix.suffix_line(self) } /// Puts `suffix` on a line below this label, with a blank line separator. - pub fn suffix_line(self, suffix: LabelText) -> LabelText<'static> { + pub fn suffix_line(self, suffix: LabelText<'_>) -> LabelText<'static> { let mut prefix = self.pre_escaped_content().into_owned(); let suffix = suffix.pre_escaped_content(); prefix.push_str(r"\n\n"); @@ -686,7 +687,7 @@ pub fn render_opts<'a, N, E, G, W>(g: &'a G, #[cfg(test)] mod tests { - use self::NodeLabels::*; + use NodeLabels::*; use super::{Id, Labeller, Nodes, Edges, GraphWalk, render, Style}; use super::LabelText::{self, LabelStr, EscStr, HtmlStr}; use std::io; From 46c2c274f27df759a7947fc4804780bda7e3432c Mon Sep 17 00:00:00 2001 From: Denys Zariaiev Date: Sun, 3 Feb 2019 15:47:15 +0100 Subject: [PATCH 034/278] Add NVPTX target into `build-manifest` --- src/tools/build-manifest/src/main.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs index 4ca285b9b1db1..91cfa0981ac3d 100644 --- a/src/tools/build-manifest/src/main.rs +++ b/src/tools/build-manifest/src/main.rs @@ -78,6 +78,7 @@ static TARGETS: &'static [&'static str] = &[ "mips64el-unknown-linux-gnuabi64", "mipsel-unknown-linux-gnu", "mipsel-unknown-linux-musl", + "nvptx64-nvidia-cuda", "powerpc-unknown-linux-gnu", "powerpc64-unknown-linux-gnu", "powerpc64le-unknown-linux-gnu", From 09275b5cb540e3a8431877321c72684df8ad8b07 Mon Sep 17 00:00:00 2001 From: Mazdak Farrokhzad Date: Sat, 2 Feb 2019 18:42:38 +0100 Subject: [PATCH 035/278] libpanic_abort => 2018 --- src/libpanic_abort/Cargo.toml | 1 + src/libpanic_abort/lib.rs | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/libpanic_abort/Cargo.toml b/src/libpanic_abort/Cargo.toml index e304e61c32936..2bee0b716c750 100644 --- a/src/libpanic_abort/Cargo.toml +++ b/src/libpanic_abort/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "panic_abort" version = "0.0.0" +edition = "2018" [lib] path = "lib.rs" diff --git a/src/libpanic_abort/lib.rs b/src/libpanic_abort/lib.rs index f6306d23c30c0..daa1998d29d72 100644 --- a/src/libpanic_abort/lib.rs +++ b/src/libpanic_abort/lib.rs @@ -10,11 +10,12 @@ html_root_url = "https://doc.rust-lang.org/nightly/", issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/")] #![panic_runtime] + #![allow(unused_features)] +#![deny(rust_2018_idioms)] #![feature(core_intrinsics)] #![feature(libc)] -#![feature(nll)] #![feature(panic_runtime)] #![feature(staged_api)] #![feature(rustc_attrs)] @@ -46,7 +47,6 @@ pub unsafe extern fn __rust_start_panic(_payload: usize) -> u32 { #[cfg(any(unix, target_os = "cloudabi"))] unsafe fn abort() -> ! { - extern crate libc; libc::abort(); } From 582bbcc161169591d7e8a9de70e9a4c844dd9321 Mon Sep 17 00:00:00 2001 From: Mazdak Farrokhzad Date: Sun, 3 Feb 2019 03:58:25 +0100 Subject: [PATCH 036/278] librustc_privacy => 2018 --- src/librustc_privacy/Cargo.toml | 1 + src/librustc_privacy/lib.rs | 13 +++++-------- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/src/librustc_privacy/Cargo.toml b/src/librustc_privacy/Cargo.toml index dfc4e5b5db45d..5bf8024c56911 100644 --- a/src/librustc_privacy/Cargo.toml +++ b/src/librustc_privacy/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_privacy" version = "0.0.0" +edition = "2018" [lib] name = "rustc_privacy" diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 1bdc22b37d73b..dda8cabc4f2f4 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -2,18 +2,15 @@ html_favicon_url = "https://doc.rust-lang.org/favicon.ico", html_root_url = "https://doc.rust-lang.org/nightly/")] -#![feature(nll)] +#![deny(rust_2018_idioms)] + #![feature(rustc_diagnostic_macros)] #![recursion_limit="256"] -#[macro_use] extern crate rustc; #[macro_use] extern crate syntax; -#[macro_use] extern crate log; -extern crate rustc_typeck; -extern crate syntax_pos; -extern crate rustc_data_structures; +use rustc::bug; use rustc::hir::{self, Node, PatKind, AssociatedItemKind}; use rustc::hir::def::Def; use rustc::hir::def_id::{CRATE_DEF_INDEX, LOCAL_CRATE, CrateNum, DefId}; @@ -1541,7 +1538,7 @@ impl<'a, 'tcx: 'a> SearchInterfaceForPrivateItemsVisitor<'a, 'tcx> { let ret = self.required_visibility == ty::Visibility::Public && self.private_crates.contains(&item_id.krate); - debug!("leaks_private_dep(item_id={:?})={}", item_id, ret); + log::debug!("leaks_private_dep(item_id={:?})={}", item_id, ret); return ret; } } @@ -1705,7 +1702,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> } } -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { *providers = Providers { privacy_access_levels, check_mod_privacy, From b5ca255cd45c3a73fcdbf97b6101f1119ff2932e Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Mon, 4 Feb 2019 00:34:55 +0900 Subject: [PATCH 037/278] Transition tidy and unstable-book-gento 2018 edition --- src/tools/tidy/src/main.rs | 1 + src/tools/tidy/src/unstable_book.rs | 2 +- src/tools/unstable-book-gen/Cargo.toml | 1 + src/tools/unstable-book-gen/src/main.rs | 3 ++- 4 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs index 81b7b2a7731ae..6622403826665 100644 --- a/src/tools/tidy/src/main.rs +++ b/src/tools/tidy/src/main.rs @@ -4,6 +4,7 @@ //! etc. This is run by default on `make check` and as part of the auto //! builders. +#![deny(rust_2018_idioms)] #![deny(warnings)] extern crate tidy; diff --git a/src/tools/tidy/src/unstable_book.rs b/src/tools/tidy/src/unstable_book.rs index bd3b1f033c761..e5f81ba29d8d3 100644 --- a/src/tools/tidy/src/unstable_book.rs +++ b/src/tools/tidy/src/unstable_book.rs @@ -1,7 +1,7 @@ use std::collections::BTreeSet; use std::fs; use std::path; -use features::{collect_lang_features, collect_lib_features, Features, Status}; +use crate::features::{collect_lang_features, collect_lib_features, Features, Status}; pub const PATH_STR: &str = "doc/unstable-book/src"; diff --git a/src/tools/unstable-book-gen/Cargo.toml b/src/tools/unstable-book-gen/Cargo.toml index 2839f93f8e279..3209de09aeb68 100644 --- a/src/tools/unstable-book-gen/Cargo.toml +++ b/src/tools/unstable-book-gen/Cargo.toml @@ -4,6 +4,7 @@ authors = ["est31 ", name = "unstable-book-gen" version = "0.1.0" license = "MIT/Apache-2.0" +edition = "2018" [dependencies] tidy = { path = "../tidy" } diff --git a/src/tools/unstable-book-gen/src/main.rs b/src/tools/unstable-book-gen/src/main.rs index df12eaf0cb028..427014ce7fe55 100644 --- a/src/tools/unstable-book-gen/src/main.rs +++ b/src/tools/unstable-book-gen/src/main.rs @@ -1,8 +1,9 @@ //! Auto-generate stub docs for the unstable book +#![deny(rust_2018_idioms)] #![deny(warnings)] -extern crate tidy; + use tidy::features::{Feature, Features, collect_lib_features, collect_lang_features}; use tidy::unstable_book::{collect_unstable_feature_names, collect_unstable_book_section_file_names, From 9851a296885cc745eccbc33858915d08e839eadc Mon Sep 17 00:00:00 2001 From: topecongiro Date: Mon, 4 Feb 2019 00:35:12 +0900 Subject: [PATCH 038/278] Add the span of attributes of the lhs to the span of the assignment expression --- src/libsyntax/parse/parser.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 514b2952c5036..1c02a80df4683 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -3455,6 +3455,14 @@ impl<'a> Parser<'a> { }), }?; + // Make sure that the span of the parent node is larger than the span of lhs and rhs, + // including the attributes. + let lhs_span = lhs + .attrs + .iter() + .filter(|a| a.style == AttrStyle::Outer) + .next() + .map_or(lhs_span, |a| a.span); let span = lhs_span.to(rhs.span); lhs = match op { AssocOp::Add | AssocOp::Subtract | AssocOp::Multiply | AssocOp::Divide | From d11d1afa64ca2c29747074bce0f7bb2278b5ae66 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Mon, 4 Feb 2019 00:45:42 +0900 Subject: [PATCH 039/278] Transition rustdoc-theme to 2018 edition --- src/tools/rustdoc-themes/Cargo.toml | 1 + src/tools/rustdoc-themes/main.rs | 2 ++ 2 files changed, 3 insertions(+) diff --git a/src/tools/rustdoc-themes/Cargo.toml b/src/tools/rustdoc-themes/Cargo.toml index c0e2f527301be..c12a20fd56c7b 100644 --- a/src/tools/rustdoc-themes/Cargo.toml +++ b/src/tools/rustdoc-themes/Cargo.toml @@ -2,6 +2,7 @@ name = "rustdoc-themes" version = "0.1.0" authors = ["Guillaume Gomez "] +edition = "2018" [[bin]] name = "rustdoc-themes" diff --git a/src/tools/rustdoc-themes/main.rs b/src/tools/rustdoc-themes/main.rs index 616b5444832c1..63432a6585a84 100644 --- a/src/tools/rustdoc-themes/main.rs +++ b/src/tools/rustdoc-themes/main.rs @@ -1,3 +1,5 @@ +#![deny(rust_2018_idioms)] + use std::env::args; use std::fs::read_dir; use std::path::Path; From 3ad0aabddab0c73dcf80f13dfb80d1a175f7364a Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Mon, 4 Feb 2019 01:05:45 +0900 Subject: [PATCH 040/278] Transition build_helper to 2018 edition --- src/build_helper/Cargo.toml | 1 + src/build_helper/lib.rs | 2 ++ 2 files changed, 3 insertions(+) diff --git a/src/build_helper/Cargo.toml b/src/build_helper/Cargo.toml index 01d704f816bbc..04c7820b45665 100644 --- a/src/build_helper/Cargo.toml +++ b/src/build_helper/Cargo.toml @@ -2,6 +2,7 @@ name = "build_helper" version = "0.1.0" authors = ["The Rust Project Developers"] +edition = "2018" [lib] name = "build_helper" diff --git a/src/build_helper/lib.rs b/src/build_helper/lib.rs index c66c5c9249087..93aa91768121c 100644 --- a/src/build_helper/lib.rs +++ b/src/build_helper/lib.rs @@ -1,3 +1,5 @@ +#![deny(rust_2018_idioms)] + use std::fs::File; use std::path::{Path, PathBuf}; use std::process::{Command, Stdio}; From ea72066f5c0cc93ea7efe73396eb691724fccaaf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lauren=C8=9Biu=20Nicola?= Date: Sun, 3 Feb 2019 18:24:05 +0200 Subject: [PATCH 041/278] Avoid some bounds checks in binary_heap::{PeekMut,Hole} --- src/liballoc/collections/binary_heap.rs | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/liballoc/collections/binary_heap.rs b/src/liballoc/collections/binary_heap.rs index ad544e6015e4a..473f7aee5c76b 100644 --- a/src/liballoc/collections/binary_heap.rs +++ b/src/liballoc/collections/binary_heap.rs @@ -248,14 +248,18 @@ impl<'a, T: Ord> Drop for PeekMut<'a, T> { impl<'a, T: Ord> Deref for PeekMut<'a, T> { type Target = T; fn deref(&self) -> &T { - &self.heap.data[0] + debug_assert!(!self.heap.is_empty()); + // SAFE: PeekMut is only instantiated for non-empty heaps + unsafe { self.heap.data.get_unchecked(0) } } } #[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] impl<'a, T: Ord> DerefMut for PeekMut<'a, T> { fn deref_mut(&mut self) -> &mut T { - &mut self.heap.data[0] + debug_assert!(!self.heap.is_empty()); + // SAFE: PeekMut is only instantiated for non-empty heaps + unsafe { self.heap.data.get_unchecked_mut(0) } } } @@ -865,7 +869,8 @@ impl<'a, T> Hole<'a, T> { #[inline] unsafe fn new(data: &'a mut [T], pos: usize) -> Self { debug_assert!(pos < data.len()); - let elt = ptr::read(&data[pos]); + // SAFE: pos should be inside the slice + let elt = ptr::read(data.get_unchecked(pos)); Hole { data, elt: ManuallyDrop::new(elt), From 6413480adf6bc788e515a9746cf382e1ceb153fe Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Mon, 4 Feb 2019 03:42:27 +0900 Subject: [PATCH 042/278] libsyntax_pos => 2018 --- src/libsyntax_pos/Cargo.toml | 1 + src/libsyntax_pos/analyze_source_file.rs | 2 +- src/libsyntax_pos/edition.rs | 2 +- src/libsyntax_pos/hygiene.rs | 10 ++--- src/libsyntax_pos/lib.rs | 41 ++++++++------------ src/libsyntax_pos/span_encoding.rs | 6 +-- src/libsyntax_pos/symbol.rs | 49 ++++++++++++------------ 7 files changed, 51 insertions(+), 60 deletions(-) diff --git a/src/libsyntax_pos/Cargo.toml b/src/libsyntax_pos/Cargo.toml index 08ee2e0f37626..5658451c54f71 100644 --- a/src/libsyntax_pos/Cargo.toml +++ b/src/libsyntax_pos/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "syntax_pos" version = "0.0.0" +edition = "2018" [lib] name = "syntax_pos" diff --git a/src/libsyntax_pos/analyze_source_file.rs b/src/libsyntax_pos/analyze_source_file.rs index 3abd260ac6f8f..18387bd5a091a 100644 --- a/src/libsyntax_pos/analyze_source_file.rs +++ b/src/libsyntax_pos/analyze_source_file.rs @@ -36,7 +36,7 @@ pub fn analyze_source_file( (lines, multi_byte_chars, non_narrow_chars) } -cfg_if! { +cfg_if::cfg_if! { if #[cfg(all(any(target_arch = "x86", target_arch = "x86_64")))] { fn analyze_source_file_dispatch(src: &str, source_file_start_pos: BytePos, diff --git a/src/libsyntax_pos/edition.rs b/src/libsyntax_pos/edition.rs index f5a745a9cd501..a0b0052f26dab 100644 --- a/src/libsyntax_pos/edition.rs +++ b/src/libsyntax_pos/edition.rs @@ -27,7 +27,7 @@ pub const EDITION_NAME_LIST: &str = "2015|2018"; pub const DEFAULT_EDITION: Edition = Edition::Edition2015; impl fmt::Display for Edition { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let s = match *self { Edition::Edition2015 => "2015", Edition::Edition2018 => "2018", diff --git a/src/libsyntax_pos/hygiene.rs b/src/libsyntax_pos/hygiene.rs index 6e32a05dee361..0c645fc678caf 100644 --- a/src/libsyntax_pos/hygiene.rs +++ b/src/libsyntax_pos/hygiene.rs @@ -5,10 +5,10 @@ //! and definition contexts*. J. Funct. Program. 22, 2 (March 2012), 181-216. //! DOI=10.1017/S0956796812000093 -use GLOBALS; -use Span; -use edition::{Edition, DEFAULT_EDITION}; -use symbol::{keywords, Symbol}; +use crate::GLOBALS; +use crate::Span; +use crate::edition::{Edition, DEFAULT_EDITION}; +use crate::symbol::{keywords, Symbol}; use serialize::{Encodable, Decodable, Encoder, Decoder}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; @@ -525,7 +525,7 @@ impl SyntaxContext { } impl fmt::Debug for SyntaxContext { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "#{}", self.0) } } diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs index 2a85779239689..13e7307570a4f 100644 --- a/src/libsyntax_pos/lib.rs +++ b/src/libsyntax_pos/lib.rs @@ -8,10 +8,11 @@ html_favicon_url = "https://doc.rust-lang.org/favicon.ico", html_root_url = "https://doc.rust-lang.org/nightly/")] +#![deny(rust_2018_idioms)] + #![feature(const_fn)] #![feature(crate_visibility_modifier)] #![feature(custom_attribute)] -#![feature(nll)] #![feature(non_exhaustive)] #![feature(optin_builtin_traits)] #![feature(rustc_attrs)] @@ -19,23 +20,11 @@ #![feature(step_trait)] #![cfg_attr(not(stage0), feature(stdsimd))] -extern crate arena; -#[macro_use] -extern crate rustc_data_structures; - -#[macro_use] -extern crate scoped_tls; - use serialize::{Encodable, Decodable, Encoder, Decoder}; -extern crate serialize; +#[allow(unused_extern_crates)] extern crate serialize as rustc_serialize; // used by deriving -#[macro_use] -extern crate cfg_if; - -extern crate unicode_width; - pub mod edition; pub mod hygiene; pub use hygiene::{Mark, SyntaxContext, ExpnInfo, ExpnFormat, CompilerDesugaringKind}; @@ -74,7 +63,7 @@ impl Globals { } } -scoped_thread_local!(pub static GLOBALS: Globals); +scoped_tls::scoped_thread_local!(pub static GLOBALS: Globals); /// Differentiates between real files and common virtual files. #[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash, RustcDecodable, RustcEncodable)] @@ -100,8 +89,8 @@ pub enum FileName { } impl std::fmt::Display for FileName { - fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result { - use self::FileName::*; + fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + use FileName::*; match *self { Real(ref path) => write!(fmt, "{}", path.display()), Macros(ref name) => write!(fmt, "<{} macros>", name), @@ -127,7 +116,7 @@ impl From for FileName { impl FileName { pub fn is_real(&self) -> bool { - use self::FileName::*; + use FileName::*; match *self { Real(_) => true, Macros(_) | @@ -143,7 +132,7 @@ impl FileName { } pub fn is_macros(&self) -> bool { - use self::FileName::*; + use FileName::*; match *self { Real(_) | Anon(_) | @@ -611,7 +600,7 @@ impl serialize::UseSpecializedDecodable for Span { } } -pub fn default_span_debug(span: Span, f: &mut fmt::Formatter) -> fmt::Result { +pub fn default_span_debug(span: Span, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("Span") .field("lo", &span.lo()) .field("hi", &span.hi()) @@ -620,13 +609,13 @@ pub fn default_span_debug(span: Span, f: &mut fmt::Formatter) -> fmt::Result { } impl fmt::Debug for Span { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { SPAN_DEBUG.with(|span_debug| span_debug.get()(*self, f)) } } impl fmt::Debug for SpanData { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { SPAN_DEBUG.with(|span_debug| span_debug.get()(Span::new(self.lo, self.hi, self.ctxt), f)) } } @@ -1009,7 +998,7 @@ impl Decodable for SourceFile { // `crate_of_origin` has to be set by the importer. // This value matches up with rustc::hir::def_id::INVALID_CRATE. // That constant is not available here unfortunately :( - crate_of_origin: ::std::u32::MAX - 1, + crate_of_origin: std::u32::MAX - 1, start_pos, end_pos, src: None, @@ -1025,7 +1014,7 @@ impl Decodable for SourceFile { } impl fmt::Debug for SourceFile { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { write!(fmt, "SourceFile({})", self.name) } } @@ -1111,7 +1100,7 @@ impl SourceFile { /// Get a line from the list of pre-computed line-beginnings. /// The line number here is 0-based. - pub fn get_line(&self, line_number: usize) -> Option> { + pub fn get_line(&self, line_number: usize) -> Option> { fn get_until_newline(src: &str, begin: usize) -> &str { // We can't use `lines.get(line_number+1)` because we might // be parsing when we call this function and thus the current @@ -1353,7 +1342,7 @@ pub struct FileLines { pub lines: Vec } -thread_local!(pub static SPAN_DEBUG: Cell fmt::Result> = +thread_local!(pub static SPAN_DEBUG: Cell) -> fmt::Result> = Cell::new(default_span_debug)); #[derive(Debug)] diff --git a/src/libsyntax_pos/span_encoding.rs b/src/libsyntax_pos/span_encoding.rs index 8cb3bc2144da1..03d7a9eb74238 100644 --- a/src/libsyntax_pos/span_encoding.rs +++ b/src/libsyntax_pos/span_encoding.rs @@ -4,9 +4,9 @@ // The encoding format for inline spans were obtained by optimizing over crates in rustc/libstd. // See https://internals.rust-lang.org/t/rfc-compiler-refactoring-spans/1357/28 -use GLOBALS; -use {BytePos, SpanData}; -use hygiene::SyntaxContext; +use crate::GLOBALS; +use crate::{BytePos, SpanData}; +use crate::hygiene::SyntaxContext; use rustc_data_structures::fx::FxHashMap; use std::hash::{Hash, Hasher}; diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs index 7097f332b8b8f..0eecdbfa97634 100644 --- a/src/libsyntax_pos/symbol.rs +++ b/src/libsyntax_pos/symbol.rs @@ -5,6 +5,7 @@ use arena::DroplessArena; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::indexed_vec::Idx; +use rustc_data_structures::newtype_index; use serialize::{Decodable, Decoder, Encodable, Encoder}; use std::fmt; @@ -12,8 +13,8 @@ use std::str; use std::cmp::{PartialEq, Ordering, PartialOrd, Ord}; use std::hash::{Hash, Hasher}; -use hygiene::SyntaxContext; -use {Span, DUMMY_SP, GLOBALS}; +use crate::hygiene::SyntaxContext; +use crate::{Span, DUMMY_SP, GLOBALS}; #[derive(Copy, Clone, Eq)] pub struct Ident { @@ -100,13 +101,13 @@ impl Hash for Ident { } impl fmt::Debug for Ident { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}{:?}", self.name, self.span.ctxt()) } } impl fmt::Display for Ident { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&self.name, f) } } @@ -181,7 +182,7 @@ impl Symbol { pub fn as_str(self) -> LocalInternedString { with_interner(|interner| unsafe { LocalInternedString { - string: ::std::mem::transmute::<&str, &str>(interner.get(self)) + string: std::mem::transmute::<&str, &str>(interner.get(self)) } }) } @@ -198,7 +199,7 @@ impl Symbol { } impl fmt::Debug for Symbol { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let is_gensymed = with_interner(|interner| interner.is_gensymed(*self)); if is_gensymed { write!(f, "{}({:?})", self, self.0) @@ -209,7 +210,7 @@ impl fmt::Debug for Symbol { } impl fmt::Display for Symbol { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(&self.as_str(), f) } } @@ -226,7 +227,7 @@ impl Decodable for Symbol { } } -impl> PartialEq for Symbol { +impl> PartialEq for Symbol { fn eq(&self, other: &T) -> bool { self.as_str() == other.deref() } @@ -335,7 +336,7 @@ macro_rules! declare_keywords {( }; )* - impl ::std::str::FromStr for Keyword { + impl std::str::FromStr for Keyword { type Err = (); fn from_str(s: &str) -> Result { @@ -519,40 +520,40 @@ impl LocalInternedString { } } -impl ::std::convert::AsRef for LocalInternedString +impl std::convert::AsRef for LocalInternedString where - str: ::std::convert::AsRef + str: std::convert::AsRef { fn as_ref(&self) -> &U { self.string.as_ref() } } -impl> ::std::cmp::PartialEq for LocalInternedString { +impl> std::cmp::PartialEq for LocalInternedString { fn eq(&self, other: &T) -> bool { self.string == other.deref() } } -impl ::std::cmp::PartialEq for str { +impl std::cmp::PartialEq for str { fn eq(&self, other: &LocalInternedString) -> bool { self == other.string } } -impl<'a> ::std::cmp::PartialEq for &'a str { +impl<'a> std::cmp::PartialEq for &'a str { fn eq(&self, other: &LocalInternedString) -> bool { *self == other.string } } -impl ::std::cmp::PartialEq for String { +impl std::cmp::PartialEq for String { fn eq(&self, other: &LocalInternedString) -> bool { self == other.string } } -impl<'a> ::std::cmp::PartialEq for &'a String { +impl<'a> std::cmp::PartialEq for &'a String { fn eq(&self, other: &LocalInternedString) -> bool { *self == other.string } @@ -561,19 +562,19 @@ impl<'a> ::std::cmp::PartialEq for &'a String { impl !Send for LocalInternedString {} impl !Sync for LocalInternedString {} -impl ::std::ops::Deref for LocalInternedString { +impl std::ops::Deref for LocalInternedString { type Target = str; fn deref(&self) -> &str { self.string } } impl fmt::Debug for LocalInternedString { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(self.string, f) } } impl fmt::Display for LocalInternedString { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(self.string, f) } } @@ -640,7 +641,7 @@ impl Ord for InternedString { } } -impl> PartialEq for InternedString { +impl> PartialEq for InternedString { fn eq(&self, other: &T) -> bool { self.with(|string| string == other.deref()) } @@ -676,20 +677,20 @@ impl<'a> PartialEq for &'a String { } } -impl ::std::convert::From for String { +impl std::convert::From for String { fn from(val: InternedString) -> String { val.as_symbol().to_string() } } impl fmt::Debug for InternedString { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.with(|str| fmt::Debug::fmt(&str, f)) } } impl fmt::Display for InternedString { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.with(|str| fmt::Display::fmt(&str, f)) } } @@ -709,7 +710,7 @@ impl Encodable for InternedString { #[cfg(test)] mod tests { use super::*; - use Globals; + use crate::Globals; #[test] fn interner_tests() { From 18da195bab0d64680d42ae141e09cbde5514a371 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Mon, 4 Feb 2019 03:55:40 +0900 Subject: [PATCH 043/278] libproc_macro => 2018 --- src/libproc_macro/Cargo.toml | 1 + src/libproc_macro/bridge/buffer.rs | 6 +-- src/libproc_macro/bridge/client.rs | 62 +++++++++++++++++------------- src/libproc_macro/bridge/mod.rs | 8 ++-- src/libproc_macro/bridge/rpc.rs | 18 ++++----- src/libproc_macro/bridge/server.rs | 14 +++---- src/libproc_macro/diagnostic.rs | 12 +++--- src/libproc_macro/lib.rs | 33 ++++++++-------- src/libproc_macro/quote.rs | 36 ++++++++--------- 9 files changed, 100 insertions(+), 90 deletions(-) diff --git a/src/libproc_macro/Cargo.toml b/src/libproc_macro/Cargo.toml index f903f79f9afc0..b3d0ee94f0e12 100644 --- a/src/libproc_macro/Cargo.toml +++ b/src/libproc_macro/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "proc_macro" version = "0.0.0" +edition = "2018" [lib] path = "lib.rs" diff --git a/src/libproc_macro/bridge/buffer.rs b/src/libproc_macro/bridge/buffer.rs index 8bc4f0fec85a8..0d8cc552d61ab 100644 --- a/src/libproc_macro/bridge/buffer.rs +++ b/src/libproc_macro/bridge/buffer.rs @@ -6,7 +6,7 @@ use std::ops::{Deref, DerefMut}; use std::slice; #[repr(C)] -struct Slice<'a, T: 'a> { +struct Slice<'a, T> { data: &'a [T; 0], len: usize, } @@ -42,7 +42,7 @@ pub struct Buffer { data: *mut T, len: usize, capacity: usize, - extend_from_slice: extern "C" fn(Buffer, Slice) -> Buffer, + extend_from_slice: extern "C" fn(Buffer, Slice<'_, T>) -> Buffer, drop: extern "C" fn(Buffer), } @@ -139,7 +139,7 @@ impl From> for Buffer { } } - extern "C" fn extend_from_slice(b: Buffer, xs: Slice) -> Buffer { + extern "C" fn extend_from_slice(b: Buffer, xs: Slice<'_, T>) -> Buffer { let mut v = to_vec(b); v.extend_from_slice(&xs); Buffer::from(v) diff --git a/src/libproc_macro/bridge/client.rs b/src/libproc_macro/bridge/client.rs index 3095c8041f2c1..b198bdb144699 100644 --- a/src/libproc_macro/bridge/client.rs +++ b/src/libproc_macro/bridge/client.rs @@ -66,7 +66,7 @@ macro_rules! define_handles { impl DecodeMut<'_, '_, HandleStore>> for Marked { - fn decode(r: &mut Reader, s: &mut HandleStore>) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut HandleStore>) -> Self { s.$oty.take(handle::Handle::decode(r, &mut ())) } } @@ -80,7 +80,7 @@ macro_rules! define_handles { impl Decode<'_, 's, HandleStore>> for &'s Marked { - fn decode(r: &mut Reader, s: &'s HandleStore>) -> Self { + fn decode(r: &mut Reader<'_>, s: &'s HandleStore>) -> Self { &s.$oty[handle::Handle::decode(r, &mut ())] } } @@ -94,7 +94,10 @@ macro_rules! define_handles { impl DecodeMut<'_, 's, HandleStore>> for &'s mut Marked { - fn decode(r: &mut Reader, s: &'s mut HandleStore>) -> Self { + fn decode( + r: &mut Reader<'_>, + s: &'s mut HandleStore> + ) -> Self { &mut s.$oty[handle::Handle::decode(r, &mut ())] } } @@ -108,7 +111,7 @@ macro_rules! define_handles { } impl DecodeMut<'_, '_, S> for $oty { - fn decode(r: &mut Reader, s: &mut S) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut S) -> Self { $oty(handle::Handle::decode(r, s)) } } @@ -130,7 +133,7 @@ macro_rules! define_handles { impl DecodeMut<'_, '_, HandleStore>> for Marked { - fn decode(r: &mut Reader, s: &mut HandleStore>) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut HandleStore>) -> Self { s.$ity.copy(handle::Handle::decode(r, &mut ())) } } @@ -144,7 +147,7 @@ macro_rules! define_handles { } impl DecodeMut<'_, '_, S> for $ity { - fn decode(r: &mut Reader, s: &mut S) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut S) -> Self { $ity(handle::Handle::decode(r, s)) } } @@ -200,7 +203,7 @@ impl Clone for Literal { // FIXME(eddyb) `Literal` should not expose internal `Debug` impls. impl fmt::Debug for Literal { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(&self.debug()) } } @@ -212,7 +215,7 @@ impl Clone for SourceFile { } impl fmt::Debug for Span { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(&self.debug()) } } @@ -275,7 +278,7 @@ impl BridgeState<'_> { /// /// N.B., while `f` is running, the thread-local state /// is `BridgeState::InUse`. - fn with(f: impl FnOnce(&mut BridgeState) -> R) -> R { + fn with(f: impl FnOnce(&mut BridgeState<'_>) -> R) -> R { BRIDGE_STATE.with(|state| { state.replace(BridgeState::InUse, |mut state| { // FIXME(#52812) pass `f` directly to `replace` when `RefMutL` is gone @@ -306,7 +309,7 @@ impl Bridge<'_> { BRIDGE_STATE.with(|state| state.set(BridgeState::Connected(self), f)) } - fn with(f: impl FnOnce(&mut Bridge) -> R) -> R { + fn with(f: impl FnOnce(&mut Bridge<'_>) -> R) -> R { BridgeState::with(|state| match state { BridgeState::NotConnected => { panic!("procedural macro API is used outside of a procedural macro"); @@ -331,15 +334,15 @@ impl Bridge<'_> { #[derive(Copy, Clone)] pub struct Client { pub(super) get_handle_counters: extern "C" fn() -> &'static HandleCounters, - pub(super) run: extern "C" fn(Bridge, F) -> Buffer, + pub(super) run: extern "C" fn(Bridge<'_>, F) -> Buffer, pub(super) f: F, } // FIXME(#53451) public to work around `Cannot create local mono-item` ICE, // affecting not only the function itself, but also the `BridgeState` `thread_local!`. pub extern "C" fn __run_expand1( - mut bridge: Bridge, - f: fn(::TokenStream) -> ::TokenStream, + mut bridge: Bridge<'_>, + f: fn(crate::TokenStream) -> crate::TokenStream, ) -> Buffer { // The initial `cached_buffer` contains the input. let mut b = bridge.cached_buffer.take(); @@ -352,7 +355,7 @@ pub extern "C" fn __run_expand1( // Put the `cached_buffer` back in the `Bridge`, for requests. Bridge::with(|bridge| bridge.cached_buffer = b.take()); - let output = f(::TokenStream(input)).0; + let output = f(crate::TokenStream(input)).0; // Take the `cached_buffer` back out, for the output value. b = Bridge::with(|bridge| bridge.cached_buffer.take()); @@ -378,8 +381,8 @@ pub extern "C" fn __run_expand1( b } -impl Client ::TokenStream> { - pub const fn expand1(f: fn(::TokenStream) -> ::TokenStream) -> Self { +impl Client crate::TokenStream> { + pub const fn expand1(f: fn(crate::TokenStream) -> crate::TokenStream) -> Self { Client { get_handle_counters: HandleCounters::get, run: __run_expand1, @@ -391,8 +394,8 @@ impl Client ::TokenStream> { // FIXME(#53451) public to work around `Cannot create local mono-item` ICE, // affecting not only the function itself, but also the `BridgeState` `thread_local!`. pub extern "C" fn __run_expand2( - mut bridge: Bridge, - f: fn(::TokenStream, ::TokenStream) -> ::TokenStream, + mut bridge: Bridge<'_>, + f: fn(crate::TokenStream, crate::TokenStream) -> crate::TokenStream, ) -> Buffer { // The initial `cached_buffer` contains the input. let mut b = bridge.cached_buffer.take(); @@ -406,7 +409,7 @@ pub extern "C" fn __run_expand2( // Put the `cached_buffer` back in the `Bridge`, for requests. Bridge::with(|bridge| bridge.cached_buffer = b.take()); - let output = f(::TokenStream(input), ::TokenStream(input2)).0; + let output = f(crate::TokenStream(input), crate::TokenStream(input2)).0; // Take the `cached_buffer` back out, for the output value. b = Bridge::with(|bridge| bridge.cached_buffer.take()); @@ -432,8 +435,10 @@ pub extern "C" fn __run_expand2( b } -impl Client ::TokenStream> { - pub const fn expand2(f: fn(::TokenStream, ::TokenStream) -> ::TokenStream) -> Self { +impl Client crate::TokenStream> { + pub const fn expand2( + f: fn(crate::TokenStream, crate::TokenStream) -> crate::TokenStream + ) -> Self { Client { get_handle_counters: HandleCounters::get, run: __run_expand2, @@ -448,17 +453,17 @@ pub enum ProcMacro { CustomDerive { trait_name: &'static str, attributes: &'static [&'static str], - client: Client ::TokenStream>, + client: Client crate::TokenStream>, }, Attr { name: &'static str, - client: Client ::TokenStream>, + client: Client crate::TokenStream>, }, Bang { name: &'static str, - client: Client ::TokenStream>, + client: Client crate::TokenStream>, }, } @@ -466,7 +471,7 @@ impl ProcMacro { pub const fn custom_derive( trait_name: &'static str, attributes: &'static [&'static str], - expand: fn(::TokenStream) -> ::TokenStream, + expand: fn(crate::TokenStream) -> crate::TokenStream, ) -> Self { ProcMacro::CustomDerive { trait_name, @@ -477,7 +482,7 @@ impl ProcMacro { pub const fn attr( name: &'static str, - expand: fn(::TokenStream, ::TokenStream) -> ::TokenStream, + expand: fn(crate::TokenStream, crate::TokenStream) -> crate::TokenStream, ) -> Self { ProcMacro::Attr { name, @@ -485,7 +490,10 @@ impl ProcMacro { } } - pub const fn bang(name: &'static str, expand: fn(::TokenStream) -> ::TokenStream) -> Self { + pub const fn bang( + name: &'static str, + expand: fn(crate::TokenStream) -> crate::TokenStream + ) -> Self { ProcMacro::Bang { name, client: Client::expand1(expand), diff --git a/src/libproc_macro/bridge/mod.rs b/src/libproc_macro/bridge/mod.rs index 6c3e534bf9197..3173651b03951 100644 --- a/src/libproc_macro/bridge/mod.rs +++ b/src/libproc_macro/bridge/mod.rs @@ -17,7 +17,7 @@ use std::panic; use std::sync::atomic::AtomicUsize; use std::sync::Once; use std::thread; -use {Delimiter, Level, LineColumn, Spacing}; +use crate::{Delimiter, Level, LineColumn, Spacing}; /// Higher-order macro describing the server RPC API, allowing automatic /// generation of type-safe Rust APIs, both client-side and server-side. @@ -196,9 +196,9 @@ mod scoped_cell; #[forbid(unsafe_code)] pub mod server; -use self::buffer::Buffer; -pub use self::rpc::PanicMessage; -use self::rpc::{Decode, DecodeMut, Encode, Reader, Writer}; +use buffer::Buffer; +pub use rpc::PanicMessage; +use rpc::{Decode, DecodeMut, Encode, Reader, Writer}; /// An active connection between a server and a client. /// The server creates the bridge (`Bridge::run_server` in `server.rs`), diff --git a/src/libproc_macro/bridge/rpc.rs b/src/libproc_macro/bridge/rpc.rs index 74ae711a47372..a3bc0d2290846 100644 --- a/src/libproc_macro/bridge/rpc.rs +++ b/src/libproc_macro/bridge/rpc.rs @@ -40,7 +40,7 @@ macro_rules! rpc_encode_decode { } impl DecodeMut<'_, '_, S> for $ty { - fn decode(r: &mut Reader, s: &mut S) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut S) -> Self { let mut byte = 0x80; let mut v = 0; let mut shift = 0; @@ -61,7 +61,7 @@ macro_rules! rpc_encode_decode { } impl DecodeMut<'_, '_, S> for $name { - fn decode(r: &mut Reader, s: &mut S) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut S) -> Self { $name { $($field: DecodeMut::decode(r, s)),* } @@ -119,7 +119,7 @@ impl Encode for () { } impl DecodeMut<'_, '_, S> for () { - fn decode(_: &mut Reader, _: &mut S) -> Self {} + fn decode(_: &mut Reader<'_>, _: &mut S) -> Self {} } impl Encode for u8 { @@ -129,7 +129,7 @@ impl Encode for u8 { } impl DecodeMut<'_, '_, S> for u8 { - fn decode(r: &mut Reader, _: &mut S) -> Self { + fn decode(r: &mut Reader<'_>, _: &mut S) -> Self { let x = r[0]; *r = &r[1..]; x @@ -146,7 +146,7 @@ impl Encode for bool { } impl DecodeMut<'_, '_, S> for bool { - fn decode(r: &mut Reader, s: &mut S) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut S) -> Self { match u8::decode(r, s) { 0 => false, 1 => true, @@ -162,7 +162,7 @@ impl Encode for char { } impl DecodeMut<'_, '_, S> for char { - fn decode(r: &mut Reader, s: &mut S) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut S) -> Self { char::from_u32(u32::decode(r, s)).unwrap() } } @@ -174,7 +174,7 @@ impl Encode for NonZeroU32 { } impl DecodeMut<'_, '_, S> for NonZeroU32 { - fn decode(r: &mut Reader, s: &mut S) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut S) -> Self { Self::new(u32::decode(r, s)).unwrap() } } @@ -251,7 +251,7 @@ impl Encode for String { } impl DecodeMut<'_, '_, S> for String { - fn decode(r: &mut Reader, s: &mut S) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut S) -> Self { <&str>::decode(r, s).to_string() } } @@ -306,7 +306,7 @@ impl Encode for PanicMessage { } impl DecodeMut<'_, '_, S> for PanicMessage { - fn decode(r: &mut Reader, s: &mut S) -> Self { + fn decode(r: &mut Reader<'_>, s: &mut S) -> Self { match Option::::decode(r, s) { Some(s) => PanicMessage::String(s), None => PanicMessage::Unknown, diff --git a/src/libproc_macro/bridge/server.rs b/src/libproc_macro/bridge/server.rs index 9a7cb1318dbe4..75806eb9d1760 100644 --- a/src/libproc_macro/bridge/server.rs +++ b/src/libproc_macro/bridge/server.rs @@ -131,7 +131,7 @@ pub trait ExecutionStrategy { &self, dispatcher: &mut impl DispatcherTrait, input: Buffer, - run_client: extern "C" fn(Bridge, D) -> Buffer, + run_client: extern "C" fn(Bridge<'_>, D) -> Buffer, client_data: D, ) -> Buffer; } @@ -143,7 +143,7 @@ impl ExecutionStrategy for SameThread { &self, dispatcher: &mut impl DispatcherTrait, input: Buffer, - run_client: extern "C" fn(Bridge, D) -> Buffer, + run_client: extern "C" fn(Bridge<'_>, D) -> Buffer, client_data: D, ) -> Buffer { let mut dispatch = |b| dispatcher.dispatch(b); @@ -168,7 +168,7 @@ impl ExecutionStrategy for CrossThread1 { &self, dispatcher: &mut impl DispatcherTrait, input: Buffer, - run_client: extern "C" fn(Bridge, D) -> Buffer, + run_client: extern "C" fn(Bridge<'_>, D) -> Buffer, client_data: D, ) -> Buffer { use std::sync::mpsc::channel; @@ -206,7 +206,7 @@ impl ExecutionStrategy for CrossThread2 { &self, dispatcher: &mut impl DispatcherTrait, input: Buffer, - run_client: extern "C" fn(Bridge, D) -> Buffer, + run_client: extern "C" fn(Bridge<'_>, D) -> Buffer, client_data: D, ) -> Buffer { use std::sync::{Arc, Mutex}; @@ -273,7 +273,7 @@ fn run_server< handle_counters: &'static client::HandleCounters, server: S, input: I, - run_client: extern "C" fn(Bridge, D) -> Buffer, + run_client: extern "C" fn(Bridge<'_>, D) -> Buffer, client_data: D, ) -> Result { let mut dispatcher = Dispatcher { @@ -289,7 +289,7 @@ fn run_server< Result::decode(&mut &b[..], &mut dispatcher.handle_store) } -impl client::Client ::TokenStream> { +impl client::Client crate::TokenStream> { pub fn run( &self, strategy: &impl ExecutionStrategy, @@ -313,7 +313,7 @@ impl client::Client ::TokenStream> { } } -impl client::Client ::TokenStream> { +impl client::Client crate::TokenStream> { pub fn run( &self, strategy: &impl ExecutionStrategy, diff --git a/src/libproc_macro/diagnostic.rs b/src/libproc_macro/diagnostic.rs index 64d0c3893c730..7a0c9419f6234 100644 --- a/src/libproc_macro/diagnostic.rs +++ b/src/libproc_macro/diagnostic.rs @@ -1,4 +1,4 @@ -use Span; +use crate::Span; /// An enum representing a diagnostic level. #[unstable(feature = "proc_macro_diagnostic", issue = "54140")] @@ -80,7 +80,7 @@ macro_rules! diagnostic_child_methods { /// Iterator over the children diagnostics of a `Diagnostic`. #[derive(Debug, Clone)] #[unstable(feature = "proc_macro_diagnostic", issue = "54140")] -pub struct Children<'a>(::std::slice::Iter<'a, Diagnostic>); +pub struct Children<'a>(std::slice::Iter<'a, Diagnostic>); #[unstable(feature = "proc_macro_diagnostic", issue = "54140")] impl<'a> Iterator for Children<'a> { @@ -161,22 +161,22 @@ impl Diagnostic { /// Returns an iterator over the children diagnostics of `self`. #[unstable(feature = "proc_macro_diagnostic", issue = "54140")] - pub fn children(&self) -> Children { + pub fn children(&self) -> Children<'_> { Children(self.children.iter()) } /// Emit the diagnostic. #[unstable(feature = "proc_macro_diagnostic", issue = "54140")] pub fn emit(self) { - fn to_internal(spans: Vec) -> ::bridge::client::MultiSpan { - let mut multi_span = ::bridge::client::MultiSpan::new(); + fn to_internal(spans: Vec) -> crate::bridge::client::MultiSpan { + let mut multi_span = crate::bridge::client::MultiSpan::new(); for span in spans { multi_span.push(span.0); } multi_span } - let mut diag = ::bridge::client::Diagnostic::new( + let mut diag = crate::bridge::client::Diagnostic::new( self.level, &self.message[..], to_internal(self.spans), diff --git a/src/libproc_macro/lib.rs b/src/libproc_macro/lib.rs index 868190d01057d..bb6f5e234f7c2 100644 --- a/src/libproc_macro/lib.rs +++ b/src/libproc_macro/lib.rs @@ -17,7 +17,8 @@ test(no_crate_inject, attr(deny(warnings))), test(attr(allow(dead_code, deprecated, unused_variables, unused_mut))))] -#![feature(nll)] +#![deny(rust_2018_idioms)] + #![feature(staged_api)] #![feature(const_fn)] #![feature(extern_types)] @@ -114,7 +115,7 @@ impl ToString for TokenStream { /// with `Delimiter::None` delimiters and negative numeric literals. #[stable(feature = "proc_macro_lib", since = "1.15.0")] impl fmt::Display for TokenStream { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(&self.to_string()) } } @@ -122,7 +123,7 @@ impl fmt::Display for TokenStream { /// Prints token in a form convenient for debugging. #[stable(feature = "proc_macro_lib", since = "1.15.0")] impl fmt::Debug for TokenStream { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str("TokenStream ")?; f.debug_list().entries(self.clone()).finish() } @@ -183,7 +184,7 @@ impl Extend for TokenStream { /// Public implementation details for the `TokenStream` type, such as iterators. #[stable(feature = "proc_macro_lib2", since = "1.29.0")] pub mod token_stream { - use {bridge, Group, Ident, Literal, Punct, TokenTree, TokenStream}; + use crate::{bridge, Group, Ident, Literal, Punct, TokenTree, TokenStream}; /// An iterator over `TokenStream`'s `TokenTree`s. /// The iteration is "shallow", e.g., the iterator doesn't recurse into delimited groups, @@ -340,7 +341,7 @@ impl Span { /// Prints a span in a form convenient for debugging. #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Debug for Span { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { self.0.fmt(f) } } @@ -398,7 +399,7 @@ impl SourceFile { #[unstable(feature = "proc_macro_span", issue = "54725")] impl fmt::Debug for SourceFile { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("SourceFile") .field("path", &self.path()) .field("is_real", &self.is_real()) @@ -483,7 +484,7 @@ impl TokenTree { /// Prints token tree in a form convenient for debugging. #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Debug for TokenTree { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { // Each of these has the name in the struct type in the derived debug, // so don't bother with an extra layer of indirection match *self { @@ -542,7 +543,7 @@ impl ToString for TokenTree { /// with `Delimiter::None` delimiters and negative numeric literals. #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Display for TokenTree { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(&self.to_string()) } } @@ -667,14 +668,14 @@ impl ToString for Group { /// with `Delimiter::None` delimiters. #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Display for Group { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(&self.to_string()) } } #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Debug for Group { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("Group") .field("delimiter", &self.delimiter()) .field("stream", &self.stream()) @@ -763,14 +764,14 @@ impl ToString for Punct { /// back into the same character. #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Display for Punct { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(&self.to_string()) } } #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Debug for Punct { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("Punct") .field("ch", &self.as_char()) .field("spacing", &self.spacing()) @@ -842,14 +843,14 @@ impl ToString for Ident { /// back into the same identifier. #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Display for Ident { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(&self.to_string()) } } #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Debug for Ident { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("Ident") .field("ident", &self.to_string()) .field("span", &self.span()) @@ -1092,14 +1093,14 @@ impl ToString for Literal { /// back into the same literal (except for possible rounding for floating point literals). #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Display for Literal { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(&self.to_string()) } } #[stable(feature = "proc_macro_lib2", since = "1.29.0")] impl fmt::Debug for Literal { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { // FIXME(eddyb) `Literal` should not expose internal `Debug` impls. self.0.fmt(f) } diff --git a/src/libproc_macro/quote.rs b/src/libproc_macro/quote.rs index bd7e96210a950..e3d31b78f4a09 100644 --- a/src/libproc_macro/quote.rs +++ b/src/libproc_macro/quote.rs @@ -4,7 +4,7 @@ //! This quasiquoter uses macros 2.0 hygiene to reliably access //! items from `proc_macro`, to build a `proc_macro::TokenStream`. -use {Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree}; +use crate::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree}; macro_rules! quote_tt { (($($t:tt)*)) => { Group::new(Delimiter::Parenthesis, quote!($($t)*)) }; @@ -63,7 +63,7 @@ macro_rules! quote { #[unstable(feature = "proc_macro_quote", issue = "54722")] pub fn quote(stream: TokenStream) -> TokenStream { if stream.is_empty() { - return quote!(::TokenStream::new()); + return quote!(crate::TokenStream::new()); } let mut after_dollar = false; let tokens = stream @@ -73,7 +73,7 @@ pub fn quote(stream: TokenStream) -> TokenStream { after_dollar = false; match tree { TokenTree::Ident(_) => { - return Some(quote!(Into::<::TokenStream>::into( + return Some(quote!(Into::::into( Clone::clone(&(@ tree))),)); } TokenTree::Punct(ref tt) if tt.as_char() == '$' => {} @@ -86,33 +86,33 @@ pub fn quote(stream: TokenStream) -> TokenStream { } } - Some(quote!(::TokenStream::from((@ match tree { - TokenTree::Punct(tt) => quote!(::TokenTree::Punct(::Punct::new( + Some(quote!(crate::TokenStream::from((@ match tree { + TokenTree::Punct(tt) => quote!(crate::TokenTree::Punct(crate::Punct::new( (@ TokenTree::from(Literal::character(tt.as_char()))), (@ match tt.spacing() { - Spacing::Alone => quote!(::Spacing::Alone), - Spacing::Joint => quote!(::Spacing::Joint), + Spacing::Alone => quote!(crate::Spacing::Alone), + Spacing::Joint => quote!(crate::Spacing::Joint), }), ))), - TokenTree::Group(tt) => quote!(::TokenTree::Group(::Group::new( + TokenTree::Group(tt) => quote!(crate::TokenTree::Group(crate::Group::new( (@ match tt.delimiter() { - Delimiter::Parenthesis => quote!(::Delimiter::Parenthesis), - Delimiter::Brace => quote!(::Delimiter::Brace), - Delimiter::Bracket => quote!(::Delimiter::Bracket), - Delimiter::None => quote!(::Delimiter::None), + Delimiter::Parenthesis => quote!(crate::Delimiter::Parenthesis), + Delimiter::Brace => quote!(crate::Delimiter::Brace), + Delimiter::Bracket => quote!(crate::Delimiter::Bracket), + Delimiter::None => quote!(crate::Delimiter::None), }), (@ quote(tt.stream())), ))), - TokenTree::Ident(tt) => quote!(::TokenTree::Ident(::Ident::new( + TokenTree::Ident(tt) => quote!(crate::TokenTree::Ident(crate::Ident::new( (@ TokenTree::from(Literal::string(&tt.to_string()))), (@ quote_span(tt.span())), ))), - TokenTree::Literal(tt) => quote!(::TokenTree::Literal({ + TokenTree::Literal(tt) => quote!(crate::TokenTree::Literal({ let mut iter = (@ TokenTree::from(Literal::string(&tt.to_string()))) - .parse::<::TokenStream>() + .parse::() .unwrap() .into_iter(); - if let (Some(::TokenTree::Literal(mut lit)), None) = + if let (Some(crate::TokenTree::Literal(mut lit)), None) = (iter.next(), iter.next()) { lit.set_span((@ quote_span(tt.span()))); @@ -129,12 +129,12 @@ pub fn quote(stream: TokenStream) -> TokenStream { panic!("unexpected trailing `$` in `quote!`"); } - quote!([(@ tokens)].iter().cloned().collect::<::TokenStream>()) + quote!([(@ tokens)].iter().cloned().collect::()) } /// Quote a `Span` into a `TokenStream`. /// This is needed to implement a custom quoter. #[unstable(feature = "proc_macro_quote", issue = "54722")] pub fn quote_span(_: Span) -> TokenStream { - quote!(::Span::def_site()) + quote!(crate::Span::def_site()) } From e8aeb83a4a1f242c4ff1394b645cc180fcdd5b23 Mon Sep 17 00:00:00 2001 From: ljedrz Date: Sun, 3 Feb 2019 09:14:31 +0100 Subject: [PATCH 044/278] hir: add HirId methods --- src/librustc/hir/map/collector.rs | 6 ++ src/librustc/hir/map/definitions.rs | 40 ++++++++++++- src/librustc/hir/map/mod.rs | 87 +++++++++++++++++++++++++++++ src/librustc/ty/item_path.rs | 6 ++ 4 files changed, 138 insertions(+), 1 deletion(-) diff --git a/src/librustc/hir/map/collector.rs b/src/librustc/hir/map/collector.rs index 7cc5d756ff311..9c4fa9e127287 100644 --- a/src/librustc/hir/map/collector.rs +++ b/src/librustc/hir/map/collector.rs @@ -1,5 +1,6 @@ use super::*; use dep_graph::{DepGraph, DepKind, DepNodeIndex}; +use hir; use hir::def_id::{LOCAL_CRATE, CrateNum}; use hir::intravisit::{Visitor, NestedVisitorMap}; use rustc_data_structures::svh::Svh; @@ -28,6 +29,8 @@ pub(super) struct NodeCollector<'a, 'hir> { /// The parent of this node parent_node: NodeId, + parent_hir: hir::HirId, + // These fields keep track of the currently relevant DepNodes during // the visitor's traversal. current_dep_node_owner: DefIndex, @@ -145,6 +148,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> { source_map: sess.source_map(), map: repeat(None).take(sess.current_node_id_count()).collect(), parent_node: CRATE_NODE_ID, + parent_hir: hir::CRATE_HIR_ID, current_signature_dep_index: root_mod_sig_dep_index, current_full_dep_index: root_mod_full_dep_index, current_dep_node_owner: CRATE_DEF_INDEX, @@ -156,6 +160,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> { }; collector.insert_entry(CRATE_NODE_ID, Entry { parent: CRATE_NODE_ID, + parent_hir: hir::CRATE_HIR_ID, dep_node: root_mod_sig_dep_index, node: Node::Crate, }); @@ -226,6 +231,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> { fn insert(&mut self, span: Span, id: NodeId, node: Node<'hir>) { let entry = Entry { parent: self.parent_node, + parent_hir: self.parent_hir, dep_node: if self.currently_in_body { self.current_full_dep_index } else { diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs index 1b7445199475c..687daca3d3ff2 100644 --- a/src/librustc/hir/map/definitions.rs +++ b/src/librustc/hir/map/definitions.rs @@ -20,7 +20,7 @@ use syntax::ast; use syntax::ext::hygiene::Mark; use syntax::symbol::{Symbol, InternedString}; use syntax_pos::{Span, DUMMY_SP}; -use util::nodemap::NodeMap; +use util::nodemap::{HirIdMap, NodeMap}; /// The DefPathTable maps DefIndexes to DefKeys and vice versa. /// Internally the DefPathTable holds a tree of DefKeys, where each DefKey @@ -147,6 +147,7 @@ impl Decodable for DefPathTable { pub struct Definitions { table: DefPathTable, node_to_def_index: NodeMap, + hir_to_def_index: HirIdMap, def_index_to_node: [Vec; 2], pub(super) node_to_hir_id: IndexVec, /// If `Mark` is an ID of some macro expansion, @@ -441,16 +442,34 @@ impl Definitions { self.node_to_def_index.get(&node).cloned() } + // FIXME(@ljedrz): replace the NodeId variant + #[inline] + pub fn opt_def_index_from_hir_id(&self, hir: hir::HirId) -> Option { + self.hir_to_def_index.get(&hir).cloned() + } + #[inline] pub fn opt_local_def_id(&self, node: ast::NodeId) -> Option { self.opt_def_index(node).map(DefId::local) } + // FIXME(@ljedrz): replace the NodeId variant + #[inline] + pub fn opt_local_def_id_from_hir_id(&self, hir: hir::HirId) -> Option { + self.opt_def_index_from_hir_id(hir).map(DefId::local) + } + #[inline] pub fn local_def_id(&self, node: ast::NodeId) -> DefId { self.opt_local_def_id(node).unwrap() } + // FIXME(@ljedrz): replace the NodeId variant + #[inline] + pub fn local_def_id_from_hir_id(&self, hir: hir::HirId) -> DefId { + self.opt_local_def_id_from_hir_id(hir).unwrap() + } + #[inline] pub fn as_local_node_id(&self, def_id: DefId) -> Option { if def_id.krate == LOCAL_CRATE { @@ -467,6 +486,21 @@ impl Definitions { } } + // FIXME(@ljedrz): replace the NodeId variant + #[inline] + pub fn as_local_hir_id(&self, def_id: DefId) -> Option { + if def_id.krate == LOCAL_CRATE { + let hir_id = self.def_index_to_hir_id(def_id.index); + if hir_id != hir::DUMMY_HIR_ID { + Some(hir_id) + } else { + None + } + } else { + None + } + } + #[inline] pub fn node_to_hir_id(&self, node_id: ast::NodeId) -> hir::HirId { self.node_to_hir_id[node_id] @@ -515,6 +549,7 @@ impl Definitions { assert!(self.def_index_to_node[address_space.index()].is_empty()); self.def_index_to_node[address_space.index()].push(ast::CRATE_NODE_ID); self.node_to_def_index.insert(ast::CRATE_NODE_ID, root_index); + self.hir_to_def_index.insert(hir::CRATE_HIR_ID, root_index); // Allocate some other DefIndices that always must exist. GlobalMetaDataKind::allocate_def_indices(self); @@ -575,6 +610,9 @@ impl Definitions { if node_id != ast::DUMMY_NODE_ID { debug!("create_def_with_parent: def_index_to_node[{:?} <-> {:?}", index, node_id); self.node_to_def_index.insert(node_id, index); + if let Some(hir_id) = self.node_to_hir_id.get(node_id) { + self.hir_to_def_index.insert(*hir_id, index); + } } if expansion != Mark::root() { diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 9066f2238cf24..c8e19c3b49260 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -40,6 +40,7 @@ pub const REGULAR_SPACE: DefIndexAddressSpace = DefIndexAddressSpace::High; #[derive(Copy, Clone, Debug)] pub struct Entry<'hir> { parent: NodeId, + parent_hir: HirId, dep_node: DepNodeIndex, node: Node<'hir>, } @@ -208,6 +209,12 @@ impl<'hir> Map<'hir> { } } + // FIXME(@ljedrz): replace the NodeId variant + pub fn read_by_hir_id(&self, hir_id: HirId) { + let node_id = self.hir_to_node_id(hir_id); + self.read(node_id); + } + #[inline] pub fn definitions(&self) -> &'hir Definitions { self.definitions @@ -224,6 +231,11 @@ impl<'hir> Map<'hir> { }) } + // FIXME(@ljedrz): replace the NodeId variant + pub fn def_path_from_hir_id(&self, id: HirId) -> DefPath { + self.def_path(self.local_def_id_from_hir_id(id)) + } + pub fn def_path(&self, def_id: DefId) -> DefPath { assert!(def_id.is_local()); self.definitions.def_path(def_id.index) @@ -237,6 +249,22 @@ impl<'hir> Map<'hir> { }) } + // FIXME(@ljedrz): replace the NodeId variant + #[inline] + pub fn local_def_id_from_hir_id(&self, hir_id: HirId) -> DefId { + self.opt_local_def_id_from_hir_id(hir_id).unwrap_or_else(|| { + let node_id = self.hir_to_node_id(hir_id); + bug!("local_def_id_from_hir_id: no entry for `{:?}`, which has a map of `{:?}`", + hir_id, self.find_entry(node_id)) + }) + } + + // FIXME(@ljedrz): replace the NodeId variant + #[inline] + pub fn opt_local_def_id_from_hir_id(&self, hir_id: HirId) -> Option { + self.definitions.opt_local_def_id_from_hir_id(hir_id) + } + #[inline] pub fn opt_local_def_id(&self, node: NodeId) -> Option { self.definitions.opt_local_def_id(node) @@ -247,6 +275,12 @@ impl<'hir> Map<'hir> { self.definitions.as_local_node_id(def_id) } + // FIXME(@ljedrz): replace the NodeId variant + #[inline] + pub fn as_local_hir_id(&self, def_id: DefId) -> Option { + self.definitions.as_local_hir_id(def_id) + } + #[inline] pub fn hir_to_node_id(&self, hir_id: HirId) -> NodeId { self.hir_to_node_id[&hir_id] @@ -566,6 +600,12 @@ impl<'hir> Map<'hir> { self.find(id).unwrap_or_else(|| bug!("couldn't find node id {} in the AST map", id)) } + // FIXME(@ljedrz): replace the NodeId variant + pub fn get_by_hir_id(&self, id: HirId) -> Node<'hir> { + let node_id = self.hir_to_node_id(id); + self.get(node_id) + } + pub fn get_if_local(&self, id: DefId) -> Option> { self.as_local_node_id(id).map(|id| self.get(id)) // read recorded by `get` } @@ -613,6 +653,12 @@ impl<'hir> Map<'hir> { result } + // FIXME(@ljedrz): replace the NodeId variant + pub fn find_by_hir_id(&self, hir_id: HirId) -> Option> { + let node_id = self.hir_to_node_id(hir_id); + self.find(node_id) + } + /// Similar to `get_parent`; returns the parent node-id, or own `id` if there is /// no parent. Note that the parent may be `CRATE_NODE_ID`, which is not itself /// present in the map -- so passing the return value of get_parent_node to @@ -633,6 +679,13 @@ impl<'hir> Map<'hir> { self.find_entry(id).and_then(|x| x.parent_node()).unwrap_or(id) } + // FIXME(@ljedrz): replace the NodeId variant + pub fn get_parent_node_by_hir_id(&self, id: HirId) -> HirId { + let node_id = self.hir_to_node_id(id); + let parent_node_id = self.get_parent_node(node_id); + self.node_to_hir_id(parent_node_id) + } + /// Check if the node is an argument. An argument is a local variable whose /// immediate parent is an item or a closure. pub fn is_argument(&self, id: NodeId) -> bool { @@ -757,6 +810,13 @@ impl<'hir> Map<'hir> { } } + // FIXME(@ljedrz): replace the NodeId variant + pub fn get_parent_item(&self, id: HirId) -> HirId { + let node_id = self.hir_to_node_id(id); + let parent_node_id = self.get_parent(node_id); + self.node_to_hir_id(parent_node_id) + } + /// Returns the `DefId` of `id`'s nearest module parent, or `id` itself if no /// module parent is in this map. pub fn get_module_parent(&self, id: NodeId) -> DefId { @@ -814,6 +874,12 @@ impl<'hir> Map<'hir> { } } + // FIXME(@ljedrz): replace the NodeId variant + pub fn expect_item_by_hir_id(&self, id: HirId) -> &'hir Item { + let node_id = self.hir_to_node_id(id); + self.expect_item(node_id) + } + pub fn expect_impl_item(&self, id: NodeId) -> &'hir ImplItem { match self.find(id) { Some(Node::ImplItem(item)) => item, @@ -960,13 +1026,28 @@ impl<'hir> Map<'hir> { node_id_to_string(self, id, true) } + // FIXME(@ljedrz): replace the NodeId variant + pub fn hir_to_string(&self, id: HirId) -> String { + hir_id_to_string(self, id, true) + } + pub fn node_to_user_string(&self, id: NodeId) -> String { node_id_to_string(self, id, false) } + // FIXME(@ljedrz): replace the NodeId variant + pub fn hir_to_user_string(&self, id: HirId) -> String { + hir_id_to_string(self, id, false) + } + pub fn node_to_pretty_string(&self, id: NodeId) -> String { print::to_string(self, |s| s.print_node(self.get(id))) } + + // FIXME(@ljedrz): replace the NodeId variant + pub fn hir_to_pretty_string(&self, id: HirId) -> String { + print::to_string(self, |s| s.print_node(self.get_by_hir_id(id))) + } } pub struct NodesMatchingSuffix<'a, 'hir:'a> { @@ -1310,6 +1391,12 @@ fn node_id_to_string(map: &Map<'_>, id: NodeId, include_id: bool) -> String { } } +// FIXME(@ljedrz): replace the NodeId variant +fn hir_id_to_string(map: &Map<'_>, id: HirId, include_id: bool) -> String { + let node_id = map.hir_to_node_id(id); + node_id_to_string(map, node_id, include_id) +} + pub fn describe_def(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Option { if let Some(node_id) = tcx.hir().as_local_node_id(def_id) { tcx.hir().describe_def(node_id) diff --git a/src/librustc/ty/item_path.rs b/src/librustc/ty/item_path.rs index 0ddc5ae87208d..adb7e1fb3e322 100644 --- a/src/librustc/ty/item_path.rs +++ b/src/librustc/ty/item_path.rs @@ -1,3 +1,4 @@ +use hir; use hir::map::DefPathData; use hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE}; use ty::{self, DefIdTree, Ty, TyCtxt}; @@ -76,6 +77,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { self.item_path_str(self.hir().local_def_id(id)) } + // FIXME(@ljedrz): replace the NodeId variant + pub fn hir_path_str(self, id: hir::HirId) -> String { + self.item_path_str(self.hir().local_def_id_from_hir_id(id)) + } + /// Returns a string identifying this def-id. This string is /// suitable for user output. It always begins with a crate identifier. pub fn absolute_item_path_str(self, def_id: DefId) -> String { From 5440149229068ef202af1b59846d123a24e4c62f Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Mon, 4 Feb 2019 06:00:16 +0900 Subject: [PATCH 045/278] libunwind => 2018 --- src/libunwind/Cargo.toml | 1 + src/libunwind/lib.rs | 4 ++-- src/libunwind/libunwind.rs | 10 +++++----- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/libunwind/Cargo.toml b/src/libunwind/Cargo.toml index 2577d6dd31d8f..2378b0a315a16 100644 --- a/src/libunwind/Cargo.toml +++ b/src/libunwind/Cargo.toml @@ -3,6 +3,7 @@ authors = ["The Rust Project Developers"] name = "unwind" version = "0.0.0" build = "build.rs" +edition = "2018" [lib] name = "unwind" diff --git a/src/libunwind/lib.rs b/src/libunwind/lib.rs index 5f9c82431b786..b9a9929ef8b87 100644 --- a/src/libunwind/lib.rs +++ b/src/libunwind/lib.rs @@ -1,8 +1,9 @@ #![no_std] #![unstable(feature = "panic_unwind", issue = "32837")] +#![deny(rust_2018_idioms)] + #![feature(link_cfg)] -#![feature(nll)] #![feature(staged_api)] #![feature(unwind_attributes)] #![feature(static_nobundle)] @@ -18,7 +19,6 @@ cfg_if! { } else if #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))] { // no unwinder on the system! } else { - extern crate libc; mod libunwind; pub use libunwind::*; } diff --git a/src/libunwind/libunwind.rs b/src/libunwind/libunwind.rs index 31e806c8fb656..339b554ed6abd 100644 --- a/src/libunwind/libunwind.rs +++ b/src/libunwind/libunwind.rs @@ -21,7 +21,7 @@ pub enum _Unwind_Reason_Code { _URC_CONTINUE_UNWIND = 8, _URC_FAILURE = 9, // used only by ARM EHABI } -pub use self::_Unwind_Reason_Code::*; +pub use _Unwind_Reason_Code::*; pub type _Unwind_Exception_Class = u64; pub type _Unwind_Word = uintptr_t; @@ -94,7 +94,7 @@ if #[cfg(all(any(target_os = "ios", target_os = "netbsd", not(target_arch = "arm _UA_FORCE_UNWIND = 8, _UA_END_OF_STACK = 16, } - pub use self::_Unwind_Action::*; + pub use _Unwind_Action::*; extern "C" { pub fn _Unwind_GetGR(ctx: *mut _Unwind_Context, reg_index: c_int) -> _Unwind_Word; @@ -118,7 +118,7 @@ if #[cfg(all(any(target_os = "ios", target_os = "netbsd", not(target_arch = "arm _US_FORCE_UNWIND = 8, _US_END_OF_STACK = 16, } - pub use self::_Unwind_State::*; + pub use _Unwind_State::*; #[repr(C)] enum _Unwind_VRS_Result { @@ -134,7 +134,7 @@ if #[cfg(all(any(target_os = "ios", target_os = "netbsd", not(target_arch = "arm _UVRSC_WMMXD = 3, _UVRSC_WMMXC = 4, } - use self::_Unwind_VRS_RegClass::*; + use _Unwind_VRS_RegClass::*; #[repr(C)] enum _Unwind_VRS_DataRepresentation { _UVRSD_UINT32 = 0, @@ -144,7 +144,7 @@ if #[cfg(all(any(target_os = "ios", target_os = "netbsd", not(target_arch = "arm _UVRSD_FLOAT = 4, _UVRSD_DOUBLE = 5, } - use self::_Unwind_VRS_DataRepresentation::*; + use _Unwind_VRS_DataRepresentation::*; pub const UNWIND_POINTER_REG: c_int = 12; pub const UNWIND_IP_REG: c_int = 15; From 9a460aac37e91f66f9ba79824dbf62105733efee Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 3 Feb 2019 22:10:39 +0100 Subject: [PATCH 046/278] some type-level docs for MaybeUninit; rename into_inner -> into_initialized --- src/libcore/macros.rs | 4 ++-- src/libcore/mem.rs | 45 +++++++++++++++++++++++++++++++++++++++++-- src/libcore/ptr.rs | 4 ++-- 3 files changed, 47 insertions(+), 6 deletions(-) diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs index 12b7adb8a9d26..664490c1997ef 100644 --- a/src/libcore/macros.rs +++ b/src/libcore/macros.rs @@ -555,12 +555,12 @@ macro_rules! unimplemented { #[macro_export] #[unstable(feature = "maybe_uninit", issue = "53491")] macro_rules! uninitialized_array { - // This `into_inner` is safe because an array of `MaybeUninit` does not + // This `into_initialized` is safe because an array of `MaybeUninit` does not // require initialization. // FIXME(#49147): Could be replaced by an array initializer, once those can // be any const expression. ($t:ty; $size:expr) => (unsafe { - MaybeUninit::<[MaybeUninit<$t>; $size]>::uninitialized().into_inner() + MaybeUninit::<[MaybeUninit<$t>; $size]>::uninitialized().into_initialized() }); } diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index 8b6d9d882b5ad..998e892bffb26 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -1034,7 +1034,41 @@ impl DerefMut for ManuallyDrop { } } -/// A newtype to construct uninitialized instances of `T` +/// A newtype to construct uninitialized instances of `T`. +/// +/// The compiler, in general, assumes that variables are properly initialized +/// at their respective type. For example, a variable of reference type must +/// be aligned and non-NULL. This is an invariant that must *always* be upheld, +/// even in unsafe code. As a consequence, 0-initializing a variable of reference +/// type causes instantaneous undefined behavior, no matter whether that reference +/// ever gets used to access memory: +/// ```rust,ignore +/// use std::mem; +/// +/// let x: &i32 = mem::zeroed(); // undefined behavior! +/// ``` +/// This is exploitet by the compiler for various optimizations, such as eliding +/// run-time checks and optimizing `enum` layout. +/// +/// Not initializing memory at all (instead of 0-initializing it) causes the same +/// issue: after all, the initial value of the variable might just happen to be +/// one that violates the invariant. +/// +/// `MaybeUninit` serves to enable unsafe code to deal with uninitialized data: +/// it is a signal to the compiler indicating that the data here may *not* +/// be initialized: +/// ```rust +/// use std::mem::MaybeUninit; +/// +/// // Create an explicitly uninitialized reference. +/// let mut x = MaybeUninit::<&i32>::uninitialized(); +/// // Set it to a valid value. +/// x.set(&0); +/// // Extract the initialized data -- this is only allowed *after* properly +/// initializing `x`! +/// let x = unsafe { x.into_initialized() }; +/// ``` +/// The compiler then knows to not optimize this code. #[allow(missing_debug_implementations)] #[unstable(feature = "maybe_uninit", issue = "53491")] // NOTE after stabilizing `MaybeUninit` proceed to deprecate `mem::{uninitialized,zeroed}` @@ -1101,11 +1135,18 @@ impl MaybeUninit { /// state, otherwise this will immediately cause undefined behavior. #[unstable(feature = "maybe_uninit", issue = "53491")] #[inline(always)] - pub unsafe fn into_inner(self) -> T { + pub unsafe fn into_initialized(self) -> T { intrinsics::panic_if_uninhabited::(); ManuallyDrop::into_inner(self.value) } + /// Deprecated alternative to `into_initialized`. Will never get stabilized. + /// Exists only to transition stdsimd to `into_initialized`. + #[inline(always)] + pub(crate) unsafe fn into_inner(self) -> T { + self.into_initialized() + } + /// Get a reference to the contained value. /// /// # Unsafety diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 02eef07afd7ab..537aa92c2cf4e 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -573,7 +573,7 @@ pub unsafe fn replace(dst: *mut T, mut src: T) -> T { pub unsafe fn read(src: *const T) -> T { let mut tmp = MaybeUninit::::uninitialized(); copy_nonoverlapping(src, tmp.as_mut_ptr(), 1); - tmp.into_inner() + tmp.into_initialized() } /// Reads the value from `src` without moving it. This leaves the @@ -642,7 +642,7 @@ pub unsafe fn read_unaligned(src: *const T) -> T { copy_nonoverlapping(src as *const u8, tmp.as_mut_ptr() as *mut u8, mem::size_of::()); - tmp.into_inner() + tmp.into_initialized() } /// Overwrites a memory location with the given value without reading or From 760424af17bc40c4fd2be95e96ebcebe70d217e9 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 3 Feb 2019 22:11:28 +0100 Subject: [PATCH 047/278] expand as_[mut_]ptr docs a bit --- src/libcore/mem.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index 998e892bffb26..3348e774a0b7a 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -1174,16 +1174,16 @@ impl MaybeUninit { &mut *self.value } - /// Get a pointer to the contained value. Reading from this pointer will be undefined - /// behavior unless the `MaybeUninit` is initialized. + /// Get a pointer to the contained value. Reading from this pointer or turning it + /// into a reference will be undefined behavior unless the `MaybeUninit` is initialized. #[unstable(feature = "maybe_uninit", issue = "53491")] #[inline(always)] pub fn as_ptr(&self) -> *const T { unsafe { &*self.value as *const T } } - /// Get a mutable pointer to the contained value. Reading from this pointer will be undefined - /// behavior unless the `MaybeUninit` is initialized. + /// Get a mutable pointer to the contained value. Reading from this pointer or turning it + /// into a reference will be undefined behavior unless the `MaybeUninit` is initialized. #[unstable(feature = "maybe_uninit", issue = "53491")] #[inline(always)] pub fn as_mut_ptr(&mut self) -> *mut T { From f8c7d8dc8e8f779e6468e83f79456ed1916a93d7 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 3 Feb 2019 22:14:14 +0100 Subject: [PATCH 048/278] make set return a mutable reference --- src/libcore/mem.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index 3348e774a0b7a..4712df1fa7cd2 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -1117,11 +1117,14 @@ impl MaybeUninit { } /// Set the value of the `MaybeUninit`. This overwrites any previous value without dropping it. + /// For your convenience, this also returns a mutable reference to the (now + /// safely initialized) content of `self`. #[unstable(feature = "maybe_uninit", issue = "53491")] #[inline(always)] - pub fn set(&mut self, val: T) { + pub fn set(&mut self, val: T) -> &mut T { unsafe { self.value = ManuallyDrop::new(val); + self.get_mut() } } From 272f4dfff6d0a6ae172e3efbef7d563ea088f6fd Mon Sep 17 00:00:00 2001 From: ljedrz Date: Sun, 3 Feb 2019 22:27:52 +0100 Subject: [PATCH 049/278] hir: remove Definitions::hir_to_def_index --- src/librustc/hir/map/definitions.rs | 25 +------------------------ src/librustc/hir/map/mod.rs | 7 ++++--- 2 files changed, 5 insertions(+), 27 deletions(-) diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs index 687daca3d3ff2..4c622adefbdb1 100644 --- a/src/librustc/hir/map/definitions.rs +++ b/src/librustc/hir/map/definitions.rs @@ -20,7 +20,7 @@ use syntax::ast; use syntax::ext::hygiene::Mark; use syntax::symbol::{Symbol, InternedString}; use syntax_pos::{Span, DUMMY_SP}; -use util::nodemap::{HirIdMap, NodeMap}; +use util::nodemap::NodeMap; /// The DefPathTable maps DefIndexes to DefKeys and vice versa. /// Internally the DefPathTable holds a tree of DefKeys, where each DefKey @@ -147,7 +147,6 @@ impl Decodable for DefPathTable { pub struct Definitions { table: DefPathTable, node_to_def_index: NodeMap, - hir_to_def_index: HirIdMap, def_index_to_node: [Vec; 2], pub(super) node_to_hir_id: IndexVec, /// If `Mark` is an ID of some macro expansion, @@ -442,34 +441,16 @@ impl Definitions { self.node_to_def_index.get(&node).cloned() } - // FIXME(@ljedrz): replace the NodeId variant - #[inline] - pub fn opt_def_index_from_hir_id(&self, hir: hir::HirId) -> Option { - self.hir_to_def_index.get(&hir).cloned() - } - #[inline] pub fn opt_local_def_id(&self, node: ast::NodeId) -> Option { self.opt_def_index(node).map(DefId::local) } - // FIXME(@ljedrz): replace the NodeId variant - #[inline] - pub fn opt_local_def_id_from_hir_id(&self, hir: hir::HirId) -> Option { - self.opt_def_index_from_hir_id(hir).map(DefId::local) - } - #[inline] pub fn local_def_id(&self, node: ast::NodeId) -> DefId { self.opt_local_def_id(node).unwrap() } - // FIXME(@ljedrz): replace the NodeId variant - #[inline] - pub fn local_def_id_from_hir_id(&self, hir: hir::HirId) -> DefId { - self.opt_local_def_id_from_hir_id(hir).unwrap() - } - #[inline] pub fn as_local_node_id(&self, def_id: DefId) -> Option { if def_id.krate == LOCAL_CRATE { @@ -549,7 +530,6 @@ impl Definitions { assert!(self.def_index_to_node[address_space.index()].is_empty()); self.def_index_to_node[address_space.index()].push(ast::CRATE_NODE_ID); self.node_to_def_index.insert(ast::CRATE_NODE_ID, root_index); - self.hir_to_def_index.insert(hir::CRATE_HIR_ID, root_index); // Allocate some other DefIndices that always must exist. GlobalMetaDataKind::allocate_def_indices(self); @@ -610,9 +590,6 @@ impl Definitions { if node_id != ast::DUMMY_NODE_ID { debug!("create_def_with_parent: def_index_to_node[{:?} <-> {:?}", index, node_id); self.node_to_def_index.insert(node_id, index); - if let Some(hir_id) = self.node_to_hir_id.get(node_id) { - self.hir_to_def_index.insert(*hir_id, index); - } } if expansion != Mark::root() { diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index c8e19c3b49260..977ab05b20932 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -252,8 +252,8 @@ impl<'hir> Map<'hir> { // FIXME(@ljedrz): replace the NodeId variant #[inline] pub fn local_def_id_from_hir_id(&self, hir_id: HirId) -> DefId { - self.opt_local_def_id_from_hir_id(hir_id).unwrap_or_else(|| { - let node_id = self.hir_to_node_id(hir_id); + let node_id = self.hir_to_node_id(hir_id); + self.opt_local_def_id(node_id).unwrap_or_else(|| { bug!("local_def_id_from_hir_id: no entry for `{:?}`, which has a map of `{:?}`", hir_id, self.find_entry(node_id)) }) @@ -262,7 +262,8 @@ impl<'hir> Map<'hir> { // FIXME(@ljedrz): replace the NodeId variant #[inline] pub fn opt_local_def_id_from_hir_id(&self, hir_id: HirId) -> Option { - self.definitions.opt_local_def_id_from_hir_id(hir_id) + let node_id = self.hir_to_node_id(hir_id); + self.definitions.opt_local_def_id(node_id) } #[inline] From 4ae8abab9369357a0e5cabd66673ad3d4af307b1 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Mon, 4 Feb 2019 00:56:16 +0900 Subject: [PATCH 050/278] Transition libtest to 2018 edition --- src/libtest/Cargo.toml | 1 + src/libtest/formatters/json.rs | 2 +- src/libtest/lib.rs | 33 +++++++++++++++++---------------- src/libtest/stats.rs | 6 +++--- 4 files changed, 22 insertions(+), 20 deletions(-) diff --git a/src/libtest/Cargo.toml b/src/libtest/Cargo.toml index aade10ed6c324..10bdd6e877c4f 100644 --- a/src/libtest/Cargo.toml +++ b/src/libtest/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "test" version = "0.0.0" +edition = "2018" [lib] name = "test" diff --git a/src/libtest/formatters/json.rs b/src/libtest/formatters/json.rs index cc1568265c02e..a06497f98626a 100644 --- a/src/libtest/formatters/json.rs +++ b/src/libtest/formatters/json.rs @@ -145,7 +145,7 @@ impl OutputFormatter for JsonFormatter { struct EscapedString>(S); impl> ::std::fmt::Display for EscapedString { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { let mut start = 0; for (i, byte) in self.0.as_ref().bytes().enumerate() { diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index c8eceeeaa5a81..b3d719d5c64db 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -17,6 +17,7 @@ // this crate, which relies on this attribute (rather than the value of `--crate-name` passed by // cargo) to detect this crate. +#![deny(rust_2018_idioms)] #![crate_name = "test"] #![unstable(feature = "test", issue = "27812")] #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -32,10 +33,10 @@ #![feature(termination_trait_lib)] #![feature(test)] -extern crate getopts; +use getopts; #[cfg(any(unix, target_os = "cloudabi"))] extern crate libc; -extern crate term; +use term; // FIXME(#54291): rustc and/or LLVM don't yet support building with panic-unwind // on aarch64-pc-windows-msvc, so we don't link libtest against @@ -78,7 +79,7 @@ const QUIET_MODE_MAX_COLUMN: usize = 100; // insert a '\n' after 100 tests in qu // to be used by rustc to compile tests in libtest pub mod test { - pub use {assert_test_result, filter_tests, parse_opts, run_test, test_main, test_main_static, + pub use crate::{assert_test_result, filter_tests, parse_opts, run_test, test_main, test_main_static, Bencher, DynTestFn, DynTestName, Metric, MetricMap, Options, RunIgnored, ShouldPanic, StaticBenchFn, StaticTestFn, StaticTestName, TestDesc, TestDescAndFn, TestName, TestOpts, TestResult, TrFailed, TrFailedMsg, TrIgnored, TrOk}; @@ -87,7 +88,7 @@ pub mod test { pub mod stats; mod formatters; -use formatters::{JsonFormatter, OutputFormatter, PrettyFormatter, TerseFormatter}; +use crate::formatters::{JsonFormatter, OutputFormatter, PrettyFormatter, TerseFormatter}; /// Whether to execute tests concurrently or not #[derive(Copy, Clone, Debug, PartialEq, Eq)] @@ -131,7 +132,7 @@ impl TestName { } } impl fmt::Display for TestName { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(self.as_slice(), f) } } @@ -185,7 +186,7 @@ impl TestFn { } impl fmt::Debug for TestFn { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(match *self { StaticTestFn(..) => "StaticTestFn(..)", StaticBenchFn(..) => "StaticBenchFn(..)", @@ -823,7 +824,7 @@ pub fn list_tests_console(opts: &TestOpts, tests: Vec) -> io::Res let mut nbench = 0; for test in filter_tests(&opts, tests) { - use TestFn::*; + use crate::TestFn::*; let TestDescAndFn { desc: TestDesc { name, .. }, @@ -1454,12 +1455,12 @@ pub fn run_test( match testfn { DynBenchFn(bencher) => { - ::bench::benchmark(desc, monitor_ch, opts.nocapture, |harness| { + crate::bench::benchmark(desc, monitor_ch, opts.nocapture, |harness| { bencher.run(harness) }); } StaticBenchFn(benchfn) => { - ::bench::benchmark(desc, monitor_ch, opts.nocapture, |harness| { + crate::bench::benchmark(desc, monitor_ch, opts.nocapture, |harness| { (benchfn.clone())(harness) }); } @@ -1673,7 +1674,7 @@ pub mod bench { use std::cmp; use std::io; use std::sync::{Arc, Mutex}; - use stats; + use crate::stats; use super::{BenchMode, BenchSamples, Bencher, MonitorMsg, Sender, Sink, TestDesc, TestResult}; pub fn benchmark(desc: TestDesc, monitor_ch: Sender, nocapture: bool, f: F) @@ -1749,13 +1750,13 @@ pub mod bench { #[cfg(test)] mod tests { - use test::{filter_tests, parse_opts, run_test, DynTestFn, DynTestName, MetricMap, RunIgnored, + use crate::test::{filter_tests, parse_opts, run_test, DynTestFn, DynTestName, MetricMap, RunIgnored, ShouldPanic, StaticTestName, TestDesc, TestDescAndFn, TestOpts, TrFailed, TrFailedMsg, TrIgnored, TrOk}; use std::sync::mpsc::channel; - use bench; - use Bencher; - use Concurrent; + use crate::bench; + use crate::Bencher; + use crate::Concurrent; fn one_ignored_one_unignored_test() -> Vec { @@ -2156,7 +2157,7 @@ mod tests { allow_fail: false, }; - ::bench::benchmark(desc, tx, true, f); + crate::bench::benchmark(desc, tx, true, f); rx.recv().unwrap(); } @@ -2175,7 +2176,7 @@ mod tests { allow_fail: false, }; - ::bench::benchmark(desc, tx, true, f); + crate::bench::benchmark(desc, tx, true, f); rx.recv().unwrap(); } } diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index 9fc5f09ba6c92..5c9421d5ea4b0 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -319,8 +319,8 @@ pub fn winsorize(samples: &mut [f64], pct: f64) { #[cfg(test)] mod tests { - use stats::Stats; - use stats::Summary; + use crate::stats::Stats; + use crate::stats::Summary; use std::f64; use std::io::prelude::*; use std::io; @@ -899,7 +899,7 @@ mod tests { mod bench { extern crate test; use self::test::Bencher; - use stats::Stats; + use crate::stats::Stats; #[bench] pub fn sum_three_items(b: &mut Bencher) { From 3c6787306d6b7a45e3b76f18ce543be700fb3c00 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Mon, 4 Feb 2019 08:22:30 +0900 Subject: [PATCH 051/278] Excute rustfmt for fixing tidy check --- src/libtest/lib.rs | 141 +++++++++++++++++++++++++++------------------ 1 file changed, 86 insertions(+), 55 deletions(-) diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index b3d719d5c64db..cced66f4a22bd 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -20,9 +20,12 @@ #![deny(rust_2018_idioms)] #![crate_name = "test"] #![unstable(feature = "test", issue = "27812")] -#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", - html_favicon_url = "https://doc.rust-lang.org/favicon.ico", - html_root_url = "https://doc.rust-lang.org/nightly/", test(attr(deny(warnings))))] +#![doc( + html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", + html_favicon_url = "https://doc.rust-lang.org/favicon.ico", + html_root_url = "https://doc.rust-lang.org/nightly/", + test(attr(deny(warnings))) +)] #![feature(asm)] #![feature(fnbox)] #![cfg_attr(any(unix, target_os = "cloudabi"), feature(libc, rustc_private))] @@ -47,52 +50,57 @@ use term; #[cfg(not(all(windows, target_arch = "aarch64")))] extern crate panic_unwind; -pub use self::TestFn::*; pub use self::ColorConfig::*; -pub use self::TestResult::*; -pub use self::TestName::*; -use self::TestEvent::*; use self::NamePadding::*; use self::OutputLocation::*; +use self::TestEvent::*; +pub use self::TestFn::*; +pub use self::TestName::*; +pub use self::TestResult::*; -use std::panic::{catch_unwind, AssertUnwindSafe}; use std::any::Any; +use std::borrow::Cow; use std::boxed::FnBox; use std::cmp; use std::collections::BTreeMap; use std::env; use std::fmt; use std::fs::File; -use std::io::prelude::*; use std::io; +use std::io::prelude::*; +use std::panic::{catch_unwind, AssertUnwindSafe}; use std::path::PathBuf; +use std::process; use std::process::Termination; use std::sync::mpsc::{channel, Sender}; use std::sync::{Arc, Mutex}; use std::thread; use std::time::{Duration, Instant}; -use std::borrow::Cow; -use std::process; const TEST_WARN_TIMEOUT_S: u64 = 60; const QUIET_MODE_MAX_COLUMN: usize = 100; // insert a '\n' after 100 tests in quiet mode // to be used by rustc to compile tests in libtest pub mod test { - pub use crate::{assert_test_result, filter_tests, parse_opts, run_test, test_main, test_main_static, - Bencher, DynTestFn, DynTestName, Metric, MetricMap, Options, RunIgnored, ShouldPanic, - StaticBenchFn, StaticTestFn, StaticTestName, TestDesc, TestDescAndFn, TestName, - TestOpts, TestResult, TrFailed, TrFailedMsg, TrIgnored, TrOk}; + pub use crate::{ + assert_test_result, filter_tests, parse_opts, run_test, test_main, test_main_static, + Bencher, DynTestFn, DynTestName, Metric, MetricMap, Options, RunIgnored, ShouldPanic, + StaticBenchFn, StaticTestFn, StaticTestName, TestDesc, TestDescAndFn, TestName, TestOpts, + TestResult, TrFailed, TrFailedMsg, TrIgnored, TrOk, + }; } -pub mod stats; mod formatters; +pub mod stats; use crate::formatters::{JsonFormatter, OutputFormatter, PrettyFormatter, TerseFormatter}; /// Whether to execute tests concurrently or not #[derive(Copy, Clone, Debug, PartialEq, Eq)] -pub enum Concurrent { Yes, No } +pub enum Concurrent { + Yes, + No, +} // The name of a test. By convention this follows the rules for rust // paths; i.e., it should be a series of identifiers separated by double @@ -330,8 +338,7 @@ pub fn test_main_static(tests: &[&TestDescAndFn]) { pub fn assert_test_result(result: T) { let code = result.report(); assert_eq!( - code, - 0, + code, 0, "the test returned a termination value with a non-zero status code ({}) \ which indicates a failure", code @@ -559,14 +566,16 @@ pub fn parse_opts(args: &[String]) -> Option { let include_ignored = matches.opt_present("include-ignored"); if !allow_unstable && include_ignored { return Some(Err( - "The \"include-ignored\" flag is only accepted on the nightly compiler".into() + "The \"include-ignored\" flag is only accepted on the nightly compiler".into(), )); } let run_ignored = match (include_ignored, matches.opt_present("ignored")) { - (true, true) => return Some(Err( - "the options --include-ignored and --ignored are mutually exclusive".into() - )), + (true, true) => { + return Some(Err( + "the options --include-ignored and --ignored are mutually exclusive".into(), + )); + } (true, false) => RunIgnored::Yes, (false, true) => RunIgnored::Only, (false, false) => RunIgnored::No, @@ -598,7 +607,7 @@ pub fn parse_opts(args: &[String]) -> Option { "argument for --test-threads must be a number > 0 \ (error: {})", e - ))) + ))); } }, None => None, @@ -614,7 +623,7 @@ pub fn parse_opts(args: &[String]) -> Option { "argument for --color must be auto, always, or never (was \ {})", v - ))) + ))); } }; @@ -636,7 +645,7 @@ pub fn parse_opts(args: &[String]) -> Option { "argument for --format must be pretty, terse, or json (was \ {})", v - ))) + ))); } }; @@ -1013,10 +1022,12 @@ fn use_color(opts: &TestOpts) -> bool { } } -#[cfg(any(target_os = "cloudabi", - target_os = "redox", - all(target_arch = "wasm32", not(target_os = "emscripten")), - all(target_vendor = "fortanix", target_env = "sgx")))] +#[cfg(any( + target_os = "cloudabi", + target_os = "redox", + all(target_arch = "wasm32", not(target_os = "emscripten")), + all(target_vendor = "fortanix", target_env = "sgx") +))] fn stdout_isatty() -> bool { // FIXME: Implement isatty on Redox and SGX false @@ -1247,21 +1258,34 @@ fn get_concurrency() -> usize { 1 } - #[cfg(any(all(target_arch = "wasm32", not(target_os = "emscripten")), - all(target_vendor = "fortanix", target_env = "sgx")))] + #[cfg(any( + all(target_arch = "wasm32", not(target_os = "emscripten")), + all(target_vendor = "fortanix", target_env = "sgx") + ))] fn num_cpus() -> usize { 1 } - #[cfg(any(target_os = "android", target_os = "cloudabi", target_os = "emscripten", - target_os = "fuchsia", target_os = "ios", target_os = "linux", - target_os = "macos", target_os = "solaris"))] + #[cfg(any( + target_os = "android", + target_os = "cloudabi", + target_os = "emscripten", + target_os = "fuchsia", + target_os = "ios", + target_os = "linux", + target_os = "macos", + target_os = "solaris" + ))] fn num_cpus() -> usize { unsafe { libc::sysconf(libc::_SC_NPROCESSORS_ONLN) as usize } } - #[cfg(any(target_os = "freebsd", target_os = "dragonfly", target_os = "bitrig", - target_os = "netbsd"))] + #[cfg(any( + target_os = "freebsd", + target_os = "dragonfly", + target_os = "bitrig", + target_os = "netbsd" + ))] fn num_cpus() -> usize { use std::ptr; @@ -1344,18 +1368,20 @@ pub fn filter_tests(opts: &TestOpts, tests: Vec) -> Vec { - filtered.iter_mut().for_each(|test| test.desc.ignore = false); - }, + filtered + .iter_mut() + .for_each(|test| test.desc.ignore = false); + } RunIgnored::Only => { filtered.retain(|test| test.desc.ignore); - filtered.iter_mut().for_each(|test| test.desc.ignore = false); + filtered + .iter_mut() + .for_each(|test| test.desc.ignore = false); } RunIgnored::No => {} } @@ -1397,7 +1423,8 @@ pub fn run_test( ) { let TestDescAndFn { desc, testfn } = test; - let ignore_because_panic_abort = cfg!(target_arch = "wasm32") && !cfg!(target_os = "emscripten") + let ignore_because_panic_abort = cfg!(target_arch = "wasm32") + && !cfg!(target_os = "emscripten") && desc.should_panic != ShouldPanic::No; if force_ignore || desc.ignore || ignore_because_panic_abort { @@ -1488,7 +1515,8 @@ fn calc_result(desc: &TestDesc, task_result: Result<(), Box>) -> match (&desc.should_panic, task_result) { (&ShouldPanic::No, Ok(())) | (&ShouldPanic::Yes, Err(_)) => TrOk, (&ShouldPanic::YesWithMessage(msg), Err(ref err)) => { - if err.downcast_ref::() + if err + .downcast_ref::() .map(|e| &**e) .or_else(|| err.downcast_ref::<&'static str>().map(|e| *e)) .map(|e| e.contains(msg)) @@ -1535,7 +1563,8 @@ impl MetricMap { } pub fn fmt_metrics(&self) -> String { - let v = self.0 + let v = self + .0 .iter() .map(|(k, v)| format!("{}: {} (+/- {})", *k, v.value, v.noise)) .collect::>(); @@ -1644,7 +1673,8 @@ where // If we've run for 100ms and seem to have converged to a // stable median. - if loop_run > Duration::from_millis(100) && summ.median_abs_dev_pct < 1.0 + if loop_run > Duration::from_millis(100) + && summ.median_abs_dev_pct < 1.0 && summ.median - summ5.median < summ5.median_abs_dev { return summ5; @@ -1670,12 +1700,12 @@ where } pub mod bench { - use std::panic::{catch_unwind, AssertUnwindSafe}; + use super::{BenchMode, BenchSamples, Bencher, MonitorMsg, Sender, Sink, TestDesc, TestResult}; + use crate::stats; use std::cmp; use std::io; + use std::panic::{catch_unwind, AssertUnwindSafe}; use std::sync::{Arc, Mutex}; - use crate::stats; - use super::{BenchMode, BenchSamples, Bencher, MonitorMsg, Sender, Sink, TestDesc, TestResult}; pub fn benchmark(desc: TestDesc, monitor_ch: Sender, nocapture: bool, f: F) where @@ -1750,14 +1780,15 @@ pub mod bench { #[cfg(test)] mod tests { - use crate::test::{filter_tests, parse_opts, run_test, DynTestFn, DynTestName, MetricMap, RunIgnored, - ShouldPanic, StaticTestName, TestDesc, TestDescAndFn, TestOpts, TrFailed, - TrFailedMsg, TrIgnored, TrOk}; - use std::sync::mpsc::channel; use crate::bench; + use crate::test::{ + filter_tests, parse_opts, run_test, DynTestFn, DynTestName, MetricMap, RunIgnored, + ShouldPanic, StaticTestName, TestDesc, TestDescAndFn, TestOpts, TrFailed, TrFailedMsg, + TrIgnored, TrOk, + }; use crate::Bencher; use crate::Concurrent; - + use std::sync::mpsc::channel; fn one_ignored_one_unignored_test() -> Vec { vec![ From fab032a01dd38693834f54ec424f30f6d9e3aace Mon Sep 17 00:00:00 2001 From: Philipp Hansch Date: Sun, 3 Feb 2019 10:12:47 +0100 Subject: [PATCH 052/278] Transition compiletest to Rust 2018 --- src/tools/compiletest/Cargo.toml | 1 + src/tools/compiletest/src/common.rs | 4 ++-- src/tools/compiletest/src/errors.rs | 2 +- src/tools/compiletest/src/header.rs | 6 ++--- src/tools/compiletest/src/json.rs | 4 ++-- src/tools/compiletest/src/main.rs | 22 +++++++----------- src/tools/compiletest/src/read2.rs | 11 ++++----- src/tools/compiletest/src/runtest.rs | 34 ++++++++++++++-------------- src/tools/compiletest/src/util.rs | 2 +- 9 files changed, 39 insertions(+), 47 deletions(-) diff --git a/src/tools/compiletest/Cargo.toml b/src/tools/compiletest/Cargo.toml index edf4aeab1c70f..00e1a53473cda 100644 --- a/src/tools/compiletest/Cargo.toml +++ b/src/tools/compiletest/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "compiletest" version = "0.0.0" +edition = "2018" [dependencies] diff = "0.1.10" diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs index f6f8ef1dff485..42afb72c91f39 100644 --- a/src/tools/compiletest/src/common.rs +++ b/src/tools/compiletest/src/common.rs @@ -5,7 +5,7 @@ use std::path::{Path, PathBuf}; use std::str::FromStr; use test::ColorConfig; -use util::PathBufExt; +use crate::util::PathBufExt; #[derive(Clone, Copy, PartialEq, Debug)] pub enum Mode { @@ -66,7 +66,7 @@ impl FromStr for Mode { } impl fmt::Display for Mode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let s = match *self { CompileFail => "compile-fail", RunFail => "run-fail", diff --git a/src/tools/compiletest/src/errors.rs b/src/tools/compiletest/src/errors.rs index fd3f002fb6682..0329fb0db1422 100644 --- a/src/tools/compiletest/src/errors.rs +++ b/src/tools/compiletest/src/errors.rs @@ -33,7 +33,7 @@ impl FromStr for ErrorKind { } impl fmt::Display for ErrorKind { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match *self { ErrorKind::Help => write!(f, "help message"), ErrorKind::Error => write!(f, "error"), diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs index 591d92f0cfa14..80a015d7aea56 100644 --- a/src/tools/compiletest/src/header.rs +++ b/src/tools/compiletest/src/header.rs @@ -4,10 +4,10 @@ use std::io::prelude::*; use std::io::BufReader; use std::path::{Path, PathBuf}; -use common::{self, CompareMode, Config, Mode}; -use util; +use crate::common::{self, CompareMode, Config, Mode}; +use crate::util; -use extract_gdb_version; +use crate::extract_gdb_version; /// Whether to ignore the test. #[derive(Clone, Copy, PartialEq, Debug)] diff --git a/src/tools/compiletest/src/json.rs b/src/tools/compiletest/src/json.rs index 106aa67157a42..12aae303f29aa 100644 --- a/src/tools/compiletest/src/json.rs +++ b/src/tools/compiletest/src/json.rs @@ -1,5 +1,5 @@ -use errors::{Error, ErrorKind}; -use runtest::ProcRes; +use crate::errors::{Error, ErrorKind}; +use crate::runtest::ProcRes; use serde_json; use std::path::Path; use std::str::FromStr; diff --git a/src/tools/compiletest/src/main.rs b/src/tools/compiletest/src/main.rs index 15d53f1e3755c..1f9b4b2ad4363 100644 --- a/src/tools/compiletest/src/main.rs +++ b/src/tools/compiletest/src/main.rs @@ -1,29 +1,21 @@ #![crate_name = "compiletest"] #![feature(test)] -#![deny(warnings)] +#![deny(warnings, rust_2018_idioms)] -extern crate diff; -extern crate env_logger; -extern crate filetime; -extern crate getopts; #[cfg(unix)] extern crate libc; #[macro_use] extern crate log; -extern crate regex; #[macro_use] extern crate lazy_static; #[macro_use] extern crate serde_derive; -extern crate serde_json; extern crate test; -extern crate rustfix; -extern crate walkdir; -use common::CompareMode; -use common::{expected_output_path, output_base_dir, output_relative_path, UI_EXTENSIONS}; -use common::{Config, TestPaths}; -use common::{DebugInfoBoth, DebugInfoGdb, DebugInfoLldb, Mode, Pretty}; +use crate::common::CompareMode; +use crate::common::{expected_output_path, output_base_dir, output_relative_path, UI_EXTENSIONS}; +use crate::common::{Config, TestPaths}; +use crate::common::{DebugInfoBoth, DebugInfoGdb, DebugInfoLldb, Mode, Pretty}; use filetime::FileTime; use getopts::Options; use std::env; @@ -33,8 +25,10 @@ use std::io::{self, ErrorKind}; use std::path::{Path, PathBuf}; use std::process::Command; use test::ColorConfig; -use util::logv; +use crate::util::logv; use walkdir::WalkDir; +use env_logger; +use getopts; use self::header::{EarlyProps, Ignore}; diff --git a/src/tools/compiletest/src/read2.rs b/src/tools/compiletest/src/read2.rs index 5a4caddcdd319..6dfd8e97c636d 100644 --- a/src/tools/compiletest/src/read2.rs +++ b/src/tools/compiletest/src/read2.rs @@ -100,18 +100,15 @@ mod imp { #[cfg(windows)] mod imp { - extern crate miow; - extern crate winapi; - use std::io; use std::os::windows::prelude::*; use std::process::{ChildStderr, ChildStdout}; use std::slice; - use self::miow::iocp::{CompletionPort, CompletionStatus}; - use self::miow::pipe::NamedPipe; - use self::miow::Overlapped; - use self::winapi::shared::winerror::ERROR_BROKEN_PIPE; + use miow::iocp::{CompletionPort, CompletionStatus}; + use miow::pipe::NamedPipe; + use miow::Overlapped; + use winapi::shared::winerror::ERROR_BROKEN_PIPE; struct Pipe<'a> { dst: &'a mut Vec, diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs index ff201b03a0bdc..31529810a04db 100644 --- a/src/tools/compiletest/src/runtest.rs +++ b/src/tools/compiletest/src/runtest.rs @@ -1,18 +1,18 @@ -use common::CompareMode; -use common::{expected_output_path, UI_EXTENSIONS, UI_FIXED, UI_STDERR, UI_STDOUT}; -use common::{output_base_dir, output_base_name, output_testname_unique}; -use common::{Codegen, CodegenUnits, DebugInfoBoth, DebugInfoGdb, DebugInfoLldb, Rustdoc}; -use common::{CompileFail, Pretty, RunFail, RunPass, RunPassValgrind}; -use common::{Config, TestPaths}; -use common::{Incremental, MirOpt, RunMake, Ui}; +use crate::common::CompareMode; +use crate::common::{expected_output_path, UI_EXTENSIONS, UI_FIXED, UI_STDERR, UI_STDOUT}; +use crate::common::{output_base_dir, output_base_name, output_testname_unique}; +use crate::common::{Codegen, CodegenUnits, DebugInfoBoth, DebugInfoGdb, DebugInfoLldb, Rustdoc}; +use crate::common::{CompileFail, Pretty, RunFail, RunPass, RunPassValgrind}; +use crate::common::{Config, TestPaths}; +use crate::common::{Incremental, MirOpt, RunMake, Ui}; use diff; -use errors::{self, Error, ErrorKind}; +use crate::errors::{self, Error, ErrorKind}; use filetime::FileTime; -use header::TestProps; -use json; +use crate::header::TestProps; +use crate::json; use regex::Regex; use rustfix::{apply_suggestions, get_suggestions_from_json, Filter}; -use util::{logv, PathBufExt}; +use crate::util::{logv, PathBufExt}; use std::collections::hash_map::DefaultHasher; use std::collections::{HashMap, HashSet, VecDeque}; @@ -27,8 +27,8 @@ use std::path::{Path, PathBuf}; use std::process::{Child, Command, ExitStatus, Output, Stdio}; use std::str; -use extract_gdb_version; -use is_android_gdb_target; +use crate::extract_gdb_version; +use crate::is_android_gdb_target; #[cfg(windows)] fn disable_error_reporting R, R>(f: F) -> R { @@ -1937,7 +1937,7 @@ impl<'test> TestCx<'test> { } fn make_cmdline(&self, command: &Command, libpath: &str) -> String { - use util; + use crate::util; // Linux and mac don't require adjusting the library search path if cfg!(unix) { @@ -3255,7 +3255,7 @@ impl<'test> TestCx<'test> { } fn create_stamp(&self) { - let stamp = ::stamp(&self.config, self.testpaths, self.revision); + let stamp = crate::stamp(&self.config, self.testpaths, self.revision); fs::write(&stamp, compute_stamp_hash(&self.config)).unwrap(); } } @@ -3311,7 +3311,7 @@ impl fmt::Debug for ExpectedLine where T: AsRef + fmt::Debug, { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { if let &ExpectedLine::Text(ref t) = self { write!(formatter, "{:?}", t) } else { @@ -3334,7 +3334,7 @@ fn nocomment_mir_line(line: &str) -> &str { } fn read2_abbreviated(mut child: Child) -> io::Result { - use read2::read2; + use crate::read2::read2; use std::mem::replace; const HEAD_LEN: usize = 160 * 1024; diff --git a/src/tools/compiletest/src/util.rs b/src/tools/compiletest/src/util.rs index 90dfadeee4612..85be2fed07567 100644 --- a/src/tools/compiletest/src/util.rs +++ b/src/tools/compiletest/src/util.rs @@ -1,7 +1,7 @@ use std::ffi::OsStr; use std::env; use std::path::PathBuf; -use common::Config; +use crate::common::Config; /// Conversion table from triple OS name to Rust SYSNAME const OS_TABLE: &'static [(&'static str, &'static str)] = &[ From 27c8dfddac4c69a6fd399abe537e1007306c58cf Mon Sep 17 00:00:00 2001 From: Austin Bonander Date: Sun, 3 Feb 2019 22:38:43 -0800 Subject: [PATCH 053/278] Improve error message and docs for non-UTF-8 bytes in stdio on Windows cc #23344 --- src/libstd/io/stdio.rs | 45 +++++++++++++++++++++++++++++++++ src/libstd/sys/windows/stdio.rs | 4 ++- 2 files changed, 48 insertions(+), 1 deletion(-) diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs index d249469323063..4068c0f9c7de5 100644 --- a/src/libstd/io/stdio.rs +++ b/src/libstd/io/stdio.rs @@ -131,6 +131,11 @@ fn handle_ebadf(r: io::Result, default: T) -> io::Result { /// /// [`io::stdin`]: fn.stdin.html /// [`BufRead`]: trait.BufRead.html +/// +/// ### Note: Windows Portability Consideration +/// When operating in a console, the Windows implementation of this stream does not support +/// non-UTF-8 byte sequences. Attempting to read bytes that are not valid UTF-8 will return +/// an error. #[stable(feature = "rust1", since = "1.0.0")] pub struct Stdin { inner: Arc>>>, @@ -144,6 +149,11 @@ pub struct Stdin { /// [`Read`]: trait.Read.html /// [`BufRead`]: trait.BufRead.html /// [`Stdin::lock`]: struct.Stdin.html#method.lock +/// +/// ### Note: Windows Portability Consideration +/// When operating in a console, the Windows implementation of this stream does not support +/// non-UTF-8 byte sequences. Attempting to read bytes that are not valid UTF-8 will return +/// an error. #[stable(feature = "rust1", since = "1.0.0")] pub struct StdinLock<'a> { inner: MutexGuard<'a, BufReader>>, @@ -157,6 +167,11 @@ pub struct StdinLock<'a> { /// /// [lock]: struct.Stdin.html#method.lock /// +/// ### Note: Windows Portability Consideration +/// When operating in a console, the Windows implementation of this stream does not support +/// non-UTF-8 byte sequences. Attempting to read bytes that are not valid UTF-8 will return +/// an error. +/// /// # Examples /// /// Using implicit synchronization: @@ -328,6 +343,11 @@ impl<'a> fmt::Debug for StdinLock<'a> { /// /// Created by the [`io::stdout`] method. /// +/// ### Note: Windows Portability Consideration +/// When operating in a console, the Windows implementation of this stream does not support +/// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return +/// an error. +/// /// [`lock`]: #method.lock /// [`io::stdout`]: fn.stdout.html #[stable(feature = "rust1", since = "1.0.0")] @@ -343,6 +363,11 @@ pub struct Stdout { /// This handle implements the [`Write`] trait, and is constructed via /// the [`Stdout::lock`] method. /// +/// ### Note: Windows Portability Consideration +/// When operating in a console, the Windows implementation of this stream does not support +/// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return +/// an error. +/// /// [`Write`]: trait.Write.html /// [`Stdout::lock`]: struct.Stdout.html#method.lock #[stable(feature = "rust1", since = "1.0.0")] @@ -358,6 +383,11 @@ pub struct StdoutLock<'a> { /// /// [Stdout::lock]: struct.Stdout.html#method.lock /// +/// ### Note: Windows Portability Consideration +/// When operating in a console, the Windows implementation of this stream does not support +/// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return +/// an error. +/// /// # Examples /// /// Using implicit synchronization: @@ -476,6 +506,11 @@ impl<'a> fmt::Debug for StdoutLock<'a> { /// For more information, see the [`io::stderr`] method. /// /// [`io::stderr`]: fn.stderr.html +/// +/// ### Note: Windows Portability Consideration +/// When operating in a console, the Windows implementation of this stream does not support +/// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return +/// an error. #[stable(feature = "rust1", since = "1.0.0")] pub struct Stderr { inner: Arc>>>, @@ -487,6 +522,11 @@ pub struct Stderr { /// the [`Stderr::lock`] method. /// /// [`Stderr::lock`]: struct.Stderr.html#method.lock +/// +/// ### Note: Windows Portability Consideration +/// When operating in a console, the Windows implementation of this stream does not support +/// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return +/// an error. #[stable(feature = "rust1", since = "1.0.0")] pub struct StderrLock<'a> { inner: ReentrantMutexGuard<'a, RefCell>>, @@ -496,6 +536,11 @@ pub struct StderrLock<'a> { /// /// This handle is not buffered. /// +/// ### Note: Windows Portability Consideration +/// When operating in a console, the Windows implementation of this stream does not support +/// non-UTF-8 byte sequences. Attempting to write bytes that are not valid UTF-8 will return +/// an error. +/// /// # Examples /// /// Using implicit synchronization: diff --git a/src/libstd/sys/windows/stdio.rs b/src/libstd/sys/windows/stdio.rs index a4f4bd22cd921..0ea19a855257b 100644 --- a/src/libstd/sys/windows/stdio.rs +++ b/src/libstd/sys/windows/stdio.rs @@ -188,7 +188,9 @@ impl Output { } fn invalid_encoding() -> io::Error { - io::Error::new(io::ErrorKind::InvalidData, "text was not valid unicode") + io::Error::new(io::ErrorKind::InvalidData, + "Windows stdio in console mode does not support non-UTF-8 byte sequences; \ + see https://github.com/rust-lang/rust/issues/23344") } fn readconsole_input_control(wakeup_mask: c::ULONG) -> c::CONSOLE_READCONSOLE_CONTROL { From 526a398c77e7be8b437ea4b7cae06e0f3a026155 Mon Sep 17 00:00:00 2001 From: Tatsuyuki Ishi Date: Mon, 4 Feb 2019 18:04:33 +0900 Subject: [PATCH 054/278] Fix #58101 --- src/librustc/middle/stability.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 3717ee7143c55..c726885337ea8 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -765,7 +765,9 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } EvalResult::Unmarked => { - span_bug!(span, "encountered unmarked API: {:?}", def_id); + // The API could be uncallable for other reasons, for example when a private module + // was referenced. + self.sess.delay_span_bug(span, &format!("encountered unmarked API: {:?}", def_id)); } } } From 789b4d1a4f9a4c0cfbce51f0939b5ec322abca0c Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Mon, 4 Feb 2019 11:11:39 +0100 Subject: [PATCH 055/278] typos --- src/libcore/mem.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index 4712df1fa7cd2..68f985ce65202 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -1047,7 +1047,7 @@ impl DerefMut for ManuallyDrop { /// /// let x: &i32 = mem::zeroed(); // undefined behavior! /// ``` -/// This is exploitet by the compiler for various optimizations, such as eliding +/// This is exploited by the compiler for various optimizations, such as eliding /// run-time checks and optimizing `enum` layout. /// /// Not initializing memory at all (instead of 0-initializing it) causes the same @@ -1055,7 +1055,7 @@ impl DerefMut for ManuallyDrop { /// one that violates the invariant. /// /// `MaybeUninit` serves to enable unsafe code to deal with uninitialized data: -/// it is a signal to the compiler indicating that the data here may *not* +/// it is a signal to the compiler indicating that the data here might *not* /// be initialized: /// ```rust /// use std::mem::MaybeUninit; From 606e5e07f6bf73297472c41a181672133bf21f16 Mon Sep 17 00:00:00 2001 From: James Munns Date: Sat, 19 Jan 2019 04:52:39 +0100 Subject: [PATCH 056/278] Add embedded book --- .gitmodules | 3 +++ src/bootstrap/builder.rs | 1 + src/bootstrap/doc.rs | 5 +---- src/ci/docker/x86_64-gnu-tools/checktools.sh | 1 + src/doc/embedded-book | 1 + src/doc/index.md | 16 ++++++++++++++++ 6 files changed, 23 insertions(+), 4 deletions(-) create mode 160000 src/doc/embedded-book diff --git a/.gitmodules b/.gitmodules index 4e368c3ebafd8..d603e4575159d 100644 --- a/.gitmodules +++ b/.gitmodules @@ -44,3 +44,6 @@ path = src/llvm-project url = https://github.com/rust-lang/llvm-project.git branch = rustc/8.0-2019-01-16 +[submodule "src/doc/embedded-book"] + path = src/doc/embedded-book + url = https://github.com/rust-embedded/book.git \ No newline at end of file diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs index 716774632a01c..b0d15e6a5df5f 100644 --- a/src/bootstrap/builder.rs +++ b/src/bootstrap/builder.rs @@ -430,6 +430,7 @@ impl<'a> Builder<'a> { doc::RustByExample, doc::RustcBook, doc::CargoBook, + doc::EmbeddedBook, doc::EditionGuide, ), Kind::Dist => describe!( diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs index 08e97396fd68b..f1d8fca71cdf7 100644 --- a/src/bootstrap/doc.rs +++ b/src/bootstrap/doc.rs @@ -61,6 +61,7 @@ macro_rules! book { // adding a build step in `src/bootstrap/builder.rs`! book!( EditionGuide, "src/doc/edition-guide", "edition-guide", RustbookVersion::MdBook1; + EmbeddedBook, "src/doc/embedded-book", "embedded-book", RustbookVersion::MdBook2; Nomicon, "src/doc/nomicon", "nomicon", RustbookVersion::MdBook1; Reference, "src/doc/reference", "reference", RustbookVersion::MdBook1; RustByExample, "src/doc/rust-by-example", "rust-by-example", RustbookVersion::MdBook1; @@ -71,10 +72,6 @@ book!( #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] enum RustbookVersion { MdBook1, - - /// Note: Currently no books use mdBook v2, but we want the option - /// to be available - #[allow(dead_code)] MdBook2, } diff --git a/src/ci/docker/x86_64-gnu-tools/checktools.sh b/src/ci/docker/x86_64-gnu-tools/checktools.sh index 2e5b335950166..3343716419ff4 100755 --- a/src/ci/docker/x86_64-gnu-tools/checktools.sh +++ b/src/ci/docker/x86_64-gnu-tools/checktools.sh @@ -23,6 +23,7 @@ python2.7 "$X_PY" test --no-fail-fast \ src/doc/nomicon \ src/doc/reference \ src/doc/rust-by-example \ + src/doc/embedded-book \ src/tools/clippy \ src/tools/rls \ src/tools/rustfmt \ diff --git a/src/doc/embedded-book b/src/doc/embedded-book new file mode 160000 index 0000000000000..36bc507044a95 --- /dev/null +++ b/src/doc/embedded-book @@ -0,0 +1 @@ +Subproject commit 36bc507044a9596df426e67e2e1685a3ed6e3c60 diff --git a/src/doc/index.md b/src/doc/index.md index 7bd1854d86f40..7a240ac0a42a5 100644 --- a/src/doc/index.md +++ b/src/doc/index.md @@ -117,3 +117,19 @@ Rust. It's also sometimes called "the 'nomicon." [The `rustc` Guide](https://rust-lang.github.io/rustc-guide/) documents how the compiler works and how to contribute to it. This is useful if you want to build or modify the Rust compiler from source (e.g. to target something non-standard). + +# Specialize Rust + +When using Rust in specific domain areas, consider using the following resources tailored to each domain. + +## Embedded Systems + +When developing for Bare Metal or Embedded Linux systems, you may find these resources maintained by the [Embedded Working Group] useful. + +[Embedded Working Group]: https://github.com/rust-embedded + +### The Embedded Rust Book + +[The Embedded Rust Book] is targeted at developers familiar with embedded development and familiar with Rust, but have not used Rust for embedded development. + +[The Embedded Rust Book]: embedded-book/index.html From e3bbd67110e977a0f17b5d9009b86563826e5df4 Mon Sep 17 00:00:00 2001 From: lukaslueg Date: Mon, 4 Feb 2019 11:21:39 +0100 Subject: [PATCH 057/278] Remove weasel word in docs for iter's take_while() The phrase "... or some similar thing." is very vague and contributes nothing to understanding the example. Simply removed. --- src/libcore/iter/traits/iterator.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/libcore/iter/traits/iterator.rs b/src/libcore/iter/traits/iterator.rs index 9dfa83f473baf..218c7199f35a6 100644 --- a/src/libcore/iter/traits/iterator.rs +++ b/src/libcore/iter/traits/iterator.rs @@ -952,8 +952,7 @@ pub trait Iterator { /// ``` /// /// The `3` is no longer there, because it was consumed in order to see if - /// the iteration should stop, but wasn't placed back into the iterator or - /// some similar thing. + /// the iteration should stop, but wasn't placed back into the iterator. #[inline] #[stable(feature = "rust1", since = "1.0.0")] fn take_while
    {}
    ", ret)); +
    {}
    ", ret.join(""))); } } @@ -4502,40 +4504,47 @@ fn sidebar_assoc_items(it: &clean::Item) -> String { impl_.inner_impl().trait_.as_ref().unwrap())), Escape(&format!("{:#}", target)))); out.push_str(""); - let ret = impls.iter() - .filter(|i| i.inner_impl().trait_.is_none()) - .flat_map(|i| get_methods(i.inner_impl(), - true, - &mut used_links)) - .collect::(); - out.push_str(&format!("
    {}
    ", ret)); + let mut ret = impls.iter() + .filter(|i| i.inner_impl().trait_.is_none()) + .flat_map(|i| get_methods(i.inner_impl(), + true, + &mut used_links)) + .collect::>(); + // We want links' order to be reproducible so we don't use unstable sort. + ret.sort(); + if !ret.is_empty() { + out.push_str(&format!("
    {}
    ", + ret.join(""))); + } } } } let format_impls = |impls: Vec<&Impl>| { let mut links = FxHashSet::default(); - impls.iter() - .filter_map(|i| { - let is_negative_impl = is_negative_impl(i.inner_impl()); - if let Some(ref i) = i.inner_impl().trait_ { - let i_display = format!("{:#}", i); - let out = Escape(&i_display); - let encoded = small_url_encode(&format!("{:#}", i)); - let generated = format!("{}{}", - encoded, - if is_negative_impl { "!" } else { "" }, - out); - if links.insert(generated.clone()) { - Some(generated) - } else { - None - } - } else { - None - } - }) - .collect::() + let mut ret = impls.iter() + .filter_map(|i| { + let is_negative_impl = is_negative_impl(i.inner_impl()); + if let Some(ref i) = i.inner_impl().trait_ { + let i_display = format!("{:#}", i); + let out = Escape(&i_display); + let encoded = small_url_encode(&format!("{:#}", i)); + let generated = format!("{}{}", + encoded, + if is_negative_impl { "!" } else { "" }, + out); + if links.insert(generated.clone()) { + Some(generated) + } else { + None + } + } else { + None + } + }) + .collect::>(); + ret.sort(); + ret.join("") }; let (synthetic, concrete): (Vec<&Impl>, Vec<&Impl>) = v @@ -4637,29 +4646,29 @@ fn sidebar_trait(fmt: &mut fmt::Formatter, it: &clean::Item, } }) .collect::(); - let required = t.items - .iter() - .filter_map(|m| { - match m.name { - Some(ref name) if m.is_ty_method() => { - Some(format!("{name}", - name=name)) + let mut required = t.items + .iter() + .filter_map(|m| { + match m.name { + Some(ref name) if m.is_ty_method() => { + Some(format!("{name}", + name=name)) + } + _ => None, } - _ => None, - } - }) - .collect::(); - let provided = t.items - .iter() - .filter_map(|m| { - match m.name { - Some(ref name) if m.is_method() => { - Some(format!("{name}", name=name)) + }) + .collect::>(); + let mut provided = t.items + .iter() + .filter_map(|m| { + match m.name { + Some(ref name) if m.is_method() => { + Some(format!("{0}", name)) + } + _ => None, } - _ => None, - } - }) - .collect::(); + }) + .collect::>(); if !types.is_empty() { sidebar.push_str(&format!("\ @@ -4672,38 +4681,41 @@ fn sidebar_trait(fmt: &mut fmt::Formatter, it: &clean::Item, consts)); } if !required.is_empty() { + required.sort(); sidebar.push_str(&format!("\ Required Methods
    {}
    ", - required)); + required.join(""))); } if !provided.is_empty() { + provided.sort(); sidebar.push_str(&format!("\ Provided Methods
    {}
    ", - provided)); + provided.join(""))); } let c = cache(); if let Some(implementors) = c.implementors.get(&it.def_id) { - let res = implementors.iter() - .filter(|i| i.inner_impl().for_.def_id() - .map_or(false, |d| !c.paths.contains_key(&d))) - .filter_map(|i| { - match extract_for_impl_name(&i.impl_item) { - Some((ref name, ref url)) => { - Some(format!("{}", - small_url_encode(url), - Escape(name))) + let mut res = implementors.iter() + .filter(|i| i.inner_impl().for_.def_id() + .map_or(false, |d| !c.paths.contains_key(&d))) + .filter_map(|i| { + match extract_for_impl_name(&i.impl_item) { + Some((ref name, ref url)) => { + Some(format!("{}", + small_url_encode(url), + Escape(name))) + } + _ => None, } - _ => None, - } - }) - .collect::(); + }) + .collect::>(); if !res.is_empty() { + res.sort(); sidebar.push_str(&format!("\ Implementations on Foreign Types
    {}
    ", - res)); + res.join(""))); } } From 94f121ff3f47fecdcf458b691f1bf87f8b1f1f1d Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Mon, 4 Feb 2019 21:49:54 +0900 Subject: [PATCH 062/278] libsyntax_ext => 2018 --- src/libsyntax_ext/Cargo.toml | 1 + src/libsyntax_ext/asm.rs | 11 +- src/libsyntax_ext/assert.rs | 5 +- src/libsyntax_ext/cfg.rs | 8 +- src/libsyntax_ext/compile_error.rs | 5 +- src/libsyntax_ext/concat.rs | 3 +- src/libsyntax_ext/concat_idents.rs | 5 +- src/libsyntax_ext/deriving/bounds.rs | 11 +- src/libsyntax_ext/deriving/clone.rs | 25 ++-- src/libsyntax_ext/deriving/cmp/eq.rs | 19 +-- src/libsyntax_ext/deriving/cmp/ord.rs | 12 +- src/libsyntax_ext/deriving/cmp/partial_eq.rs | 18 +-- src/libsyntax_ext/deriving/cmp/partial_ord.rs | 22 ++-- src/libsyntax_ext/deriving/custom.rs | 15 +-- src/libsyntax_ext/deriving/debug.rs | 12 +- src/libsyntax_ext/deriving/decodable.rs | 22 ++-- src/libsyntax_ext/deriving/default.rs | 14 ++- src/libsyntax_ext/deriving/encodable.rs | 18 +-- src/libsyntax_ext/deriving/generic/mod.rs | 108 +++++++++--------- src/libsyntax_ext/deriving/generic/ty.rs | 29 +++-- src/libsyntax_ext/deriving/hash.rs | 10 +- src/libsyntax_ext/deriving/mod.rs | 4 +- src/libsyntax_ext/diagnostics.rs | 2 + src/libsyntax_ext/env.rs | 7 +- src/libsyntax_ext/format.rs | 33 +++--- src/libsyntax_ext/format_foreign.rs | 30 +++-- src/libsyntax_ext/global_asm.rs | 9 +- src/libsyntax_ext/lib.rs | 16 +-- src/libsyntax_ext/log_syntax.rs | 2 +- src/libsyntax_ext/proc_macro_decls.rs | 7 +- src/libsyntax_ext/proc_macro_impl.rs | 26 ++--- src/libsyntax_ext/proc_macro_server.rs | 7 +- src/libsyntax_ext/test.rs | 14 +-- src/libsyntax_ext/test_case.rs | 2 +- src/libsyntax_ext/trace_macros.rs | 5 +- 35 files changed, 269 insertions(+), 268 deletions(-) diff --git a/src/libsyntax_ext/Cargo.toml b/src/libsyntax_ext/Cargo.toml index 7ad08f75e8bdd..c22b55b8c13a0 100644 --- a/src/libsyntax_ext/Cargo.toml +++ b/src/libsyntax_ext/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "syntax_ext" version = "0.0.0" +edition = "2018" [lib] name = "syntax_ext" diff --git a/src/libsyntax_ext/asm.rs b/src/libsyntax_ext/asm.rs index 41ee6e91b3dc9..ebcdceea7c5a9 100644 --- a/src/libsyntax_ext/asm.rs +++ b/src/libsyntax_ext/asm.rs @@ -1,13 +1,13 @@ // Inline assembly support. // -use self::State::*; +use State::*; use rustc_data_structures::thin_vec::ThinVec; -use errors::DiagnosticBuilder; +use crate::errors::DiagnosticBuilder; + use syntax::ast; -use syntax::ext::base; -use syntax::ext::base::*; +use syntax::ext::base::{self, *}; use syntax::feature_gate; use syntax::parse::{self, token}; use syntax::ptr::P; @@ -15,6 +15,7 @@ use syntax::symbol::Symbol; use syntax::ast::AsmDialect; use syntax_pos::Span; use syntax::tokenstream; +use syntax::{span_err, struct_span_err}; enum State { Asm, @@ -40,7 +41,7 @@ impl State { const OPTIONS: &[&str] = &["volatile", "alignstack", "intel"]; -pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, +pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree]) -> Box { diff --git a/src/libsyntax_ext/assert.rs b/src/libsyntax_ext/assert.rs index b27f495322a42..984ef26f5ab8b 100644 --- a/src/libsyntax_ext/assert.rs +++ b/src/libsyntax_ext/assert.rs @@ -1,4 +1,5 @@ -use errors::DiagnosticBuilder; +use crate::errors::DiagnosticBuilder; + use syntax::ast::{self, *}; use syntax::source_map::Spanned; use syntax::ext::base::*; @@ -11,7 +12,7 @@ use syntax::tokenstream::{TokenStream, TokenTree}; use syntax_pos::{Span, DUMMY_SP}; pub fn expand_assert<'cx>( - cx: &'cx mut ExtCtxt, + cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: &[TokenTree], ) -> Box { diff --git a/src/libsyntax_ext/cfg.rs b/src/libsyntax_ext/cfg.rs index 3b47b03cbe8dc..e2104550878ec 100644 --- a/src/libsyntax_ext/cfg.rs +++ b/src/libsyntax_ext/cfg.rs @@ -2,17 +2,17 @@ /// a literal `true` or `false` based on whether the given cfg matches the /// current compilation environment. -use errors::DiagnosticBuilder; +use crate::errors::DiagnosticBuilder; + use syntax::ast; -use syntax::ext::base::*; -use syntax::ext::base; +use syntax::ext::base::{self, *}; use syntax::ext::build::AstBuilder; use syntax::attr; use syntax::tokenstream; use syntax::parse::token; use syntax_pos::Span; -pub fn expand_cfg<'cx>(cx: &mut ExtCtxt, +pub fn expand_cfg<'cx>(cx: &mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree]) -> Box { diff --git a/src/libsyntax_ext/compile_error.rs b/src/libsyntax_ext/compile_error.rs index 8f7f5deb091ac..59d3f2c9c7813 100644 --- a/src/libsyntax_ext/compile_error.rs +++ b/src/libsyntax_ext/compile_error.rs @@ -1,11 +1,10 @@ // The compiler code necessary to support the compile_error! extension. -use syntax::ext::base::*; -use syntax::ext::base; +use syntax::ext::base::{self, *}; use syntax_pos::Span; use syntax::tokenstream; -pub fn expand_compile_error<'cx>(cx: &'cx mut ExtCtxt, +pub fn expand_compile_error<'cx>(cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree]) -> Box { diff --git a/src/libsyntax_ext/concat.rs b/src/libsyntax_ext/concat.rs index f148f8e003df3..230b00c0f8f55 100644 --- a/src/libsyntax_ext/concat.rs +++ b/src/libsyntax_ext/concat.rs @@ -3,12 +3,11 @@ use syntax::ext::base; use syntax::ext::build::AstBuilder; use syntax::symbol::Symbol; use syntax::tokenstream; -use syntax_pos; use std::string::String; pub fn expand_syntax_ext( - cx: &mut base::ExtCtxt, + cx: &mut base::ExtCtxt<'_>, sp: syntax_pos::Span, tts: &[tokenstream::TokenTree], ) -> Box { diff --git a/src/libsyntax_ext/concat_idents.rs b/src/libsyntax_ext/concat_idents.rs index de96de4bdc2bc..8c9eb4bf2d8ff 100644 --- a/src/libsyntax_ext/concat_idents.rs +++ b/src/libsyntax_ext/concat_idents.rs @@ -1,8 +1,7 @@ use rustc_data_structures::thin_vec::ThinVec; use syntax::ast; -use syntax::ext::base::*; -use syntax::ext::base; +use syntax::ext::base::{self, *}; use syntax::feature_gate; use syntax::parse::token; use syntax::ptr::P; @@ -10,7 +9,7 @@ use syntax_pos::Span; use syntax_pos::symbol::Symbol; use syntax::tokenstream::TokenTree; -pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt, +pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: &[TokenTree]) -> Box { diff --git a/src/libsyntax_ext/deriving/bounds.rs b/src/libsyntax_ext/deriving/bounds.rs index dcfc6ab0391b8..c7b805e0bdca6 100644 --- a/src/libsyntax_ext/deriving/bounds.rs +++ b/src/libsyntax_ext/deriving/bounds.rs @@ -1,11 +1,12 @@ -use deriving::path_std; -use deriving::generic::*; -use deriving::generic::ty::*; +use crate::deriving::path_std; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; + use syntax::ast::MetaItem; use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax_pos::Span; -pub fn expand_deriving_unsafe_bound(cx: &mut ExtCtxt, +pub fn expand_deriving_unsafe_bound(cx: &mut ExtCtxt<'_>, span: Span, _: &MetaItem, _: &Annotatable, @@ -13,7 +14,7 @@ pub fn expand_deriving_unsafe_bound(cx: &mut ExtCtxt, cx.span_err(span, "this unsafe trait should be implemented explicitly"); } -pub fn expand_deriving_copy(cx: &mut ExtCtxt, +pub fn expand_deriving_copy(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, diff --git a/src/libsyntax_ext/deriving/clone.rs b/src/libsyntax_ext/deriving/clone.rs index 38d433e842cd7..b347092e1bc4c 100644 --- a/src/libsyntax_ext/deriving/clone.rs +++ b/src/libsyntax_ext/deriving/clone.rs @@ -1,9 +1,8 @@ -use deriving::path_std; -use deriving::generic::*; -use deriving::generic::ty::*; +use crate::deriving::path_std; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; -use syntax::ast::{self, Expr, Generics, ItemKind, MetaItem, VariantData}; -use syntax::ast::GenericArg; +use syntax::ast::{self, Expr, GenericArg, Generics, ItemKind, MetaItem, VariantData}; use syntax::attr; use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; @@ -11,7 +10,7 @@ use syntax::ptr::P; use syntax::symbol::{Symbol, keywords}; use syntax_pos::Span; -pub fn expand_deriving_clone(cx: &mut ExtCtxt, +pub fn expand_deriving_clone(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -105,12 +104,12 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt, } fn cs_clone_shallow(name: &str, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, trait_span: Span, - substr: &Substructure, + substr: &Substructure<'_>, is_union: bool) -> P { - fn assert_ty_bounds(cx: &mut ExtCtxt, stmts: &mut Vec, + fn assert_ty_bounds(cx: &mut ExtCtxt<'_>, stmts: &mut Vec, ty: P, span: Span, helper_name: &str) { // Generate statement `let _: helper_name;`, // set the expn ID so we can use the unstable struct. @@ -120,7 +119,7 @@ fn cs_clone_shallow(name: &str, vec![GenericArg::Type(ty)], vec![]); stmts.push(cx.stmt_let_type_only(span, cx.ty_path(assert_path))); } - fn process_variant(cx: &mut ExtCtxt, stmts: &mut Vec, variant: &VariantData) { + fn process_variant(cx: &mut ExtCtxt<'_>, stmts: &mut Vec, variant: &VariantData) { for field in variant.fields() { // let _: AssertParamIsClone; assert_ty_bounds(cx, stmts, field.ty.clone(), field.span, "AssertParamIsClone"); @@ -151,14 +150,14 @@ fn cs_clone_shallow(name: &str, } fn cs_clone(name: &str, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, trait_span: Span, - substr: &Substructure) + substr: &Substructure<'_>) -> P { let ctor_path; let all_fields; let fn_path = cx.std_path(&["clone", "Clone", "clone"]); - let subcall = |cx: &mut ExtCtxt, field: &FieldInfo| { + let subcall = |cx: &mut ExtCtxt<'_>, field: &FieldInfo<'_>| { let args = vec![cx.expr_addr_of(field.span, field.self_.clone())]; cx.expr_call_global(field.span, fn_path.clone(), args) }; diff --git a/src/libsyntax_ext/deriving/cmp/eq.rs b/src/libsyntax_ext/deriving/cmp/eq.rs index dbba8c3b7a006..a1035ff641fa1 100644 --- a/src/libsyntax_ext/deriving/cmp/eq.rs +++ b/src/libsyntax_ext/deriving/cmp/eq.rs @@ -1,6 +1,6 @@ -use deriving::path_std; -use deriving::generic::*; -use deriving::generic::ty::*; +use crate::deriving::path_std; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; use syntax::ast::{self, Expr, MetaItem, GenericArg}; use syntax::ext::base::{Annotatable, ExtCtxt}; @@ -9,7 +9,7 @@ use syntax::ptr::P; use syntax::symbol::Symbol; use syntax_pos::Span; -pub fn expand_deriving_eq(cx: &mut ExtCtxt, +pub fn expand_deriving_eq(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -44,8 +44,11 @@ pub fn expand_deriving_eq(cx: &mut ExtCtxt, trait_def.expand_ext(cx, mitem, item, push, true) } -fn cs_total_eq_assert(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P { - fn assert_ty_bounds(cx: &mut ExtCtxt, stmts: &mut Vec, +fn cs_total_eq_assert(cx: &mut ExtCtxt<'_>, + trait_span: Span, + substr: &Substructure<'_>) + -> P { + fn assert_ty_bounds(cx: &mut ExtCtxt<'_>, stmts: &mut Vec, ty: P, span: Span, helper_name: &str) { // Generate statement `let _: helper_name;`, // set the expn ID so we can use the unstable struct. @@ -55,7 +58,9 @@ fn cs_total_eq_assert(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) vec![GenericArg::Type(ty)], vec![]); stmts.push(cx.stmt_let_type_only(span, cx.ty_path(assert_path))); } - fn process_variant(cx: &mut ExtCtxt, stmts: &mut Vec, variant: &ast::VariantData) { + fn process_variant(cx: &mut ExtCtxt<'_>, + stmts: &mut Vec, + variant: &ast::VariantData) { for field in variant.fields() { // let _: AssertParamIsEq; assert_ty_bounds(cx, stmts, field.ty.clone(), field.span, "AssertParamIsEq"); diff --git a/src/libsyntax_ext/deriving/cmp/ord.rs b/src/libsyntax_ext/deriving/cmp/ord.rs index 21bd56710ac9b..e4f939c151f3e 100644 --- a/src/libsyntax_ext/deriving/cmp/ord.rs +++ b/src/libsyntax_ext/deriving/cmp/ord.rs @@ -1,6 +1,6 @@ -use deriving::path_std; -use deriving::generic::*; -use deriving::generic::ty::*; +use crate::deriving::path_std; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; use syntax::ast::{self, Expr, MetaItem}; use syntax::ext::base::{Annotatable, ExtCtxt}; @@ -9,7 +9,7 @@ use syntax::ptr::P; use syntax::symbol::Symbol; use syntax_pos::Span; -pub fn expand_deriving_ord(cx: &mut ExtCtxt, +pub fn expand_deriving_ord(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -44,7 +44,7 @@ pub fn expand_deriving_ord(cx: &mut ExtCtxt, } -pub fn ordering_collapsed(cx: &mut ExtCtxt, +pub fn ordering_collapsed(cx: &mut ExtCtxt<'_>, span: Span, self_arg_tags: &[ast::Ident]) -> P { @@ -53,7 +53,7 @@ pub fn ordering_collapsed(cx: &mut ExtCtxt, cx.expr_method_call(span, lft, cx.ident_of("cmp"), vec![rgt]) } -pub fn cs_cmp(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { +pub fn cs_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> P { let test_id = cx.ident_of("cmp").gensym(); let equals_path = cx.path_global(span, cx.std_path(&["cmp", "Ordering", "Equal"])); diff --git a/src/libsyntax_ext/deriving/cmp/partial_eq.rs b/src/libsyntax_ext/deriving/cmp/partial_eq.rs index 4ec24bce4cd48..07026ae373919 100644 --- a/src/libsyntax_ext/deriving/cmp/partial_eq.rs +++ b/src/libsyntax_ext/deriving/cmp/partial_eq.rs @@ -1,6 +1,6 @@ -use deriving::{path_local, path_std}; -use deriving::generic::*; -use deriving::generic::ty::*; +use crate::deriving::{path_local, path_std}; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; use syntax::ast::{BinOpKind, Expr, MetaItem}; use syntax::ext::base::{Annotatable, ExtCtxt}; @@ -9,22 +9,22 @@ use syntax::ptr::P; use syntax::symbol::Symbol; use syntax_pos::Span; -pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt, +pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, push: &mut dyn FnMut(Annotatable)) { // structures are equal if all fields are equal, and non equal, if // any fields are not equal or if the enum variants are different - fn cs_op(cx: &mut ExtCtxt, + fn cs_op(cx: &mut ExtCtxt<'_>, span: Span, - substr: &Substructure, + substr: &Substructure<'_>, op: BinOpKind, combiner: BinOpKind, base: bool) -> P { - let op = |cx: &mut ExtCtxt, span: Span, self_f: P, other_fs: &[P]| { + let op = |cx: &mut ExtCtxt<'_>, span: Span, self_f: P, other_fs: &[P]| { let other_f = match (other_fs.len(), other_fs.get(0)) { (1, Some(o_f)) => o_f, _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialEq)`"), @@ -53,10 +53,10 @@ pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt, substr) } - fn cs_eq(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { + fn cs_eq(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> P { cs_op(cx, span, substr, BinOpKind::Eq, BinOpKind::And, true) } - fn cs_ne(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { + fn cs_ne(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> P { cs_op(cx, span, substr, BinOpKind::Ne, BinOpKind::Or, false) } diff --git a/src/libsyntax_ext/deriving/cmp/partial_ord.rs b/src/libsyntax_ext/deriving/cmp/partial_ord.rs index 9ef481edf51ca..e99abeb118ea2 100644 --- a/src/libsyntax_ext/deriving/cmp/partial_ord.rs +++ b/src/libsyntax_ext/deriving/cmp/partial_ord.rs @@ -1,8 +1,8 @@ -pub use self::OrderingOp::*; +pub use OrderingOp::*; -use deriving::{path_local, pathvec_std, path_std}; -use deriving::generic::*; -use deriving::generic::ty::*; +use crate::deriving::{path_local, pathvec_std, path_std}; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; use syntax::ast::{self, BinOpKind, Expr, MetaItem}; use syntax::ext::base::{Annotatable, ExtCtxt}; @@ -11,7 +11,7 @@ use syntax::ptr::P; use syntax::symbol::Symbol; use syntax_pos::Span; -pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt, +pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -95,7 +95,7 @@ pub enum OrderingOp { GeOp, } -pub fn some_ordering_collapsed(cx: &mut ExtCtxt, +pub fn some_ordering_collapsed(cx: &mut ExtCtxt<'_>, span: Span, op: OrderingOp, self_arg_tags: &[ast::Ident]) @@ -112,7 +112,7 @@ pub fn some_ordering_collapsed(cx: &mut ExtCtxt, cx.expr_method_call(span, lft, cx.ident_of(op_str), vec![rgt]) } -pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { +pub fn cs_partial_cmp(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> P { let test_id = cx.ident_of("cmp").gensym(); let ordering = cx.path_global(span, cx.std_path(&["cmp", "Ordering", "Equal"])); let ordering_expr = cx.expr_path(ordering.clone()); @@ -184,14 +184,14 @@ pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P< /// Strict inequality. fn cs_op(less: bool, inclusive: bool, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, span: Span, - substr: &Substructure) -> P { - let ordering_path = |cx: &mut ExtCtxt, name: &str| { + substr: &Substructure<'_>) -> P { + let ordering_path = |cx: &mut ExtCtxt<'_>, name: &str| { cx.expr_path(cx.path_global(span, cx.std_path(&["cmp", "Ordering", name]))) }; - let par_cmp = |cx: &mut ExtCtxt, span, self_f: P, other_fs: &[P], default| { + let par_cmp = |cx: &mut ExtCtxt<'_>, span, self_f: P, other_fs: &[P], default| { let other_f = match (other_fs.len(), other_fs.get(0)) { (1, Some(o_f)) => o_f, _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`"), diff --git a/src/libsyntax_ext/deriving/custom.rs b/src/libsyntax_ext/deriving/custom.rs index 2f20814ef3efd..7d9b8402cac3f 100644 --- a/src/libsyntax_ext/deriving/custom.rs +++ b/src/libsyntax_ext/deriving/custom.rs @@ -1,4 +1,7 @@ -use errors::FatalError; +use crate::errors::FatalError; +use crate::proc_macro_impl::EXEC_STRATEGY; +use crate::proc_macro_server; + use syntax::ast::{self, ItemKind, Attribute, Mac}; use syntax::attr::{mark_used, mark_known}; use syntax::source_map::Span; @@ -9,8 +12,6 @@ use syntax::tokenstream; use syntax::visit::Visitor; use syntax_pos::DUMMY_SP; -use proc_macro_impl::EXEC_STRATEGY; - struct MarkAttrs<'a>(&'a [ast::Name]); impl<'a> Visitor<'a> for MarkAttrs<'a> { @@ -25,15 +26,15 @@ impl<'a> Visitor<'a> for MarkAttrs<'a> { } pub struct ProcMacroDerive { - pub client: ::proc_macro::bridge::client::Client< - fn(::proc_macro::TokenStream) -> ::proc_macro::TokenStream, + pub client: proc_macro::bridge::client::Client< + fn(proc_macro::TokenStream) -> proc_macro::TokenStream, >, pub attrs: Vec, } impl MultiItemModifier for ProcMacroDerive { fn expand(&self, - ecx: &mut ExtCtxt, + ecx: &mut ExtCtxt<'_>, span: Span, _meta_item: &ast::MetaItem, item: Annotatable) @@ -67,7 +68,7 @@ impl MultiItemModifier for ProcMacroDerive { let token = Token::interpolated(token::NtItem(item)); let input = tokenstream::TokenTree::Token(DUMMY_SP, token).into(); - let server = ::proc_macro_server::Rustc::new(ecx); + let server = proc_macro_server::Rustc::new(ecx); let stream = match self.client.run(&EXEC_STRATEGY, server, input) { Ok(stream) => stream, Err(e) => { diff --git a/src/libsyntax_ext/deriving/debug.rs b/src/libsyntax_ext/deriving/debug.rs index b3e5bd9283ef6..7dc2d007d73d6 100644 --- a/src/libsyntax_ext/deriving/debug.rs +++ b/src/libsyntax_ext/deriving/debug.rs @@ -1,6 +1,6 @@ -use deriving::path_std; -use deriving::generic::*; -use deriving::generic::ty::*; +use crate::deriving::path_std; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; use rustc_data_structures::thin_vec::ThinVec; @@ -11,7 +11,7 @@ use syntax::ext::build::AstBuilder; use syntax::ptr::P; use syntax_pos::{DUMMY_SP, Span}; -pub fn expand_deriving_debug(cx: &mut ExtCtxt, +pub fn expand_deriving_debug(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -47,7 +47,7 @@ pub fn expand_deriving_debug(cx: &mut ExtCtxt, } /// We use the debug builders to do the heavy lifting here -fn show_substructure(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { +fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> P { // build fmt.debug_struct().field(, &)....build() // or fmt.debug_tuple().field(&)....build() // based on the "shape". @@ -124,7 +124,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P) -> ast::Stmt { +fn stmt_let_undescore(cx: &mut ExtCtxt<'_>, sp: Span, expr: P) -> ast::Stmt { let local = P(ast::Local { pat: cx.pat_wild(sp), ty: None, diff --git a/src/libsyntax_ext/deriving/decodable.rs b/src/libsyntax_ext/deriving/decodable.rs index 89c630e991530..b082351d5f684 100644 --- a/src/libsyntax_ext/deriving/decodable.rs +++ b/src/libsyntax_ext/deriving/decodable.rs @@ -1,9 +1,9 @@ //! The compiler code necessary for `#[derive(Decodable)]`. See encodable.rs for more. -use deriving::{self, pathvec_std}; -use deriving::generic::*; -use deriving::generic::ty::*; -use deriving::warn_if_deprecated; +use crate::deriving::{self, pathvec_std}; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; +use crate::deriving::warn_if_deprecated; use syntax::ast; use syntax::ast::{Expr, MetaItem, Mutability}; @@ -13,7 +13,7 @@ use syntax::ptr::P; use syntax::symbol::Symbol; use syntax_pos::Span; -pub fn expand_deriving_rustc_decodable(cx: &mut ExtCtxt, +pub fn expand_deriving_rustc_decodable(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -21,7 +21,7 @@ pub fn expand_deriving_rustc_decodable(cx: &mut ExtCtxt, expand_deriving_decodable_imp(cx, span, mitem, item, push, "rustc_serialize") } -pub fn expand_deriving_decodable(cx: &mut ExtCtxt, +pub fn expand_deriving_decodable(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -30,7 +30,7 @@ pub fn expand_deriving_decodable(cx: &mut ExtCtxt, expand_deriving_decodable_imp(cx, span, mitem, item, push, "serialize") } -fn expand_deriving_decodable_imp(cx: &mut ExtCtxt, +fn expand_deriving_decodable_imp(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -79,9 +79,9 @@ fn expand_deriving_decodable_imp(cx: &mut ExtCtxt, trait_def.expand(cx, mitem, item, push) } -fn decodable_substructure(cx: &mut ExtCtxt, +fn decodable_substructure(cx: &mut ExtCtxt<'_>, trait_span: Span, - substr: &Substructure, + substr: &Substructure<'_>, krate: &str) -> P { let decoder = substr.nonself_args[0].clone(); @@ -168,13 +168,13 @@ fn decodable_substructure(cx: &mut ExtCtxt, /// Create a decoder for a single enum variant/struct: /// - `outer_pat_path` is the path to this enum variant/struct /// - `getarg` should retrieve the `usize`-th field with name `@str`. -fn decode_static_fields(cx: &mut ExtCtxt, +fn decode_static_fields(cx: &mut ExtCtxt<'_>, trait_span: Span, outer_pat_path: ast::Path, fields: &StaticFields, mut getarg: F) -> P - where F: FnMut(&mut ExtCtxt, Span, Symbol, usize) -> P + where F: FnMut(&mut ExtCtxt<'_>, Span, Symbol, usize) -> P { match *fields { Unnamed(ref fields, is_tuple) => { diff --git a/src/libsyntax_ext/deriving/default.rs b/src/libsyntax_ext/deriving/default.rs index 32d02bec7989b..6db0a29165a4a 100644 --- a/src/libsyntax_ext/deriving/default.rs +++ b/src/libsyntax_ext/deriving/default.rs @@ -1,15 +1,16 @@ -use deriving::path_std; -use deriving::generic::*; -use deriving::generic::ty::*; +use crate::deriving::path_std; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; use syntax::ast::{Expr, MetaItem}; use syntax::ext::base::{Annotatable, DummyResult, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::ptr::P; use syntax::symbol::Symbol; +use syntax::span_err; use syntax_pos::Span; -pub fn expand_deriving_default(cx: &mut ExtCtxt, +pub fn expand_deriving_default(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -42,7 +43,10 @@ pub fn expand_deriving_default(cx: &mut ExtCtxt, trait_def.expand(cx, mitem, item, push) } -fn default_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P { +fn default_substructure(cx: &mut ExtCtxt<'_>, + trait_span: Span, + substr: &Substructure<'_>) + -> P { let default_ident = cx.std_path(&["default", "Default", "default"]); let default_call = |span| cx.expr_call_global(span, default_ident.clone(), Vec::new()); diff --git a/src/libsyntax_ext/deriving/encodable.rs b/src/libsyntax_ext/deriving/encodable.rs index c8935874158a2..dd5646342b362 100644 --- a/src/libsyntax_ext/deriving/encodable.rs +++ b/src/libsyntax_ext/deriving/encodable.rs @@ -82,10 +82,10 @@ //! } //! ``` -use deriving::{self, pathvec_std}; -use deriving::generic::*; -use deriving::generic::ty::*; -use deriving::warn_if_deprecated; +use crate::deriving::{self, pathvec_std}; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; +use crate::deriving::warn_if_deprecated; use syntax::ast::{Expr, ExprKind, MetaItem, Mutability}; use syntax::ext::base::{Annotatable, ExtCtxt}; @@ -94,7 +94,7 @@ use syntax::ptr::P; use syntax::symbol::Symbol; use syntax_pos::Span; -pub fn expand_deriving_rustc_encodable(cx: &mut ExtCtxt, +pub fn expand_deriving_rustc_encodable(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -102,7 +102,7 @@ pub fn expand_deriving_rustc_encodable(cx: &mut ExtCtxt, expand_deriving_encodable_imp(cx, span, mitem, item, push, "rustc_serialize") } -pub fn expand_deriving_encodable(cx: &mut ExtCtxt, +pub fn expand_deriving_encodable(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -111,7 +111,7 @@ pub fn expand_deriving_encodable(cx: &mut ExtCtxt, expand_deriving_encodable_imp(cx, span, mitem, item, push, "serialize") } -fn expand_deriving_encodable_imp(cx: &mut ExtCtxt, +fn expand_deriving_encodable_imp(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -162,9 +162,9 @@ fn expand_deriving_encodable_imp(cx: &mut ExtCtxt, trait_def.expand(cx, mitem, item, push) } -fn encodable_substructure(cx: &mut ExtCtxt, +fn encodable_substructure(cx: &mut ExtCtxt<'_>, trait_span: Span, - substr: &Substructure, + substr: &Substructure<'_>, krate: &'static str) -> P { let encoder = substr.nonself_args[0].clone(); diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs index 22643db501693..0c88ae0311d52 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -174,8 +174,8 @@ //! (, , Named(vec![(, )]))]) //! ``` -pub use self::StaticFields::*; -pub use self::SubstructureFields::*; +pub use StaticFields::*; +pub use SubstructureFields::*; use std::cell::RefCell; use std::iter; @@ -195,9 +195,9 @@ use syntax::symbol::{Symbol, keywords}; use syntax::parse::ParseSess; use syntax_pos::{DUMMY_SP, Span}; -use self::ty::{LifetimeBounds, Path, Ptr, PtrTy, Self_, Ty}; +use ty::{LifetimeBounds, Path, Ptr, PtrTy, Self_, Ty}; -use deriving; +use crate::deriving; pub mod ty; @@ -321,7 +321,7 @@ pub enum SubstructureFields<'a> { /// Combine the values of all the fields together. The last argument is /// all the fields of all the structures. pub type CombineSubstructureFunc<'a> = - Box P + 'a>; + Box, Span, &Substructure<'_>) -> P + 'a>; /// Deal with non-matching enum variants. The tuple is a list of /// identifiers (one for each `Self` argument, which could be any of the @@ -329,7 +329,7 @@ pub type CombineSubstructureFunc<'a> = /// holding the variant index value for each of the `Self` arguments. The /// last argument is all the non-`Self` args of the method being derived. pub type EnumNonMatchCollapsedFunc<'a> = - Box]) -> P + 'a>; + Box, Span, (&[Ident], &[Ident]), &[P]) -> P + 'a>; pub fn combine_substructure<'a>(f: CombineSubstructureFunc<'a>) -> RefCell> { @@ -342,7 +342,7 @@ pub fn combine_substructure<'a>(f: CombineSubstructureFunc<'a>) fn find_type_parameters(ty: &ast::Ty, ty_param_names: &[ast::Name], span: Span, - cx: &ExtCtxt) + cx: &ExtCtxt<'_>) -> Vec> { use syntax::visit; @@ -386,7 +386,7 @@ fn find_type_parameters(ty: &ast::Ty, impl<'a> TraitDef<'a> { pub fn expand(self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, mitem: &ast::MetaItem, item: &'a Annotatable, push: &mut dyn FnMut(Annotatable)) { @@ -394,7 +394,7 @@ impl<'a> TraitDef<'a> { } pub fn expand_ext(self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, mitem: &ast::MetaItem, item: &'a Annotatable, push: &mut dyn FnMut(Annotatable), @@ -513,7 +513,7 @@ impl<'a> TraitDef<'a> { /// where B1, ..., BN are the bounds given by `bounds_paths`.'. Z is a phantom type, and /// therefore does not get bound by the derived trait. fn create_derived_impl(&self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, type_ident: Ident, generics: &Generics, field_tys: Vec>, @@ -696,7 +696,7 @@ impl<'a> TraitDef<'a> { } fn expand_struct_def(&self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, struct_def: &'a VariantData, type_ident: Ident, generics: &Generics, @@ -746,7 +746,7 @@ impl<'a> TraitDef<'a> { } fn expand_enum_def(&self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, enum_def: &'a EnumDef, type_attrs: &[ast::Attribute], type_ident: Ident, @@ -832,12 +832,12 @@ fn find_repr_type_name(sess: &ParseSess, type_attrs: &[ast::Attribute]) -> &'sta impl<'a> MethodDef<'a> { fn call_substructure_method(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, + cx: &mut ExtCtxt<'_>, + trait_: &TraitDef<'_>, type_ident: Ident, self_args: &[P], nonself_args: &[P], - fields: &SubstructureFields) + fields: &SubstructureFields<'_>) -> P { let substructure = Substructure { type_ident, @@ -847,13 +847,13 @@ impl<'a> MethodDef<'a> { fields, }; let mut f = self.combine_substructure.borrow_mut(); - let f: &mut CombineSubstructureFunc = &mut *f; + let f: &mut CombineSubstructureFunc<'_> = &mut *f; f(cx, trait_.span, &substructure) } fn get_ret_ty(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, + cx: &mut ExtCtxt<'_>, + trait_: &TraitDef<'_>, generics: &Generics, type_ident: Ident) -> P { @@ -866,8 +866,8 @@ impl<'a> MethodDef<'a> { fn split_self_nonself_args (&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, + cx: &mut ExtCtxt<'_>, + trait_: &TraitDef<'_>, type_ident: Ident, generics: &Generics) -> (Option, Vec>, Vec>, Vec<(Ident, P)>) { @@ -912,8 +912,8 @@ impl<'a> MethodDef<'a> { } fn create_method(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, + cx: &mut ExtCtxt<'_>, + trait_: &TraitDef<'_>, type_ident: Ident, generics: &Generics, abi: Abi, @@ -1005,7 +1005,7 @@ impl<'a> MethodDef<'a> { /// } /// ``` fn expand_struct_method_body<'b>(&self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, trait_: &TraitDef<'b>, struct_def: &'b VariantData, type_ident: Ident, @@ -1077,8 +1077,8 @@ impl<'a> MethodDef<'a> { } fn expand_static_struct_method_body(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, + cx: &mut ExtCtxt<'_>, + trait_: &TraitDef<'_>, struct_def: &VariantData, type_ident: Ident, self_args: &[P], @@ -1125,7 +1125,7 @@ impl<'a> MethodDef<'a> { /// as their results are unused. The point of `__self_vi` and /// `__arg_1_vi` is for `PartialOrd`; see #15503.) fn expand_enum_method_body<'b>(&self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, trait_: &TraitDef<'b>, enum_def: &'b EnumDef, type_attrs: &[ast::Attribute], @@ -1179,7 +1179,7 @@ impl<'a> MethodDef<'a> { /// } /// ``` fn build_enum_match_tuple<'b>(&self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, trait_: &TraitDef<'b>, enum_def: &'b EnumDef, type_attrs: &[ast::Attribute], @@ -1230,7 +1230,7 @@ impl<'a> MethodDef<'a> { .enumerate() .filter(|&(_, v)| !(self.unify_fieldless_variants && v.node.data.fields().is_empty())) .map(|(index, variant)| { - let mk_self_pat = |cx: &mut ExtCtxt, self_arg_name: &str| { + let mk_self_pat = |cx: &mut ExtCtxt<'_>, self_arg_name: &str| { let (p, idents) = trait_.create_enum_variant_pattern(cx, type_ident, variant, @@ -1296,7 +1296,7 @@ impl<'a> MethodDef<'a> { other: others, attrs, } - }).collect::>(); + }).collect::>>(); // Now, for some given VariantK, we have built up // expressions for referencing every field of every @@ -1501,8 +1501,8 @@ impl<'a> MethodDef<'a> { } fn expand_static_enum_method_body(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, + cx: &mut ExtCtxt<'_>, + trait_: &TraitDef<'_>, enum_def: &EnumDef, type_ident: Ident, self_args: &[P], @@ -1527,7 +1527,7 @@ impl<'a> MethodDef<'a> { // general helper methods. impl<'a> TraitDef<'a> { - fn summarise_struct(&self, cx: &mut ExtCtxt, struct_def: &VariantData) -> StaticFields { + fn summarise_struct(&self, cx: &mut ExtCtxt<'_>, struct_def: &VariantData) -> StaticFields { let mut named_idents = Vec::new(); let mut just_spans = Vec::new(); for field in struct_def.fields() { @@ -1553,7 +1553,7 @@ impl<'a> TraitDef<'a> { } fn create_subpatterns(&self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, field_paths: Vec, mutbl: ast::Mutability, use_temporaries: bool) @@ -1573,7 +1573,7 @@ impl<'a> TraitDef<'a> { fn create_struct_pattern (&self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, struct_path: ast::Path, struct_def: &'a VariantData, prefix: &str, @@ -1633,7 +1633,7 @@ impl<'a> TraitDef<'a> { fn create_enum_variant_pattern (&self, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, enum_ident: ast::Ident, variant: &'a ast::Variant, prefix: &str, @@ -1652,10 +1652,10 @@ impl<'a> TraitDef<'a> { pub fn cs_fold_fields<'a, F>(use_foldl: bool, mut f: F, base: P, - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, all_fields: &[FieldInfo<'a>]) -> P - where F: FnMut(&mut ExtCtxt, Span, P, P, &[P]) -> P + where F: FnMut(&mut ExtCtxt<'_>, Span, P, P, &[P]) -> P { if use_foldl { all_fields.iter().fold(base, |old, field| { @@ -1668,10 +1668,10 @@ pub fn cs_fold_fields<'a, F>(use_foldl: bool, } } -pub fn cs_fold_enumnonmatch(mut enum_nonmatch_f: EnumNonMatchCollapsedFunc, - cx: &mut ExtCtxt, +pub fn cs_fold_enumnonmatch(mut enum_nonmatch_f: EnumNonMatchCollapsedFunc<'_>, + cx: &mut ExtCtxt<'_>, trait_span: Span, - substructure: &Substructure) + substructure: &Substructure<'_>) -> P { match *substructure.fields { @@ -1685,7 +1685,7 @@ pub fn cs_fold_enumnonmatch(mut enum_nonmatch_f: EnumNonMatchCollapsedFunc, } } -pub fn cs_fold_static(cx: &mut ExtCtxt, +pub fn cs_fold_static(cx: &mut ExtCtxt<'_>, trait_span: Span) -> P { @@ -1697,12 +1697,12 @@ pub fn cs_fold_static(cx: &mut ExtCtxt, pub fn cs_fold(use_foldl: bool, f: F, base: P, - enum_nonmatch_f: EnumNonMatchCollapsedFunc, - cx: &mut ExtCtxt, + enum_nonmatch_f: EnumNonMatchCollapsedFunc<'_>, + cx: &mut ExtCtxt<'_>, trait_span: Span, - substructure: &Substructure) + substructure: &Substructure<'_>) -> P - where F: FnMut(&mut ExtCtxt, Span, P, P, &[P]) -> P + where F: FnMut(&mut ExtCtxt<'_>, Span, P, P, &[P]) -> P { match *substructure.fields { EnumMatching(.., ref all_fields) | @@ -1730,13 +1730,13 @@ pub fn cs_fold(use_foldl: bool, pub fn cs_fold1(use_foldl: bool, f: F, mut b: B, - enum_nonmatch_f: EnumNonMatchCollapsedFunc, - cx: &mut ExtCtxt, + enum_nonmatch_f: EnumNonMatchCollapsedFunc<'_>, + cx: &mut ExtCtxt<'_>, trait_span: Span, - substructure: &Substructure) + substructure: &Substructure<'_>) -> P - where F: FnMut(&mut ExtCtxt, Span, P, P, &[P]) -> P, - B: FnMut(&mut ExtCtxt, Option<(Span, P, &[P])>) -> P + where F: FnMut(&mut ExtCtxt<'_>, Span, P, P, &[P]) -> P, + B: FnMut(&mut ExtCtxt<'_>, Option<(Span, P, &[P])>) -> P { match *substructure.fields { EnumMatching(.., ref all_fields) | @@ -1776,12 +1776,12 @@ pub fn cs_fold1(use_foldl: bool, /// ``` #[inline] pub fn cs_same_method(f: F, - mut enum_nonmatch_f: EnumNonMatchCollapsedFunc, - cx: &mut ExtCtxt, + mut enum_nonmatch_f: EnumNonMatchCollapsedFunc<'_>, + cx: &mut ExtCtxt<'_>, trait_span: Span, - substructure: &Substructure) + substructure: &Substructure<'_>) -> P - where F: FnOnce(&mut ExtCtxt, Span, Vec>) -> P + where F: FnOnce(&mut ExtCtxt<'_>, Span, Vec>) -> P { match *substructure.fields { EnumMatching(.., ref all_fields) | diff --git a/src/libsyntax_ext/deriving/generic/ty.rs b/src/libsyntax_ext/deriving/generic/ty.rs index 83ec99b3573b4..ea6e07922b2b3 100644 --- a/src/libsyntax_ext/deriving/generic/ty.rs +++ b/src/libsyntax_ext/deriving/generic/ty.rs @@ -1,11 +1,10 @@ //! A mini version of ast::Ty, which is easier to use, and features an explicit `Self` type to use //! when specifying impls to be derived. -pub use self::PtrTy::*; -pub use self::Ty::*; +pub use PtrTy::*; +pub use Ty::*; -use syntax::ast; -use syntax::ast::{Expr, GenericParamKind, Generics, Ident, SelfKind, GenericArg}; +use syntax::ast::{self, Expr, GenericParamKind, Generics, Ident, SelfKind, GenericArg}; use syntax::ext::base::ExtCtxt; use syntax::ext::build::AstBuilder; use syntax::source_map::{respan, DUMMY_SP}; @@ -60,7 +59,7 @@ impl<'a> Path<'a> { } pub fn to_ty(&self, - cx: &ExtCtxt, + cx: &ExtCtxt<'_>, span: Span, self_ty: Ident, self_generics: &Generics) @@ -68,7 +67,7 @@ impl<'a> Path<'a> { cx.ty_path(self.to_path(cx, span, self_ty, self_generics)) } pub fn to_path(&self, - cx: &ExtCtxt, + cx: &ExtCtxt<'_>, span: Span, self_ty: Ident, self_generics: &Generics) @@ -127,19 +126,19 @@ pub fn nil_ty<'r>() -> Ty<'r> { Tuple(Vec::new()) } -fn mk_lifetime(cx: &ExtCtxt, span: Span, lt: &Option<&str>) -> Option { +fn mk_lifetime(cx: &ExtCtxt<'_>, span: Span, lt: &Option<&str>) -> Option { lt.map(|s| cx.lifetime(span, Ident::from_str(s)) ) } -fn mk_lifetimes(cx: &ExtCtxt, span: Span, lt: &Option<&str>) -> Vec { +fn mk_lifetimes(cx: &ExtCtxt<'_>, span: Span, lt: &Option<&str>) -> Vec { mk_lifetime(cx, span, lt).into_iter().collect() } impl<'a> Ty<'a> { pub fn to_ty(&self, - cx: &ExtCtxt, + cx: &ExtCtxt<'_>, span: Span, self_ty: Ident, self_generics: &Generics) @@ -167,7 +166,7 @@ impl<'a> Ty<'a> { } pub fn to_path(&self, - cx: &ExtCtxt, + cx: &ExtCtxt<'_>, span: Span, self_ty: Ident, generics: &Generics) @@ -193,11 +192,11 @@ impl<'a> Ty<'a> { } -fn mk_ty_param(cx: &ExtCtxt, +fn mk_ty_param(cx: &ExtCtxt<'_>, span: Span, name: &str, attrs: &[ast::Attribute], - bounds: &[Path], + bounds: &[Path<'_>], self_ident: Ident, self_generics: &Generics) -> ast::GenericParam { @@ -237,7 +236,7 @@ impl<'a> LifetimeBounds<'a> { } } pub fn to_generics(&self, - cx: &ExtCtxt, + cx: &ExtCtxt<'_>, span: Span, self_ty: Ident, self_generics: &Generics) @@ -262,9 +261,9 @@ impl<'a> LifetimeBounds<'a> { } } -pub fn get_explicit_self(cx: &ExtCtxt, +pub fn get_explicit_self(cx: &ExtCtxt<'_>, span: Span, - self_ptr: &Option) + self_ptr: &Option>) -> (P, ast::ExplicitSelf) { // this constructs a fresh `self` path let self_path = cx.expr_self(span); diff --git a/src/libsyntax_ext/deriving/hash.rs b/src/libsyntax_ext/deriving/hash.rs index 4af2bd57b00e2..0d4f2ddc3be7b 100644 --- a/src/libsyntax_ext/deriving/hash.rs +++ b/src/libsyntax_ext/deriving/hash.rs @@ -1,6 +1,6 @@ -use deriving::{self, pathvec_std, path_std}; -use deriving::generic::*; -use deriving::generic::ty::*; +use crate::deriving::{self, pathvec_std, path_std}; +use crate::deriving::generic::*; +use crate::deriving::generic::ty::*; use syntax::ast::{Expr, MetaItem, Mutability}; use syntax::ext::base::{Annotatable, ExtCtxt}; @@ -8,7 +8,7 @@ use syntax::ext::build::AstBuilder; use syntax::ptr::P; use syntax_pos::Span; -pub fn expand_deriving_hash(cx: &mut ExtCtxt, +pub fn expand_deriving_hash(cx: &mut ExtCtxt<'_>, span: Span, mitem: &MetaItem, item: &Annotatable, @@ -50,7 +50,7 @@ pub fn expand_deriving_hash(cx: &mut ExtCtxt, hash_trait_def.expand(cx, mitem, item, push); } -fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P { +fn hash_substructure(cx: &mut ExtCtxt<'_>, trait_span: Span, substr: &Substructure<'_>) -> P { let state_expr = match (substr.nonself_args.len(), substr.nonself_args.get(0)) { (1, Some(o_f)) => o_f, _ => { diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs index 7548d43f18444..2c8a996cdb0cb 100644 --- a/src/libsyntax_ext/deriving/mod.rs +++ b/src/libsyntax_ext/deriving/mod.rs @@ -90,7 +90,7 @@ derive_traits! { } #[inline] // because `name` is a compile-time constant -fn warn_if_deprecated(ecx: &mut ExtCtxt, sp: Span, name: &str) { +fn warn_if_deprecated(ecx: &mut ExtCtxt<'_>, sp: Span, name: &str) { if let Some(replacement) = match name { "Encodable" => Some("RustcEncodable"), "Decodable" => Some("RustcDecodable"), @@ -131,7 +131,7 @@ fn hygienic_type_parameter(item: &Annotatable, base: &str) -> String { } /// Constructs an expression that calls an intrinsic -fn call_intrinsic(cx: &ExtCtxt, +fn call_intrinsic(cx: &ExtCtxt<'_>, mut span: Span, intrinsic: &str, args: Vec>) diff --git a/src/libsyntax_ext/diagnostics.rs b/src/libsyntax_ext/diagnostics.rs index e8ad4af68508e..9bbd9fdec17d6 100644 --- a/src/libsyntax_ext/diagnostics.rs +++ b/src/libsyntax_ext/diagnostics.rs @@ -1,5 +1,7 @@ #![allow(non_snake_case)] +use syntax::{register_diagnostic, register_long_diagnostics}; + // Error messages for EXXXX errors. // Each message should start and end with a new line, and be wrapped to 80 characters. // In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use `:set tw=0` to disable. diff --git a/src/libsyntax_ext/env.rs b/src/libsyntax_ext/env.rs index 16fb64a5f3912..ccff4aec2c8c7 100644 --- a/src/libsyntax_ext/env.rs +++ b/src/libsyntax_ext/env.rs @@ -4,8 +4,7 @@ // use syntax::ast::{self, Ident, GenericArg}; -use syntax::ext::base::*; -use syntax::ext::base; +use syntax::ext::base::{self, *}; use syntax::ext::build::AstBuilder; use syntax::symbol::{keywords, Symbol}; use syntax_pos::Span; @@ -13,7 +12,7 @@ use syntax::tokenstream; use std::env; -pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, +pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree]) -> Box { @@ -44,7 +43,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, MacEager::expr(e) } -pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, +pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree]) -> Box { diff --git a/src/libsyntax_ext/format.rs b/src/libsyntax_ext/format.rs index 4c473fe7612af..6bb7ee1d5ddfd 100644 --- a/src/libsyntax_ext/format.rs +++ b/src/libsyntax_ext/format.rs @@ -1,9 +1,11 @@ -use self::ArgumentType::*; -use self::Position::*; +use ArgumentType::*; +use Position::*; use fmt_macros as parse; -use errors::DiagnosticBuilder; +use crate::errors::DiagnosticBuilder; +use crate::errors::Applicability; + use syntax::ast; use syntax::ext::base::{self, *}; use syntax::ext::build::AstBuilder; @@ -13,7 +15,6 @@ use syntax::ptr::P; use syntax::symbol::Symbol; use syntax::tokenstream; use syntax_pos::{MultiSpan, Span, DUMMY_SP}; -use errors::Applicability; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use std::borrow::Cow; @@ -184,7 +185,7 @@ fn parse_args<'a>( } impl<'a, 'b> Context<'a, 'b> { - fn resolve_name_inplace(&self, p: &mut parse::Piece) { + fn resolve_name_inplace(&self, p: &mut parse::Piece<'_>) { // NOTE: the `unwrap_or` branch is needed in case of invalid format // arguments, e.g., `format_args!("{foo}")`. let lookup = |s| *self.names.get(s).unwrap_or(&0); @@ -208,7 +209,7 @@ impl<'a, 'b> Context<'a, 'b> { /// Verifies one piece of a parse string, and remembers it if valid. /// All errors are not emitted as fatal so we can continue giving errors /// about this and possibly other format strings. - fn verify_piece(&mut self, p: &parse::Piece) { + fn verify_piece(&mut self, p: &parse::Piece<'_>) { match *p { parse::String(..) => {} parse::NextArgument(ref arg) => { @@ -231,7 +232,7 @@ impl<'a, 'b> Context<'a, 'b> { } } - fn verify_count(&mut self, c: parse::Count) { + fn verify_count(&mut self, c: parse::Count<'_>) { match c { parse::CountImplied | parse::CountIs(..) => {} @@ -244,7 +245,7 @@ impl<'a, 'b> Context<'a, 'b> { } } - fn describe_num_args(&self) -> Cow { + fn describe_num_args(&self) -> Cow<'_, str> { match self.args.len() { 0 => "no arguments were given".into(), 1 => "there is 1 argument".into(), @@ -385,11 +386,11 @@ impl<'a, 'b> Context<'a, 'b> { self.count_args_index_offset = sofar; } - fn rtpath(ecx: &ExtCtxt, s: &str) -> Vec { + fn rtpath(ecx: &ExtCtxt<'_>, s: &str) -> Vec { ecx.std_path(&["fmt", "rt", "v1", s]) } - fn build_count(&self, c: parse::Count) -> P { + fn build_count(&self, c: parse::Count<'_>) -> P { let sp = self.macsp; let count = |c, arg| { let mut path = Context::rtpath(self.ecx, "Count"); @@ -426,7 +427,7 @@ impl<'a, 'b> Context<'a, 'b> { /// Build a static `rt::Argument` from a `parse::Piece` or append /// to the `literal` string. fn build_piece(&mut self, - piece: &parse::Piece, + piece: &parse::Piece<'_>, arg_index_consumed: &mut Vec) -> Option> { let sp = self.macsp; @@ -647,7 +648,7 @@ impl<'a, 'b> Context<'a, 'b> { self.ecx.expr_call_global(self.macsp, path, fn_args) } - fn format_arg(ecx: &ExtCtxt, + fn format_arg(ecx: &ExtCtxt<'_>, macsp: Span, mut sp: Span, ty: &ArgumentType, @@ -686,7 +687,7 @@ impl<'a, 'b> Context<'a, 'b> { } } -pub fn expand_format_args<'cx>(ecx: &'cx mut ExtCtxt, +pub fn expand_format_args<'cx>(ecx: &'cx mut ExtCtxt<'_>, mut sp: Span, tts: &[tokenstream::TokenTree]) -> Box { @@ -703,7 +704,7 @@ pub fn expand_format_args<'cx>(ecx: &'cx mut ExtCtxt, } pub fn expand_format_args_nl<'cx>( - ecx: &'cx mut ExtCtxt, + ecx: &'cx mut ExtCtxt<'_>, mut sp: Span, tts: &[tokenstream::TokenTree], ) -> Box { @@ -734,7 +735,7 @@ pub fn expand_format_args_nl<'cx>( /// Take the various parts of `format_args!(efmt, args..., name=names...)` /// and construct the appropriate formatting expression. -pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, +pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt<'_>, sp: Span, efmt: P, args: Vec>, @@ -952,7 +953,7 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, piece }).collect::>(); - let numbered_position_args = pieces.iter().any(|arg: &parse::Piece| { + let numbered_position_args = pieces.iter().any(|arg: &parse::Piece<'_>| { match *arg { parse::String(_) => false, parse::NextArgument(arg) => { diff --git a/src/libsyntax_ext/format_foreign.rs b/src/libsyntax_ext/format_foreign.rs index 8ac6d460ec3d9..381325b2963ef 100644 --- a/src/libsyntax_ext/format_foreign.rs +++ b/src/libsyntax_ext/format_foreign.rs @@ -68,7 +68,7 @@ pub mod printf { pub position: (usize, usize), } - impl<'a> Format<'a> { + impl Format<'_> { /// Translate this directive into an equivalent Rust formatting directive. /// /// Returns `None` in cases where the `printf` directive does not have an exact Rust @@ -249,12 +249,12 @@ pub mod printf { } } - fn translate(&self, s: &mut String) -> ::std::fmt::Result { + fn translate(&self, s: &mut String) -> std::fmt::Result { use std::fmt::Write; match *self { Num::Num(n) => write!(s, "{}", n), Num::Arg(n) => { - let n = n.checked_sub(1).ok_or(::std::fmt::Error)?; + let n = n.checked_sub(1).ok_or(std::fmt::Error)?; write!(s, "{}$", n) }, Num::Next => write!(s, "*"), @@ -263,7 +263,7 @@ pub mod printf { } /// Returns an iterator over all substitutions in a given string. - pub fn iter_subs(s: &str) -> Substitutions { + pub fn iter_subs(s: &str) -> Substitutions<'_> { Substitutions { s, pos: 0, @@ -309,7 +309,7 @@ pub mod printf { } /// Parse the next substitution from the input string. - pub fn parse_next_substitution(s: &str) -> Option<(Substitution, &str)> { + pub fn parse_next_substitution(s: &str) -> Option<(Substitution<'_>, &str)> { use self::State::*; let at = { @@ -389,7 +389,7 @@ pub mod printf { let mut precision: Option = None; let mut length: Option<&str> = None; let mut type_: &str = ""; - let end: Cur; + let end: Cur<'_>; if let Start = state { match c { @@ -575,7 +575,7 @@ pub mod printf { Some((Substitution::Format(f), end.slice_after())) } - fn at_next_cp_while(mut cur: Cur, mut pred: F) -> Cur + fn at_next_cp_while(mut cur: Cur<'_>, mut pred: F) -> Cur<'_> where F: FnMut(char) -> bool { loop { match cur.next_cp() { @@ -769,7 +769,7 @@ pub mod shell { Escape((usize, usize)), } - impl<'a> Substitution<'a> { + impl Substitution<'_> { pub fn as_str(&self) -> String { match self { Substitution::Ordinal(n, _) => format!("${}", n), @@ -804,7 +804,7 @@ pub mod shell { } /// Returns an iterator over all substitutions in a given string. - pub fn iter_subs(s: &str) -> Substitutions { + pub fn iter_subs(s: &str) -> Substitutions<'_> { Substitutions { s, pos: 0, @@ -839,7 +839,7 @@ pub mod shell { } /// Parse the next substitution from the input string. - pub fn parse_next_substitution(s: &str) -> Option<(Substitution, &str)> { + pub fn parse_next_substitution(s: &str) -> Option<(Substitution<'_>, &str)> { let at = { let start = s.find('$')?; match s[start+1..].chars().next()? { @@ -868,7 +868,7 @@ pub mod shell { } } - fn at_next_cp_while(mut cur: Cur, mut pred: F) -> Cur + fn at_next_cp_while(mut cur: Cur<'_>, mut pred: F) -> Cur<'_> where F: FnMut(char) -> bool { loop { match cur.next_cp() { @@ -962,8 +962,6 @@ pub mod shell { } mod strcursor { - use std; - pub struct StrCursor<'a> { s: &'a str, pub at: usize, @@ -1028,7 +1026,7 @@ mod strcursor { } } - impl<'a> Copy for StrCursor<'a> {} + impl Copy for StrCursor<'_> {} impl<'a> Clone for StrCursor<'a> { fn clone(&self) -> StrCursor<'a> { @@ -1036,8 +1034,8 @@ mod strcursor { } } - impl<'a> std::fmt::Debug for StrCursor<'a> { - fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result { + impl std::fmt::Debug for StrCursor<'_> { + fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(fmt, "StrCursor({:?} | {:?})", self.slice_before(), self.slice_after()) } } diff --git a/src/libsyntax_ext/global_asm.rs b/src/libsyntax_ext/global_asm.rs index 0a12e27c4fc21..14dbd9300232b 100644 --- a/src/libsyntax_ext/global_asm.rs +++ b/src/libsyntax_ext/global_asm.rs @@ -8,21 +8,22 @@ /// LLVM's `module asm "some assembly here"`. All of LLVM's caveats /// therefore apply. -use errors::DiagnosticBuilder; +use crate::errors::DiagnosticBuilder; + use syntax::ast; use syntax::source_map::respan; -use syntax::ext::base; -use syntax::ext::base::*; +use syntax::ext::base::{self, *}; use syntax::feature_gate; use syntax::parse::token; use syntax::ptr::P; use syntax::symbol::Symbol; use syntax_pos::Span; use syntax::tokenstream; +use smallvec::smallvec; pub const MACRO: &str = "global_asm"; -pub fn expand_global_asm<'cx>(cx: &'cx mut ExtCtxt, +pub fn expand_global_asm<'cx>(cx: &'cx mut ExtCtxt<'_>, sp: Span, tts: &[tokenstream::TokenTree]) -> Box { if !cx.ecfg.enable_global_asm() { diff --git a/src/libsyntax_ext/lib.rs b/src/libsyntax_ext/lib.rs index 5e767d237cc0e..9308cfb3a4f2e 100644 --- a/src/libsyntax_ext/lib.rs +++ b/src/libsyntax_ext/lib.rs @@ -4,29 +4,21 @@ html_favicon_url = "https://doc.rust-lang.org/favicon.ico", html_root_url = "https://doc.rust-lang.org/nightly/")] +#![deny(rust_2018_idioms)] + #![feature(in_band_lifetimes)] #![feature(proc_macro_diagnostic)] #![feature(proc_macro_internals)] #![feature(proc_macro_span)] #![feature(decl_macro)] -#![feature(nll)] #![feature(str_escape)] #![feature(rustc_diagnostic_macros)] #![recursion_limit="256"] -extern crate fmt_macros; -#[macro_use] -extern crate syntax; -extern crate syntax_pos; extern crate proc_macro; -extern crate rustc_data_structures; -extern crate rustc_errors as errors; -extern crate rustc_target; -#[macro_use] -extern crate smallvec; -#[macro_use] -extern crate log; + +use rustc_errors as errors; mod diagnostics; diff --git a/src/libsyntax_ext/log_syntax.rs b/src/libsyntax_ext/log_syntax.rs index a143186b9451f..658ce98d26884 100644 --- a/src/libsyntax_ext/log_syntax.rs +++ b/src/libsyntax_ext/log_syntax.rs @@ -4,7 +4,7 @@ use syntax::print; use syntax::tokenstream; use syntax_pos; -pub fn expand_syntax_ext<'cx>(cx: &'cx mut base::ExtCtxt, +pub fn expand_syntax_ext<'cx>(cx: &'cx mut base::ExtCtxt<'_>, sp: syntax_pos::Span, tts: &[tokenstream::TokenTree]) -> Box { diff --git a/src/libsyntax_ext/proc_macro_decls.rs b/src/libsyntax_ext/proc_macro_decls.rs index 46c502965eea8..fbc4d8990742c 100644 --- a/src/libsyntax_ext/proc_macro_decls.rs +++ b/src/libsyntax_ext/proc_macro_decls.rs @@ -1,6 +1,7 @@ use std::mem; -use errors; +use crate::deriving; +use crate::errors; use syntax::ast::{self, Ident}; use syntax::attr; @@ -18,8 +19,6 @@ use syntax::visit::{self, Visitor}; use syntax_pos::{Span, DUMMY_SP}; -use deriving; - const PROC_MACRO_KINDS: [&str; 3] = ["proc_macro_derive", "proc_macro_attribute", "proc_macro"]; struct ProcMacroDerive { @@ -324,7 +323,7 @@ impl<'a> Visitor<'a> for CollectProcMacros<'a> { // ]; // } fn mk_decls( - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, custom_derives: &[ProcMacroDerive], custom_attrs: &[ProcMacroDef], custom_macros: &[ProcMacroDef], diff --git a/src/libsyntax_ext/proc_macro_impl.rs b/src/libsyntax_ext/proc_macro_impl.rs index 60d167d01eebe..88e20e3dc7c9e 100644 --- a/src/libsyntax_ext/proc_macro_impl.rs +++ b/src/libsyntax_ext/proc_macro_impl.rs @@ -1,27 +1,27 @@ -use errors::FatalError; +use crate::errors::FatalError; +use crate::proc_macro_server; use syntax::source_map::Span; -use syntax::ext::base::*; +use syntax::ext::base::{self, *}; use syntax::tokenstream::TokenStream; -use syntax::ext::base; -pub const EXEC_STRATEGY: ::proc_macro::bridge::server::SameThread = - ::proc_macro::bridge::server::SameThread; +pub const EXEC_STRATEGY: proc_macro::bridge::server::SameThread = + proc_macro::bridge::server::SameThread; pub struct AttrProcMacro { - pub client: ::proc_macro::bridge::client::Client< - fn(::proc_macro::TokenStream, ::proc_macro::TokenStream) -> ::proc_macro::TokenStream, + pub client: proc_macro::bridge::client::Client< + fn(proc_macro::TokenStream, proc_macro::TokenStream) -> proc_macro::TokenStream, >, } impl base::AttrProcMacro for AttrProcMacro { fn expand<'cx>(&self, - ecx: &'cx mut ExtCtxt, + ecx: &'cx mut ExtCtxt<'_>, span: Span, annotation: TokenStream, annotated: TokenStream) -> TokenStream { - let server = ::proc_macro_server::Rustc::new(ecx); + let server = proc_macro_server::Rustc::new(ecx); match self.client.run(&EXEC_STRATEGY, server, annotation, annotated) { Ok(stream) => stream, Err(e) => { @@ -39,18 +39,18 @@ impl base::AttrProcMacro for AttrProcMacro { } pub struct BangProcMacro { - pub client: ::proc_macro::bridge::client::Client< - fn(::proc_macro::TokenStream) -> ::proc_macro::TokenStream, + pub client: proc_macro::bridge::client::Client< + fn(proc_macro::TokenStream) -> proc_macro::TokenStream, >, } impl base::ProcMacro for BangProcMacro { fn expand<'cx>(&self, - ecx: &'cx mut ExtCtxt, + ecx: &'cx mut ExtCtxt<'_>, span: Span, input: TokenStream) -> TokenStream { - let server = ::proc_macro_server::Rustc::new(ecx); + let server = proc_macro_server::Rustc::new(ecx); match self.client.run(&EXEC_STRATEGY, server, input) { Ok(stream) => stream, Err(e) => { diff --git a/src/libsyntax_ext/proc_macro_server.rs b/src/libsyntax_ext/proc_macro_server.rs index 7de9b9343a8fa..730262683c0b7 100644 --- a/src/libsyntax_ext/proc_macro_server.rs +++ b/src/libsyntax_ext/proc_macro_server.rs @@ -1,4 +1,5 @@ -use errors::{self, Diagnostic, DiagnosticBuilder}; +use crate::errors::{self, Diagnostic, DiagnosticBuilder}; + use std::panic; use proc_macro::bridge::{server, TokenTree}; @@ -369,7 +370,7 @@ pub(crate) struct Rustc<'a> { } impl<'a> Rustc<'a> { - pub fn new(cx: &'a ExtCtxt) -> Self { + pub fn new(cx: &'a ExtCtxt<'_>) -> Self { // No way to determine def location for a proc macro right now, so use call location. let location = cx.current_expansion.mark.expn_info().unwrap().call_site; let to_span = |transparency| { @@ -650,7 +651,7 @@ impl server::Literal for Rustc<'_> { } } -impl<'a> server::SourceFile for Rustc<'a> { +impl server::SourceFile for Rustc<'_> { fn eq(&mut self, file1: &Self::SourceFile, file2: &Self::SourceFile) -> bool { Lrc::ptr_eq(file1, file2) } diff --git a/src/libsyntax_ext/test.rs b/src/libsyntax_ext/test.rs index 11c734b299c1e..832bebb6113e9 100644 --- a/src/libsyntax_ext/test.rs +++ b/src/libsyntax_ext/test.rs @@ -13,7 +13,7 @@ use syntax::source_map::{ExpnInfo, MacroAttribute}; use std::iter; pub fn expand_test( - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, attr_sp: Span, _meta_item: &ast::MetaItem, item: Annotatable, @@ -22,7 +22,7 @@ pub fn expand_test( } pub fn expand_bench( - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, attr_sp: Span, _meta_item: &ast::MetaItem, item: Annotatable, @@ -31,7 +31,7 @@ pub fn expand_bench( } pub fn expand_test_or_bench( - cx: &mut ExtCtxt, + cx: &mut ExtCtxt<'_>, attr_sp: Span, item: Annotatable, is_bench: bool @@ -180,7 +180,7 @@ pub fn expand_test_or_bench( ast::ItemKind::ExternCrate(Some(Symbol::intern("test"))) ); - debug!("Synthetic test item:\n{}\n", pprust::item_to_string(&test_const)); + log::debug!("Synthetic test item:\n{}\n", pprust::item_to_string(&test_const)); vec![ // Access to libtest under a gensymed name @@ -210,7 +210,7 @@ fn should_fail(i: &ast::Item) -> bool { attr::contains_name(&i.attrs, "allow_fail") } -fn should_panic(cx: &ExtCtxt, i: &ast::Item) -> ShouldPanic { +fn should_panic(cx: &ExtCtxt<'_>, i: &ast::Item) -> ShouldPanic { match attr::find_by_name(&i.attrs, "should_panic") { Some(attr) => { let ref sd = cx.parse_sess.span_diagnostic; @@ -243,7 +243,7 @@ fn should_panic(cx: &ExtCtxt, i: &ast::Item) -> ShouldPanic { } } -fn has_test_signature(cx: &ExtCtxt, i: &ast::Item) -> bool { +fn has_test_signature(cx: &ExtCtxt<'_>, i: &ast::Item) -> bool { let has_should_panic_attr = attr::contains_name(&i.attrs, "should_panic"); let ref sd = cx.parse_sess.span_diagnostic; if let ast::ItemKind::Fn(ref decl, ref header, ref generics, _) = i.node { @@ -296,7 +296,7 @@ fn has_test_signature(cx: &ExtCtxt, i: &ast::Item) -> bool { } } -fn has_bench_signature(cx: &ExtCtxt, i: &ast::Item) -> bool { +fn has_bench_signature(cx: &ExtCtxt<'_>, i: &ast::Item) -> bool { let has_sig = if let ast::ItemKind::Fn(ref decl, _, _, _) = i.node { // N.B., inadequate check, but we're running // well before resolve, can't get too deep. diff --git a/src/libsyntax_ext/test_case.rs b/src/libsyntax_ext/test_case.rs index 04e33671872f5..63417b702d569 100644 --- a/src/libsyntax_ext/test_case.rs +++ b/src/libsyntax_ext/test_case.rs @@ -20,7 +20,7 @@ use syntax::source_map::{ExpnInfo, MacroAttribute}; use syntax::feature_gate; pub fn expand( - ecx: &mut ExtCtxt, + ecx: &mut ExtCtxt<'_>, attr_sp: Span, _meta_item: &ast::MetaItem, anno_item: Annotatable diff --git a/src/libsyntax_ext/trace_macros.rs b/src/libsyntax_ext/trace_macros.rs index 638d7b5568bfb..4d35daf3de998 100644 --- a/src/libsyntax_ext/trace_macros.rs +++ b/src/libsyntax_ext/trace_macros.rs @@ -1,11 +1,10 @@ -use syntax::ext::base::ExtCtxt; -use syntax::ext::base; +use syntax::ext::base::{self, ExtCtxt}; use syntax::feature_gate; use syntax::symbol::keywords; use syntax_pos::Span; use syntax::tokenstream::TokenTree; -pub fn expand_trace_macros(cx: &mut ExtCtxt, +pub fn expand_trace_macros(cx: &mut ExtCtxt<'_>, sp: Span, tt: &[TokenTree]) -> Box { From 4847c097b46265963bbf9cd8006456b3ff31169b Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Mon, 4 Feb 2019 22:41:39 +0900 Subject: [PATCH 063/278] Add #[must_use] to core::task::Poll --- src/libcore/task/poll.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/libcore/task/poll.rs b/src/libcore/task/poll.rs index 27b1139e15c79..ac656153519e1 100644 --- a/src/libcore/task/poll.rs +++ b/src/libcore/task/poll.rs @@ -7,6 +7,7 @@ use result::Result; /// Indicates whether a value is available or if the current task has been /// scheduled to receive a wakeup instead. +#[must_use = "this `Poll` may be a `Pending` variant, which should be handled"] #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] pub enum Poll { /// Represents that a value is immediately ready. From 927614ff3ea38014549e24152fd3198532919b2c Mon Sep 17 00:00:00 2001 From: ljedrz Date: Mon, 4 Feb 2019 11:09:32 +0100 Subject: [PATCH 064/278] hir: more HirId methods --- src/librustc/hir/map/mod.rs | 60 +++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 977ab05b20932..d35306ba353a3 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -401,6 +401,12 @@ impl<'hir> Map<'hir> { } } + // FIXME(@ljedrz): replace the NodeId variant + pub fn describe_def_by_hir_id(&self, hir_id: HirId) -> Option { + let node_id = self.hir_to_node_id(hir_id); + self.describe_def(node_id) + } + fn entry_count(&self) -> usize { self.map.len() } @@ -445,6 +451,12 @@ impl<'hir> Map<'hir> { } } + // FIXME(@ljedrz): replace the NodeId variant + pub fn fn_decl_by_hir_id(&self, hir_id: HirId) -> Option { + let node_id = self.hir_to_node_id(hir_id); + self.fn_decl(node_id) + } + /// Returns the `NodeId` that corresponds to the definition of /// which this is the body of, i.e., a `fn`, `const` or `static` /// item (possibly associated), a closure, or a `hir::AnonConst`. @@ -855,6 +867,12 @@ impl<'hir> Map<'hir> { self.local_def_id(self.get_parent(id)) } + // FIXME(@ljedrz): replace the NodeId variant + pub fn get_parent_did_by_hir_id(&self, id: HirId) -> DefId { + let node_id = self.hir_to_node_id(id); + self.get_parent_did(node_id) + } + pub fn get_foreign_abi(&self, id: NodeId) -> Abi { let parent = self.get_parent(id); if let Some(entry) = self.find_entry(parent) { @@ -868,6 +886,12 @@ impl<'hir> Map<'hir> { bug!("expected foreign mod or inlined parent, found {}", self.node_to_string(parent)) } + // FIXME(@ljedrz): replace the NodeId variant + pub fn get_foreign_abi_by_hir_id(&self, id: HirId) -> Abi { + let node_id = self.hir_to_node_id(id); + self.get_foreign_abi(node_id) + } + pub fn expect_item(&self, id: NodeId) -> &'hir Item { match self.find(id) { // read recorded by `find` Some(Node::Item(item)) => item, @@ -888,6 +912,18 @@ impl<'hir> Map<'hir> { } } + // FIXME(@ljedrz): replace the NodeId variant + pub fn expect_impl_item_by_hir_id(&self, id: HirId) -> &'hir ImplItem { + let node_id = self.hir_to_node_id(id); + self.expect_impl_item(node_id) + } + + // FIXME(@ljedrz): replace the NodeId variant + pub fn expect_trait_item_by_hir_id(&self, id: HirId) -> &'hir TraitItem { + let node_id = self.hir_to_node_id(id); + self.expect_trait_item(node_id) + } + pub fn expect_trait_item(&self, id: NodeId) -> &'hir TraitItem { match self.find(id) { Some(Node::TraitItem(item)) => item, @@ -931,6 +967,12 @@ impl<'hir> Map<'hir> { } } + // FIXME(@ljedrz): replace the NodeId variant + pub fn expect_expr_by_hir_id(&self, id: HirId) -> &'hir Expr { + let node_id = self.hir_to_node_id(id); + self.expect_expr(node_id) + } + /// Returns the name associated with the given NodeId's AST. pub fn name(&self, id: NodeId) -> Name { match self.get(id) { @@ -948,6 +990,12 @@ impl<'hir> Map<'hir> { } } + // FIXME(@ljedrz): replace the NodeId variant + pub fn name_by_hir_id(&self, id: HirId) -> Name { + let node_id = self.hir_to_node_id(id); + self.name(node_id) + } + /// Given a node ID, get a list of attributes associated with the AST /// corresponding to the Node ID pub fn attrs(&self, id: NodeId) -> &'hir [ast::Attribute] { @@ -970,6 +1018,12 @@ impl<'hir> Map<'hir> { attrs.unwrap_or(&[]) } + // FIXME(@ljedrz): replace the NodeId variant + pub fn attrs_by_hir_id(&self, id: HirId) -> &'hir [ast::Attribute] { + let node_id = self.hir_to_node_id(id); + self.attrs(node_id) + } + /// Returns an iterator that yields the node id's with paths that /// match `parts`. (Requires `parts` is non-empty.) /// @@ -1019,6 +1073,12 @@ impl<'hir> Map<'hir> { } } + // FIXME(@ljedrz): replace the NodeId variant + pub fn span_by_hir_id(&self, id: HirId) -> Span { + let node_id = self.hir_to_node_id(id); + self.span(node_id) + } + pub fn span_if_local(&self, id: DefId) -> Option { self.as_local_node_id(id).map(|id| self.span(id)) } From d0f88c4da31b3a3ff2a0b62342b3d36e0c0bd6cf Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Mon, 4 Feb 2019 14:59:06 +0100 Subject: [PATCH 065/278] Prevent automatic collapse of methods impl blocks --- src/librustdoc/html/static/main.js | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js index 82604cc7ad8bb..631d8236464ae 100644 --- a/src/librustdoc/html/static/main.js +++ b/src/librustdoc/html/static/main.js @@ -1887,12 +1887,30 @@ if (!DOMTokenList.prototype.remove) { updateLocalStorage("rustdoc-collapse", "true"); addClass(innerToggle, "will-expand"); onEveryMatchingChild(innerToggle, "inner", function(e) { - e.innerHTML = labelForToggleButton(true); + var parent = e.parentNode; + var superParent = null; + + if (parent) { + superParent = parent.parentNode; + } + if (!parent || !superParent || superParent.id !== "main" || + hasClass(parent, "impl") === false) { + e.innerHTML = labelForToggleButton(true); + } }); innerToggle.title = "expand all docs"; if (fromAutoCollapse !== true) { onEachLazy(document.getElementsByClassName("collapse-toggle"), function(e) { - collapseDocs(e, "hide", pageId); + var parent = e.parentNode; + var superParent = null; + + if (parent) { + superParent = parent.parentNode; + } + if (!parent || !superParent || superParent.id !== "main" || + hasClass(parent, "impl") === false) { + collapseDocs(e, "hide", pageId); + } }); } } From 4ca3c7b156f0ecb18c15e91800b6933a5c0f47b4 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Tue, 5 Feb 2019 01:21:07 +0900 Subject: [PATCH 066/278] update rust-installer from 27dec6c to ccdc47b --- src/tools/rust-installer | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/rust-installer b/src/tools/rust-installer index 27dec6cae3a81..ccdc47b657a76 160000 --- a/src/tools/rust-installer +++ b/src/tools/rust-installer @@ -1 +1 @@ -Subproject commit 27dec6cae3a8132d8a073aad6775425c85095c99 +Subproject commit ccdc47b657a7600cbd0c2858eb52a8d712cfce18 From bd4df0c6dd95b93a2157922970b8c7b97b9db086 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Tue, 5 Feb 2019 01:31:48 +0900 Subject: [PATCH 067/278] Add Cargo.lock automatically adding message --- Cargo.lock | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Cargo.lock b/Cargo.lock index b52f2094584ce..6121ee0ccf75a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,3 +1,5 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. [[package]] name = "adler32" version = "1.0.3" From 59ea75b51ce3100d8e176551b41ec99330b8e011 Mon Sep 17 00:00:00 2001 From: Pietro Albini Date: Mon, 4 Feb 2019 19:27:43 +0100 Subject: [PATCH 068/278] add more debugging code to track down appveyor 259 exit code --- appveyor.yml | 5 ++++- src/ci/run.sh | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index d70ad54b1c812..0ec4210af98b2 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -207,7 +207,10 @@ test_script: - sh src/ci/init_repo.sh . /c/cache/rustsrc - set SRC=. - set NO_CCACHE=1 - - sh src/ci/run.sh + # Added this debugging code to try tracking down https://github.com/rust-lang/rust/issues/58160 + # Replace it with the commented line below after the issue with AppVeyor is fixed + - "sh src/ci/run.sh & set ret=%errorlevel% & echo exit code in appveyor.yml: %ret% & exit %ret%" +# - sh src/ci/run.sh on_failure: # Dump crash log diff --git a/src/ci/run.sh b/src/ci/run.sh index 0f2517c7d1f55..b8b1052c41c12 100755 --- a/src/ci/run.sh +++ b/src/ci/run.sh @@ -127,7 +127,7 @@ if [ ! -z "$SCRIPT" ]; then set +e sh -x -c "$SCRIPT" ret=$? - echo "script exited with $ret" + echo "exit code in src/ci/run.sh: $ret" exit $ret else do_make() { From 57c4c2863d4e1a18d668fdd79cab210105deb13c Mon Sep 17 00:00:00 2001 From: Melody Horn Date: Mon, 4 Feb 2019 14:43:30 -0700 Subject: [PATCH 069/278] Update contributor name in .mailmap --- .mailmap | 1 + 1 file changed, 1 insertion(+) diff --git a/.mailmap b/.mailmap index a928606b693e5..d265f45c5cafa 100644 --- a/.mailmap +++ b/.mailmap @@ -155,6 +155,7 @@ Matt Brubeck Matthew Auld Matthew McPherrin Matthijs Hofstra +Melody Horn Michael Williams Michael Woerister Mickaël Raybaud-Roig m-r-r From 75b19579fb22b91ded35cdda3c381b17faa63798 Mon Sep 17 00:00:00 2001 From: garyemerson Date: Mon, 4 Feb 2019 15:26:33 -0800 Subject: [PATCH 070/278] update split docs Some confusion about split popped up at https://news.ycombinator.com/item?id=19080931 since the docs sorta sound like `&str`, `char` and closures are the only types that can be patterns. cc @steveklabnik --- src/libcore/str/mod.rs | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index 130142103a9ba..e9190cc3ddf1b 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -2961,8 +2961,8 @@ impl str { /// An iterator over substrings of this string slice, separated by /// characters matched by a pattern. /// - /// The pattern can be a `&str`, [`char`], or a closure that determines the - /// split. + /// The pattern can be any type that implements the Pattern trait. Notable + /// examples are `&str`, [`char`], and closures that determines the split. /// /// # Iterator behavior /// @@ -3078,8 +3078,8 @@ impl str { /// An iterator over substrings of the given string slice, separated by /// characters matched by a pattern and yielded in reverse order. /// - /// The pattern can be a `&str`, [`char`], or a closure that determines the - /// split. + /// The pattern can be any type that implements the Pattern trait. Notable + /// examples are `&str`, [`char`], and closures that determines the split. /// /// # Iterator behavior /// @@ -3128,8 +3128,8 @@ impl str { /// An iterator over substrings of the given string slice, separated by /// characters matched by a pattern. /// - /// The pattern can be a `&str`, [`char`], or a closure that determines the - /// split. + /// The pattern can be any type that implements the Pattern trait. Notable + /// examples are `&str`, [`char`], and closures that determines the split. /// /// Equivalent to [`split`], except that the trailing substring /// is skipped if empty. @@ -3175,8 +3175,8 @@ impl str { /// An iterator over substrings of `self`, separated by characters /// matched by a pattern and yielded in reverse order. /// - /// The pattern can be a simple `&str`, [`char`], or a closure that - /// determines the split. + /// The pattern can be any type that implements the Pattern trait. Notable + /// examples are `&str`, [`char`], and closures that determines the split. /// Additional libraries might provide more complex patterns like /// regular expressions. /// @@ -3222,8 +3222,8 @@ impl str { /// If `n` substrings are returned, the last substring (the `n`th substring) /// will contain the remainder of the string. /// - /// The pattern can be a `&str`, [`char`], or a closure that determines the - /// split. + /// The pattern can be any type that implements the Pattern trait. Notable + /// examples are `&str`, [`char`], and closures that determines the split. /// /// # Iterator behavior /// @@ -3275,8 +3275,8 @@ impl str { /// If `n` substrings are returned, the last substring (the `n`th substring) /// will contain the remainder of the string. /// - /// The pattern can be a `&str`, [`char`], or a closure that - /// determines the split. + /// The pattern can be any type that implements the Pattern trait. Notable + /// examples are `&str`, [`char`], and closures that determines the split. /// /// # Iterator behavior /// @@ -3319,8 +3319,8 @@ impl str { /// An iterator over the disjoint matches of a pattern within the given string /// slice. /// - /// The pattern can be a `&str`, [`char`], or a closure that - /// determines if a character matches. + /// The pattern can be any type that implements the Pattern trait. Notable + /// examples are `&str`, [`char`], and closures that determines the split. /// /// # Iterator behavior /// From 5d9eed4191c3edae4704737a95706dcf714334f8 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Mon, 4 Feb 2019 00:05:53 +0900 Subject: [PATCH 071/278] Transition build-manifest to 2018 edition --- src/tools/build-manifest/Cargo.toml | 1 + src/tools/build-manifest/src/main.rs | 4 +++- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/tools/build-manifest/Cargo.toml b/src/tools/build-manifest/Cargo.toml index 844b7aad72fde..0fda887ea61fe 100644 --- a/src/tools/build-manifest/Cargo.toml +++ b/src/tools/build-manifest/Cargo.toml @@ -2,6 +2,7 @@ name = "build-manifest" version = "0.1.0" authors = ["Alex Crichton "] +edition = "2018" [dependencies] toml = "0.4" diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs index 4ca285b9b1db1..5e8559725f134 100644 --- a/src/tools/build-manifest/src/main.rs +++ b/src/tools/build-manifest/src/main.rs @@ -1,4 +1,6 @@ -extern crate toml; +#![deny(rust_2018_idioms)] + +use toml; #[macro_use] extern crate serde_derive; From 212533afbe352e74c6c8bb64c2d8b526cfa15350 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Tue, 5 Feb 2019 01:11:08 +0900 Subject: [PATCH 072/278] Remove macro_use --- src/tools/build-manifest/src/main.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs index 5e8559725f134..9d88ac8dd0498 100644 --- a/src/tools/build-manifest/src/main.rs +++ b/src/tools/build-manifest/src/main.rs @@ -1,8 +1,7 @@ #![deny(rust_2018_idioms)] use toml; -#[macro_use] -extern crate serde_derive; +use serde_derive::Serialize; use std::collections::BTreeMap; use std::env; From 6904fac6d915b9bb3538ac2e6fbd31ad301a64c8 Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Tue, 5 Feb 2019 10:51:47 +0900 Subject: [PATCH 073/278] Use derive feature of serde --- src/tools/build-manifest/Cargo.toml | 2 +- src/tools/build-manifest/src/main.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tools/build-manifest/Cargo.toml b/src/tools/build-manifest/Cargo.toml index 0fda887ea61fe..93d0f61e1d9f0 100644 --- a/src/tools/build-manifest/Cargo.toml +++ b/src/tools/build-manifest/Cargo.toml @@ -6,5 +6,5 @@ edition = "2018" [dependencies] toml = "0.4" -serde = "1.0" +serde = { version = "1.0", features = ["derive"] } serde_derive = "1.0" diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs index 9d88ac8dd0498..335cd617759a9 100644 --- a/src/tools/build-manifest/src/main.rs +++ b/src/tools/build-manifest/src/main.rs @@ -1,7 +1,7 @@ #![deny(rust_2018_idioms)] use toml; -use serde_derive::Serialize; +use serde::Serialize; use std::collections::BTreeMap; use std::env; From 47a587fb2b8f654aa165e2f87e533bc99b1546fd Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Tue, 5 Feb 2019 10:59:18 +0900 Subject: [PATCH 074/278] Remove unncessary return statement --- src/tools/build-manifest/src/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs index 335cd617759a9..a51eb4b4a10ad 100644 --- a/src/tools/build-manifest/src/main.rs +++ b/src/tools/build-manifest/src/main.rs @@ -469,7 +469,7 @@ impl Builder { } manifest.pkg.insert("rust".to_string(), pkg); - return manifest; + manifest } fn profile(&mut self, From b9686416c63117db3832e8015b609cbc83f11e4b Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 5 Feb 2019 15:09:23 +1100 Subject: [PATCH 075/278] Remove some unnecessary `ast::` and `fold::` qualifiers. --- src/libsyntax/ext/expand.rs | 7 ++-- src/libsyntax/fold.rs | 76 +++++++++++++++++-------------------- 2 files changed, 37 insertions(+), 46 deletions(-) diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 1b4b44270ad06..957187ec71c61 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -9,7 +9,6 @@ use ext::derive::{add_derived_markers, collect_derives}; use ext::hygiene::{self, Mark, SyntaxContext}; use ext::placeholders::{placeholder, PlaceholderExpander}; use feature_gate::{self, Features, GateIssue, is_builtin_attr, emit_feature_err}; -use fold; use fold::*; use parse::{DirectoryOwnership, PResult, ParseSess}; use parse::token::{self, Token}; @@ -1395,7 +1394,7 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { self.check_attributes(&attrs); self.collect_bang(mac, span, AstFragmentKind::TraitItems).make_trait_items() } - _ => fold::noop_fold_trait_item(item, self), + _ => noop_fold_trait_item(item, self), } } @@ -1414,14 +1413,14 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { self.check_attributes(&attrs); self.collect_bang(mac, span, AstFragmentKind::ImplItems).make_impl_items() } - _ => fold::noop_fold_impl_item(item, self), + _ => noop_fold_impl_item(item, self), } } fn fold_ty(&mut self, ty: P) -> P { let ty = match ty.node { ast::TyKind::Mac(_) => ty.into_inner(), - _ => return fold::noop_fold_ty(ty, self), + _ => return noop_fold_ty(ty, self), }; match ty.node { diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index fdcbbb939a6cf..d8afad5e37912 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -9,7 +9,6 @@ //! that are created by the expansion of a macro. use ast::*; -use ast; use syntax_pos::Span; use source_map::{Spanned, respan}; use parse::token::{self, Token}; @@ -785,31 +784,26 @@ pub fn noop_fold_where_predicate( fld: &mut T) -> WherePredicate { match pred { - ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate{bound_generic_params, - bounded_ty, - bounds, - span}) => { - ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate { + WherePredicate::BoundPredicate(WhereBoundPredicate { bound_generic_params, + bounded_ty, + bounds, + span }) => { + WherePredicate::BoundPredicate(WhereBoundPredicate { bound_generic_params: fld.fold_generic_params(bound_generic_params), bounded_ty: fld.fold_ty(bounded_ty), bounds: bounds.move_map(|x| fld.fold_param_bound(x)), span: fld.new_span(span) }) } - ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate{lifetime, - bounds, - span}) => { - ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate { + WherePredicate::RegionPredicate(WhereRegionPredicate { lifetime, bounds, span }) => { + WherePredicate::RegionPredicate(WhereRegionPredicate { span: fld.new_span(span), lifetime: noop_fold_lifetime(lifetime, fld), bounds: bounds.move_map(|bound| noop_fold_param_bound(bound, fld)) }) } - ast::WherePredicate::EqPredicate(ast::WhereEqPredicate{id, - lhs_ty, - rhs_ty, - span}) => { - ast::WherePredicate::EqPredicate(ast::WhereEqPredicate{ + WherePredicate::EqPredicate(WhereEqPredicate { id, lhs_ty, rhs_ty, span }) => { + WherePredicate::EqPredicate(WhereEqPredicate{ id: fld.new_id(id), lhs_ty: fld.fold_ty(lhs_ty), rhs_ty: fld.fold_ty(rhs_ty), @@ -821,15 +815,13 @@ pub fn noop_fold_where_predicate( pub fn noop_fold_variant_data(vdata: VariantData, fld: &mut T) -> VariantData { match vdata { - ast::VariantData::Struct(fields, id) => { - ast::VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)), - fld.new_id(id)) + VariantData::Struct(fields, id) => { + VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id)) } - ast::VariantData::Tuple(fields, id) => { - ast::VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)), - fld.new_id(id)) + VariantData::Tuple(fields, id) => { + VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id)) } - ast::VariantData::Unit(id) => ast::VariantData::Unit(fld.new_id(id)) + VariantData::Unit(id) => VariantData::Unit(fld.new_id(id)) } } @@ -839,14 +831,14 @@ pub fn noop_fold_trait_ref(p: TraitRef, fld: &mut T) -> TraitRef { path, ref_id: _, } = p; - ast::TraitRef { + TraitRef { path: fld.fold_path(path), ref_id: id, } } pub fn noop_fold_poly_trait_ref(p: PolyTraitRef, fld: &mut T) -> PolyTraitRef { - ast::PolyTraitRef { + PolyTraitRef { bound_generic_params: fld.fold_generic_params(p.bound_generic_params), trait_ref: fld.fold_trait_ref(p.trait_ref), span: fld.new_span(p.span), @@ -932,7 +924,7 @@ pub fn noop_fold_item_kind(i: ItemKind, folder: &mut T) -> ItemKind { ItemKind::Enum(enum_definition, generics) => { let generics = folder.fold_generics(generics); let variants = enum_definition.variants.move_map(|x| folder.fold_variant(x)); - ItemKind::Enum(ast::EnumDef { variants }, generics) + ItemKind::Enum(EnumDef { variants }, generics) } ItemKind::Struct(struct_def, generics) => { let generics = folder.fold_generics(generics); @@ -991,7 +983,7 @@ pub fn noop_fold_trait_item(i: TraitItem, folder: &mut T) -> SmallVec TraitItemKind::Type(folder.fold_bounds(bounds), default.map(|x| folder.fold_ty(x))) } - ast::TraitItemKind::Macro(mac) => { + TraitItemKind::Macro(mac) => { TraitItemKind::Macro(folder.fold_mac(mac)) } }, @@ -1009,18 +1001,18 @@ pub fn noop_fold_impl_item(i: ImplItem, folder: &mut T)-> SmallVec<[I generics: folder.fold_generics(i.generics), defaultness: i.defaultness, node: match i.node { - ast::ImplItemKind::Const(ty, expr) => { - ast::ImplItemKind::Const(folder.fold_ty(ty), folder.fold_expr(expr)) + ImplItemKind::Const(ty, expr) => { + ImplItemKind::Const(folder.fold_ty(ty), folder.fold_expr(expr)) } - ast::ImplItemKind::Method(sig, body) => { - ast::ImplItemKind::Method(noop_fold_method_sig(sig, folder), + ImplItemKind::Method(sig, body) => { + ImplItemKind::Method(noop_fold_method_sig(sig, folder), folder.fold_block(body)) } - ast::ImplItemKind::Type(ty) => ast::ImplItemKind::Type(folder.fold_ty(ty)), - ast::ImplItemKind::Existential(bounds) => { - ast::ImplItemKind::Existential(folder.fold_bounds(bounds)) + ImplItemKind::Type(ty) => ImplItemKind::Type(folder.fold_ty(ty)), + ImplItemKind::Existential(bounds) => { + ImplItemKind::Existential(folder.fold_bounds(bounds)) }, - ast::ImplItemKind::Macro(mac) => ast::ImplItemKind::Macro(folder.fold_mac(mac)) + ImplItemKind::Macro(mac) => ImplItemKind::Macro(folder.fold_mac(mac)) }, span: folder.new_span(i.span), tokens: i.tokens, @@ -1042,13 +1034,13 @@ pub fn noop_fold_mod(Mod {inner, items, inline}: Mod, folder: &mut T) pub fn noop_fold_crate(Crate {module, attrs, span}: Crate, folder: &mut T) -> Crate { - let mut items = folder.fold_item(P(ast::Item { + let mut items = folder.fold_item(P(Item { ident: keywords::Invalid.ident(), attrs, - id: ast::DUMMY_NODE_ID, - vis: respan(span.shrink_to_lo(), ast::VisibilityKind::Public), + id: DUMMY_NODE_ID, + vis: respan(span.shrink_to_lo(), VisibilityKind::Public), span, - node: ast::ItemKind::Mod(module), + node: ItemKind::Mod(module), tokens: None, })).into_iter(); @@ -1056,14 +1048,14 @@ pub fn noop_fold_crate(Crate {module, attrs, span}: Crate, Some(item) => { assert!(items.next().is_none(), "a crate cannot expand to more than one item"); - item.and_then(|ast::Item { attrs, span, node, .. }| { + item.and_then(|Item { attrs, span, node, .. }| { match node { - ast::ItemKind::Mod(m) => (m, attrs, span), + ItemKind::Mod(m) => (m, attrs, span), _ => panic!("fold converted a module to not a module"), } }) } - None => (ast::Mod { + None => (Mod { inner: span, items: vec![], inline: true, @@ -1155,7 +1147,7 @@ pub fn noop_fold_pat(p: P, folder: &mut T) -> P { let pth = folder.fold_path(pth); let fs = fields.move_map(|f| { Spanned { span: folder.new_span(f.span), - node: ast::FieldPat { + node: FieldPat { ident: folder.fold_ident(f.node.ident), pat: folder.fold_pat(f.node.pat), is_shorthand: f.node.is_shorthand, From faa82eb46c800857756ddc5458623a906a9f103e Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 5 Feb 2019 15:10:04 +1100 Subject: [PATCH 076/278] Streamline `Folder`. Specifically: - Remove dead methods: fold_usize, fold_meta_items, fold_opt_bounds. - Remove useless methods: fold_global_asm, fold_range_end. - Inline and remove unnecessary methods: fold_item_simple, fold_foreign_item_simple. --- src/libsyntax/fold.rs | 97 +++++++++---------------------------------- 1 file changed, 20 insertions(+), 77 deletions(-) diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index d8afad5e37912..6f856f63d6c7f 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -45,10 +45,6 @@ pub trait Folder : Sized { noop_fold_crate(c, self) } - fn fold_meta_items(&mut self, meta_items: Vec) -> Vec { - noop_fold_meta_items(meta_items, self) - } - fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem { noop_fold_meta_list_item(list_item, self) } @@ -65,18 +61,10 @@ pub trait Folder : Sized { noop_fold_foreign_item(ni, self) } - fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem { - noop_fold_foreign_item_simple(ni, self) - } - fn fold_item(&mut self, i: P) -> SmallVec<[P; 1]> { noop_fold_item(i, self) } - fn fold_item_simple(&mut self, i: Item) -> Item { - noop_fold_item_simple(i, self) - } - fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader { noop_fold_fn_header(header, self) } @@ -133,10 +121,6 @@ pub trait Folder : Sized { e.map(|e| noop_fold_expr(e, self)) } - fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd { - noop_fold_range_end(re, self) - } - fn fold_opt_expr(&mut self, e: P) -> Option> { noop_fold_opt_expr(e, self) } @@ -172,10 +156,6 @@ pub trait Folder : Sized { noop_fold_foreign_mod(nm, self) } - fn fold_global_asm(&mut self, ga: P) -> P { - noop_fold_global_asm(ga, self) - } - fn fold_variant(&mut self, v: Variant) -> Variant { noop_fold_variant(v, self) } @@ -184,10 +164,6 @@ pub trait Folder : Sized { noop_fold_ident(i, self) } - fn fold_usize(&mut self, i: usize) -> usize { - noop_fold_usize(i, self) - } - fn fold_path(&mut self, p: Path) -> Path { noop_fold_path(p, self) } @@ -281,10 +257,6 @@ pub trait Folder : Sized { noop_fold_interpolated(nt, self) } - fn fold_opt_bounds(&mut self, b: Option) -> Option { - noop_fold_opt_bounds(b, self) - } - fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds { noop_fold_bounds(b, self) } @@ -324,10 +296,6 @@ pub trait Folder : Sized { } } -pub fn noop_fold_meta_items(meta_items: Vec, fld: &mut T) -> Vec { - meta_items.move_map(|x| fld.fold_meta_item(x)) -} - pub fn noop_fold_use_tree(use_tree: UseTree, fld: &mut T) -> UseTree { UseTree { span: fld.new_span(use_tree.span), @@ -430,11 +398,6 @@ pub fn noop_fold_foreign_mod(ForeignMod {abi, items}: ForeignMod, } } -pub fn noop_fold_global_asm(ga: P, - _: &mut T) -> P { - ga -} - pub fn noop_fold_variant(v: Variant, fld: &mut T) -> Variant { Spanned { node: Variant_ { @@ -451,10 +414,6 @@ pub fn noop_fold_ident(ident: Ident, fld: &mut T) -> Ident { Ident::new(ident.name, fld.new_span(ident.span)) } -pub fn noop_fold_usize(i: usize, _: &mut T) -> usize { - i -} - pub fn noop_fold_path(Path { segments, span }: Path, fld: &mut T) -> Path { Path { segments: segments.move_map(|PathSegment { ident, id, args }| PathSegment { @@ -873,11 +832,6 @@ pub fn noop_fold_mt(MutTy {ty, mutbl}: MutTy, folder: &mut T) -> MutT } } -pub fn noop_fold_opt_bounds(b: Option, folder: &mut T) - -> Option { - b.map(|bounds| folder.fold_bounds(bounds)) -} - fn noop_fold_bounds(bounds: GenericBounds, folder: &mut T) -> GenericBounds { bounds.move_map(|bound| folder.fold_param_bound(bound)) @@ -913,7 +867,7 @@ pub fn noop_fold_item_kind(i: ItemKind, folder: &mut T) -> ItemKind { } ItemKind::Mod(m) => ItemKind::Mod(folder.fold_mod(m)), ItemKind::ForeignMod(nm) => ItemKind::ForeignMod(folder.fold_foreign_mod(nm)), - ItemKind::GlobalAsm(ga) => ItemKind::GlobalAsm(folder.fold_global_asm(ga)), + ItemKind::GlobalAsm(ga) => ItemKind::GlobalAsm(ga), ItemKind::Ty(t, generics) => { ItemKind::Ty(folder.fold_ty(t), folder.fold_generics(generics)) } @@ -1071,34 +1025,27 @@ pub fn noop_fold_crate(Crate {module, attrs, span}: Crate, // fold one item into possibly many items pub fn noop_fold_item(i: P, folder: &mut T) -> SmallVec<[P; 1]> { - smallvec![i.map(|i| folder.fold_item_simple(i))] -} - -// fold one item into exactly one item -pub fn noop_fold_item_simple(Item {id, ident, attrs, node, vis, span, tokens}: Item, - folder: &mut T) -> Item { - Item { - id: folder.new_id(id), - vis: folder.fold_vis(vis), - ident: folder.fold_ident(ident), - attrs: fold_attrs(attrs, folder), - node: folder.fold_item_kind(node), - span: folder.new_span(span), - - // FIXME: if this is replaced with a call to `folder.fold_tts` it causes - // an ICE during resolve... odd! - tokens, - } + smallvec![i.map(|i| { + let Item {id, ident, attrs, node, vis, span, tokens} = i; + Item { + id: folder.new_id(id), + vis: folder.fold_vis(vis), + ident: folder.fold_ident(ident), + attrs: fold_attrs(attrs, folder), + node: folder.fold_item_kind(node), + span: folder.new_span(span), + + // FIXME: if this is replaced with a call to `folder.fold_tts` it causes + // an ICE during resolve... odd! + tokens, + } + })] } pub fn noop_fold_foreign_item(ni: ForeignItem, folder: &mut T) -> SmallVec<[ForeignItem; 1]> { - smallvec![folder.fold_foreign_item_simple(ni)] -} - -pub fn noop_fold_foreign_item_simple(ni: ForeignItem, folder: &mut T) -> ForeignItem { - ForeignItem { + smallvec![ForeignItem { id: folder.new_id(ni.id), vis: folder.fold_vis(ni.vis), ident: folder.fold_ident(ni.ident), @@ -1114,7 +1061,7 @@ pub fn noop_fold_foreign_item_simple(ni: ForeignItem, folder: &mut T) ForeignItemKind::Macro(mac) => ForeignItemKind::Macro(folder.fold_mac(mac)), }, span: folder.new_span(ni.span) - } + }] } pub fn noop_fold_method_sig(sig: MethodSig, folder: &mut T) -> MethodSig { @@ -1161,10 +1108,10 @@ pub fn noop_fold_pat(p: P, folder: &mut T) -> P { } PatKind::Box(inner) => PatKind::Box(folder.fold_pat(inner)), PatKind::Ref(inner, mutbl) => PatKind::Ref(folder.fold_pat(inner), mutbl), - PatKind::Range(e1, e2, Spanned { span, node: end }) => { + PatKind::Range(e1, e2, Spanned { span, node }) => { PatKind::Range(folder.fold_expr(e1), folder.fold_expr(e2), - Spanned { span, node: folder.fold_range_end(end) }) + Spanned { span, node }) }, PatKind::Slice(before, slice, after) => { PatKind::Slice(before.move_map(|x| folder.fold_pat(x)), @@ -1178,10 +1125,6 @@ pub fn noop_fold_pat(p: P, folder: &mut T) -> P { }) } -pub fn noop_fold_range_end(end: RangeEnd, _folder: &mut T) -> RangeEnd { - end -} - pub fn noop_fold_anon_const(constant: AnonConst, folder: &mut T) -> AnonConst { let AnonConst {id, value} = constant; AnonConst { From eea2dfe76f7afea0df3ae99fcdd30f1afbf4402d Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 5 Feb 2019 15:11:10 +1100 Subject: [PATCH 077/278] Fold some overlooked spans. --- src/libsyntax/fold.rs | 27 ++++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 6f856f63d6c7f..c01ac3107b6d8 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -734,7 +734,7 @@ pub fn noop_fold_where_clause( predicates: predicates.move_map(|predicate| { fld.fold_where_predicate(predicate) }), - span, + span: fld.new_span(span), } } @@ -1111,7 +1111,7 @@ pub fn noop_fold_pat(p: P, folder: &mut T) -> P { PatKind::Range(e1, e2, Spanned { span, node }) => { PatKind::Range(folder.fold_expr(e1), folder.fold_expr(e2), - Spanned { span, node }) + Spanned { node, span: folder.new_span(span) }) }, PatKind::Slice(before, slice, after) => { PatKind::Slice(before.move_map(|x| folder.fold_pat(x)), @@ -1342,15 +1342,20 @@ pub fn noop_fold_stmt_kind(node: StmtKind, folder: &mut T) -> SmallVe } } -pub fn noop_fold_vis(vis: Visibility, folder: &mut T) -> Visibility { - match vis.node { - VisibilityKind::Restricted { path, id } => { - respan(vis.span, VisibilityKind::Restricted { - path: path.map(|path| folder.fold_path(path)), - id: folder.new_id(id), - }) - } - _ => vis, +pub fn noop_fold_vis(Spanned { node, span }: Visibility, folder: &mut T) -> Visibility { + Visibility { + node: match node { + VisibilityKind::Public => VisibilityKind::Public, + VisibilityKind::Crate(sugar) => VisibilityKind::Crate(sugar), + VisibilityKind::Restricted { path, id } => { + VisibilityKind::Restricted { + path: path.map(|path| folder.fold_path(path)), + id: folder.new_id(id), + } + } + VisibilityKind::Inherited => VisibilityKind::Inherited, + }, + span: folder.new_span(span), } } From f97e896fd669b61051027d76d6dccb89c72c4c52 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 5 Feb 2019 15:11:27 +1100 Subject: [PATCH 078/278] Simplify `fold_attribute`. It doesn't need to return an `Option`. --- src/libsyntax/ext/expand.rs | 8 +++----- src/libsyntax/fold.rs | 16 ++++++---------- 2 files changed, 9 insertions(+), 15 deletions(-) diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 957187ec71c61..72e0a86bf5909 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -1465,7 +1465,7 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { noop_fold_generic_param(param, self) } - fn fold_attribute(&mut self, at: ast::Attribute) -> Option { + fn fold_attribute(&mut self, at: ast::Attribute) -> ast::Attribute { // turn `#[doc(include="filename")]` attributes into `#[doc(include(file="filename", // contents="file contents")]` attributes if !at.check_name("doc") { @@ -1585,10 +1585,8 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { let meta = attr::mk_list_item(DUMMY_SP, Ident::from_str("doc"), items); match at.style { - ast::AttrStyle::Inner => - Some(attr::mk_spanned_attr_inner(at.span, at.id, meta)), - ast::AttrStyle::Outer => - Some(attr::mk_spanned_attr_outer(at.span, at.id, meta)), + ast::AttrStyle::Inner => attr::mk_spanned_attr_inner(at.span, at.id, meta), + ast::AttrStyle::Outer => attr::mk_spanned_attr_outer(at.span, at.id, meta), } } else { noop_fold_attribute(at, self) diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index c01ac3107b6d8..1ab1de1ba5c33 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -209,7 +209,7 @@ pub trait Folder : Sized { noop_fold_label(label, self) } - fn fold_attribute(&mut self, at: Attribute) -> Option { + fn fold_attribute(&mut self, at: Attribute) -> Attribute { noop_fold_attribute(at, self) } @@ -313,7 +313,7 @@ pub fn noop_fold_use_tree(use_tree: UseTree, fld: &mut T) -> UseTree } pub fn fold_attrs(attrs: Vec, fld: &mut T) -> Vec { - attrs.move_flat_map(|x| fld.fold_attribute(x)) + attrs.move_map(|x| fld.fold_attribute(x)) } pub fn fold_thin_attrs(attrs: ThinVec, fld: &mut T) -> ThinVec { @@ -485,15 +485,15 @@ pub fn noop_fold_local(l: P, fld: &mut T) -> P { }) } -pub fn noop_fold_attribute(attr: Attribute, fld: &mut T) -> Option { - Some(Attribute { +pub fn noop_fold_attribute(attr: Attribute, fld: &mut T) -> Attribute { + Attribute { id: attr.id, style: attr.style, path: fld.fold_path(attr.path), tokens: fld.fold_tts(attr.tokens), is_sugared_doc: attr.is_sugared_doc, span: fld.new_span(attr.span), - }) + } } pub fn noop_fold_mac(Spanned {node, span}: Mac, fld: &mut T) -> Mac { @@ -678,14 +678,10 @@ pub fn noop_fold_param_bound(pb: GenericBound, fld: &mut T) -> GenericBound w } pub fn noop_fold_generic_param(param: GenericParam, fld: &mut T) -> GenericParam { - let attrs: Vec<_> = param.attrs.into(); GenericParam { ident: fld.fold_ident(param.ident), id: fld.new_id(param.id), - attrs: attrs.into_iter() - .flat_map(|x| fld.fold_attribute(x).into_iter()) - .collect::>() - .into(), + attrs: fold_thin_attrs(param.attrs, fld), bounds: param.bounds.move_map(|l| noop_fold_param_bound(l, fld)), kind: match param.kind { GenericParamKind::Lifetime => GenericParamKind::Lifetime, From 8909f70a3249f61be10627fc6b6634dedf66f77a Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 5 Feb 2019 15:11:52 +1100 Subject: [PATCH 079/278] Change `fold_qpath` to `fold_qself`. It's simpler that way. --- src/libsyntax/fold.rs | 22 ++++++++-------------- 1 file changed, 8 insertions(+), 14 deletions(-) diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 1ab1de1ba5c33..a7e835fbd45f2 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -168,8 +168,8 @@ pub trait Folder : Sized { noop_fold_path(p, self) } - fn fold_qpath(&mut self, qs: Option, p: Path) -> (Option, Path) { - noop_fold_qpath(qs, p, self) + fn fold_qself(&mut self, qs: Option) -> Option { + noop_fold_qself(qs, self) } fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs { @@ -367,8 +367,7 @@ pub fn noop_fold_ty(t: P, fld: &mut T) -> P { TyKind::Tup(tys) => TyKind::Tup(tys.move_map(|ty| fld.fold_ty(ty))), TyKind::Paren(ty) => TyKind::Paren(fld.fold_ty(ty)), TyKind::Path(qself, path) => { - let (qself, path) = fld.fold_qpath(qself, path); - TyKind::Path(qself, path) + TyKind::Path(fld.fold_qself(qself), fld.fold_path(path)) } TyKind::Array(ty, length) => { TyKind::Array(fld.fold_ty(ty), fld.fold_anon_const(length)) @@ -425,17 +424,14 @@ pub fn noop_fold_path(Path { segments, span }: Path, fld: &mut T) -> } } -pub fn noop_fold_qpath(qself: Option, - path: Path, - fld: &mut T) -> (Option, Path) { - let qself = qself.map(|QSelf { ty, path_span, position }| { +pub fn noop_fold_qself(qself: Option, fld: &mut T) -> Option { + qself.map(|QSelf { ty, path_span, position }| { QSelf { ty: fld.fold_ty(ty), path_span: fld.new_span(path_span), position, } - }); - (qself, fld.fold_path(path)) + }) } pub fn noop_fold_generic_args(generic_args: GenericArgs, fld: &mut T) -> GenericArgs @@ -1083,8 +1079,7 @@ pub fn noop_fold_pat(p: P, folder: &mut T) -> P { pats.move_map(|x| folder.fold_pat(x)), ddpos) } PatKind::Path(qself, pth) => { - let (qself, pth) = folder.fold_qpath(qself, pth); - PatKind::Path(qself, pth) + PatKind::Path(folder.fold_qself(qself), folder.fold_path(pth)) } PatKind::Struct(pth, fields, etc) => { let pth = folder.fold_path(pth); @@ -1251,8 +1246,7 @@ pub fn noop_fold_expr(Expr {id, node, span, attrs}: Expr, folder: &mu lim) } ExprKind::Path(qself, path) => { - let (qself, path) = folder.fold_qpath(qself, path); - ExprKind::Path(qself, path) + ExprKind::Path(folder.fold_qself(qself), folder.fold_path(path)) } ExprKind::Break(opt_label, opt_expr) => { ExprKind::Break(opt_label.map(|label| folder.fold_label(label)), From 473095345b74b4d6b836d3ab2e3ace0c6719b20f Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 5 Feb 2019 15:12:15 +1100 Subject: [PATCH 080/278] Neaten up `fold_crate`. --- src/libsyntax/fold.rs | 39 +++++++++++++++------------------------ 1 file changed, 15 insertions(+), 24 deletions(-) diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index a7e835fbd45f2..567175b84df1a 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -980,7 +980,7 @@ pub fn noop_fold_mod(Mod {inner, items, inline}: Mod, folder: &mut T) pub fn noop_fold_crate(Crate {module, attrs, span}: Crate, folder: &mut T) -> Crate { - let mut items = folder.fold_item(P(Item { + let item = P(Item { ident: keywords::Invalid.ident(), attrs, id: DUMMY_NODE_ID, @@ -988,30 +988,21 @@ pub fn noop_fold_crate(Crate {module, attrs, span}: Crate, span, node: ItemKind::Mod(module), tokens: None, - })).into_iter(); - - let (module, attrs, span) = match items.next() { - Some(item) => { - assert!(items.next().is_none(), - "a crate cannot expand to more than one item"); - item.and_then(|Item { attrs, span, node, .. }| { - match node { - ItemKind::Mod(m) => (m, attrs, span), - _ => panic!("fold converted a module to not a module"), - } - }) + }); + let items = folder.fold_item(item); + + let len = items.len(); + if len == 0 { + let module = Mod { inner: span, items: vec![], inline: true }; + Crate { module, attrs: vec![], span } + } else if len == 1 { + let Item { attrs, span, node, .. } = items.into_iter().next().unwrap().into_inner(); + match node { + ItemKind::Mod(module) => Crate { module, attrs, span }, + _ => panic!("fold converted a module to not a module"), } - None => (Mod { - inner: span, - items: vec![], - inline: true, - }, vec![], span) - }; - - Crate { - module, - attrs, - span, + } else { + panic!("a crate cannot expand to more than one item"); } } From 372fe84a8349ab4a8693d656bd786a5a47e22a56 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 5 Feb 2019 15:13:12 +1100 Subject: [PATCH 081/278] Streamline `Folder` some more. By eliminating some unnecessary methods, and moving/renaming some functions that look like they might be methods but aren't. --- src/libsyntax/fold.rs | 82 ++++++++++++++++++++----------------------- 1 file changed, 39 insertions(+), 43 deletions(-) diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 567175b84df1a..5fb0132ad4566 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -125,10 +125,6 @@ pub trait Folder : Sized { noop_fold_opt_expr(e, self) } - fn fold_exprs(&mut self, es: Vec>) -> Vec> { - noop_fold_exprs(es, self) - } - fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg { match arg { GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.fold_lifetime(lt)), @@ -257,10 +253,6 @@ pub trait Folder : Sized { noop_fold_interpolated(nt, self) } - fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds { - noop_fold_bounds(b, self) - } - fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound { noop_fold_param_bound(tpb, self) } @@ -296,6 +288,34 @@ pub trait Folder : Sized { } } +// No `noop_` prefix because there isn't a corresponding method in `Folder`. +fn fold_attrs(attrs: Vec, fld: &mut T) -> Vec { + attrs.move_map(|x| fld.fold_attribute(x)) +} + +// No `noop_` prefix because there isn't a corresponding method in `Folder`. +fn fold_thin_attrs(attrs: ThinVec, fld: &mut T) -> ThinVec { + fold_attrs(attrs.into(), fld).into() +} + +// No `noop_` prefix because there isn't a corresponding method in `Folder`. +fn fold_exprs(es: Vec>, fld: &mut T) -> Vec> { + es.move_flat_map(|e| fld.fold_opt_expr(e)) +} + +// No `noop_` prefix because there isn't a corresponding method in `Folder`. +fn fold_bounds(bounds: GenericBounds, folder: &mut T) -> GenericBounds { + bounds.move_map(|bound| folder.fold_param_bound(bound)) +} + +// No `noop_` prefix because there isn't a corresponding method in `Folder`. +fn fold_method_sig(sig: MethodSig, folder: &mut T) -> MethodSig { + MethodSig { + header: folder.fold_fn_header(sig.header), + decl: folder.fold_fn_decl(sig.decl) + } +} + pub fn noop_fold_use_tree(use_tree: UseTree, fld: &mut T) -> UseTree { UseTree { span: fld.new_span(use_tree.span), @@ -312,14 +332,6 @@ pub fn noop_fold_use_tree(use_tree: UseTree, fld: &mut T) -> UseTree } } -pub fn fold_attrs(attrs: Vec, fld: &mut T) -> Vec { - attrs.move_map(|x| fld.fold_attribute(x)) -} - -pub fn fold_thin_attrs(attrs: ThinVec, fld: &mut T) -> ThinVec { - fold_attrs(attrs.into(), fld).into() -} - pub fn noop_fold_arm(Arm {attrs, pats, guard, body}: Arm, fld: &mut T) -> Arm { Arm { @@ -824,11 +836,6 @@ pub fn noop_fold_mt(MutTy {ty, mutbl}: MutTy, folder: &mut T) -> MutT } } -fn noop_fold_bounds(bounds: GenericBounds, folder: &mut T) - -> GenericBounds { - bounds.move_map(|bound| folder.fold_param_bound(bound)) -} - pub fn noop_fold_block(b: P, folder: &mut T) -> P { b.map(|Block {id, stmts, rules, span}| Block { id: folder.new_id(id), @@ -864,7 +871,7 @@ pub fn noop_fold_item_kind(i: ItemKind, folder: &mut T) -> ItemKind { ItemKind::Ty(folder.fold_ty(t), folder.fold_generics(generics)) } ItemKind::Existential(bounds, generics) => ItemKind::Existential( - folder.fold_bounds(bounds), + fold_bounds(bounds, folder), folder.fold_generics(generics), ), ItemKind::Enum(enum_definition, generics) => { @@ -899,12 +906,12 @@ pub fn noop_fold_item_kind(i: ItemKind, folder: &mut T) -> ItemKind { is_auto, unsafety, folder.fold_generics(generics), - folder.fold_bounds(bounds), + fold_bounds(bounds, folder), items.move_flat_map(|item| folder.fold_trait_item(item)), ), ItemKind::TraitAlias(generics, bounds) => ItemKind::TraitAlias( folder.fold_generics(generics), - folder.fold_bounds(bounds)), + fold_bounds(bounds, folder)), ItemKind::Mac(m) => ItemKind::Mac(folder.fold_mac(m)), ItemKind::MacroDef(def) => ItemKind::MacroDef(folder.fold_macro_def(def)), } @@ -922,11 +929,11 @@ pub fn noop_fold_trait_item(i: TraitItem, folder: &mut T) -> SmallVec default.map(|x| folder.fold_expr(x))) } TraitItemKind::Method(sig, body) => { - TraitItemKind::Method(noop_fold_method_sig(sig, folder), + TraitItemKind::Method(fold_method_sig(sig, folder), body.map(|x| folder.fold_block(x))) } TraitItemKind::Type(bounds, default) => { - TraitItemKind::Type(folder.fold_bounds(bounds), + TraitItemKind::Type(fold_bounds(bounds, folder), default.map(|x| folder.fold_ty(x))) } TraitItemKind::Macro(mac) => { @@ -951,12 +958,12 @@ pub fn noop_fold_impl_item(i: ImplItem, folder: &mut T)-> SmallVec<[I ImplItemKind::Const(folder.fold_ty(ty), folder.fold_expr(expr)) } ImplItemKind::Method(sig, body) => { - ImplItemKind::Method(noop_fold_method_sig(sig, folder), + ImplItemKind::Method(fold_method_sig(sig, folder), folder.fold_block(body)) } ImplItemKind::Type(ty) => ImplItemKind::Type(folder.fold_ty(ty)), ImplItemKind::Existential(bounds) => { - ImplItemKind::Existential(folder.fold_bounds(bounds)) + ImplItemKind::Existential(fold_bounds(bounds, folder)) }, ImplItemKind::Macro(mac) => ImplItemKind::Macro(folder.fold_mac(mac)) }, @@ -1047,13 +1054,6 @@ pub fn noop_fold_foreign_item(ni: ForeignItem, folder: &mut T) }] } -pub fn noop_fold_method_sig(sig: MethodSig, folder: &mut T) -> MethodSig { - MethodSig { - header: folder.fold_fn_header(sig.header), - decl: folder.fold_fn_decl(sig.decl) - } -} - pub fn noop_fold_pat(p: P, folder: &mut T) -> P { p.map(|Pat {id, node, span}| Pat { id: folder.new_id(id), @@ -1125,15 +1125,15 @@ pub fn noop_fold_expr(Expr {id, node, span, attrs}: Expr, folder: &mu ExprKind::ObsoleteInPlace(folder.fold_expr(a), folder.fold_expr(b)) } ExprKind::Array(exprs) => { - ExprKind::Array(folder.fold_exprs(exprs)) + ExprKind::Array(fold_exprs(exprs, folder)) } ExprKind::Repeat(expr, count) => { ExprKind::Repeat(folder.fold_expr(expr), folder.fold_anon_const(count)) } - ExprKind::Tup(exprs) => ExprKind::Tup(folder.fold_exprs(exprs)), + ExprKind::Tup(exprs) => ExprKind::Tup(fold_exprs(exprs, folder)), ExprKind::Call(f, args) => { ExprKind::Call(folder.fold_expr(f), - folder.fold_exprs(args)) + fold_exprs(args, folder)) } ExprKind::MethodCall(seg, args) => { ExprKind::MethodCall( @@ -1144,7 +1144,7 @@ pub fn noop_fold_expr(Expr {id, node, span, attrs}: Expr, folder: &mu args.map(|args| folder.fold_generic_args(args)) }), }, - folder.fold_exprs(args)) + fold_exprs(args, folder)) } ExprKind::Binary(binop, lhs, rhs) => { ExprKind::Binary(binop, @@ -1294,10 +1294,6 @@ pub fn noop_fold_opt_expr(e: P, folder: &mut T) -> Option(es: Vec>, folder: &mut T) -> Vec> { - es.move_flat_map(|e| folder.fold_opt_expr(e)) -} - pub fn noop_fold_stmt(Stmt {node, span, id}: Stmt, folder: &mut T) -> SmallVec<[Stmt; 1]> { let id = folder.new_id(id); From 970b5d189af48dd6ec26e90bb8d6d236824edf4b Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 5 Feb 2019 15:18:29 +1100 Subject: [PATCH 082/278] Various improvements in `Folder` impls. --- src/libsyntax/config.rs | 44 +++++++++---------------------- src/libsyntax/ext/expand.rs | 5 +--- src/libsyntax/ext/placeholders.rs | 15 ++++------- 3 files changed, 18 insertions(+), 46 deletions(-) diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs index 2930ce079c848..b35730bf2381b 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -13,6 +13,7 @@ use edition::Edition; use parse::{token, ParseSess}; use smallvec::SmallVec; use errors::Applicability; +use util::move_map::MoveMap; use ptr::P; @@ -220,19 +221,19 @@ impl<'a> StripUnconfigured<'a> { pub fn configure_foreign_mod(&mut self, foreign_mod: ast::ForeignMod) -> ast::ForeignMod { ast::ForeignMod { abi: foreign_mod.abi, - items: foreign_mod.items.into_iter().filter_map(|item| self.configure(item)).collect(), + items: foreign_mod.items.move_flat_map(|item| self.configure(item)), } } fn configure_variant_data(&mut self, vdata: ast::VariantData) -> ast::VariantData { match vdata { ast::VariantData::Struct(fields, id) => { - let fields = fields.into_iter().filter_map(|field| self.configure(field)); - ast::VariantData::Struct(fields.collect(), id) + let fields = fields.move_flat_map(|field| self.configure(field)); + ast::VariantData::Struct(fields, id) } ast::VariantData::Tuple(fields, id) => { - let fields = fields.into_iter().filter_map(|field| self.configure(field)); - ast::VariantData::Tuple(fields.collect(), id) + let fields = fields.move_flat_map(|field| self.configure(field)); + ast::VariantData::Tuple(fields, id) } ast::VariantData::Unit(id) => ast::VariantData::Unit(id) } @@ -247,7 +248,7 @@ impl<'a> StripUnconfigured<'a> { ast::ItemKind::Union(self.configure_variant_data(def), generics) } ast::ItemKind::Enum(def, generics) => { - let variants = def.variants.into_iter().filter_map(|v| { + let variants = def.variants.move_flat_map(|v| { self.configure(v).map(|v| { Spanned { node: ast::Variant_ { @@ -260,9 +261,7 @@ impl<'a> StripUnconfigured<'a> { } }) }); - ast::ItemKind::Enum(ast::EnumDef { - variants: variants.collect(), - }, generics) + ast::ItemKind::Enum(ast::EnumDef { variants }, generics) } item => item, } @@ -271,15 +270,11 @@ impl<'a> StripUnconfigured<'a> { pub fn configure_expr_kind(&mut self, expr_kind: ast::ExprKind) -> ast::ExprKind { match expr_kind { ast::ExprKind::Match(m, arms) => { - let arms = arms.into_iter().filter_map(|a| self.configure(a)).collect(); + let arms = arms.move_flat_map(|a| self.configure(a)); ast::ExprKind::Match(m, arms) } ast::ExprKind::Struct(path, fields, base) => { - let fields = fields.into_iter() - .filter_map(|field| { - self.configure(field) - }) - .collect(); + let fields = fields.move_flat_map(|field| self.configure(field)); ast::ExprKind::Struct(path, fields, base) } _ => expr_kind, @@ -304,22 +299,10 @@ impl<'a> StripUnconfigured<'a> { self.process_cfg_attrs(expr) } - pub fn configure_stmt(&mut self, stmt: ast::Stmt) -> Option { - self.configure(stmt) - } - - pub fn configure_struct_expr_field(&mut self, field: ast::Field) -> Option { - self.configure(field) - } - pub fn configure_pat(&mut self, pattern: P) -> P { pattern.map(|mut pattern| { if let ast::PatKind::Struct(path, fields, etc) = pattern.node { - let fields = fields.into_iter() - .filter_map(|field| { - self.configure(field) - }) - .collect(); + let fields = fields.move_flat_map(|field| self.configure(field)); pattern.node = ast::PatKind::Struct(path, fields, etc); } pattern @@ -367,10 +350,7 @@ impl<'a> fold::Folder for StripUnconfigured<'a> { } fn fold_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> { - match self.configure_stmt(stmt) { - Some(stmt) => fold::noop_fold_stmt(stmt, self), - None => return SmallVec::new(), - } + fold::noop_fold_stmt(configure!(self, stmt), self) } fn fold_item(&mut self, item: P) -> SmallVec<[P; 1]> { diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 72e0a86bf5909..2effd910e8545 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -1247,10 +1247,7 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { } fn fold_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> { - let mut stmt = match self.cfg.configure_stmt(stmt) { - Some(stmt) => stmt, - None => return SmallVec::new(), - }; + let mut stmt = configure!(self, stmt); // we'll expand attributes on expressions separately if !stmt.is_expr() { diff --git a/src/libsyntax/ext/placeholders.rs b/src/libsyntax/ext/placeholders.rs index 3b0402d910a85..0928bc804041d 100644 --- a/src/libsyntax/ext/placeholders.rs +++ b/src/libsyntax/ext/placeholders.rs @@ -181,17 +181,12 @@ impl<'a, 'b> Folder for PlaceholderExpander<'a, 'b> { fn fold_block(&mut self, block: P) -> P { noop_fold_block(block, self).map(|mut block| { - let mut remaining_stmts = block.stmts.len(); - - block.stmts = block.stmts.move_flat_map(|mut stmt| { - remaining_stmts -= 1; - + block.stmts = block.stmts.move_map(|mut stmt| { if self.monotonic { assert_eq!(stmt.id, ast::DUMMY_NODE_ID); stmt.id = self.cx.resolver.next_node_id(); } - - Some(stmt) + stmt }); block @@ -200,9 +195,9 @@ impl<'a, 'b> Folder for PlaceholderExpander<'a, 'b> { fn fold_mod(&mut self, module: ast::Mod) -> ast::Mod { let mut module = noop_fold_mod(module, self); - module.items = module.items.move_flat_map(|item| match item.node { - ast::ItemKind::Mac(_) if !self.cx.ecfg.keep_macs => None, // remove macro definitions - _ => Some(item), + module.items.retain(|item| match item.node { + ast::ItemKind::Mac(_) if !self.cx.ecfg.keep_macs => false, // remove macro definitions + _ => true, }); module } From 2bfb4b336fc8fcd499c36dbc997dd18c7a5e62cf Mon Sep 17 00:00:00 2001 From: Pietro Albini Date: Tue, 5 Feb 2019 08:47:52 +0100 Subject: [PATCH 083/278] add even more debugging code to track down appveyor 259 exit code --- src/ci/run.sh | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/ci/run.sh b/src/ci/run.sh index b8b1052c41c12..0841e70a6ed29 100755 --- a/src/ci/run.sh +++ b/src/ci/run.sh @@ -128,6 +128,12 @@ if [ ! -z "$SCRIPT" ]; then sh -x -c "$SCRIPT" ret=$? echo "exit code in src/ci/run.sh: $ret" + + echo "tasklist:" + tasklist + echo -n "location of sh: " + where sh + exit $ret else do_make() { From b377d0b14ce141b8ce6c9bb22c22b1fb12d8232f Mon Sep 17 00:00:00 2001 From: David Wood Date: Tue, 5 Feb 2019 09:03:39 +0100 Subject: [PATCH 084/278] Fix span for closure return type when annotated. This commit adjusts the span used to label closure return types so that if the user specifies the return type, i.e. `|_| -> X {}` instead of `|_| {}`, we correctly highlight all of it and not just the last character. --- .../error_reporting/region_name.rs | 7 +++++-- src/test/ui/nll/issue-58053.rs | 14 +++++++++++++ src/test/ui/nll/issue-58053.stderr | 20 +++++++++++++++++++ 3 files changed, 39 insertions(+), 2 deletions(-) create mode 100644 src/test/ui/nll/issue-58053.rs create mode 100644 src/test/ui/nll/issue-58053.stderr diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs index bff8015511242..6adab3128d707 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs @@ -681,10 +681,13 @@ impl<'tcx> RegionInferenceContext<'tcx> { let (return_span, mir_description) = match tcx.hir().get(mir_node_id) { hir::Node::Expr(hir::Expr { - node: hir::ExprKind::Closure(_, _, _, span, gen_move), + node: hir::ExprKind::Closure(_, return_ty, _, span, gen_move), .. }) => ( - tcx.sess.source_map().end_point(*span), + match return_ty.output { + hir::FunctionRetTy::DefaultReturn(_) => tcx.sess.source_map().end_point(*span), + hir::FunctionRetTy::Return(_) => return_ty.output.span(), + }, if gen_move.is_some() { " of generator" } else { diff --git a/src/test/ui/nll/issue-58053.rs b/src/test/ui/nll/issue-58053.rs new file mode 100644 index 0000000000000..d4338905ed2df --- /dev/null +++ b/src/test/ui/nll/issue-58053.rs @@ -0,0 +1,14 @@ +#![allow(warnings)] +#![feature(nll)] + +fn main() { + let i = &3; + + let f = |x: &i32| -> &i32 { x }; + //~^ ERROR lifetime may not live long enough + let j = f(i); + + let g = |x: &i32| { x }; + //~^ ERROR lifetime may not live long enough + let k = g(i); +} diff --git a/src/test/ui/nll/issue-58053.stderr b/src/test/ui/nll/issue-58053.stderr new file mode 100644 index 0000000000000..9048983318b36 --- /dev/null +++ b/src/test/ui/nll/issue-58053.stderr @@ -0,0 +1,20 @@ +error: lifetime may not live long enough + --> $DIR/issue-58053.rs:7:33 + | +LL | let f = |x: &i32| -> &i32 { x }; + | - ---- ^ returning this value requires that `'1` must outlive `'2` + | | | + | | return type of closure is &'2 i32 + | let's call the lifetime of this reference `'1` + +error: lifetime may not live long enough + --> $DIR/issue-58053.rs:11:25 + | +LL | let g = |x: &i32| { x }; + | - - ^ returning this value requires that `'1` must outlive `'2` + | | | + | | return type of closure is &'2 i32 + | let's call the lifetime of this reference `'1` + +error: aborting due to 2 previous errors + From 4c8c0fc1e2145b520ef31d1bf5e4d3fa1050c579 Mon Sep 17 00:00:00 2001 From: Jethro Beekman Date: Tue, 5 Feb 2019 16:19:05 +0530 Subject: [PATCH 085/278] SGX target: handle empty user buffers correctly --- src/libstd/sys/sgx/abi/usercalls/alloc.rs | 7 ++++++- src/libstd/sys/sgx/abi/usercalls/mod.rs | 3 ++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/libstd/sys/sgx/abi/usercalls/alloc.rs b/src/libstd/sys/sgx/abi/usercalls/alloc.rs index 8d0013a235ac7..2efbaa9b1487a 100644 --- a/src/libstd/sys/sgx/abi/usercalls/alloc.rs +++ b/src/libstd/sys/sgx/abi/usercalls/alloc.rs @@ -537,7 +537,12 @@ impl UserRef { pub fn copy_user_buffer(&self) -> Vec { unsafe { let buf = self.to_enclave(); - User::from_raw_parts(buf.data as _, buf.len).to_enclave() + if buf.len > 0 { + User::from_raw_parts(buf.data as _, buf.len).to_enclave() + } else { + // Mustn't look at `data` or call `free` if `len` is `0`. + Vec::with_capacity(0) + } } } } diff --git a/src/libstd/sys/sgx/abi/usercalls/mod.rs b/src/libstd/sys/sgx/abi/usercalls/mod.rs index 58903761ebe40..511d6e9e9273a 100644 --- a/src/libstd/sys/sgx/abi/usercalls/mod.rs +++ b/src/libstd/sys/sgx/abi/usercalls/mod.rs @@ -22,7 +22,8 @@ pub fn read(fd: Fd, buf: &mut [u8]) -> IoResult { #[unstable(feature = "sgx_platform", issue = "56975")] pub fn read_alloc(fd: Fd) -> IoResult> { unsafe { - let mut userbuf = alloc::User::::uninitialized(); + let userbuf = ByteBuffer { data: ::ptr::null_mut(), len: 0 }; + let mut userbuf = alloc::User::new_from_enclave(&userbuf); raw::read_alloc(fd, userbuf.as_raw_mut_ptr()).from_sgx_result()?; Ok(userbuf.copy_user_buffer()) } From d89ebdd475ceaa35173e7d39dfdf23f8b7318745 Mon Sep 17 00:00:00 2001 From: Jethro Beekman Date: Tue, 5 Feb 2019 16:19:20 +0530 Subject: [PATCH 086/278] Expose correct items in `os::fortanix_sgx::usercalls::alloc` --- src/libstd/os/fortanix_sgx/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libstd/os/fortanix_sgx/mod.rs b/src/libstd/os/fortanix_sgx/mod.rs index 810965fc1b85a..f536c5d04e6ee 100644 --- a/src/libstd/os/fortanix_sgx/mod.rs +++ b/src/libstd/os/fortanix_sgx/mod.rs @@ -16,7 +16,7 @@ pub mod usercalls { /// Primitives for allocating memory in userspace as well as copying data /// to and from user memory. pub mod alloc { - pub use sys::abi::usercalls::alloc; + pub use sys::abi::usercalls::alloc::*; } /// Lowest-level interfaces to usercalls and usercall ABI type definitions. From a6f2f7f15e4c4c24f9091bbbb8c56952c15ab70a Mon Sep 17 00:00:00 2001 From: Hirokazu Hata Date: Mon, 4 Feb 2019 00:39:37 +0900 Subject: [PATCH 087/278] Transition rustdoc to 2018 edition --- src/tools/rustdoc/Cargo.toml | 1 + src/tools/rustdoc/main.rs | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/tools/rustdoc/Cargo.toml b/src/tools/rustdoc/Cargo.toml index d38815004418c..36aa5916da733 100644 --- a/src/tools/rustdoc/Cargo.toml +++ b/src/tools/rustdoc/Cargo.toml @@ -2,6 +2,7 @@ name = "rustdoc-tool" version = "0.0.0" authors = ["The Rust Project Developers"] +edition = "2018" # Cargo adds a number of paths to the dylib search path on windows, which results in # the wrong rustdoc being executed. To avoid the conflicting rustdocs, we name the "tool" diff --git a/src/tools/rustdoc/main.rs b/src/tools/rustdoc/main.rs index df9d2c6ba96db..8bdc365c4ca68 100644 --- a/src/tools/rustdoc/main.rs +++ b/src/tools/rustdoc/main.rs @@ -1,3 +1,5 @@ +#![deny(rust_2018_idioms)] + #![feature(link_args)] #[allow(unused_attributes)] @@ -10,6 +12,4 @@ // See src/rustc/rustc.rs for the corresponding rustc settings. extern {} -extern crate rustdoc; - fn main() { rustdoc::main() } From 014ffa3ac9e499fc0c3f03b7e902be6d819d02f3 Mon Sep 17 00:00:00 2001 From: liv Date: Tue, 5 Feb 2019 15:32:59 +0100 Subject: [PATCH 088/278] Add Rustlings to the doc index --- src/doc/index.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/doc/index.md b/src/doc/index.md index 7a240ac0a42a5..0a2a80e8fd6e2 100644 --- a/src/doc/index.md +++ b/src/doc/index.md @@ -52,6 +52,12 @@ If reading multiple hundreds of pages about a language isn't your style, then a lot of words, RBE shows off a bunch of code, and keeps the talking to a minimum. It also includes exercises! +## Rustlings + +[Rustlings](https://github.com/rust-lang/rustlings) guides you through downloading and setting up the Rust toolchain, +and teaches you the basics of reading and writing Rust syntax. It's an +alternative to Rust by Example that works with your own environment. + # Use Rust Once you've gotten familiar with the language, these resources can help you From aaafc3c7fa1846b952b1a479ed69420b9b3f86bb Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Tue, 5 Feb 2019 17:22:46 +0100 Subject: [PATCH 089/278] fix doctest --- src/libcore/mem.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index 68f985ce65202..18302e36ff762 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -1042,7 +1042,7 @@ impl DerefMut for ManuallyDrop { /// even in unsafe code. As a consequence, 0-initializing a variable of reference /// type causes instantaneous undefined behavior, no matter whether that reference /// ever gets used to access memory: -/// ```rust,ignore +/// ```rust,no_run /// use std::mem; /// /// let x: &i32 = mem::zeroed(); // undefined behavior! @@ -1065,7 +1065,7 @@ impl DerefMut for ManuallyDrop { /// // Set it to a valid value. /// x.set(&0); /// // Extract the initialized data -- this is only allowed *after* properly -/// initializing `x`! +/// // initializing `x`! /// let x = unsafe { x.into_initialized() }; /// ``` /// The compiler then knows to not optimize this code. From e957ed9d10ec589bdd523b88b4b44c41b1ecf763 Mon Sep 17 00:00:00 2001 From: Mark Mansi Date: Tue, 5 Feb 2019 11:20:45 -0600 Subject: [PATCH 090/278] move librustc to 2018 --- src/librustc/Cargo.toml | 1 + src/librustc/cfg/construct.rs | 10 +- src/librustc/cfg/graphviz.rs | 6 +- src/librustc/cfg/mod.rs | 6 +- src/librustc/dep_graph/cgu_reuse_tracker.rs | 2 +- src/librustc/dep_graph/dep_node.rs | 22 ++-- src/librustc/dep_graph/dep_tracking_map.rs | 2 +- src/librustc/dep_graph/graph.rs | 10 +- src/librustc/dep_graph/prev.rs | 2 +- src/librustc/dep_graph/safe.rs | 6 +- src/librustc/dep_graph/serialized.rs | 4 +- src/librustc/hir/check_attr.rs | 10 +- src/librustc/hir/def.rs | 8 +- src/librustc/hir/def_id.rs | 6 +- src/librustc/hir/intravisit.rs | 6 +- src/librustc/hir/lowering.rs | 28 ++--- src/librustc/hir/map/blocks.rs | 8 +- src/librustc/hir/map/collector.rs | 20 ++-- src/librustc/hir/map/def_collector.rs | 8 +- src/librustc/hir/map/definitions.rs | 10 +- src/librustc/hir/map/hir_id_validator.rs | 6 +- src/librustc/hir/map/mod.rs | 24 ++--- src/librustc/hir/mod.rs | 14 +-- src/librustc/hir/pat_util.rs | 6 +- src/librustc/hir/print.rs | 8 +- src/librustc/ich/hcx.rs | 18 ++-- src/librustc/ich/impls_cstore.rs | 18 ++-- src/librustc/ich/impls_hir.rs | 16 +-- src/librustc/ich/impls_mir.rs | 4 +- src/librustc/ich/impls_misc.rs | 2 +- src/librustc/ich/impls_syntax.rs | 4 +- src/librustc/ich/impls_ty.rs | 54 +++++----- src/librustc/infer/at.rs | 2 +- src/librustc/infer/canonical/canonicalizer.rs | 10 +- src/librustc/infer/canonical/mod.rs | 18 ++-- .../infer/canonical/query_response.rs | 24 ++--- src/librustc/infer/canonical/substitute.rs | 8 +- src/librustc/infer/combine.rs | 14 +-- src/librustc/infer/equate.rs | 10 +- src/librustc/infer/error_reporting/mod.rs | 22 ++-- .../infer/error_reporting/need_type_info.rs | 12 +-- .../nice_region_error/different_lifetimes.rs | 6 +- .../nice_region_error/find_anon_type.rs | 12 +-- .../error_reporting/nice_region_error/mod.rs | 10 +- .../nice_region_error/named_anon_conflict.rs | 8 +- .../nice_region_error/outlives_closure.rs | 14 +-- .../nice_region_error/placeholder_error.rs | 24 ++--- .../nice_region_error/static_impl_trait.rs | 10 +- .../error_reporting/nice_region_error/util.rs | 8 +- src/librustc/infer/error_reporting/note.rs | 10 +- src/librustc/infer/freshen.rs | 6 +- src/librustc/infer/fudge.rs | 6 +- src/librustc/infer/glb.rs | 6 +- src/librustc/infer/higher_ranked/mod.rs | 4 +- src/librustc/infer/lattice.rs | 8 +- .../infer/lexical_region_resolve/graphviz.rs | 14 +-- .../infer/lexical_region_resolve/mod.rs | 26 ++--- src/librustc/infer/lub.rs | 6 +- src/librustc/infer/mod.rs | 36 +++---- src/librustc/infer/opaque_types/mod.rs | 22 ++-- src/librustc/infer/outlives/env.rs | 8 +- .../infer/outlives/free_region_map.rs | 2 +- src/librustc/infer/outlives/obligations.rs | 12 +-- src/librustc/infer/outlives/verify.rs | 14 +-- src/librustc/infer/region_constraints/mod.rs | 8 +- src/librustc/infer/resolve.rs | 4 +- src/librustc/infer/sub.rs | 10 +- src/librustc/infer/type_variable.rs | 2 +- src/librustc/infer/unify_key.rs | 2 +- src/librustc/lib.rs | 38 +++---- src/librustc/lint/builtin.rs | 6 +- src/librustc/lint/context.rs | 30 +++--- src/librustc/lint/levels.rs | 16 +-- src/librustc/lint/mod.rs | 24 ++--- src/librustc/middle/borrowck.rs | 6 +- src/librustc/middle/cstore.rs | 12 +-- src/librustc/middle/dead.rs | 24 ++--- src/librustc/middle/dependency_format.rs | 12 +-- src/librustc/middle/entry.rs | 16 +-- src/librustc/middle/exported_symbols.rs | 8 +- src/librustc/middle/expr_use_visitor.rs | 18 ++-- src/librustc/middle/free_region.rs | 8 +- src/librustc/middle/intrinsicck.rs | 14 +-- src/librustc/middle/lang_items.rs | 14 +-- src/librustc/middle/lib_features.rs | 6 +- src/librustc/middle/liveness.rs | 24 ++--- src/librustc/middle/mem_categorization.rs | 28 ++--- src/librustc/middle/privacy.rs | 2 +- src/librustc/middle/reachable.rs | 28 ++--- src/librustc/middle/recursion_limit.rs | 2 +- src/librustc/middle/region.rs | 24 ++--- src/librustc/middle/resolve_lifetime.rs | 26 ++--- src/librustc/middle/stability.rs | 20 ++-- src/librustc/middle/weak_lang_items.rs | 14 +-- src/librustc/mir/cache.rs | 6 +- src/librustc/mir/interpret/allocation.rs | 4 +- src/librustc/mir/interpret/error.rs | 16 +-- src/librustc/mir/interpret/mod.rs | 16 +-- src/librustc/mir/interpret/pointer.rs | 4 +- src/librustc/mir/interpret/value.rs | 2 +- src/librustc/mir/mod.rs | 42 ++++---- src/librustc/mir/mono.rs | 8 +- src/librustc/mir/tcx.rs | 12 +-- src/librustc/mir/visit.rs | 10 +- src/librustc/session/config.rs | 30 +++--- src/librustc/session/filesearch.rs | 2 +- src/librustc/session/mod.rs | 28 ++--- src/librustc/session/search_paths.rs | 4 +- src/librustc/traits/auto_trait.rs | 8 +- src/librustc/traits/chalk_fulfill.rs | 10 +- src/librustc/traits/codegen/mod.rs | 12 +-- src/librustc/traits/coherence.rs | 20 ++-- src/librustc/traits/engine.rs | 8 +- src/librustc/traits/error_reporting.rs | 30 +++--- src/librustc/traits/fulfill.rs | 8 +- src/librustc/traits/mod.rs | 22 ++-- src/librustc/traits/object_safety.rs | 12 +-- src/librustc/traits/on_unimplemented.rs | 8 +- src/librustc/traits/project.rs | 16 +-- src/librustc/traits/query/dropck_outlives.rs | 10 +- .../traits/query/evaluate_obligation.rs | 6 +- src/librustc/traits/query/method_autoderef.rs | 4 +- src/librustc/traits/query/mod.rs | 6 +- src/librustc/traits/query/normalize.rs | 18 ++-- .../traits/query/normalize_erasing_regions.rs | 4 +- src/librustc/traits/query/outlives_bounds.rs | 12 +-- .../traits/query/type_op/ascribe_user_type.rs | 10 +- src/librustc/traits/query/type_op/custom.rs | 10 +- src/librustc/traits/query/type_op/eq.rs | 6 +- .../query/type_op/implied_outlives_bounds.rs | 8 +- src/librustc/traits/query/type_op/mod.rs | 12 +-- .../traits/query/type_op/normalize.rs | 8 +- src/librustc/traits/query/type_op/outlives.rs | 10 +- .../traits/query/type_op/prove_predicate.rs | 6 +- src/librustc/traits/query/type_op/subtype.rs | 6 +- src/librustc/traits/select.rs | 26 ++--- src/librustc/traits/specialize/mod.rs | 14 +-- .../traits/specialize/specialization_graph.rs | 16 +-- src/librustc/traits/structural_impls.rs | 22 ++-- src/librustc/traits/util.rs | 14 +-- src/librustc/ty/_match.rs | 6 +- src/librustc/ty/adjustment.rs | 8 +- src/librustc/ty/binding.rs | 6 +- src/librustc/ty/cast.rs | 2 +- src/librustc/ty/codec.rs | 14 +-- src/librustc/ty/constness.rs | 10 +- src/librustc/ty/context.rs | 100 +++++++++--------- src/librustc/ty/erase_regions.rs | 4 +- src/librustc/ty/error.rs | 8 +- src/librustc/ty/fast_reject.rs | 6 +- src/librustc/ty/flags.rs | 4 +- src/librustc/ty/fold.rs | 6 +- .../ty/inhabitedness/def_id_forest.rs | 4 +- src/librustc/ty/inhabitedness/mod.rs | 10 +- src/librustc/ty/instance.rs | 12 +-- src/librustc/ty/item_path.rs | 10 +- src/librustc/ty/layout.rs | 22 ++-- src/librustc/ty/mod.rs | 50 ++++----- src/librustc/ty/outlives.rs | 2 +- src/librustc/ty/query/config.rs | 28 ++--- src/librustc/ty/query/job.rs | 24 +++-- src/librustc/ty/query/keys.rs | 14 +-- src/librustc/ty/query/mod.rs | 78 +++++++------- src/librustc/ty/query/on_disk_cache.rs | 36 +++---- src/librustc/ty/query/plumbing.rs | 48 ++++----- src/librustc/ty/query/values.rs | 2 +- src/librustc/ty/relate.rs | 30 +++--- src/librustc/ty/structural_impls.rs | 54 +++++----- src/librustc/ty/sty.rs | 22 ++-- src/librustc/ty/subst.rs | 8 +- src/librustc/ty/trait_def.rs | 16 +-- src/librustc/ty/util.rs | 26 ++--- src/librustc/ty/walk.rs | 2 +- src/librustc/ty/wf.rs | 12 +-- src/librustc/util/bug.rs | 2 +- src/librustc/util/common.rs | 6 +- src/librustc/util/nodemap.rs | 4 +- src/librustc/util/ppaux.rs | 26 ++--- src/librustc/util/profiling.rs | 2 +- 179 files changed, 1234 insertions(+), 1243 deletions(-) diff --git a/src/librustc/Cargo.toml b/src/librustc/Cargo.toml index a5521effc7d8d..c9a04f4c6834d 100644 --- a/src/librustc/Cargo.toml +++ b/src/librustc/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc" version = "0.0.0" +edition = "2018" [lib] name = "rustc" diff --git a/src/librustc/cfg/construct.rs b/src/librustc/cfg/construct.rs index 669c2998d1cb2..f7ffbe8c65833 100644 --- a/src/librustc/cfg/construct.rs +++ b/src/librustc/cfg/construct.rs @@ -1,11 +1,11 @@ -use cfg::*; -use middle::region; +use crate::cfg::*; +use crate::middle::region; use rustc_data_structures::graph::implementation as graph; use syntax::ptr::P; -use ty::{self, TyCtxt}; +use crate::ty::{self, TyCtxt}; -use hir::{self, PatKind}; -use hir::def_id::DefId; +use crate::hir::{self, PatKind}; +use crate::hir::def_id::DefId; struct CFGBuilder<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx>, diff --git a/src/librustc/cfg/graphviz.rs b/src/librustc/cfg/graphviz.rs index 6dec421760899..969c38bd66329 100644 --- a/src/librustc/cfg/graphviz.rs +++ b/src/librustc/cfg/graphviz.rs @@ -4,9 +4,9 @@ // For clarity, rename the graphviz crate locally to dot. use graphviz as dot; -use cfg; -use hir; -use ty::TyCtxt; +use crate::cfg; +use crate::hir; +use crate::ty::TyCtxt; pub type Node<'a> = (cfg::CFGIndex, &'a cfg::CFGNode); pub type Edge<'a> = &'a cfg::CFGEdge; diff --git a/src/librustc/cfg/mod.rs b/src/librustc/cfg/mod.rs index e58557839f9b9..345dff88b5f0b 100644 --- a/src/librustc/cfg/mod.rs +++ b/src/librustc/cfg/mod.rs @@ -2,9 +2,9 @@ //! Uses `Graph` as the underlying representation. use rustc_data_structures::graph::implementation as graph; -use ty::TyCtxt; -use hir; -use hir::def_id::DefId; +use crate::ty::TyCtxt; +use crate::hir; +use crate::hir::def_id::DefId; mod construct; pub mod graphviz; diff --git a/src/librustc/dep_graph/cgu_reuse_tracker.rs b/src/librustc/dep_graph/cgu_reuse_tracker.rs index e8d1b71048705..13f6f95332973 100644 --- a/src/librustc/dep_graph/cgu_reuse_tracker.rs +++ b/src/librustc/dep_graph/cgu_reuse_tracker.rs @@ -2,7 +2,7 @@ //! compilation. This is used for incremental compilation tests and debug //! output. -use session::Session; +use crate::session::Session; use rustc_data_structures::fx::FxHashMap; use std::sync::{Arc, Mutex}; use syntax_pos::Span; diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs index cda469657ed87..58087b76266b5 100644 --- a/src/librustc/dep_graph/dep_node.rs +++ b/src/librustc/dep_graph/dep_node.rs @@ -49,25 +49,25 @@ //! user of the `DepNode` API of having to know how to compute the expected //! fingerprint for a given set of node parameters. -use mir::interpret::GlobalId; -use hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX}; -use hir::map::DefPathHash; -use hir::HirId; +use crate::mir::interpret::GlobalId; +use crate::hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX}; +use crate::hir::map::DefPathHash; +use crate::hir::HirId; -use ich::{Fingerprint, StableHashingContext}; +use crate::ich::{Fingerprint, StableHashingContext}; use rustc_data_structures::stable_hasher::{StableHasher, HashStable}; use std::fmt; use std::hash::Hash; use syntax_pos::symbol::InternedString; -use traits; -use traits::query::{ +use crate::traits; +use crate::traits::query::{ CanonicalProjectionGoal, CanonicalTyGoal, CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpSubtypeGoal, CanonicalPredicateGoal, CanonicalTypeOpProvePredicateGoal, CanonicalTypeOpNormalizeGoal, }; -use ty::{TyCtxt, FnSig, Instance, InstanceDef, +use crate::ty::{TyCtxt, FnSig, Instance, InstanceDef, ParamEnv, ParamEnvAnd, Predicate, PolyFnSig, PolyTraitRef, Ty}; -use ty::subst::Substs; +use crate::ty::subst::Substs; // erase!() just makes tokens go away. It's used to specify which macro argument // is repeated (i.e., which sub-expression of the macro we are in) but don't need @@ -389,7 +389,7 @@ impl fmt::Debug for DepNode { write!(f, "(")?; - ::ty::tls::with_opt(|opt_tcx| { + crate::ty::tls::with_opt(|opt_tcx| { if let Some(tcx) = opt_tcx { if let Some(def_id) = self.extract_def_id(tcx) { write!(f, "{}", tcx.def_path_debug_str(def_id))?; @@ -825,6 +825,6 @@ impl WorkProductId { } } -impl_stable_hash_for!(struct ::dep_graph::WorkProductId { +impl_stable_hash_for!(struct crate::dep_graph::WorkProductId { hash }); diff --git a/src/librustc/dep_graph/dep_tracking_map.rs b/src/librustc/dep_graph/dep_tracking_map.rs index 331a9c6109c4c..a296a3379c2ac 100644 --- a/src/librustc/dep_graph/dep_tracking_map.rs +++ b/src/librustc/dep_graph/dep_tracking_map.rs @@ -2,7 +2,7 @@ use rustc_data_structures::fx::FxHashMap; use std::cell::RefCell; use std::hash::Hash; use std::marker::PhantomData; -use util::common::MemoizationMap; +use crate::util::common::MemoizationMap; use super::{DepKind, DepNodeIndex, DepGraph}; diff --git a/src/librustc/dep_graph/graph.rs b/src/librustc/dep_graph/graph.rs index c9353a451e2cd..663c408ac22fd 100644 --- a/src/librustc/dep_graph/graph.rs +++ b/src/librustc/dep_graph/graph.rs @@ -1,4 +1,4 @@ -use errors::{Diagnostic, DiagnosticBuilder}; +use crate::errors::{Diagnostic, DiagnosticBuilder}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::indexed_vec::{Idx, IndexVec}; @@ -7,11 +7,11 @@ use rustc_data_structures::sync::{Lrc, Lock, AtomicU32, Ordering}; use std::env; use std::hash::Hash; use std::collections::hash_map::Entry; -use ty::{self, TyCtxt}; -use util::common::{ProfileQueriesMsg, profq_msg}; +use crate::ty::{self, TyCtxt}; +use crate::util::common::{ProfileQueriesMsg, profq_msg}; use parking_lot::{Mutex, Condvar}; -use ich::{StableHashingContext, StableHashingContextProvider, Fingerprint}; +use crate::ich::{StableHashingContext, StableHashingContextProvider, Fingerprint}; use super::debug::EdgeFilter; use super::dep_node::{DepNode, DepKind, WorkProductId}; @@ -669,7 +669,7 @@ impl DepGraph { // We failed to mark it green, so we try to force the query. debug!("try_mark_previous_green({:?}) --- trying to force \ dependency {:?}", dep_node, dep_dep_node); - if ::ty::query::force_from_dep_node(tcx, dep_dep_node) { + if crate::ty::query::force_from_dep_node(tcx, dep_dep_node) { let dep_dep_node_color = data.colors.get(dep_dep_node_index); match dep_dep_node_color { diff --git a/src/librustc/dep_graph/prev.rs b/src/librustc/dep_graph/prev.rs index ea5350ac97fee..d971690bbe317 100644 --- a/src/librustc/dep_graph/prev.rs +++ b/src/librustc/dep_graph/prev.rs @@ -1,4 +1,4 @@ -use ich::Fingerprint; +use crate::ich::Fingerprint; use rustc_data_structures::fx::FxHashMap; use super::dep_node::DepNode; use super::serialized::{SerializedDepGraph, SerializedDepNodeIndex}; diff --git a/src/librustc/dep_graph/safe.rs b/src/librustc/dep_graph/safe.rs index f1e8224a70d14..fc767defe9c71 100644 --- a/src/librustc/dep_graph/safe.rs +++ b/src/librustc/dep_graph/safe.rs @@ -1,9 +1,9 @@ //! The `DepGraphSafe` trait -use hir::BodyId; -use hir::def_id::DefId; +use crate::hir::BodyId; +use crate::hir::def_id::DefId; use syntax::ast::NodeId; -use ty::TyCtxt; +use crate::ty::TyCtxt; /// The `DepGraphSafe` trait is used to specify what kinds of values /// are safe to "leak" into a task. The idea is that this should be diff --git a/src/librustc/dep_graph/serialized.rs b/src/librustc/dep_graph/serialized.rs index 3c04f01a5e1eb..b64f71ed908d8 100644 --- a/src/librustc/dep_graph/serialized.rs +++ b/src/librustc/dep_graph/serialized.rs @@ -1,7 +1,7 @@ //! The data that we will serialize and deserialize. -use dep_graph::DepNode; -use ich::Fingerprint; +use crate::dep_graph::DepNode; +use crate::ich::Fingerprint; use rustc_data_structures::indexed_vec::{IndexVec, Idx}; newtype_index! { diff --git a/src/librustc/hir/check_attr.rs b/src/librustc/hir/check_attr.rs index 4ce41fec18240..75710210d7722 100644 --- a/src/librustc/hir/check_attr.rs +++ b/src/librustc/hir/check_attr.rs @@ -5,12 +5,12 @@ //! item. -use ty::TyCtxt; -use ty::query::Providers; +use crate::ty::TyCtxt; +use crate::ty::query::Providers; -use hir; -use hir::def_id::DefId; -use hir::intravisit::{self, Visitor, NestedVisitorMap}; +use crate::hir; +use crate::hir::def_id::DefId; +use crate::hir::intravisit::{self, Visitor, NestedVisitorMap}; use std::fmt::{self, Display}; use syntax_pos::Span; diff --git a/src/librustc/hir/def.rs b/src/librustc/hir/def.rs index f8f27992b3ea8..6566c6041b6e5 100644 --- a/src/librustc/hir/def.rs +++ b/src/librustc/hir/def.rs @@ -1,10 +1,10 @@ -use hir::def_id::DefId; -use util::nodemap::{NodeMap, DefIdMap}; +use crate::hir::def_id::DefId; +use crate::util::nodemap::{NodeMap, DefIdMap}; use syntax::ast; use syntax::ext::base::MacroKind; use syntax_pos::Span; -use hir; -use ty; +use crate::hir; +use crate::ty; use self::Namespace::*; diff --git a/src/librustc/hir/def_id.rs b/src/librustc/hir/def_id.rs index 9181076740ba0..e06f09e21cbf3 100644 --- a/src/librustc/hir/def_id.rs +++ b/src/librustc/hir/def_id.rs @@ -1,6 +1,6 @@ -use ty; -use ty::TyCtxt; -use hir::map::definitions::FIRST_FREE_HIGH_DEF_INDEX; +use crate::ty; +use crate::ty::TyCtxt; +use crate::hir::map::definitions::FIRST_FREE_HIGH_DEF_INDEX; use rustc_data_structures::indexed_vec::Idx; use serialize; use std::fmt; diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index 5f85e33fb87ee..86c3fb9e4fcd7 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -33,9 +33,9 @@ use syntax::ast::{NodeId, CRATE_NODE_ID, Ident, Name, Attribute}; use syntax_pos::Span; -use hir::*; -use hir::def::Def; -use hir::map::Map; +use crate::hir::*; +use crate::hir::def::Def; +use crate::hir::map::Map; use super::itemlikevisit::DeepVisitor; #[derive(Copy, Clone)] diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index e3c913313adee..d0fd5bd6844b0 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -30,24 +30,24 @@ //! get confused if the spans from leaf AST nodes occur in multiple places //! in the HIR, especially for multiple identifiers. -use dep_graph::DepGraph; -use errors::Applicability; -use hir::{self, ParamName}; -use hir::HirVec; -use hir::map::{DefKey, DefPathData, Definitions}; -use hir::def_id::{DefId, DefIndex, DefIndexAddressSpace, CRATE_DEF_INDEX}; -use hir::def::{Def, PathResolution, PerNS}; -use hir::GenericArg; -use lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES, +use crate::dep_graph::DepGraph; +use crate::errors::Applicability; +use crate::hir::{self, ParamName}; +use crate::hir::HirVec; +use crate::hir::map::{DefKey, DefPathData, Definitions}; +use crate::hir::def_id::{DefId, DefIndex, DefIndexAddressSpace, CRATE_DEF_INDEX}; +use crate::hir::def::{Def, PathResolution, PerNS}; +use crate::hir::GenericArg; +use crate::lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES, ELIDED_LIFETIMES_IN_PATHS}; -use middle::cstore::CrateStore; +use crate::middle::cstore::CrateStore; use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::indexed_vec::IndexVec; use rustc_data_structures::thin_vec::ThinVec; -use session::Session; -use session::config::nightly_options; -use util::common::FN_OUTPUT_NAME; -use util::nodemap::{DefIdMap, NodeMap}; +use crate::session::Session; +use crate::session::config::nightly_options; +use crate::util::common::FN_OUTPUT_NAME; +use crate::util::nodemap::{DefIdMap, NodeMap}; use std::collections::{BTreeSet, BTreeMap}; use std::fmt::Debug; diff --git a/src/librustc/hir/map/blocks.rs b/src/librustc/hir/map/blocks.rs index f61b8551927bb..d5fb578d8d492 100644 --- a/src/librustc/hir/map/blocks.rs +++ b/src/librustc/hir/map/blocks.rs @@ -11,10 +11,10 @@ //! nested within a uniquely determined `FnLike`), and users can ask //! for the `Code` associated with a particular NodeId. -use hir as ast; -use hir::map; -use hir::{Expr, FnDecl, Node}; -use hir::intravisit::FnKind; +use crate::hir as ast; +use crate::hir::map; +use crate::hir::{Expr, FnDecl, Node}; +use crate::hir::intravisit::FnKind; use syntax::ast::{Attribute, Ident, NodeId}; use syntax_pos::Span; diff --git a/src/librustc/hir/map/collector.rs b/src/librustc/hir/map/collector.rs index 9c4fa9e127287..f84bb77e29b27 100644 --- a/src/librustc/hir/map/collector.rs +++ b/src/librustc/hir/map/collector.rs @@ -1,19 +1,19 @@ use super::*; -use dep_graph::{DepGraph, DepKind, DepNodeIndex}; -use hir; -use hir::def_id::{LOCAL_CRATE, CrateNum}; -use hir::intravisit::{Visitor, NestedVisitorMap}; +use crate::dep_graph::{DepGraph, DepKind, DepNodeIndex}; +use crate::hir; +use crate::hir::def_id::{LOCAL_CRATE, CrateNum}; +use crate::hir::intravisit::{Visitor, NestedVisitorMap}; use rustc_data_structures::svh::Svh; -use ich::Fingerprint; -use middle::cstore::CrateStore; -use session::CrateDisambiguator; -use session::Session; +use crate::ich::Fingerprint; +use crate::middle::cstore::CrateStore; +use crate::session::CrateDisambiguator; +use crate::session::Session; use std::iter::repeat; use syntax::ast::{NodeId, CRATE_NODE_ID}; use syntax::source_map::SourceMap; use syntax_pos::Span; -use ich::StableHashingContext; +use crate::ich::StableHashingContext; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; /// A Visitor that walks over the HIR and collects Nodes into a HIR map @@ -253,7 +253,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> { None => format!("{:?}", node) }; - let forgot_str = if hir_id == ::hir::DUMMY_HIR_ID { + let forgot_str = if hir_id == crate::hir::DUMMY_HIR_ID { format!("\nMaybe you forgot to lower the node id {:?}?", id) } else { String::new() diff --git a/src/librustc/hir/map/def_collector.rs b/src/librustc/hir/map/def_collector.rs index c9b4b2bb99717..710170674f761 100644 --- a/src/librustc/hir/map/def_collector.rs +++ b/src/librustc/hir/map/def_collector.rs @@ -1,6 +1,6 @@ -use hir::map::definitions::*; -use hir::def_id::{CRATE_DEF_INDEX, DefIndex, DefIndexAddressSpace}; -use session::CrateDisambiguator; +use crate::hir::map::definitions::*; +use crate::hir::def_id::{CRATE_DEF_INDEX, DefIndex, DefIndexAddressSpace}; +use crate::session::CrateDisambiguator; use syntax::ast::*; use syntax::ext::hygiene::Mark; @@ -10,7 +10,7 @@ use syntax::symbol::Symbol; use syntax::parse::token::{self, Token}; use syntax_pos::Span; -use hir::map::{ITEM_LIKE_SPACE, REGULAR_SPACE}; +use crate::hir::map::{ITEM_LIKE_SPACE, REGULAR_SPACE}; /// Creates def ids for nodes in the AST. pub struct DefCollector<'a> { diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs index 4c622adefbdb1..a8193e1d34837 100644 --- a/src/librustc/hir/map/definitions.rs +++ b/src/librustc/hir/map/definitions.rs @@ -4,15 +4,15 @@ //! There are also some rather random cases (like const initializer //! expressions) that are mostly just leftovers. -use hir; -use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, DefIndexAddressSpace, +use crate::hir; +use crate::hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, DefIndexAddressSpace, CRATE_DEF_INDEX}; -use ich::Fingerprint; +use crate::ich::Fingerprint; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::indexed_vec::{IndexVec}; use rustc_data_structures::stable_hasher::StableHasher; use serialize::{Encodable, Decodable, Encoder, Decoder}; -use session::CrateDisambiguator; +use crate::session::CrateDisambiguator; use std::borrow::Borrow; use std::fmt::Write; use std::hash::Hash; @@ -20,7 +20,7 @@ use syntax::ast; use syntax::ext::hygiene::Mark; use syntax::symbol::{Symbol, InternedString}; use syntax_pos::{Span, DUMMY_SP}; -use util::nodemap::NodeMap; +use crate::util::nodemap::NodeMap; /// The DefPathTable maps DefIndexes to DefKeys and vice versa. /// Internally the DefPathTable holds a tree of DefKeys, where each DefKey diff --git a/src/librustc/hir/map/hir_id_validator.rs b/src/librustc/hir/map/hir_id_validator.rs index 91c8c29144406..2c3ff4c9b5c05 100644 --- a/src/librustc/hir/map/hir_id_validator.rs +++ b/src/librustc/hir/map/hir_id_validator.rs @@ -1,7 +1,7 @@ -use hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX}; -use hir::{self, intravisit, HirId, ItemLocalId}; +use crate::hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX}; +use crate::hir::{self, intravisit, HirId, ItemLocalId}; use syntax::ast::NodeId; -use hir::itemlikevisit::ItemLikeVisitor; +use crate::hir::itemlikevisit::ItemLikeVisitor; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::sync::{Lock, ParallelIterator, par_iter}; diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 977ab05b20932..6db1ec3e99b53 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -3,11 +3,11 @@ pub use self::def_collector::{DefCollector, MacroInvocationData}; pub use self::definitions::{Definitions, DefKey, DefPath, DefPathData, DisambiguatedDefPathData, DefPathHash}; -use dep_graph::{DepGraph, DepNode, DepKind, DepNodeIndex}; +use crate::dep_graph::{DepGraph, DepNode, DepKind, DepNodeIndex}; -use hir::def_id::{CRATE_DEF_INDEX, DefId, LocalDefId, DefIndexAddressSpace}; +use crate::hir::def_id::{CRATE_DEF_INDEX, DefId, LocalDefId, DefIndexAddressSpace}; -use middle::cstore::CrateStoreDyn; +use crate::middle::cstore::CrateStoreDyn; use rustc_target::spec::abi::Abi; use rustc_data_structures::svh::Svh; @@ -17,15 +17,15 @@ use syntax::source_map::Spanned; use syntax::ext::base::MacroKind; use syntax_pos::{Span, DUMMY_SP}; -use hir::*; -use hir::itemlikevisit::ItemLikeVisitor; -use hir::print::Nested; -use util::nodemap::FxHashMap; -use util::common::time; +use crate::hir::*; +use crate::hir::itemlikevisit::ItemLikeVisitor; +use crate::hir::print::Nested; +use crate::util::nodemap::FxHashMap; +use crate::util::common::time; use std::io; use std::result::Result::Err; -use ty::TyCtxt; +use crate::ty::TyCtxt; pub mod blocks; mod collector; @@ -1152,13 +1152,13 @@ impl Named for StructField { fn name(&self) -> Name { self.ident.name } } impl Named for TraitItem { fn name(&self) -> Name { self.ident.name } } impl Named for ImplItem { fn name(&self) -> Name { self.ident.name } } -pub fn map_crate<'hir>(sess: &::session::Session, +pub fn map_crate<'hir>(sess: &crate::session::Session, cstore: &CrateStoreDyn, forest: &'hir Forest, definitions: &'hir Definitions) -> Map<'hir> { let ((map, crate_hash), hir_to_node_id) = join(|| { - let hcx = ::ich::StableHashingContext::new(sess, &forest.krate, definitions, cstore); + let hcx = crate::ich::StableHashingContext::new(sess, &forest.krate, definitions, cstore); let mut collector = NodeCollector::root(sess, &forest.krate, @@ -1269,7 +1269,7 @@ fn node_id_to_string(map: &Map<'_>, id: NodeId, include_id: bool) -> String { let path_str = || { // This functionality is used for debugging, try to use TyCtxt to get // the user-friendly path, otherwise fall back to stringifying DefPath. - ::ty::tls::with_opt(|tcx| { + crate::ty::tls::with_opt(|tcx| { if let Some(tcx) = tcx { tcx.node_path_str(id) } else if let Some(path) = map.def_path_from_id(id) { diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 924b044da5fc3..f8fb2b88e2750 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -10,11 +10,11 @@ pub use self::PrimTy::*; pub use self::UnOp::*; pub use self::UnsafeSource::*; -use errors::FatalError; -use hir::def::Def; -use hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX}; -use util::nodemap::{NodeMap, FxHashSet}; -use mir::mono::Linkage; +use crate::errors::FatalError; +use crate::hir::def::Def; +use crate::hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX}; +use crate::util::nodemap::{NodeMap, FxHashSet}; +use crate::mir::mono::Linkage; use syntax_pos::{Span, DUMMY_SP, symbol::InternedString}; use syntax::source_map::Spanned; @@ -27,8 +27,8 @@ use syntax::ptr::P; use syntax::symbol::{Symbol, keywords}; use syntax::tokenstream::TokenStream; use syntax::util::parser::ExprPrecedence; -use ty::AdtKind; -use ty::query::Providers; +use crate::ty::AdtKind; +use crate::ty::query::Providers; use rustc_data_structures::sync::{ParallelIterator, par_iter, Send, Sync, scope}; use rustc_data_structures::thin_vec::ThinVec; diff --git a/src/librustc/hir/pat_util.rs b/src/librustc/hir/pat_util.rs index e2a03c638764d..c92cbc9b96c93 100644 --- a/src/librustc/hir/pat_util.rs +++ b/src/librustc/hir/pat_util.rs @@ -1,6 +1,6 @@ -use hir::def::Def; -use hir::def_id::DefId; -use hir::{self, HirId, PatKind}; +use crate::hir::def::Def; +use crate::hir::def_id::DefId; +use crate::hir::{self, HirId, PatKind}; use syntax::ast; use syntax_pos::Span; diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index 89b5b7a190df6..9b6fcf259be14 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -11,9 +11,9 @@ use syntax::symbol::keywords; use syntax::util::parser::{self, AssocOp, Fixity}; use syntax_pos::{self, BytePos, FileName}; -use hir; -use hir::{PatKind, GenericBound, TraitBoundModifier, RangeEnd}; -use hir::{GenericParam, GenericParamKind, GenericArg}; +use crate::hir; +use crate::hir::{PatKind, GenericBound, TraitBoundModifier, RangeEnd}; +use crate::hir::{GenericParam, GenericParamKind, GenericArg}; use std::borrow::Cow; use std::cell::Cell; @@ -2401,7 +2401,7 @@ fn stmt_ends_with_semi(stmt: &hir::StmtKind) -> bool { } fn bin_op_to_assoc_op(op: hir::BinOpKind) -> AssocOp { - use hir::BinOpKind::*; + use crate::hir::BinOpKind::*; match op { Add => AssocOp::Add, Sub => AssocOp::Subtract, diff --git a/src/librustc/ich/hcx.rs b/src/librustc/ich/hcx.rs index d5c9d9ff16dcb..e60fdd62debd1 100644 --- a/src/librustc/ich/hcx.rs +++ b/src/librustc/ich/hcx.rs @@ -1,11 +1,11 @@ -use hir; -use hir::def_id::{DefId, DefIndex}; -use hir::map::DefPathHash; -use hir::map::definitions::Definitions; -use ich::{self, CachingSourceMapView, Fingerprint}; -use middle::cstore::CrateStore; -use ty::{TyCtxt, fast_reject}; -use session::Session; +use crate::hir; +use crate::hir::def_id::{DefId, DefIndex}; +use crate::hir::map::DefPathHash; +use crate::hir::map::definitions::Definitions; +use crate::ich::{self, CachingSourceMapView, Fingerprint}; +use crate::middle::cstore::CrateStore; +use crate::ty::{TyCtxt, fast_reject}; +use crate::session::Session; use std::cmp::Ord; use std::hash as std_hash; @@ -218,7 +218,7 @@ impl<'a> StableHashingContextProvider<'a> for StableHashingContext<'a> { } } -impl<'a> ::dep_graph::DepGraphSafe for StableHashingContext<'a> { +impl<'a> crate::dep_graph::DepGraphSafe for StableHashingContext<'a> { } diff --git a/src/librustc/ich/impls_cstore.rs b/src/librustc/ich/impls_cstore.rs index fdea62a1dd8f6..17ed1a79d45e0 100644 --- a/src/librustc/ich/impls_cstore.rs +++ b/src/librustc/ich/impls_cstore.rs @@ -1,23 +1,21 @@ //! This module contains `HashStable` implementations for various data types //! from rustc::middle::cstore in no particular order. -use middle; - -impl_stable_hash_for!(enum middle::cstore::DepKind { +impl_stable_hash_for!(enum crate::middle::cstore::DepKind { UnexportedMacrosOnly, MacrosOnly, Implicit, Explicit }); -impl_stable_hash_for!(enum middle::cstore::NativeLibraryKind { +impl_stable_hash_for!(enum crate::middle::cstore::NativeLibraryKind { NativeStatic, NativeStaticNobundle, NativeFramework, NativeUnknown }); -impl_stable_hash_for!(struct middle::cstore::NativeLibrary { +impl_stable_hash_for!(struct crate::middle::cstore::NativeLibrary { kind, name, cfg, @@ -25,30 +23,30 @@ impl_stable_hash_for!(struct middle::cstore::NativeLibrary { wasm_import_module }); -impl_stable_hash_for!(struct middle::cstore::ForeignModule { +impl_stable_hash_for!(struct crate::middle::cstore::ForeignModule { foreign_items, def_id }); -impl_stable_hash_for!(enum middle::cstore::LinkagePreference { +impl_stable_hash_for!(enum crate::middle::cstore::LinkagePreference { RequireDynamic, RequireStatic }); -impl_stable_hash_for!(struct middle::cstore::ExternCrate { +impl_stable_hash_for!(struct crate::middle::cstore::ExternCrate { src, span, path_len, direct }); -impl_stable_hash_for!(enum middle::cstore::ExternCrateSource { +impl_stable_hash_for!(enum crate::middle::cstore::ExternCrateSource { Extern(def_id), Use, Path, }); -impl_stable_hash_for!(struct middle::cstore::CrateSource { +impl_stable_hash_for!(struct crate::middle::cstore::CrateSource { dylib, rlib, rmeta diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index 1061ea752af11..2b359428b1fa1 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -1,10 +1,10 @@ //! This module contains `HashStable` implementations for various HIR data //! types in no particular order. -use hir; -use hir::map::DefPathHash; -use hir::def_id::{DefId, LocalDefId, CrateNum, CRATE_DEF_INDEX}; -use ich::{StableHashingContext, NodeIdHashingMode, Fingerprint}; +use crate::hir; +use crate::hir::map::DefPathHash; +use crate::hir::def_id::{DefId, LocalDefId, CrateNum, CRATE_DEF_INDEX}; +use crate::ich::{StableHashingContext, NodeIdHashingMode, Fingerprint}; use rustc_data_structures::stable_hasher::{HashStable, ToStableHashKey, StableHasher, StableHasherResult}; use std::mem; @@ -619,7 +619,7 @@ impl<'a> HashStable> for hir::MatchSource { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use hir::MatchSource; + use crate::hir::MatchSource; mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -1116,12 +1116,12 @@ impl_stable_hash_for!(struct hir::def::Export { span }); -impl_stable_hash_for!(struct ::middle::lib_features::LibFeatures { +impl_stable_hash_for!(struct crate::middle::lib_features::LibFeatures { stable, unstable }); -impl<'a> HashStable> for ::middle::lang_items::LangItem { +impl<'a> HashStable> for crate::middle::lang_items::LangItem { fn hash_stable(&self, _: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { @@ -1129,7 +1129,7 @@ impl<'a> HashStable> for ::middle::lang_items::LangItem } } -impl_stable_hash_for!(struct ::middle::lang_items::LanguageItems { +impl_stable_hash_for!(struct crate::middle::lang_items::LanguageItems { items, missing }); diff --git a/src/librustc/ich/impls_mir.rs b/src/librustc/ich/impls_mir.rs index 002ac7cc7a9bb..51fc78ffc8669 100644 --- a/src/librustc/ich/impls_mir.rs +++ b/src/librustc/ich/impls_mir.rs @@ -1,8 +1,8 @@ //! This module contains `HashStable` implementations for various MIR data //! types in no particular order. -use ich::StableHashingContext; -use mir; +use crate::ich::StableHashingContext; +use crate::mir; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; use std::mem; diff --git a/src/librustc/ich/impls_misc.rs b/src/librustc/ich/impls_misc.rs index f79adc8109a7f..8a388fafce5e8 100644 --- a/src/librustc/ich/impls_misc.rs +++ b/src/librustc/ich/impls_misc.rs @@ -1,7 +1,7 @@ //! This module contains `HashStable` implementations for various data types //! that don't fit into any of the other impls_xxx modules. -impl_stable_hash_for!(enum ::session::search_paths::PathKind { +impl_stable_hash_for!(enum crate::session::search_paths::PathKind { Native, Crate, Dependency, diff --git a/src/librustc/ich/impls_syntax.rs b/src/librustc/ich/impls_syntax.rs index e10359636f749..f34423ccca655 100644 --- a/src/librustc/ich/impls_syntax.rs +++ b/src/librustc/ich/impls_syntax.rs @@ -1,7 +1,7 @@ //! This module contains `HashStable` implementations for various data types //! from libsyntax in no particular order. -use ich::StableHashingContext; +use crate::ich::StableHashingContext; use std::hash as std_hash; use std::mem; @@ -13,7 +13,7 @@ use syntax::symbol::{InternedString, LocalInternedString}; use syntax::tokenstream; use syntax_pos::SourceFile; -use hir::def_id::{DefId, CrateNum, CRATE_DEF_INDEX}; +use crate::hir::def_id::{DefId, CrateNum, CRATE_DEF_INDEX}; use smallvec::SmallVec; use rustc_data_structures::stable_hasher::{HashStable, ToStableHashKey, diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index bd2349161f74a..1e1dbd0b621ec 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -1,18 +1,18 @@ //! This module contains `HashStable` implementations for various data types //! from rustc::ty in no particular order. -use ich::{Fingerprint, StableHashingContext, NodeIdHashingMode}; +use crate::ich::{Fingerprint, StableHashingContext, NodeIdHashingMode}; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::stable_hasher::{HashStable, ToStableHashKey, StableHasher, StableHasherResult}; use std::cell::RefCell; use std::hash as std_hash; use std::mem; -use middle::region; -use infer; -use traits; -use ty; -use mir; +use crate::middle::region; +use crate::infer; +use crate::traits; +use crate::ty; +use crate::mir; impl<'a, 'gcx, T> HashStable> for &'gcx ty::List @@ -306,7 +306,7 @@ impl_stable_hash_for!( ByRef(id, alloc, offset), } ); -impl_stable_hash_for!(struct ::mir::interpret::RawConst<'tcx> { +impl_stable_hash_for!(struct crate::mir::interpret::RawConst<'tcx> { alloc_id, ty, }); @@ -512,20 +512,22 @@ impl_stable_hash_for!(enum ty::GenericParamDefKind { }); impl_stable_hash_for!( - impl for enum ::middle::resolve_lifetime::Set1 [ ::middle::resolve_lifetime::Set1 ] { + impl for enum crate::middle::resolve_lifetime::Set1 + [ crate::middle::resolve_lifetime::Set1 ] + { Empty, Many, One(value), } ); -impl_stable_hash_for!(enum ::middle::resolve_lifetime::LifetimeDefOrigin { +impl_stable_hash_for!(enum crate::middle::resolve_lifetime::LifetimeDefOrigin { ExplicitOrElided, InBand, Error, }); -impl_stable_hash_for!(enum ::middle::resolve_lifetime::Region { +impl_stable_hash_for!(enum crate::middle::resolve_lifetime::Region { Static, EarlyBound(index, decl, is_in_band), LateBound(db_index, decl, is_in_band), @@ -547,9 +549,9 @@ impl_stable_hash_for!(enum ty::cast::CastKind { FnPtrAddrCast }); -impl_stable_hash_for!(struct ::middle::region::Scope { id, data }); +impl_stable_hash_for!(struct crate::middle::region::Scope { id, data }); -impl_stable_hash_for!(enum ::middle::region::ScopeData { +impl_stable_hash_for!(enum crate::middle::region::ScopeData { Node, CallSite, Arguments, @@ -588,7 +590,7 @@ for ty::TyKind<'gcx> fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use ty::TyKind::*; + use crate::ty::TyKind::*; mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -882,7 +884,7 @@ impl_stable_hash_for!(enum traits::Reveal { All }); -impl_stable_hash_for!(enum ::middle::privacy::AccessLevel { +impl_stable_hash_for!(enum crate::middle::privacy::AccessLevel { ReachableFromImplTrait, Reachable, Exported, @@ -890,12 +892,12 @@ impl_stable_hash_for!(enum ::middle::privacy::AccessLevel { }); impl<'a> HashStable> -for ::middle::privacy::AccessLevels { +for crate::middle::privacy::AccessLevels { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| { - let ::middle::privacy::AccessLevels { + let crate::middle::privacy::AccessLevels { ref map } = *self; @@ -908,14 +910,14 @@ impl_stable_hash_for!(struct ty::CrateInherentImpls { inherent_impls }); -impl_stable_hash_for!(enum ::session::CompileIncomplete { +impl_stable_hash_for!(enum crate::session::CompileIncomplete { Stopped, Errored(error_reported) }); -impl_stable_hash_for!(struct ::util::common::ErrorReported {}); +impl_stable_hash_for!(struct crate::util::common::ErrorReported {}); -impl_stable_hash_for!(tuple_struct ::middle::reachable::ReachableSet { +impl_stable_hash_for!(tuple_struct crate::middle::reachable::ReachableSet { reachable_set }); @@ -924,7 +926,7 @@ for traits::Vtable<'gcx, N> where N: HashStable> { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use traits::Vtable::*; + use crate::traits::Vtable::*; mem::discriminant(self).hash_stable(hcx, hasher); @@ -1105,7 +1107,7 @@ impl<'a, 'tcx> HashStable> for traits::WhereClause<'tcx fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use traits::WhereClause::*; + use crate::traits::WhereClause::*; mem::discriminant(self).hash_stable(hcx, hasher); match self { @@ -1121,7 +1123,7 @@ impl<'a, 'tcx> HashStable> for traits::WellFormed<'tcx> fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use traits::WellFormed::*; + use crate::traits::WellFormed::*; mem::discriminant(self).hash_stable(hcx, hasher); match self { @@ -1135,7 +1137,7 @@ impl<'a, 'tcx> HashStable> for traits::FromEnv<'tcx> { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use traits::FromEnv::*; + use crate::traits::FromEnv::*; mem::discriminant(self).hash_stable(hcx, hasher); match self { @@ -1149,7 +1151,7 @@ impl<'a, 'tcx> HashStable> for traits::DomainGoal<'tcx> fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use traits::DomainGoal::*; + use crate::traits::DomainGoal::*; mem::discriminant(self).hash_stable(hcx, hasher); match self { @@ -1165,7 +1167,7 @@ impl<'a, 'tcx> HashStable> for traits::Goal<'tcx> { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use traits::GoalKind::*; + use crate::traits::GoalKind::*; mem::discriminant(self).hash_stable(hcx, hasher); match self { @@ -1208,7 +1210,7 @@ impl<'a, 'tcx> HashStable> for traits::Clause<'tcx> { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use traits::Clause::*; + use crate::traits::Clause::*; mem::discriminant(self).hash_stable(hcx, hasher); match self { diff --git a/src/librustc/infer/at.rs b/src/librustc/infer/at.rs index 328d518ca66aa..7b2b1184a6336 100644 --- a/src/librustc/infer/at.rs +++ b/src/librustc/infer/at.rs @@ -27,7 +27,7 @@ use super::*; -use ty::relate::{Relate, TypeRelation}; +use crate::ty::relate::{Relate, TypeRelation}; pub struct At<'a, 'gcx: 'tcx, 'tcx: 'a> { pub infcx: &'a InferCtxt<'a, 'gcx, 'tcx>, diff --git a/src/librustc/infer/canonical/canonicalizer.rs b/src/librustc/infer/canonical/canonicalizer.rs index 408cba42ae04b..4e1c797a2c72a 100644 --- a/src/librustc/infer/canonical/canonicalizer.rs +++ b/src/librustc/infer/canonical/canonicalizer.rs @@ -5,15 +5,15 @@ //! //! [c]: https://rust-lang.github.io/rustc-guide/traits/canonicalization.html -use infer::canonical::{ +use crate::infer::canonical::{ Canonical, CanonicalTyVarKind, CanonicalVarInfo, CanonicalVarKind, Canonicalized, OriginalQueryValues, }; -use infer::InferCtxt; +use crate::infer::InferCtxt; use std::sync::atomic::Ordering; -use ty::fold::{TypeFoldable, TypeFolder}; -use ty::subst::Kind; -use ty::{self, BoundVar, Lift, List, Ty, TyCtxt, TypeFlags}; +use crate::ty::fold::{TypeFoldable, TypeFolder}; +use crate::ty::subst::Kind; +use crate::ty::{self, BoundVar, Lift, List, Ty, TyCtxt, TypeFlags}; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::indexed_vec::Idx; diff --git a/src/librustc/infer/canonical/mod.rs b/src/librustc/infer/canonical/mod.rs index eaf72f5a68710..6f28c0b131f61 100644 --- a/src/librustc/infer/canonical/mod.rs +++ b/src/librustc/infer/canonical/mod.rs @@ -21,16 +21,16 @@ //! //! [c]: https://rust-lang.github.io/rustc-guide/traits/canonicalization.html -use infer::{InferCtxt, RegionVariableOrigin, TypeVariableOrigin}; +use crate::infer::{InferCtxt, RegionVariableOrigin, TypeVariableOrigin}; use rustc_data_structures::indexed_vec::IndexVec; use rustc_data_structures::sync::Lrc; use serialize::UseSpecializedDecodable; use smallvec::SmallVec; use std::ops::Index; use syntax::source_map::Span; -use ty::fold::TypeFoldable; -use ty::subst::Kind; -use ty::{self, BoundVar, Lift, List, Region, TyCtxt}; +use crate::ty::fold::TypeFoldable; +use crate::ty::subst::Kind; +use crate::ty::{self, BoundVar, Lift, List, Region, TyCtxt}; mod canonicalizer; @@ -393,14 +393,14 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> { } CloneTypeFoldableAndLiftImpls! { - ::infer::canonical::Certainty, - ::infer::canonical::CanonicalVarInfo, - ::infer::canonical::CanonicalVarKind, + crate::infer::canonical::Certainty, + crate::infer::canonical::CanonicalVarInfo, + crate::infer::canonical::CanonicalVarKind, } CloneTypeFoldableImpls! { for <'tcx> { - ::infer::canonical::CanonicalVarInfos<'tcx>, + crate::infer::canonical::CanonicalVarInfos<'tcx>, } } @@ -431,7 +431,7 @@ impl<'tcx> CanonicalVarValues<'tcx> { /// we'll return a substitution `subst` with: /// `subst.var_values == [Type(^0), Lifetime(^1), Type(^2)]`. pub fn make_identity<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Self { - use ty::subst::UnpackedKind; + use crate::ty::subst::UnpackedKind; CanonicalVarValues { var_values: self.var_values.iter() diff --git a/src/librustc/infer/canonical/query_response.rs b/src/librustc/infer/canonical/query_response.rs index 7f113f07276d8..409afca43203d 100644 --- a/src/librustc/infer/canonical/query_response.rs +++ b/src/librustc/infer/canonical/query_response.rs @@ -7,26 +7,26 @@ //! //! [c]: https://rust-lang.github.io/rustc-guide/traits/canonicalization.html -use infer::canonical::substitute::substitute_value; -use infer::canonical::{ +use crate::infer::canonical::substitute::substitute_value; +use crate::infer::canonical::{ Canonical, CanonicalVarValues, CanonicalizedQueryResponse, Certainty, OriginalQueryValues, QueryRegionConstraint, QueryResponse, }; -use infer::region_constraints::{Constraint, RegionConstraintData}; -use infer::InferCtxtBuilder; -use infer::{InferCtxt, InferOk, InferResult}; +use crate::infer::region_constraints::{Constraint, RegionConstraintData}; +use crate::infer::InferCtxtBuilder; +use crate::infer::{InferCtxt, InferOk, InferResult}; use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::indexed_vec::IndexVec; use rustc_data_structures::sync::Lrc; use std::fmt::Debug; use syntax_pos::DUMMY_SP; -use traits::query::{Fallible, NoSolution}; -use traits::TraitEngine; -use traits::{Obligation, ObligationCause, PredicateObligation}; -use ty::fold::TypeFoldable; -use ty::subst::{Kind, UnpackedKind}; -use ty::{self, BoundVar, Lift, Ty, TyCtxt}; -use util::captures::Captures; +use crate::traits::query::{Fallible, NoSolution}; +use crate::traits::TraitEngine; +use crate::traits::{Obligation, ObligationCause, PredicateObligation}; +use crate::ty::fold::TypeFoldable; +use crate::ty::subst::{Kind, UnpackedKind}; +use crate::ty::{self, BoundVar, Lift, Ty, TyCtxt}; +use crate::util::captures::Captures; impl<'cx, 'gcx, 'tcx> InferCtxtBuilder<'cx, 'gcx, 'tcx> { /// The "main method" for a canonicalized trait query. Given the diff --git a/src/librustc/infer/canonical/substitute.rs b/src/librustc/infer/canonical/substitute.rs index d3ed00481dcee..5af4e8366818b 100644 --- a/src/librustc/infer/canonical/substitute.rs +++ b/src/librustc/infer/canonical/substitute.rs @@ -6,10 +6,10 @@ //! //! [c]: https://rust-lang.github.io/rustc-guide/traits/canonicalization.html -use infer::canonical::{Canonical, CanonicalVarValues}; -use ty::fold::TypeFoldable; -use ty::subst::UnpackedKind; -use ty::{self, TyCtxt}; +use crate::infer::canonical::{Canonical, CanonicalVarValues}; +use crate::ty::fold::TypeFoldable; +use crate::ty::subst::UnpackedKind; +use crate::ty::{self, TyCtxt}; impl<'tcx, V> Canonical<'tcx, V> { /// Instantiate the wrapped value, replacing each canonical value diff --git a/src/librustc/infer/combine.rs b/src/librustc/infer/combine.rs index 40c11695d51e2..7e22521473491 100644 --- a/src/librustc/infer/combine.rs +++ b/src/librustc/infer/combine.rs @@ -29,13 +29,13 @@ use super::lub::Lub; use super::sub::Sub; use super::type_variable::TypeVariableValue; -use hir::def_id::DefId; -use ty::{IntType, UintType}; -use ty::{self, Ty, TyCtxt}; -use ty::error::TypeError; -use ty::relate::{self, Relate, RelateResult, TypeRelation}; -use ty::subst::Substs; -use traits::{Obligation, PredicateObligations}; +use crate::hir::def_id::DefId; +use crate::ty::{IntType, UintType}; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::error::TypeError; +use crate::ty::relate::{self, Relate, RelateResult, TypeRelation}; +use crate::ty::subst::Substs; +use crate::traits::{Obligation, PredicateObligations}; use syntax::ast; use syntax_pos::Span; diff --git a/src/librustc/infer/equate.rs b/src/librustc/infer/equate.rs index 60a7eb0d54f8b..a4b62307a60b8 100644 --- a/src/librustc/infer/equate.rs +++ b/src/librustc/infer/equate.rs @@ -1,12 +1,12 @@ use super::combine::{CombineFields, RelationDir}; use super::{Subtype}; -use hir::def_id::DefId; +use crate::hir::def_id::DefId; -use ty::{self, Ty, TyCtxt}; -use ty::TyVar; -use ty::subst::Substs; -use ty::relate::{self, Relate, RelateResult, TypeRelation}; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::TyVar; +use crate::ty::subst::Substs; +use crate::ty::relate::{self, Relate, RelateResult, TypeRelation}; /// Ensures `a` is made equal to `b`. Returns `a` on success. pub struct Equate<'combine, 'infcx: 'combine, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> { diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs index 66e4cd49c807f..8510533391287 100644 --- a/src/librustc/infer/error_reporting/mod.rs +++ b/src/librustc/infer/error_reporting/mod.rs @@ -48,19 +48,19 @@ use super::lexical_region_resolve::RegionResolutionError; use super::region_constraints::GenericKind; use super::{InferCtxt, RegionVariableOrigin, SubregionOrigin, TypeTrace, ValuePairs}; -use infer::{self, SuppressRegionErrors}; +use crate::infer::{self, SuppressRegionErrors}; -use errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString}; -use hir; -use hir::def_id::DefId; -use hir::Node; -use middle::region; +use crate::errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString}; +use crate::hir; +use crate::hir::def_id::DefId; +use crate::hir::Node; +use crate::middle::region; use std::{cmp, fmt}; use syntax::ast::DUMMY_NODE_ID; use syntax_pos::{Pos, Span}; -use traits::{ObligationCause, ObligationCauseCode}; -use ty::error::TypeError; -use ty::{self, subst::Subst, Region, Ty, TyCtxt, TyKind, TypeFoldable}; +use crate::traits::{ObligationCause, ObligationCauseCode}; +use crate::ty::error::TypeError; +use crate::ty::{self, subst::Subst, Region, Ty, TyCtxt, TyKind, TypeFoldable}; mod note; @@ -1479,7 +1479,7 @@ enum FailureCode { impl<'tcx> ObligationCause<'tcx> { fn as_failure_code(&self, terr: &TypeError<'tcx>) -> FailureCode { use self::FailureCode::*; - use traits::ObligationCauseCode::*; + use crate::traits::ObligationCauseCode::*; match self.code { CompareImplMethodObligation { .. } => Error0308("method not compatible with trait"), MatchExpressionArm { source, .. } => Error0308(match source { @@ -1509,7 +1509,7 @@ impl<'tcx> ObligationCause<'tcx> { } fn as_requirement_str(&self) -> &'static str { - use traits::ObligationCauseCode::*; + use crate::traits::ObligationCauseCode::*; match self.code { CompareImplMethodObligation { .. } => "method type is compatible with trait", ExprAssignable => "expression is assignable", diff --git a/src/librustc/infer/error_reporting/need_type_info.rs b/src/librustc/infer/error_reporting/need_type_info.rs index 8ee367c87c3ea..fac498bd6dd78 100644 --- a/src/librustc/infer/error_reporting/need_type_info.rs +++ b/src/librustc/infer/error_reporting/need_type_info.rs @@ -1,11 +1,11 @@ -use hir::{self, Local, Pat, Body, HirId}; -use hir::intravisit::{self, Visitor, NestedVisitorMap}; -use infer::InferCtxt; -use infer::type_variable::TypeVariableOrigin; -use ty::{self, Ty, Infer, TyVar}; +use crate::hir::{self, Local, Pat, Body, HirId}; +use crate::hir::intravisit::{self, Visitor, NestedVisitorMap}; +use crate::infer::InferCtxt; +use crate::infer::type_variable::TypeVariableOrigin; +use crate::ty::{self, Ty, Infer, TyVar}; use syntax::source_map::CompilerDesugaringKind; use syntax_pos::Span; -use errors::DiagnosticBuilder; +use crate::errors::DiagnosticBuilder; struct FindLocalByTypeVisitor<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> { infcx: &'a InferCtxt<'a, 'gcx, 'tcx>, diff --git a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs index 8be49b2792441..0f4401517792c 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/different_lifetimes.rs @@ -1,9 +1,9 @@ //! Error Reporting for Anonymous Region Lifetime Errors //! where both the regions are anonymous. -use infer::error_reporting::nice_region_error::NiceRegionError; -use infer::error_reporting::nice_region_error::util::AnonymousArgInfo; -use util::common::ErrorReported; +use crate::infer::error_reporting::nice_region_error::NiceRegionError; +use crate::infer::error_reporting::nice_region_error::util::AnonymousArgInfo; +use crate::util::common::ErrorReported; impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> { /// Print the error message for lifetime errors when both the concerned regions are anonymous. diff --git a/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs b/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs index ebaef4977f400..ea748874fc4e2 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/find_anon_type.rs @@ -1,9 +1,9 @@ -use hir; -use ty::{self, Region, TyCtxt}; -use hir::Node; -use middle::resolve_lifetime as rl; -use hir::intravisit::{self, NestedVisitorMap, Visitor}; -use infer::error_reporting::nice_region_error::NiceRegionError; +use crate::hir; +use crate::ty::{self, Region, TyCtxt}; +use crate::hir::Node; +use crate::middle::resolve_lifetime as rl; +use crate::hir::intravisit::{self, NestedVisitorMap, Visitor}; +use crate::infer::error_reporting::nice_region_error::NiceRegionError; impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> { /// This function calls the `visit_ty` method for the parameters diff --git a/src/librustc/infer/error_reporting/nice_region_error/mod.rs b/src/librustc/infer/error_reporting/nice_region_error/mod.rs index d34b71c33f4b4..dad1e3ba80da3 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/mod.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/mod.rs @@ -1,9 +1,9 @@ -use infer::InferCtxt; -use infer::lexical_region_resolve::RegionResolutionError; -use infer::lexical_region_resolve::RegionResolutionError::*; +use crate::infer::InferCtxt; +use crate::infer::lexical_region_resolve::RegionResolutionError; +use crate::infer::lexical_region_resolve::RegionResolutionError::*; use syntax::source_map::Span; -use ty::{self, TyCtxt}; -use util::common::ErrorReported; +use crate::ty::{self, TyCtxt}; +use crate::util::common::ErrorReported; mod different_lifetimes; mod find_anon_type; diff --git a/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs b/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs index 05333f4337336..d66bb274b34ce 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/named_anon_conflict.rs @@ -1,9 +1,9 @@ //! Error Reporting for Anonymous Region Lifetime Errors //! where one region is named and the other is anonymous. -use infer::error_reporting::nice_region_error::NiceRegionError; -use ty; -use util::common::ErrorReported; -use errors::Applicability; +use crate::infer::error_reporting::nice_region_error::NiceRegionError; +use crate::ty; +use crate::util::common::ErrorReported; +use crate::errors::Applicability; impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> { /// When given a `ConcreteFailure` for a function with arguments containing a named region and diff --git a/src/librustc/infer/error_reporting/nice_region_error/outlives_closure.rs b/src/librustc/infer/error_reporting/nice_region_error/outlives_closure.rs index cbd36a8b2db8a..6432780de0670 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/outlives_closure.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/outlives_closure.rs @@ -1,13 +1,13 @@ //! Error Reporting for Anonymous Region Lifetime Errors //! where both the regions are anonymous. -use infer::error_reporting::nice_region_error::NiceRegionError; -use infer::SubregionOrigin; -use ty::RegionKind; -use hir::{Expr, ExprKind::Closure}; -use hir::Node; -use util::common::ErrorReported; -use infer::lexical_region_resolve::RegionResolutionError::SubSupConflict; +use crate::infer::error_reporting::nice_region_error::NiceRegionError; +use crate::infer::SubregionOrigin; +use crate::ty::RegionKind; +use crate::hir::{Expr, ExprKind::Closure}; +use crate::hir::Node; +use crate::util::common::ErrorReported; +use crate::infer::lexical_region_resolve::RegionResolutionError::SubSupConflict; impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> { /// Print the error message for lifetime errors when binding escapes a closure. diff --git a/src/librustc/infer/error_reporting/nice_region_error/placeholder_error.rs b/src/librustc/infer/error_reporting/nice_region_error/placeholder_error.rs index ebac5a0c2a69e..6893a1fb168b8 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/placeholder_error.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/placeholder_error.rs @@ -1,15 +1,15 @@ -use errors::DiagnosticBuilder; -use hir::def_id::DefId; -use infer::error_reporting::nice_region_error::NiceRegionError; -use infer::lexical_region_resolve::RegionResolutionError; -use infer::ValuePairs; -use infer::{SubregionOrigin, TypeTrace}; -use traits::{ObligationCause, ObligationCauseCode}; -use ty; -use ty::error::ExpectedFound; -use ty::subst::Substs; -use util::common::ErrorReported; -use util::ppaux::RegionHighlightMode; +use crate::errors::DiagnosticBuilder; +use crate::hir::def_id::DefId; +use crate::infer::error_reporting::nice_region_error::NiceRegionError; +use crate::infer::lexical_region_resolve::RegionResolutionError; +use crate::infer::ValuePairs; +use crate::infer::{SubregionOrigin, TypeTrace}; +use crate::traits::{ObligationCause, ObligationCauseCode}; +use crate::ty; +use crate::ty::error::ExpectedFound; +use crate::ty::subst::Substs; +use crate::util::common::ErrorReported; +use crate::util::ppaux::RegionHighlightMode; impl NiceRegionError<'me, 'gcx, 'tcx> { /// When given a `ConcreteFailure` for a function with arguments containing a named region and diff --git a/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs b/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs index 4331518d403dd..3f0297952278a 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs @@ -1,10 +1,10 @@ //! Error Reporting for static impl Traits. -use infer::error_reporting::nice_region_error::NiceRegionError; -use infer::lexical_region_resolve::RegionResolutionError; -use ty::{BoundRegion, FreeRegion, RegionKind}; -use util::common::ErrorReported; -use errors::Applicability; +use crate::infer::error_reporting::nice_region_error::NiceRegionError; +use crate::infer::lexical_region_resolve::RegionResolutionError; +use crate::ty::{BoundRegion, FreeRegion, RegionKind}; +use crate::util::common::ErrorReported; +use crate::errors::Applicability; impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> { /// Print the error message for lifetime errors when the return type is a static impl Trait. diff --git a/src/librustc/infer/error_reporting/nice_region_error/util.rs b/src/librustc/infer/error_reporting/nice_region_error/util.rs index dd8a33829eb53..f73f8d8bb82be 100644 --- a/src/librustc/infer/error_reporting/nice_region_error/util.rs +++ b/src/librustc/infer/error_reporting/nice_region_error/util.rs @@ -1,10 +1,10 @@ //! Helper functions corresponding to lifetime errors due to //! anonymous regions. -use hir; -use infer::error_reporting::nice_region_error::NiceRegionError; -use ty::{self, Region, Ty}; -use hir::def_id::DefId; +use crate::hir; +use crate::infer::error_reporting::nice_region_error::NiceRegionError; +use crate::ty::{self, Region, Ty}; +use crate::hir::def_id::DefId; use syntax_pos::Span; // The struct contains the information about the anonymous region diff --git a/src/librustc/infer/error_reporting/note.rs b/src/librustc/infer/error_reporting/note.rs index e45a4b17cdd9c..efd7f3c55e900 100644 --- a/src/librustc/infer/error_reporting/note.rs +++ b/src/librustc/infer/error_reporting/note.rs @@ -1,8 +1,8 @@ -use infer::{self, InferCtxt, SubregionOrigin}; -use middle::region; -use ty::{self, Region}; -use ty::error::TypeError; -use errors::DiagnosticBuilder; +use crate::infer::{self, InferCtxt, SubregionOrigin}; +use crate::middle::region; +use crate::ty::{self, Region}; +use crate::ty::error::TypeError; +use crate::errors::DiagnosticBuilder; impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { pub(super) fn note_region_origin(&self, diff --git a/src/librustc/infer/freshen.rs b/src/librustc/infer/freshen.rs index 74abcf82529cb..201717b34ee41 100644 --- a/src/librustc/infer/freshen.rs +++ b/src/librustc/infer/freshen.rs @@ -31,9 +31,9 @@ //! variable only once, and it does so as soon as it can, so it is reasonable to ask what the type //! inferencer knows "so far". -use ty::{self, Ty, TyCtxt, TypeFoldable}; -use ty::fold::TypeFolder; -use util::nodemap::FxHashMap; +use crate::ty::{self, Ty, TyCtxt, TypeFoldable}; +use crate::ty::fold::TypeFolder; +use crate::util::nodemap::FxHashMap; use std::collections::hash_map::Entry; diff --git a/src/librustc/infer/fudge.rs b/src/librustc/infer/fudge.rs index a38db5d210f7b..d205cfcf73b7e 100644 --- a/src/librustc/infer/fudge.rs +++ b/src/librustc/infer/fudge.rs @@ -1,6 +1,6 @@ -use infer::type_variable::TypeVariableMap; -use ty::{self, Ty, TyCtxt}; -use ty::fold::{TypeFoldable, TypeFolder}; +use crate::infer::type_variable::TypeVariableMap; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::fold::{TypeFoldable, TypeFolder}; use super::InferCtxt; use super::RegionVariableOrigin; diff --git a/src/librustc/infer/glb.rs b/src/librustc/infer/glb.rs index 635a6d00270b7..910c6571853dc 100644 --- a/src/librustc/infer/glb.rs +++ b/src/librustc/infer/glb.rs @@ -3,9 +3,9 @@ use super::InferCtxt; use super::lattice::{self, LatticeDir}; use super::Subtype; -use traits::ObligationCause; -use ty::{self, Ty, TyCtxt}; -use ty::relate::{Relate, RelateResult, TypeRelation}; +use crate::traits::ObligationCause; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::relate::{Relate, RelateResult, TypeRelation}; /// "Greatest lower bound" (common subtype) pub struct Glb<'combine, 'infcx: 'combine, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> { diff --git a/src/librustc/infer/higher_ranked/mod.rs b/src/librustc/infer/higher_ranked/mod.rs index 709e8c0ba9b24..c7fc446b9787b 100644 --- a/src/librustc/infer/higher_ranked/mod.rs +++ b/src/librustc/infer/higher_ranked/mod.rs @@ -4,8 +4,8 @@ use super::combine::CombineFields; use super::{HigherRankedType, InferCtxt, PlaceholderMap}; -use ty::relate::{Relate, RelateResult, TypeRelation}; -use ty::{self, Binder, TypeFoldable}; +use crate::ty::relate::{Relate, RelateResult, TypeRelation}; +use crate::ty::{self, Binder, TypeFoldable}; impl<'a, 'gcx, 'tcx> CombineFields<'a, 'gcx, 'tcx> { pub fn higher_ranked_sub( diff --git a/src/librustc/infer/lattice.rs b/src/librustc/infer/lattice.rs index a8794b4076a9d..dfa086a64de61 100644 --- a/src/librustc/infer/lattice.rs +++ b/src/librustc/infer/lattice.rs @@ -22,10 +22,10 @@ use super::InferCtxt; use super::type_variable::TypeVariableOrigin; -use traits::ObligationCause; -use ty::TyVar; -use ty::{self, Ty}; -use ty::relate::{RelateResult, TypeRelation}; +use crate::traits::ObligationCause; +use crate::ty::TyVar; +use crate::ty::{self, Ty}; +use crate::ty::relate::{RelateResult, TypeRelation}; pub trait LatticeDir<'f, 'gcx: 'f+'tcx, 'tcx: 'f> : TypeRelation<'f, 'gcx, 'tcx> { fn infcx(&self) -> &'f InferCtxt<'f, 'gcx, 'tcx>; diff --git a/src/librustc/infer/lexical_region_resolve/graphviz.rs b/src/librustc/infer/lexical_region_resolve/graphviz.rs index 7ce2aba54f5cc..073a3f74422c6 100644 --- a/src/librustc/infer/lexical_region_resolve/graphviz.rs +++ b/src/librustc/infer/lexical_region_resolve/graphviz.rs @@ -8,14 +8,14 @@ /// For clarity, rename the graphviz crate locally to dot. use graphviz as dot; -use hir::def_id::DefIndex; -use ty; -use middle::free_region::RegionRelations; -use middle::region; +use crate::hir::def_id::DefIndex; +use crate::ty; +use crate::middle::free_region::RegionRelations; +use crate::middle::region; use super::Constraint; -use infer::SubregionOrigin; -use infer::region_constraints::RegionConstraintData; -use util::nodemap::{FxHashMap, FxHashSet}; +use crate::infer::SubregionOrigin; +use crate::infer::region_constraints::RegionConstraintData; +use crate::util::nodemap::{FxHashMap, FxHashSet}; use std::borrow::Cow; use std::collections::hash_map::Entry::Vacant; diff --git a/src/librustc/infer/lexical_region_resolve/mod.rs b/src/librustc/infer/lexical_region_resolve/mod.rs index c0952fefac0e1..7add8a26ede09 100644 --- a/src/librustc/infer/lexical_region_resolve/mod.rs +++ b/src/librustc/infer/lexical_region_resolve/mod.rs @@ -1,13 +1,13 @@ //! The code to do lexical region resolution. -use infer::region_constraints::Constraint; -use infer::region_constraints::GenericKind; -use infer::region_constraints::RegionConstraintData; -use infer::region_constraints::VarInfos; -use infer::region_constraints::VerifyBound; -use infer::RegionVariableOrigin; -use infer::SubregionOrigin; -use middle::free_region::RegionRelations; +use crate::infer::region_constraints::Constraint; +use crate::infer::region_constraints::GenericKind; +use crate::infer::region_constraints::RegionConstraintData; +use crate::infer::region_constraints::VarInfos; +use crate::infer::region_constraints::VerifyBound; +use crate::infer::RegionVariableOrigin; +use crate::infer::SubregionOrigin; +use crate::middle::free_region::RegionRelations; use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::graph::implementation::{ Direction, Graph, NodeIndex, INCOMING, OUTGOING, @@ -16,11 +16,11 @@ use rustc_data_structures::indexed_vec::{Idx, IndexVec}; use smallvec::SmallVec; use std::fmt; use std::u32; -use ty::fold::TypeFoldable; -use ty::{self, Ty, TyCtxt}; -use ty::{ReEarlyBound, ReEmpty, ReErased, ReFree, ReStatic}; -use ty::{ReLateBound, ReScope, RePlaceholder, ReVar}; -use ty::{Region, RegionVid}; +use crate::ty::fold::TypeFoldable; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::{ReEarlyBound, ReEmpty, ReErased, ReFree, ReStatic}; +use crate::ty::{ReLateBound, ReScope, RePlaceholder, ReVar}; +use crate::ty::{Region, RegionVid}; mod graphviz; diff --git a/src/librustc/infer/lub.rs b/src/librustc/infer/lub.rs index 0b9839f69fa2a..f9eb60d82d17b 100644 --- a/src/librustc/infer/lub.rs +++ b/src/librustc/infer/lub.rs @@ -3,9 +3,9 @@ use super::InferCtxt; use super::lattice::{self, LatticeDir}; use super::Subtype; -use traits::ObligationCause; -use ty::{self, Ty, TyCtxt}; -use ty::relate::{Relate, RelateResult, TypeRelation}; +use crate::traits::ObligationCause; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::relate::{Relate, RelateResult, TypeRelation}; /// "Least upper bound" (common supertype) pub struct Lub<'combine, 'infcx: 'combine, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> { diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs index 958982545750f..06c94d133344c 100644 --- a/src/librustc/infer/mod.rs +++ b/src/librustc/infer/mod.rs @@ -5,31 +5,31 @@ pub use self::LateBoundRegionConversionTime::*; pub use self::RegionVariableOrigin::*; pub use self::SubregionOrigin::*; pub use self::ValuePairs::*; -pub use ty::IntVarValue; +pub use crate::ty::IntVarValue; use arena::SyncDroplessArena; -use errors::DiagnosticBuilder; -use hir::def_id::DefId; -use infer::canonical::{Canonical, CanonicalVarValues}; -use middle::free_region::RegionRelations; -use middle::lang_items; -use middle::region; +use crate::errors::DiagnosticBuilder; +use crate::hir::def_id::DefId; +use crate::infer::canonical::{Canonical, CanonicalVarValues}; +use crate::middle::free_region::RegionRelations; +use crate::middle::lang_items; +use crate::middle::region; use rustc_data_structures::unify as ut; -use session::config::BorrowckMode; +use crate::session::config::BorrowckMode; use std::cell::{Cell, Ref, RefCell, RefMut}; use std::collections::BTreeMap; use std::fmt; use syntax::ast; use syntax_pos::symbol::InternedString; use syntax_pos::{self, Span}; -use traits::{self, ObligationCause, PredicateObligations, TraitEngine}; -use ty::error::{ExpectedFound, TypeError, UnconstrainedNumeric}; -use ty::fold::TypeFoldable; -use ty::relate::RelateResult; -use ty::subst::{Kind, Substs}; -use ty::{self, GenericParamDefKind, Ty, TyCtxt, CtxtInterners}; -use ty::{FloatVid, IntVid, TyVid}; -use util::nodemap::FxHashMap; +use crate::traits::{self, ObligationCause, PredicateObligations, TraitEngine}; +use crate::ty::error::{ExpectedFound, TypeError, UnconstrainedNumeric}; +use crate::ty::fold::TypeFoldable; +use crate::ty::relate::RelateResult; +use crate::ty::subst::{Kind, Substs}; +use crate::ty::{self, GenericParamDefKind, Ty, TyCtxt, CtxtInterners}; +use crate::ty::{FloatVid, IntVid, TyVid}; +use crate::util::nodemap::FxHashMap; use self::combine::CombineFields; use self::lexical_region_resolve::LexicalRegionResolutions; @@ -617,8 +617,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { } pub fn type_is_unconstrained_numeric(&'a self, ty: Ty<'_>) -> UnconstrainedNumeric { - use ty::error::UnconstrainedNumeric::Neither; - use ty::error::UnconstrainedNumeric::{UnconstrainedFloat, UnconstrainedInt}; + use crate::ty::error::UnconstrainedNumeric::Neither; + use crate::ty::error::UnconstrainedNumeric::{UnconstrainedFloat, UnconstrainedInt}; match ty.sty { ty::Infer(ty::IntVar(vid)) => { if self.int_unification_table diff --git a/src/librustc/infer/opaque_types/mod.rs b/src/librustc/infer/opaque_types/mod.rs index 5e94bb1f877fb..e28157f05f15f 100644 --- a/src/librustc/infer/opaque_types/mod.rs +++ b/src/librustc/infer/opaque_types/mod.rs @@ -1,16 +1,16 @@ -use hir::def_id::DefId; -use hir; -use hir::Node; -use infer::{self, InferCtxt, InferOk, TypeVariableOrigin}; -use infer::outlives::free_region_map::FreeRegionRelations; +use crate::hir::def_id::DefId; +use crate::hir; +use crate::hir::Node; +use crate::infer::{self, InferCtxt, InferOk, TypeVariableOrigin}; +use crate::infer::outlives::free_region_map::FreeRegionRelations; use rustc_data_structures::fx::FxHashMap; use syntax::ast; -use traits::{self, PredicateObligation}; -use ty::{self, Ty, TyCtxt, GenericParamDefKind}; -use ty::fold::{BottomUpFolder, TypeFoldable, TypeFolder}; -use ty::outlives::Component; -use ty::subst::{Kind, Substs, UnpackedKind}; -use util::nodemap::DefIdMap; +use crate::traits::{self, PredicateObligation}; +use crate::ty::{self, Ty, TyCtxt, GenericParamDefKind}; +use crate::ty::fold::{BottomUpFolder, TypeFoldable, TypeFolder}; +use crate::ty::outlives::Component; +use crate::ty::subst::{Kind, Substs, UnpackedKind}; +use crate::util::nodemap::DefIdMap; pub type OpaqueTypeMap<'tcx> = DefIdMap>; diff --git a/src/librustc/infer/outlives/env.rs b/src/librustc/infer/outlives/env.rs index 677b6136ea03b..20d03f3c6edb5 100644 --- a/src/librustc/infer/outlives/env.rs +++ b/src/librustc/infer/outlives/env.rs @@ -1,10 +1,10 @@ -use infer::outlives::free_region_map::FreeRegionMap; -use infer::{GenericKind, InferCtxt}; +use crate::infer::outlives::free_region_map::FreeRegionMap; +use crate::infer::{GenericKind, InferCtxt}; use rustc_data_structures::fx::FxHashMap; use syntax::ast; use syntax_pos::Span; -use traits::query::outlives_bounds::{self, OutlivesBound}; -use ty::{self, Ty}; +use crate::traits::query::outlives_bounds::{self, OutlivesBound}; +use crate::ty::{self, Ty}; /// The `OutlivesEnvironment` collects information about what outlives /// what in a given type-checking setting. For example, if we have a diff --git a/src/librustc/infer/outlives/free_region_map.rs b/src/librustc/infer/outlives/free_region_map.rs index a6703c9d679da..7daf6d71980f6 100644 --- a/src/librustc/infer/outlives/free_region_map.rs +++ b/src/librustc/infer/outlives/free_region_map.rs @@ -1,4 +1,4 @@ -use ty::{self, Lift, TyCtxt, Region}; +use crate::ty::{self, Lift, TyCtxt, Region}; use rustc_data_structures::transitive_relation::TransitiveRelation; #[derive(Clone, RustcEncodable, RustcDecodable, Debug, Default)] diff --git a/src/librustc/infer/outlives/obligations.rs b/src/librustc/infer/outlives/obligations.rs index abe835c9211a5..884bd58b4023b 100644 --- a/src/librustc/infer/outlives/obligations.rs +++ b/src/librustc/infer/outlives/obligations.rs @@ -59,14 +59,14 @@ //! might later infer `?U` to something like `&'b u32`, which would //! imply that `'b: 'a`. -use infer::outlives::env::RegionBoundPairs; -use infer::outlives::verify::VerifyBoundCx; -use infer::{self, GenericKind, InferCtxt, RegionObligation, SubregionOrigin, VerifyBound}; +use crate::infer::outlives::env::RegionBoundPairs; +use crate::infer::outlives::verify::VerifyBoundCx; +use crate::infer::{self, GenericKind, InferCtxt, RegionObligation, SubregionOrigin, VerifyBound}; use rustc_data_structures::fx::FxHashMap; use syntax::ast; -use traits::ObligationCause; -use ty::outlives::Component; -use ty::{self, Region, Ty, TyCtxt, TypeFoldable}; +use crate::traits::ObligationCause; +use crate::ty::outlives::Component; +use crate::ty::{self, Region, Ty, TyCtxt, TypeFoldable}; impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> { /// Registers that the given region obligation must be resolved diff --git a/src/librustc/infer/outlives/verify.rs b/src/librustc/infer/outlives/verify.rs index 4e9a8e9ded899..0457e7179461c 100644 --- a/src/librustc/infer/outlives/verify.rs +++ b/src/librustc/infer/outlives/verify.rs @@ -1,10 +1,10 @@ -use hir::def_id::DefId; -use infer::outlives::env::RegionBoundPairs; -use infer::{GenericKind, VerifyBound}; -use traits; -use ty::subst::{Subst, Substs}; -use ty::{self, Ty, TyCtxt}; -use util::captures::Captures; +use crate::hir::def_id::DefId; +use crate::infer::outlives::env::RegionBoundPairs; +use crate::infer::{GenericKind, VerifyBound}; +use crate::traits; +use crate::ty::subst::{Subst, Substs}; +use crate::ty::{self, Ty, TyCtxt}; +use crate::util::captures::Captures; /// The `TypeOutlives` struct has the job of "lowering" a `T: 'a` /// obligation into a series of `'a: 'b` constraints and "verifys", as diff --git a/src/librustc/infer/region_constraints/mod.rs b/src/librustc/infer/region_constraints/mod.rs index 56ae850226c91..500497dc011e1 100644 --- a/src/librustc/infer/region_constraints/mod.rs +++ b/src/librustc/infer/region_constraints/mod.rs @@ -9,10 +9,10 @@ use super::{MiscVariable, RegionVariableOrigin, SubregionOrigin}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::indexed_vec::IndexVec; use rustc_data_structures::unify as ut; -use ty::ReStatic; -use ty::{self, Ty, TyCtxt}; -use ty::{BrFresh, ReLateBound, ReVar}; -use ty::{Region, RegionVid}; +use crate::ty::ReStatic; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::{BrFresh, ReLateBound, ReVar}; +use crate::ty::{Region, RegionVid}; use std::collections::BTreeMap; use std::{cmp, fmt, mem, u32}; diff --git a/src/librustc/infer/resolve.rs b/src/librustc/infer/resolve.rs index f6131c01b372f..4a8f0c34ead11 100644 --- a/src/librustc/infer/resolve.rs +++ b/src/librustc/infer/resolve.rs @@ -1,6 +1,6 @@ use super::{InferCtxt, FixupError, FixupResult}; -use ty::{self, Ty, TyCtxt, TypeFoldable}; -use ty::fold::{TypeFolder, TypeVisitor}; +use crate::ty::{self, Ty, TyCtxt, TypeFoldable}; +use crate::ty::fold::{TypeFolder, TypeVisitor}; /////////////////////////////////////////////////////////////////////////// // OPPORTUNISTIC TYPE RESOLVER diff --git a/src/librustc/infer/sub.rs b/src/librustc/infer/sub.rs index df76d1d3afb34..0cff42742c30a 100644 --- a/src/librustc/infer/sub.rs +++ b/src/librustc/infer/sub.rs @@ -1,11 +1,11 @@ use super::SubregionOrigin; use super::combine::{CombineFields, RelationDir}; -use traits::Obligation; -use ty::{self, Ty, TyCtxt}; -use ty::TyVar; -use ty::fold::TypeFoldable; -use ty::relate::{Cause, Relate, RelateResult, TypeRelation}; +use crate::traits::Obligation; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::TyVar; +use crate::ty::fold::TypeFoldable; +use crate::ty::relate::{Cause, Relate, RelateResult, TypeRelation}; use std::mem; /// Ensures `a` is made a subtype of `b`. Returns `a` on success. diff --git a/src/librustc/infer/type_variable.rs b/src/librustc/infer/type_variable.rs index 3ec27bdcf1bcd..14f3261bfc203 100644 --- a/src/librustc/infer/type_variable.rs +++ b/src/librustc/infer/type_variable.rs @@ -1,6 +1,6 @@ use syntax::symbol::InternedString; use syntax_pos::Span; -use ty::{self, Ty}; +use crate::ty::{self, Ty}; use std::cmp; use std::marker::PhantomData; diff --git a/src/librustc/infer/unify_key.rs b/src/librustc/infer/unify_key.rs index 068ff0c90e7fc..09f800d9f9bfc 100644 --- a/src/librustc/infer/unify_key.rs +++ b/src/librustc/infer/unify_key.rs @@ -1,4 +1,4 @@ -use ty::{self, FloatVarValue, IntVarValue, Ty, TyCtxt}; +use crate::ty::{self, FloatVarValue, IntVarValue, Ty, TyCtxt}; use rustc_data_structures::unify::{NoError, EqUnifyValue, UnifyKey, UnifyValue}; pub trait ToType { diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index f886e50246ac0..d19513515201e 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -30,6 +30,9 @@ html_favicon_url = "https://doc.rust-lang.org/favicon.ico", html_root_url = "https://doc.rust-lang.org/nightly/")] +#![deny(rust_2018_idioms)] +#![allow(explicit_outlives_requirements)] + #![feature(box_patterns)] #![feature(box_syntax)] #![feature(core_intrinsics)] @@ -64,41 +67,24 @@ #![warn(elided_lifetimes_in_paths)] -extern crate arena; #[macro_use] extern crate bitflags; -extern crate core; -extern crate fmt_macros; extern crate getopts; -extern crate graphviz; -extern crate num_cpus; #[macro_use] extern crate lazy_static; #[macro_use] extern crate scoped_tls; #[cfg(windows)] extern crate libc; -extern crate polonius_engine; -extern crate rustc_target; #[macro_use] extern crate rustc_data_structures; -extern crate serialize; -extern crate parking_lot; -extern crate rustc_errors as errors; -extern crate rustc_rayon as rayon; -extern crate rustc_rayon_core as rayon_core; + #[macro_use] extern crate log; #[macro_use] extern crate syntax; -extern crate syntax_pos; -extern crate jobserver; -extern crate proc_macro; -extern crate chalk_engine; -extern crate rustc_fs_util; -extern crate serialize as rustc_serialize; // used by deriving +// FIXME: This import is used by deriving `RustcDecodable` and `RustcEncodable`. Removing this +// results in a bunch of "failed to resolve" errors. Hopefully, the compiler moves to serde or +// something, and we can get rid of this. +#[allow(rust_2018_idioms)] +extern crate serialize as rustc_serialize; -extern crate rustc_apfloat; -extern crate byteorder; -extern crate backtrace; - -#[macro_use] -extern crate smallvec; +#[macro_use] extern crate smallvec; // Note that librustc doesn't actually depend on these crates, see the note in // `Cargo.toml` for this crate about why these are here. @@ -166,9 +152,11 @@ pub mod util { // `libstd` uses the same trick. #[doc(hidden)] mod rustc { - pub use lint; + pub use crate::lint; } +use rustc_errors as errors; + // FIXME(#27438): right now the unit tests of librustc don't refer to any actual // functions generated in librustc_data_structures (all // references are through generic functions), but statics are diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 3fe544d690640..6ae7448645a20 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -4,9 +4,9 @@ //! compiler code, rather than using their own custom pass. Those //! lints are all available in `rustc_lint::builtin`. -use errors::{Applicability, DiagnosticBuilder}; -use lint::{LintPass, LateLintPass, LintArray}; -use session::Session; +use crate::errors::{Applicability, DiagnosticBuilder}; +use crate::lint::{LintPass, LateLintPass, LintArray}; +use crate::session::Session; use syntax::ast; use syntax::source_map::Span; diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 394e404fb881f..27ead805d5dbd 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -18,26 +18,26 @@ use self::TargetLint::*; use std::slice; use rustc_data_structures::sync::ReadGuard; -use lint::{EarlyLintPass, EarlyLintPassObject, LateLintPassObject}; -use lint::{LintArray, Level, Lint, LintId, LintPass, LintBuffer}; -use lint::builtin::BuiltinLintDiagnostics; -use lint::levels::{LintLevelSets, LintLevelsBuilder}; -use middle::privacy::AccessLevels; -use rustc_serialize::{Decoder, Decodable, Encoder, Encodable}; -use session::{config, early_error, Session}; -use ty::{self, TyCtxt, Ty}; -use ty::layout::{LayoutError, LayoutOf, TyLayout}; -use util::nodemap::FxHashMap; -use util::common::time; +use crate::lint::{EarlyLintPass, EarlyLintPassObject, LateLintPassObject}; +use crate::lint::{LintArray, Level, Lint, LintId, LintPass, LintBuffer}; +use crate::lint::builtin::BuiltinLintDiagnostics; +use crate::lint::levels::{LintLevelSets, LintLevelsBuilder}; +use crate::middle::privacy::AccessLevels; +use crate::rustc_serialize::{Decoder, Decodable, Encoder, Encodable}; +use crate::session::{config, early_error, Session}; +use crate::ty::{self, TyCtxt, Ty}; +use crate::ty::layout::{LayoutError, LayoutOf, TyLayout}; +use crate::util::nodemap::FxHashMap; +use crate::util::common::time; use std::default::Default as StdDefault; use syntax::ast; use syntax::edition; use syntax_pos::{MultiSpan, Span, symbol::{LocalInternedString, Symbol}}; -use errors::DiagnosticBuilder; -use hir; -use hir::def_id::LOCAL_CRATE; -use hir::intravisit as hir_visit; +use crate::errors::DiagnosticBuilder; +use crate::hir; +use crate::hir::def_id::LOCAL_CRATE; +use crate::hir::intravisit as hir_visit; use syntax::util::lev_distance::find_best_match_for_name; use syntax::visit as ast_visit; diff --git a/src/librustc/lint/levels.rs b/src/librustc/lint/levels.rs index 616915769435d..62bd54de7c929 100644 --- a/src/librustc/lint/levels.rs +++ b/src/librustc/lint/levels.rs @@ -1,20 +1,20 @@ use std::cmp; -use errors::{Applicability, DiagnosticBuilder}; -use hir::HirId; -use ich::StableHashingContext; -use lint::builtin; -use lint::context::CheckLintNameResult; -use lint::{self, Lint, LintId, Level, LintSource}; +use crate::errors::{Applicability, DiagnosticBuilder}; +use crate::hir::HirId; +use crate::ich::StableHashingContext; +use crate::lint::builtin; +use crate::lint::context::CheckLintNameResult; +use crate::lint::{self, Lint, LintId, Level, LintSource}; use rustc_data_structures::stable_hasher::{HashStable, ToStableHashKey, StableHasher, StableHasherResult}; -use session::Session; +use crate::session::Session; use syntax::ast; use syntax::attr; use syntax::feature_gate; use syntax::source_map::MultiSpan; use syntax::symbol::Symbol; -use util::nodemap::FxHashMap; +use crate::util::nodemap::FxHashMap; pub struct LintLevelSets { list: Vec, diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index a95fa350bf1c3..4e6bf753b01aa 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -23,13 +23,13 @@ pub use self::LintSource::*; use rustc_data_structures::sync::{self, Lrc}; -use errors::{DiagnosticBuilder, DiagnosticId}; -use hir::def_id::{CrateNum, LOCAL_CRATE}; -use hir::intravisit; -use hir; -use lint::builtin::BuiltinLintDiagnostics; -use lint::builtin::parser::{QUESTION_MARK_MACRO_SEP, ILL_FORMED_ATTRIBUTE_INPUT}; -use session::{Session, DiagnosticMessageId}; +use crate::errors::{DiagnosticBuilder, DiagnosticId}; +use crate::hir::def_id::{CrateNum, LOCAL_CRATE}; +use crate::hir::intravisit; +use crate::hir; +use crate::lint::builtin::BuiltinLintDiagnostics; +use crate::lint::builtin::parser::{QUESTION_MARK_MACRO_SEP, ILL_FORMED_ATTRIBUTE_INPUT}; +use crate::session::{Session, DiagnosticMessageId}; use std::{hash, ptr}; use syntax::ast; use syntax::source_map::{MultiSpan, ExpnFormat}; @@ -37,11 +37,11 @@ use syntax::early_buffered_lints::BufferedEarlyLintId; use syntax::edition::Edition; use syntax::symbol::Symbol; use syntax_pos::Span; -use ty::TyCtxt; -use ty::query::Providers; -use util::nodemap::NodeMap; +use crate::ty::TyCtxt; +use crate::ty::query::Providers; +use crate::util::nodemap::NodeMap; -pub use lint::context::{LateContext, EarlyContext, LintContext, LintStore, +pub use crate::lint::context::{LateContext, EarlyContext, LintContext, LintStore, check_crate, check_ast_crate, CheckLintNameResult, FutureIncompatibleInfo, BufferedEarlyLint}; @@ -678,7 +678,7 @@ pub fn struct_lint_level<'a>(sess: &'a Session, "this was previously accepted by the compiler but is being phased out; \ it will become a hard error"; - let explanation = if lint_id == LintId::of(::lint::builtin::UNSTABLE_NAME_COLLISIONS) { + let explanation = if lint_id == LintId::of(crate::lint::builtin::UNSTABLE_NAME_COLLISIONS) { "once this method is added to the standard library, \ the ambiguity may cause an error or change in behavior!" .to_owned() diff --git a/src/librustc/middle/borrowck.rs b/src/librustc/middle/borrowck.rs index 120ba6b1d4e9f..2799f9424d919 100644 --- a/src/librustc/middle/borrowck.rs +++ b/src/librustc/middle/borrowck.rs @@ -1,6 +1,6 @@ -use ich::StableHashingContext; -use hir::HirId; -use util::nodemap::FxHashSet; +use crate::ich::StableHashingContext; +use crate::hir::HirId; +use crate::util::nodemap::FxHashSet; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs index 9168bbf907f1e..6e9552a1e9209 100644 --- a/src/librustc/middle/cstore.rs +++ b/src/librustc/middle/cstore.rs @@ -2,13 +2,13 @@ //! are *mostly* used as a part of that interface, but these should //! probably get a better home if someone can find one. -use hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; -use hir::map as hir_map; -use hir::map::definitions::{DefKey, DefPathTable}; +use crate::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; +use crate::hir::map as hir_map; +use crate::hir::map::definitions::{DefKey, DefPathTable}; use rustc_data_structures::svh::Svh; -use ty::{self, TyCtxt}; -use session::{Session, CrateDisambiguator}; -use session::search_paths::PathKind; +use crate::ty::{self, TyCtxt}; +use crate::session::{Session, CrateDisambiguator}; +use crate::session::search_paths::PathKind; use std::any::Any; use std::path::{Path, PathBuf}; diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index abbf0ae210c25..6dffe8efba612 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -2,18 +2,18 @@ // closely. The idea is that all reachable symbols are live, codes called // from live codes are live, and everything else is dead. -use hir::Node; -use hir::{self, PatKind}; -use hir::intravisit::{self, Visitor, NestedVisitorMap}; -use hir::itemlikevisit::ItemLikeVisitor; - -use hir::def::Def; -use hir::CodegenFnAttrFlags; -use hir::def_id::{DefId, LOCAL_CRATE}; -use lint; -use middle::privacy; -use ty::{self, TyCtxt}; -use util::nodemap::FxHashSet; +use crate::hir::Node; +use crate::hir::{self, PatKind}; +use crate::hir::intravisit::{self, Visitor, NestedVisitorMap}; +use crate::hir::itemlikevisit::ItemLikeVisitor; + +use crate::hir::def::Def; +use crate::hir::CodegenFnAttrFlags; +use crate::hir::def_id::{DefId, LOCAL_CRATE}; +use crate::lint; +use crate::middle::privacy; +use crate::ty::{self, TyCtxt}; +use crate::util::nodemap::FxHashSet; use rustc_data_structures::fx::FxHashMap; diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 16c9344a03722..a24d25cba1184 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -51,13 +51,13 @@ //! Additionally, the algorithm is geared towards finding *any* solution rather //! than finding a number of solutions (there are normally quite a few). -use hir::def_id::CrateNum; +use crate::hir::def_id::CrateNum; -use session::config; -use ty::TyCtxt; -use middle::cstore::{self, DepKind}; -use middle::cstore::LinkagePreference::{self, RequireStatic, RequireDynamic}; -use util::nodemap::FxHashMap; +use crate::session::config; +use crate::ty::TyCtxt; +use crate::middle::cstore::{self, DepKind}; +use crate::middle::cstore::LinkagePreference::{self, RequireStatic, RequireDynamic}; +use crate::util::nodemap::FxHashMap; use rustc_target::spec::PanicStrategy; /// A list of dependencies for a certain crate type. diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index 218ca3b7553c0..2d0e6c3917bb8 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -1,15 +1,15 @@ -use hir::map as hir_map; -use hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId, LOCAL_CRATE}; -use session::{config, Session}; -use session::config::EntryFnType; +use crate::hir::map as hir_map; +use crate::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId, LOCAL_CRATE}; +use crate::session::{config, Session}; +use crate::session::config::EntryFnType; use syntax::ast::NodeId; use syntax::attr; use syntax::entry::EntryPointType; use syntax_pos::Span; -use hir::{Item, ItemKind, ImplItem, TraitItem}; -use hir::itemlikevisit::ItemLikeVisitor; -use ty::TyCtxt; -use ty::query::Providers; +use crate::hir::{Item, ItemKind, ImplItem, TraitItem}; +use crate::hir::itemlikevisit::ItemLikeVisitor; +use crate::ty::TyCtxt; +use crate::ty::query::Providers; struct EntryContext<'a, 'tcx: 'a> { session: &'a Session, diff --git a/src/librustc/middle/exported_symbols.rs b/src/librustc/middle/exported_symbols.rs index a0a73ea0b81fb..6c43068a22772 100644 --- a/src/librustc/middle/exported_symbols.rs +++ b/src/librustc/middle/exported_symbols.rs @@ -1,11 +1,11 @@ -use hir::def_id::{DefId, LOCAL_CRATE}; -use ich::StableHashingContext; +use crate::hir::def_id::{DefId, LOCAL_CRATE}; +use crate::ich::StableHashingContext; use rustc_data_structures::stable_hasher::{StableHasher, HashStable, StableHasherResult}; use std::cmp; use std::mem; -use ty; -use ty::subst::Substs; +use crate::ty; +use crate::ty::subst::Substs; /// The SymbolExportLevel of a symbols specifies from which kinds of crates /// the symbol will be exported. `C` symbols will be exported from any diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 08210c3f075ce..0939f07f43bb3 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -9,20 +9,20 @@ pub use self::MatchMode::*; use self::TrackMatchMode::*; use self::OverloadedCallType::*; -use hir::def::Def; -use hir::def_id::DefId; -use infer::InferCtxt; -use middle::mem_categorization as mc; -use middle::region; -use ty::{self, TyCtxt, adjustment}; - -use hir::{self, PatKind}; +use crate::hir::def::Def; +use crate::hir::def_id::DefId; +use crate::infer::InferCtxt; +use crate::middle::mem_categorization as mc; +use crate::middle::region; +use crate::ty::{self, TyCtxt, adjustment}; + +use crate::hir::{self, PatKind}; use rustc_data_structures::sync::Lrc; use std::rc::Rc; use syntax::ast; use syntax::ptr::P; use syntax_pos::Span; -use util::nodemap::ItemLocalSet; +use crate::util::nodemap::ItemLocalSet; /////////////////////////////////////////////////////////////////////////// // The Delegate trait diff --git a/src/librustc/middle/free_region.rs b/src/librustc/middle/free_region.rs index 6e9eadca6a521..e752643e842aa 100644 --- a/src/librustc/middle/free_region.rs +++ b/src/librustc/middle/free_region.rs @@ -5,10 +5,10 @@ //! `TransitiveRelation` type and use that to decide when one free //! region outlives another and so forth. -use infer::outlives::free_region_map::{FreeRegionMap, FreeRegionRelations}; -use hir::def_id::DefId; -use middle::region; -use ty::{self, TyCtxt, Region}; +use crate::infer::outlives::free_region_map::{FreeRegionMap, FreeRegionRelations}; +use crate::hir::def_id::DefId; +use crate::middle::region; +use crate::ty::{self, TyCtxt, Region}; /// Combines a `region::ScopeTree` (which governs relationships between /// scopes) and a `FreeRegionMap` (which governs relationships between diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs index 29d3713900ad9..ee361e9776313 100644 --- a/src/librustc/middle/intrinsicck.rs +++ b/src/librustc/middle/intrinsicck.rs @@ -1,14 +1,14 @@ -use hir::def::Def; -use hir::def_id::DefId; -use ty::{self, Ty, TyCtxt}; -use ty::layout::{LayoutError, Pointer, SizeSkeleton, VariantIdx}; -use ty::query::Providers; +use crate::hir::def::Def; +use crate::hir::def_id::DefId; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::layout::{LayoutError, Pointer, SizeSkeleton, VariantIdx}; +use crate::ty::query::Providers; use rustc_target::spec::abi::Abi::RustIntrinsic; use rustc_data_structures::indexed_vec::Idx; use syntax_pos::Span; -use hir::intravisit::{self, Visitor, NestedVisitorMap}; -use hir; +use crate::hir::intravisit::{self, Visitor, NestedVisitorMap}; +use crate::hir; pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { for &module in tcx.hir().krate().modules.keys() { diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 87107f727a05d..3f9230ab551d5 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -11,17 +11,17 @@ pub use self::LangItem::*; -use hir::def_id::DefId; -use hir::check_attr::Target; -use ty::{self, TyCtxt}; -use middle::weak_lang_items; -use util::nodemap::FxHashMap; +use crate::hir::def_id::DefId; +use crate::hir::check_attr::Target; +use crate::ty::{self, TyCtxt}; +use crate::middle::weak_lang_items; +use crate::util::nodemap::FxHashMap; use syntax::ast; use syntax::symbol::Symbol; use syntax_pos::Span; -use hir::itemlikevisit::ItemLikeVisitor; -use hir; +use crate::hir::itemlikevisit::ItemLikeVisitor; +use crate::hir; // The actual lang items defined come at the end of this file in one handy table. // So you probably just want to nip down to the end. diff --git a/src/librustc/middle/lib_features.rs b/src/librustc/middle/lib_features.rs index 8c23377324f1f..45095d9bc986b 100644 --- a/src/librustc/middle/lib_features.rs +++ b/src/librustc/middle/lib_features.rs @@ -4,13 +4,13 @@ // and `#[unstable (..)]`), but are not declared in one single location // (unlike lang features), which means we need to collect them instead. -use ty::TyCtxt; +use crate::ty::TyCtxt; use syntax::symbol::Symbol; use syntax::ast::{Attribute, MetaItem, MetaItemKind}; use syntax_pos::Span; -use hir::intravisit::{self, NestedVisitorMap, Visitor}; +use crate::hir::intravisit::{self, NestedVisitorMap, Visitor}; use rustc_data_structures::fx::{FxHashSet, FxHashMap}; -use errors::DiagnosticId; +use crate::errors::DiagnosticId; pub struct LibFeatures { // A map from feature to stabilisation version. diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index d47ad009c1db6..ce4a0f69c2864 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -97,13 +97,13 @@ use self::LoopKind::*; use self::LiveNodeKind::*; use self::VarKind::*; -use hir::def::*; -use hir::Node; -use ty::{self, TyCtxt}; -use ty::query::Providers; -use lint; -use errors::Applicability; -use util::nodemap::{NodeMap, HirIdMap, HirIdSet}; +use crate::hir::def::*; +use crate::hir::Node; +use crate::ty::{self, TyCtxt}; +use crate::ty::query::Providers; +use crate::lint; +use crate::errors::Applicability; +use crate::util::nodemap::{NodeMap, HirIdMap, HirIdSet}; use std::collections::{BTreeMap, VecDeque}; use std::{fmt, u32}; @@ -115,10 +115,10 @@ use syntax::ptr::P; use syntax::symbol::keywords; use syntax_pos::Span; -use hir; -use hir::{Expr, HirId}; -use hir::def_id::DefId; -use hir::intravisit::{self, Visitor, FnKind, NestedVisitorMap}; +use crate::hir; +use crate::hir::{Expr, HirId}; +use crate::hir::def_id::DefId; +use crate::hir::intravisit::{self, Visitor, FnKind, NestedVisitorMap}; /// For use with `propagate_through_loop`. enum LoopKind<'a> { @@ -406,7 +406,7 @@ fn add_from_pat<'a, 'tcx>(ir: &mut IrMaps<'a, 'tcx>, pat: &P) { let mut pats = VecDeque::new(); pats.push_back(pat); while let Some(pat) = pats.pop_front() { - use hir::PatKind::*; + use crate::hir::PatKind::*; match pat.node { Binding(_, _, _, _, ref inner_pat) => { pats.extend(inner_pat.iter()); diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 370f0d1a6c6d7..04e4a0b39a2ca 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -58,19 +58,19 @@ pub use self::Note::*; use self::Aliasability::*; -use middle::region; -use hir::def_id::{DefId, LocalDefId}; -use hir::Node; -use infer::InferCtxt; -use hir::def::{Def, CtorKind}; -use ty::adjustment; -use ty::{self, Ty, TyCtxt}; -use ty::fold::TypeFoldable; -use ty::layout::VariantIdx; - -use hir::{MutImmutable, MutMutable, PatKind}; -use hir::pat_util::EnumerateAndAdjustIterator; -use hir; +use crate::middle::region; +use crate::hir::def_id::{DefId, LocalDefId}; +use crate::hir::Node; +use crate::infer::InferCtxt; +use crate::hir::def::{Def, CtorKind}; +use crate::ty::adjustment; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::fold::TypeFoldable; +use crate::ty::layout::VariantIdx; + +use crate::hir::{MutImmutable, MutMutable, PatKind}; +use crate::hir::pat_util::EnumerateAndAdjustIterator; +use crate::hir; use syntax::ast::{self, Name}; use syntax_pos::Span; @@ -80,7 +80,7 @@ use std::hash::{Hash, Hasher}; use rustc_data_structures::sync::Lrc; use rustc_data_structures::indexed_vec::Idx; use std::rc::Rc; -use util::nodemap::ItemLocalSet; +use crate::util::nodemap::ItemLocalSet; #[derive(Clone, Debug, PartialEq)] pub enum Categorization<'tcx> { diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 3baf0f0ea39ff..1655d8356a5a7 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -2,7 +2,7 @@ //! outside their scopes. This pass will also generate a set of exported items //! which are available for use externally when compiled as a library. -use util::nodemap::{DefIdSet, FxHashMap}; +use crate::util::nodemap::{DefIdSet, FxHashMap}; use std::hash::Hash; use std::fmt; diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index 10deca836fff3..73ba47d411915 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -5,24 +5,24 @@ // makes all other generics or inline functions that it references // reachable as well. -use hir::{CodegenFnAttrs, CodegenFnAttrFlags}; -use hir::Node; -use hir::def::Def; -use hir::def_id::{DefId, CrateNum}; +use crate::hir::{CodegenFnAttrs, CodegenFnAttrFlags}; +use crate::hir::Node; +use crate::hir::def::Def; +use crate::hir::def_id::{DefId, CrateNum}; use rustc_data_structures::sync::Lrc; -use ty::{self, TyCtxt}; -use ty::query::Providers; -use middle::privacy; -use session::config; -use util::nodemap::{NodeSet, FxHashSet}; +use crate::ty::{self, TyCtxt}; +use crate::ty::query::Providers; +use crate::middle::privacy; +use crate::session::config; +use crate::util::nodemap::{NodeSet, FxHashSet}; use rustc_target::spec::abi::Abi; use syntax::ast; -use hir; -use hir::def_id::LOCAL_CRATE; -use hir::intravisit::{Visitor, NestedVisitorMap}; -use hir::itemlikevisit::ItemLikeVisitor; -use hir::intravisit; +use crate::hir; +use crate::hir::def_id::LOCAL_CRATE; +use crate::hir::intravisit::{Visitor, NestedVisitorMap}; +use crate::hir::itemlikevisit::ItemLikeVisitor; +use crate::hir::intravisit; // Returns true if the given item must be inlined because it may be // monomorphized or it was marked with `#[inline]`. This will only return diff --git a/src/librustc/middle/recursion_limit.rs b/src/librustc/middle/recursion_limit.rs index 1eabd7f59e689..ea077220e0be3 100644 --- a/src/librustc/middle/recursion_limit.rs +++ b/src/librustc/middle/recursion_limit.rs @@ -5,7 +5,7 @@ // this via an attribute on the crate like `#![recursion_limit="22"]`. This pass // just peeks and looks for that attribute. -use session::Session; +use crate::session::Session; use syntax::ast; use rustc_data_structures::sync::Once; diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index db52cc3074b9a..788d2185d6da2 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -6,9 +6,9 @@ //! //! [rustc guide]: https://rust-lang.github.io/rustc-guide/mir/borrowck.html -use ich::{StableHashingContext, NodeIdHashingMode}; -use util::nodemap::{FxHashMap, FxHashSet}; -use ty; +use crate::ich::{StableHashingContext, NodeIdHashingMode}; +use crate::util::nodemap::{FxHashMap, FxHashSet}; +use crate::ty; use std::mem; use std::fmt; @@ -16,14 +16,14 @@ use rustc_data_structures::sync::Lrc; use syntax::source_map; use syntax::ast; use syntax_pos::{Span, DUMMY_SP}; -use ty::TyCtxt; -use ty::query::Providers; - -use hir; -use hir::Node; -use hir::def_id::DefId; -use hir::intravisit::{self, Visitor, NestedVisitorMap}; -use hir::{Block, Arm, Pat, PatKind, Stmt, Expr, Local}; +use crate::ty::TyCtxt; +use crate::ty::query::Providers; + +use crate::hir; +use crate::hir::Node; +use crate::hir::def_id::DefId; +use crate::hir::intravisit::{self, Visitor, NestedVisitorMap}; +use crate::hir::{Block, Arm, Pat, PatKind, Stmt, Expr, Local}; use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; @@ -154,7 +154,7 @@ newtype_index! { pub struct FirstStatementIndex { .. } } -impl_stable_hash_for!(struct ::middle::region::FirstStatementIndex { private }); +impl_stable_hash_for!(struct crate::middle::region::FirstStatementIndex { private }); // compilation error if size of `ScopeData` is not the same as a `u32` static_assert!(ASSERT_SCOPE_DATA: mem::size_of::() == 4); diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 34db30a1706b9..f7cd241236498 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -5,16 +5,16 @@ //! used between functions, and they operate in a purely top-down //! way. Therefore we break lifetime name resolution into a separate pass. -use hir::def::Def; -use hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE}; -use hir::map::Map; -use hir::{GenericArg, GenericParam, ItemLocalId, LifetimeName, Node, ParamName}; -use ty::{self, DefIdTree, GenericParamDefKind, TyCtxt}; - -use errors::{Applicability, DiagnosticBuilder}; -use rustc::lint; +use crate::hir::def::Def; +use crate::hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE}; +use crate::hir::map::Map; +use crate::hir::{GenericArg, GenericParam, ItemLocalId, LifetimeName, Node, ParamName}; +use crate::ty::{self, DefIdTree, GenericParamDefKind, TyCtxt}; + +use crate::errors::{Applicability, DiagnosticBuilder}; +use crate::rustc::lint; use rustc_data_structures::sync::Lrc; -use session::Session; +use crate::session::Session; use std::borrow::Cow; use std::cell::Cell; use std::mem::replace; @@ -23,10 +23,10 @@ use syntax::attr; use syntax::ptr::P; use syntax::symbol::keywords; use syntax_pos::Span; -use util::nodemap::{DefIdMap, FxHashMap, FxHashSet, NodeMap, NodeSet}; +use crate::util::nodemap::{DefIdMap, FxHashMap, FxHashSet, NodeMap, NodeSet}; -use hir::intravisit::{self, NestedVisitorMap, Visitor}; -use hir::{self, GenericParamKind, LifetimeParamKind}; +use crate::hir::intravisit::{self, NestedVisitorMap, Visitor}; +use crate::hir::{self, GenericParamKind, LifetimeParamKind}; /// The origin of a named lifetime definition. /// @@ -216,7 +216,7 @@ pub struct ResolveLifetimes { FxHashMap>>>>, } -impl_stable_hash_for!(struct ::middle::resolve_lifetime::ResolveLifetimes { +impl_stable_hash_for!(struct crate::middle::resolve_lifetime::ResolveLifetimes { defs, late_bound, object_lifetime_defaults diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index 3717ee7143c55..85b5409465a8d 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -3,14 +3,14 @@ pub use self::StabilityLevel::*; -use lint::{self, Lint}; -use hir::{self, Item, Generics, StructField, Variant, HirId}; -use hir::def::Def; -use hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId, LOCAL_CRATE}; -use hir::intravisit::{self, Visitor, NestedVisitorMap}; -use ty::query::Providers; -use middle::privacy::AccessLevels; -use session::{DiagnosticMessageId, Session}; +use crate::lint::{self, Lint}; +use crate::hir::{self, Item, Generics, StructField, Variant, HirId}; +use crate::hir::def::Def; +use crate::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId, LOCAL_CRATE}; +use crate::hir::intravisit::{self, Visitor, NestedVisitorMap}; +use crate::ty::query::Providers; +use crate::middle::privacy::AccessLevels; +use crate::session::{DiagnosticMessageId, Session}; use syntax::symbol::Symbol; use syntax_pos::{Span, MultiSpan}; use syntax::ast; @@ -18,8 +18,8 @@ use syntax::ast::{NodeId, Attribute}; use syntax::errors::Applicability; use syntax::feature_gate::{GateIssue, emit_feature_err}; use syntax::attr::{self, Stability, Deprecation}; -use ty::{self, TyCtxt}; -use util::nodemap::{FxHashSet, FxHashMap}; +use crate::ty::{self, TyCtxt}; +use crate::util::nodemap::{FxHashSet, FxHashMap}; use std::mem::replace; use std::cmp::Ordering; diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs index 82f19cbb82a19..119e855c58551 100644 --- a/src/librustc/middle/weak_lang_items.rs +++ b/src/librustc/middle/weak_lang_items.rs @@ -1,18 +1,18 @@ //! Validity checking for weak lang items -use session::config; -use middle::lang_items; +use crate::session::config; +use crate::middle::lang_items; use rustc_data_structures::fx::FxHashSet; use rustc_target::spec::PanicStrategy; use syntax::ast; use syntax::symbol::Symbol; use syntax_pos::Span; -use hir::def_id::DefId; -use hir::intravisit::{Visitor, NestedVisitorMap}; -use hir::intravisit; -use hir; -use ty::TyCtxt; +use crate::hir::def_id::DefId; +use crate::hir::intravisit::{Visitor, NestedVisitorMap}; +use crate::hir::intravisit; +use crate::hir; +use crate::ty::TyCtxt; macro_rules! weak_lang_items { ($($name:ident, $item:ident, $sym:ident;)*) => ( diff --git a/src/librustc/mir/cache.rs b/src/librustc/mir/cache.rs index 56ab263c47740..1cc927b1f720f 100644 --- a/src/librustc/mir/cache.rs +++ b/src/librustc/mir/cache.rs @@ -2,10 +2,10 @@ use rustc_data_structures::indexed_vec::IndexVec; use rustc_data_structures::sync::{RwLock, MappedReadGuard, ReadGuard}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; -use ich::StableHashingContext; -use mir::{Mir, BasicBlock}; +use crate::ich::StableHashingContext; +use crate::mir::{Mir, BasicBlock}; -use rustc_serialize as serialize; +use crate::rustc_serialize as serialize; #[derive(Clone, Debug)] pub struct Cache { diff --git a/src/librustc/mir/interpret/allocation.rs b/src/librustc/mir/interpret/allocation.rs index 7ed29c5afd03f..7761e1fdafac5 100644 --- a/src/librustc/mir/interpret/allocation.rs +++ b/src/librustc/mir/interpret/allocation.rs @@ -5,10 +5,10 @@ use super::{ truncate, }; -use ty::layout::{Size, Align}; +use crate::ty::layout::{Size, Align}; use syntax::ast::Mutability; use std::iter; -use mir; +use crate::mir; use std::ops::{Deref, DerefMut}; use rustc_data_structures::sorted_map::SortedMap; use rustc_target::abi::HasDataLayout; diff --git a/src/librustc/mir/interpret/error.rs b/src/librustc/mir/interpret/error.rs index c3fe5d773ab16..870a51f95df1c 100644 --- a/src/librustc/mir/interpret/error.rs +++ b/src/librustc/mir/interpret/error.rs @@ -1,17 +1,17 @@ use std::{fmt, env}; -use hir::map::definitions::DefPathData; -use mir; -use ty::{self, Ty, layout}; -use ty::layout::{Size, Align, LayoutError}; +use crate::hir::map::definitions::DefPathData; +use crate::mir; +use crate::ty::{self, Ty, layout}; +use crate::ty::layout::{Size, Align, LayoutError}; use rustc_target::spec::abi::Abi; use super::{RawConst, Pointer, InboundsCheck, ScalarMaybeUndef}; use backtrace::Backtrace; -use ty::query::TyCtxtAt; -use errors::DiagnosticBuilder; +use crate::ty::query::TyCtxtAt; +use crate::errors::DiagnosticBuilder; use syntax_pos::{Pos, Span}; use syntax::ast; @@ -42,7 +42,7 @@ pub type ConstEvalResult<'tcx> = Result, ErrorHandled>; #[derive(Clone, Debug, RustcEncodable, RustcDecodable)] pub struct ConstEvalErr<'tcx> { pub span: Span, - pub error: ::mir::interpret::EvalErrorKind<'tcx, u64>, + pub error: crate::mir::interpret::EvalErrorKind<'tcx, u64>, pub stacktrace: Vec>, } @@ -136,7 +136,7 @@ impl<'a, 'gcx, 'tcx> ConstEvalErr<'tcx> { .next() .unwrap_or(lint_root); tcx.struct_span_lint_node( - ::rustc::lint::builtin::CONST_ERR, + crate::rustc::lint::builtin::CONST_ERR, node_id, tcx.span, message, diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs index e6a560b2ad7b6..efd233f1f3854 100644 --- a/src/librustc/mir/interpret/mod.rs +++ b/src/librustc/mir/interpret/mod.rs @@ -25,17 +25,17 @@ pub use self::allocation::{ pub use self::pointer::{Pointer, PointerArithmetic}; use std::fmt; -use mir; -use hir::def_id::DefId; -use ty::{self, TyCtxt, Instance}; -use ty::layout::{self, Size}; +use crate::mir; +use crate::hir::def_id::DefId; +use crate::ty::{self, TyCtxt, Instance}; +use crate::ty::layout::{self, Size}; use std::io; -use rustc_serialize::{Encoder, Decodable, Encodable}; +use crate::rustc_serialize::{Encoder, Decodable, Encodable}; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::sync::{Lock as Mutex, HashMapExt}; use rustc_data_structures::tiny_list::TinyList; use byteorder::{WriteBytesExt, ReadBytesExt, LittleEndian, BigEndian}; -use ty::codec::TyDecoder; +use crate::ty::codec::TyDecoder; use std::sync::atomic::{AtomicU32, Ordering}; use std::num::NonZeroU32; @@ -53,8 +53,8 @@ pub struct GlobalId<'tcx> { #[derive(Copy, Clone, Eq, Hash, Ord, PartialEq, PartialOrd, Debug)] pub struct AllocId(pub u64); -impl ::rustc_serialize::UseSpecializedEncodable for AllocId {} -impl ::rustc_serialize::UseSpecializedDecodable for AllocId {} +impl crate::rustc_serialize::UseSpecializedEncodable for AllocId {} +impl crate::rustc_serialize::UseSpecializedDecodable for AllocId {} #[derive(RustcDecodable, RustcEncodable)] enum AllocDiscriminant { diff --git a/src/librustc/mir/interpret/pointer.rs b/src/librustc/mir/interpret/pointer.rs index 498c0b5b917e9..551e7b2fd41ec 100644 --- a/src/librustc/mir/interpret/pointer.rs +++ b/src/librustc/mir/interpret/pointer.rs @@ -1,5 +1,5 @@ -use mir; -use ty::layout::{self, HasDataLayout, Size}; +use crate::mir; +use crate::ty::layout::{self, HasDataLayout, Size}; use super::{ AllocId, EvalResult, InboundsCheck, diff --git a/src/librustc/mir/interpret/value.rs b/src/librustc/mir/interpret/value.rs index 1328a1aeeab96..73917342814de 100644 --- a/src/librustc/mir/interpret/value.rs +++ b/src/librustc/mir/interpret/value.rs @@ -515,7 +515,7 @@ impl<'tcx, Tag> ScalarMaybeUndef { } } -impl_stable_hash_for!(enum ::mir::interpret::ScalarMaybeUndef { +impl_stable_hash_for!(enum crate::mir::interpret::ScalarMaybeUndef { Scalar(v), Undef }); diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs index 82083b4f69964..009997bfcf2c4 100644 --- a/src/librustc/mir/mod.rs +++ b/src/librustc/mir/mod.rs @@ -2,11 +2,11 @@ //! //! [rustc guide]: https://rust-lang.github.io/rustc-guide/mir/index.html -use hir::def::CtorKind; -use hir::def_id::DefId; -use hir::{self, HirId, InlineAsm}; -use mir::interpret::{ConstValue, EvalErrorKind, Scalar}; -use mir::visit::MirVisitable; +use crate::hir::def::CtorKind; +use crate::hir::def_id::DefId; +use crate::hir::{self, HirId, InlineAsm}; +use crate::mir::interpret::{ConstValue, EvalErrorKind, Scalar}; +use crate::mir::visit::MirVisitable; use rustc_apfloat::ieee::{Double, Single}; use rustc_apfloat::Float; use rustc_data_structures::fx::FxHashSet; @@ -15,7 +15,7 @@ use rustc_data_structures::graph::{self, GraphPredecessors, GraphSuccessors}; use rustc_data_structures::indexed_vec::{Idx, IndexVec}; use rustc_data_structures::sync::Lrc; use rustc_data_structures::sync::MappedReadGuard; -use rustc_serialize::{self as serialize}; +use crate::rustc_serialize::{self as serialize}; use smallvec::SmallVec; use std::borrow::Cow; use std::fmt::{self, Debug, Formatter, Write}; @@ -26,16 +26,16 @@ use std::{iter, mem, option, u32}; use syntax::ast::{self, Name}; use syntax::symbol::InternedString; use syntax_pos::{Span, DUMMY_SP}; -use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; -use ty::subst::{Subst, Substs}; -use ty::layout::VariantIdx; -use ty::{ +use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; +use crate::ty::subst::{Subst, Substs}; +use crate::ty::layout::VariantIdx; +use crate::ty::{ self, AdtDef, CanonicalUserTypeAnnotations, ClosureSubsts, GeneratorSubsts, Region, Ty, TyCtxt, UserTypeAnnotationIndex, }; -use util::ppaux; +use crate::util::ppaux; -pub use mir::interpret::AssertMessage; +pub use crate::mir::interpret::AssertMessage; mod cache; pub mod interpret; @@ -676,7 +676,7 @@ impl_stable_hash_for!(enum self::MirPhase { }); mod binding_form_impl { - use ich::StableHashingContext; + use crate::ich::StableHashingContext; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; impl<'a, 'tcx> HashStable> for super::BindingForm<'tcx> { @@ -2625,7 +2625,7 @@ CloneTypeFoldableAndLiftImpls! { ProjectionKind<'tcx>, } impl<'tcx> TypeFoldable<'tcx> for UserTypeProjection<'tcx> { fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { - use mir::ProjectionElem::*; + use crate::mir::ProjectionElem::*; let base = self.base.fold_with(folder); let projs: Vec<_> = self.projs @@ -2671,7 +2671,7 @@ pub fn fmt_lazy_const_val(f: &mut impl Write, const_val: &ty::LazyConst<'_>) -> /// Write a `ConstValue` in a way closer to the original source code than the `Debug` output. pub fn fmt_const_val(f: &mut impl Write, const_val: ty::Const<'_>) -> fmt::Result { - use ty::TyKind::*; + use crate::ty::TyKind::*; let value = const_val.val; let ty = const_val.ty; // print some primitives @@ -3116,7 +3116,7 @@ EnumTypeFoldableImpl! { impl<'tcx> TypeFoldable<'tcx> for Terminator<'tcx> { fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { - use mir::TerminatorKind::*; + use crate::mir::TerminatorKind::*; let kind = match self.kind { Goto { target } => Goto { target }, @@ -3229,7 +3229,7 @@ impl<'tcx> TypeFoldable<'tcx> for Terminator<'tcx> { } fn super_visit_with>(&self, visitor: &mut V) -> bool { - use mir::TerminatorKind::*; + use crate::mir::TerminatorKind::*; match self.kind { SwitchInt { @@ -3301,7 +3301,7 @@ impl<'tcx> TypeFoldable<'tcx> for Place<'tcx> { impl<'tcx> TypeFoldable<'tcx> for Rvalue<'tcx> { fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { - use mir::Rvalue::*; + use crate::mir::Rvalue::*; match *self { Use(ref op) => Use(op.fold_with(folder)), Repeat(ref op, len) => Repeat(op.fold_with(folder), len), @@ -3343,7 +3343,7 @@ impl<'tcx> TypeFoldable<'tcx> for Rvalue<'tcx> { } fn super_visit_with>(&self, visitor: &mut V) -> bool { - use mir::Rvalue::*; + use crate::mir::Rvalue::*; match *self { Use(ref op) => op.visit_with(visitor), Repeat(ref op, _) => op.visit_with(visitor), @@ -3395,7 +3395,7 @@ where T: TypeFoldable<'tcx>, { fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { - use mir::ProjectionElem::*; + use crate::mir::ProjectionElem::*; let base = self.base.fold_with(folder); let elem = match self.elem { @@ -3409,7 +3409,7 @@ where } fn super_visit_with>(&self, visitor: &mut Vs) -> bool { - use mir::ProjectionElem::*; + use crate::mir::ProjectionElem::*; self.base.visit_with(visitor) || match self.elem { Field(_, ref ty) => ty.visit_with(visitor), diff --git a/src/librustc/mir/mono.rs b/src/librustc/mir/mono.rs index 55f5c36cde66d..affa9f9fdd4d7 100644 --- a/src/librustc/mir/mono.rs +++ b/src/librustc/mir/mono.rs @@ -1,12 +1,12 @@ -use hir::def_id::{DefId, CrateNum, LOCAL_CRATE}; +use crate::hir::def_id::{DefId, CrateNum, LOCAL_CRATE}; use syntax::ast::NodeId; use syntax::symbol::{Symbol, InternedString}; -use ty::{Instance, TyCtxt}; -use util::nodemap::FxHashMap; +use crate::ty::{Instance, TyCtxt}; +use crate::util::nodemap::FxHashMap; use rustc_data_structures::base_n; use rustc_data_structures::stable_hasher::{HashStable, StableHasherResult, StableHasher}; -use ich::{Fingerprint, StableHashingContext, NodeIdHashingMode}; +use crate::ich::{Fingerprint, StableHashingContext, NodeIdHashingMode}; use std::fmt; use std::hash::Hash; diff --git a/src/librustc/mir/tcx.rs b/src/librustc/mir/tcx.rs index 649370059f0ea..ac3a97898b405 100644 --- a/src/librustc/mir/tcx.rs +++ b/src/librustc/mir/tcx.rs @@ -3,12 +3,12 @@ * building is complete. */ -use mir::*; -use ty::subst::{Subst, Substs}; -use ty::{self, AdtDef, Ty, TyCtxt}; -use ty::layout::VariantIdx; -use hir; -use ty::util::IntTypeExt; +use crate::mir::*; +use crate::ty::subst::{Subst, Substs}; +use crate::ty::{self, AdtDef, Ty, TyCtxt}; +use crate::ty::layout::VariantIdx; +use crate::hir; +use crate::ty::util::IntTypeExt; #[derive(Copy, Clone, Debug)] pub enum PlaceTy<'tcx> { diff --git a/src/librustc/mir/visit.rs b/src/librustc/mir/visit.rs index 598303f29328f..0180256661630 100644 --- a/src/librustc/mir/visit.rs +++ b/src/librustc/mir/visit.rs @@ -1,7 +1,7 @@ -use hir::def_id::DefId; -use ty::subst::Substs; -use ty::{CanonicalUserTypeAnnotation, ClosureSubsts, GeneratorSubsts, Region, Ty}; -use mir::*; +use crate::hir::def_id::DefId; +use crate::ty::subst::Substs; +use crate::ty::{CanonicalUserTypeAnnotation, ClosureSubsts, GeneratorSubsts, Region, Ty}; +use crate::mir::*; use syntax_pos::Span; // # The MIR Visitor @@ -567,7 +567,7 @@ macro_rules! make_mir_visitor { fn super_assert_message(&mut self, msg: & $($mutability)* AssertMessage<'tcx>, location: Location) { - use mir::interpret::EvalErrorKind::*; + use crate::mir::interpret::EvalErrorKind::*; if let BoundsCheck { ref $($mutability)* len, ref $($mutability)* index diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 86f676fbf888a..f8de61f146337 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -3,13 +3,13 @@ use std::str::FromStr; -use session::{early_error, early_warn, Session}; -use session::search_paths::SearchPath; +use crate::session::{early_error, early_warn, Session}; +use crate::session::search_paths::SearchPath; use rustc_target::spec::{LinkerFlavor, MergeFunctions, PanicStrategy, RelroLevel}; use rustc_target::spec::{Target, TargetTriple}; -use lint; -use middle::cstore; +use crate::lint; +use crate::middle::cstore; use syntax::ast::{self, IntTy, UintTy, MetaItemKind}; use syntax::source_map::{FileName, FilePathMapping}; @@ -19,7 +19,7 @@ use syntax::parse; use syntax::symbol::Symbol; use syntax::feature_gate::UnstableFeatures; -use errors::{ColorConfig, FatalError, Handler}; +use crate::errors::{ColorConfig, FatalError, Handler}; use getopts; use std::collections::{BTreeMap, BTreeSet}; @@ -2342,7 +2342,7 @@ pub mod nightly_options { use getopts; use syntax::feature_gate::UnstableFeatures; use super::{ErrorOutputType, OptionStability, RustcOptGroup}; - use session::early_error; + use crate::session::early_error; pub fn is_unstable_enabled(matches: &getopts::Matches) -> bool { is_nightly_build() @@ -2431,8 +2431,8 @@ impl fmt::Display for CrateType { /// we have an opt-in scheme here, so one is hopefully forced to think about /// how the hash should be calculated when adding a new command-line argument. mod dep_tracking { - use lint; - use middle::cstore; + use crate::lint; + use crate::middle::cstore; use std::collections::BTreeMap; use std::hash::Hash; use std::path::PathBuf; @@ -2565,14 +2565,14 @@ mod dep_tracking { #[cfg(test)] mod tests { - use errors; + use crate::errors; use getopts; - use lint; - use middle::cstore; - use session::config::{build_configuration, build_session_options_and_crate_config}; - use session::config::{LtoCli, CrossLangLto}; - use session::build_session; - use session::search_paths::SearchPath; + use crate::lint; + use crate::middle::cstore; + use crate::session::config::{build_configuration, build_session_options_and_crate_config}; + use crate::session::config::{LtoCli, CrossLangLto}; + use crate::session::build_session; + use crate::session::search_paths::SearchPath; use std::collections::{BTreeMap, BTreeSet}; use std::iter::FromIterator; use std::path::PathBuf; diff --git a/src/librustc/session/filesearch.rs b/src/librustc/session/filesearch.rs index 19f1c7a18fad1..77f190e281229 100644 --- a/src/librustc/session/filesearch.rs +++ b/src/librustc/session/filesearch.rs @@ -7,7 +7,7 @@ use std::env; use std::fs; use std::path::{Path, PathBuf}; -use session::search_paths::{SearchPath, PathKind}; +use crate::session::search_paths::{SearchPath, PathKind}; use rustc_fs_util::fix_windows_verbatim_for_gcc; #[derive(Copy, Clone)] diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index c5034415d6ffb..d2beb64b38861 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -1,19 +1,19 @@ pub use self::code_stats::{DataTypeKind, SizeKind, FieldInfo, VariantInfo}; use self::code_stats::CodeStats; -use dep_graph::cgu_reuse_tracker::CguReuseTracker; -use hir::def_id::CrateNum; +use crate::dep_graph::cgu_reuse_tracker::CguReuseTracker; +use crate::hir::def_id::CrateNum; use rustc_data_structures::fingerprint::Fingerprint; -use lint; -use lint::builtin::BuiltinLintDiagnostics; -use middle::allocator::AllocatorKind; -use middle::dependency_format; -use session::config::{OutputType, Lto}; -use session::search_paths::{PathKind, SearchPath}; -use util::nodemap::{FxHashMap, FxHashSet}; -use util::common::{duration_to_secs_str, ErrorReported}; -use util::common::ProfileQueriesMsg; +use crate::lint; +use crate::lint::builtin::BuiltinLintDiagnostics; +use crate::middle::allocator::AllocatorKind; +use crate::middle::dependency_format; +use crate::session::config::{OutputType, Lto}; +use crate::session::search_paths::{PathKind, SearchPath}; +use crate::util::nodemap::{FxHashMap, FxHashSet}; +use crate::util::common::{duration_to_secs_str, ErrorReported}; +use crate::util::common::ProfileQueriesMsg; use rustc_data_structures::base_n; use rustc_data_structures::sync::{ @@ -21,8 +21,8 @@ use rustc_data_structures::sync::{ Ordering::SeqCst, }; -use errors::{self, DiagnosticBuilder, DiagnosticId, Applicability}; -use errors::emitter::{Emitter, EmitterWriter}; +use crate::errors::{self, DiagnosticBuilder, DiagnosticId, Applicability}; +use crate::errors::emitter::{Emitter, EmitterWriter}; use syntax::ast::{self, NodeId}; use syntax::edition::Edition; use syntax::feature_gate::{self, AttributeType}; @@ -30,7 +30,7 @@ use syntax::json::JsonEmitter; use syntax::source_map; use syntax::parse::{self, ParseSess}; use syntax_pos::{MultiSpan, Span}; -use util::profiling::SelfProfiler; +use crate::util::profiling::SelfProfiler; use rustc_target::spec::{PanicStrategy, RelroLevel, Target, TargetTriple}; use rustc_data_structures::flock; diff --git a/src/librustc/session/search_paths.rs b/src/librustc/session/search_paths.rs index 85d64b1571266..a950258cefd0c 100644 --- a/src/librustc/session/search_paths.rs +++ b/src/librustc/session/search_paths.rs @@ -1,6 +1,6 @@ use std::path::{Path, PathBuf}; -use session::{early_error, config}; -use session::filesearch::make_target_lib_path; +use crate::session::{early_error, config}; +use crate::session::filesearch::make_target_lib_path; #[derive(Clone, Debug)] pub struct SearchPath { diff --git a/src/librustc/traits/auto_trait.rs b/src/librustc/traits/auto_trait.rs index 92004ece26d00..d1db49e05f190 100644 --- a/src/librustc/traits/auto_trait.rs +++ b/src/librustc/traits/auto_trait.rs @@ -6,12 +6,12 @@ use super::*; use std::collections::hash_map::Entry; use std::collections::VecDeque; -use infer::region_constraints::{Constraint, RegionConstraintData}; -use infer::InferCtxt; +use crate::infer::region_constraints::{Constraint, RegionConstraintData}; +use crate::infer::InferCtxt; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; -use ty::fold::TypeFolder; -use ty::{Region, RegionVid}; +use crate::ty::fold::TypeFolder; +use crate::ty::{Region, RegionVid}; // FIXME(twk): this is obviously not nice to duplicate like that #[derive(Eq, PartialEq, Hash, Copy, Clone, Debug)] diff --git a/src/librustc/traits/chalk_fulfill.rs b/src/librustc/traits/chalk_fulfill.rs index df4e08e0eb5f3..d9eb6d8157dfb 100644 --- a/src/librustc/traits/chalk_fulfill.rs +++ b/src/librustc/traits/chalk_fulfill.rs @@ -1,4 +1,4 @@ -use traits::{ +use crate::traits::{ Environment, InEnvironment, TraitEngine, @@ -8,10 +8,10 @@ use traits::{ FulfillmentErrorCode, SelectionError, }; -use traits::query::NoSolution; -use infer::InferCtxt; -use infer::canonical::{Canonical, OriginalQueryValues}; -use ty::{self, Ty}; +use crate::traits::query::NoSolution; +use crate::infer::InferCtxt; +use crate::infer::canonical::{Canonical, OriginalQueryValues}; +use crate::ty::{self, Ty}; use rustc_data_structures::fx::FxHashSet; pub type CanonicalGoal<'tcx> = Canonical<'tcx, InEnvironment<'tcx, ty::Predicate<'tcx>>>; diff --git a/src/librustc/traits/codegen/mod.rs b/src/librustc/traits/codegen/mod.rs index 94d56c2cbfc88..eed9345afae16 100644 --- a/src/librustc/traits/codegen/mod.rs +++ b/src/librustc/traits/codegen/mod.rs @@ -3,16 +3,16 @@ // seems likely that they should eventually be merged into more // general routines. -use dep_graph::{DepKind, DepTrackingMapConfig}; +use crate::dep_graph::{DepKind, DepTrackingMapConfig}; use std::marker::PhantomData; use syntax_pos::DUMMY_SP; -use infer::InferCtxt; +use crate::infer::InferCtxt; use syntax_pos::Span; -use traits::{FulfillmentContext, Obligation, ObligationCause, SelectionContext, +use crate::traits::{FulfillmentContext, Obligation, ObligationCause, SelectionContext, TraitEngine, Vtable}; -use ty::{self, Ty, TyCtxt}; -use ty::subst::{Subst, Substs}; -use ty::fold::TypeFoldable; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::subst::{Subst, Substs}; +use crate::ty::fold::TypeFoldable; /// Attempts to resolve an obligation to a vtable.. The result is /// a shallow vtable resolution -- meaning that we do not diff --git a/src/librustc/traits/coherence.rs b/src/librustc/traits/coherence.rs index 4c7049c366207..4fe7a1507f737 100644 --- a/src/librustc/traits/coherence.rs +++ b/src/librustc/traits/coherence.rs @@ -4,17 +4,17 @@ //! [trait-resolution]: https://rust-lang.github.io/rustc-guide/traits/resolution.html //! [trait-specialization]: https://rust-lang.github.io/rustc-guide/traits/specialization.html -use infer::CombinedSnapshot; -use hir::def_id::{DefId, LOCAL_CRATE}; +use crate::infer::CombinedSnapshot; +use crate::hir::def_id::{DefId, LOCAL_CRATE}; use syntax_pos::DUMMY_SP; -use traits::{self, Normalized, SelectionContext, Obligation, ObligationCause}; -use traits::IntercrateMode; -use traits::select::IntercrateAmbiguityCause; -use ty::{self, Ty, TyCtxt}; -use ty::fold::TypeFoldable; -use ty::subst::Subst; +use crate::traits::{self, Normalized, SelectionContext, Obligation, ObligationCause}; +use crate::traits::IntercrateMode; +use crate::traits::select::IntercrateAmbiguityCause; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::fold::TypeFoldable; +use crate::ty::subst::Subst; -use infer::{InferOk}; +use crate::infer::{InferOk}; /// Whether we do the orphan check relative to this crate or /// to some remote crate. @@ -39,7 +39,7 @@ pub struct OverlapResult<'tcx> { pub involves_placeholder: bool, } -pub fn add_placeholder_note(err: &mut ::errors::DiagnosticBuilder<'_>) { +pub fn add_placeholder_note(err: &mut crate::errors::DiagnosticBuilder<'_>) { err.note(&format!( "this behavior recently changed as a result of a bug fix; \ see rust-lang/rust#56105 for details" diff --git a/src/librustc/traits/engine.rs b/src/librustc/traits/engine.rs index c759a9ddf2ce6..2f019d823ff5d 100644 --- a/src/librustc/traits/engine.rs +++ b/src/librustc/traits/engine.rs @@ -1,7 +1,7 @@ -use infer::InferCtxt; -use ty::{self, Ty, TyCtxt, ToPredicate}; -use traits::Obligation; -use hir::def_id::DefId; +use crate::infer::InferCtxt; +use crate::ty::{self, Ty, TyCtxt, ToPredicate}; +use crate::traits::Obligation; +use crate::hir::def_id::DefId; use super::{ChalkFulfillmentContext, FulfillmentContext, FulfillmentError}; use super::{ObligationCause, PredicateObligation}; diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index ea3ea59c7613f..79afc593a4676 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -17,23 +17,23 @@ use super::{ Overflow, }; -use errors::{Applicability, DiagnosticBuilder}; -use hir; -use hir::Node; -use hir::def_id::DefId; -use infer::{self, InferCtxt}; -use infer::type_variable::TypeVariableOrigin; +use crate::errors::{Applicability, DiagnosticBuilder}; +use crate::hir; +use crate::hir::Node; +use crate::hir::def_id::DefId; +use crate::infer::{self, InferCtxt}; +use crate::infer::type_variable::TypeVariableOrigin; use std::fmt; use syntax::ast; -use session::DiagnosticMessageId; -use ty::{self, AdtKind, ToPredicate, ToPolyTraitRef, Ty, TyCtxt, TypeFoldable}; -use ty::GenericParamDefKind; -use ty::error::ExpectedFound; -use ty::fast_reject; -use ty::fold::TypeFolder; -use ty::subst::Subst; -use ty::SubtypePredicate; -use util::nodemap::{FxHashMap, FxHashSet}; +use crate::session::DiagnosticMessageId; +use crate::ty::{self, AdtKind, ToPredicate, ToPolyTraitRef, Ty, TyCtxt, TypeFoldable}; +use crate::ty::GenericParamDefKind; +use crate::ty::error::ExpectedFound; +use crate::ty::fast_reject; +use crate::ty::fold::TypeFolder; +use crate::ty::subst::Subst; +use crate::ty::SubtypePredicate; +use crate::util::nodemap::{FxHashMap, FxHashSet}; use syntax_pos::{DUMMY_SP, Span, ExpnInfo, ExpnFormat}; diff --git a/src/librustc/traits/fulfill.rs b/src/librustc/traits/fulfill.rs index 2e00d4d4b7c3b..98784bccb6f82 100644 --- a/src/librustc/traits/fulfill.rs +++ b/src/librustc/traits/fulfill.rs @@ -1,7 +1,7 @@ -use infer::InferCtxt; -use mir::interpret::{GlobalId, ErrorHandled}; -use ty::{self, Ty, TypeFoldable, ToPolyTraitRef}; -use ty::error::ExpectedFound; +use crate::infer::InferCtxt; +use crate::mir::interpret::{GlobalId, ErrorHandled}; +use crate::ty::{self, Ty, TypeFoldable, ToPolyTraitRef}; +use crate::ty::error::ExpectedFound; use rustc_data_structures::obligation_forest::{DoCompleted, Error, ForestObligation}; use rustc_data_structures::obligation_forest::{ObligationForest, ObligationProcessor}; use rustc_data_structures::obligation_forest::{ProcessResult}; diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs index 68383bef37a6a..d1be8d377a84d 100644 --- a/src/librustc/traits/mod.rs +++ b/src/librustc/traits/mod.rs @@ -20,20 +20,20 @@ mod util; pub mod query; use chalk_engine; -use hir; -use hir::def_id::DefId; -use infer::{InferCtxt, SuppressRegionErrors}; -use infer::outlives::env::OutlivesEnvironment; -use middle::region; -use mir::interpret::ErrorHandled; +use crate::hir; +use crate::hir::def_id::DefId; +use crate::infer::{InferCtxt, SuppressRegionErrors}; +use crate::infer::outlives::env::OutlivesEnvironment; +use crate::middle::region; +use crate::mir::interpret::ErrorHandled; use rustc_data_structures::sync::Lrc; use syntax::ast; use syntax_pos::{Span, DUMMY_SP}; -use ty::subst::Substs; -use ty::{self, AdtKind, List, Ty, TyCtxt, GenericParamDefKind, ToPredicate}; -use ty::error::{ExpectedFound, TypeError}; -use ty::fold::{TypeFolder, TypeFoldable, TypeVisitor}; -use util::common::ErrorReported; +use crate::ty::subst::Substs; +use crate::ty::{self, AdtKind, List, Ty, TyCtxt, GenericParamDefKind, ToPredicate}; +use crate::ty::error::{ExpectedFound, TypeError}; +use crate::ty::fold::{TypeFolder, TypeFoldable, TypeVisitor}; +use crate::util::common::ErrorReported; use std::fmt::Debug; use std::rc::Rc; diff --git a/src/librustc/traits/object_safety.rs b/src/librustc/traits/object_safety.rs index c37dc2a855ed0..75eaa67e767c2 100644 --- a/src/librustc/traits/object_safety.rs +++ b/src/librustc/traits/object_safety.rs @@ -10,11 +10,11 @@ use super::elaborate_predicates; -use hir::def_id::DefId; -use lint; -use traits::{self, Obligation, ObligationCause}; -use ty::{self, Ty, TyCtxt, TypeFoldable, Predicate, ToPredicate}; -use ty::subst::{Subst, Substs}; +use crate::hir::def_id::DefId; +use crate::lint; +use crate::traits::{self, Obligation, ObligationCause}; +use crate::ty::{self, Ty, TyCtxt, TypeFoldable, Predicate, ToPredicate}; +use crate::ty::subst::{Subst, Substs}; use std::borrow::Cow; use std::iter::{self}; use syntax::ast::{self, Name}; @@ -341,7 +341,7 @@ impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> { } else { // sanity check to make sure the receiver actually has the layout of a pointer - use ty::layout::Abi; + use crate::ty::layout::Abi; let param_env = self.param_env(method.def_id); diff --git a/src/librustc/traits/on_unimplemented.rs b/src/librustc/traits/on_unimplemented.rs index 3ec901f50e4cc..f61c32614cc93 100644 --- a/src/librustc/traits/on_unimplemented.rs +++ b/src/librustc/traits/on_unimplemented.rs @@ -1,9 +1,9 @@ use fmt_macros::{Parser, Piece, Position}; -use hir::def_id::DefId; -use ty::{self, TyCtxt, GenericParamDefKind}; -use util::common::ErrorReported; -use util::nodemap::FxHashMap; +use crate::hir::def_id::DefId; +use crate::ty::{self, TyCtxt, GenericParamDefKind}; +use crate::util::common::ErrorReported; +use crate::util::nodemap::FxHashMap; use syntax::ast::{MetaItem, NestedMetaItem}; use syntax::attr; diff --git a/src/librustc/traits/project.rs b/src/librustc/traits/project.rs index bec45046cb93e..99107a1a6d4e1 100644 --- a/src/librustc/traits/project.rs +++ b/src/librustc/traits/project.rs @@ -12,16 +12,16 @@ use super::SelectionError; use super::{VtableImplData, VtableClosureData, VtableGeneratorData, VtableFnPointerData}; use super::util; -use hir::def_id::DefId; -use infer::{InferCtxt, InferOk, LateBoundRegionConversionTime}; -use infer::type_variable::TypeVariableOrigin; -use mir::interpret::{GlobalId}; +use crate::hir::def_id::DefId; +use crate::infer::{InferCtxt, InferOk, LateBoundRegionConversionTime}; +use crate::infer::type_variable::TypeVariableOrigin; +use crate::mir::interpret::{GlobalId}; use rustc_data_structures::snapshot_map::{Snapshot, SnapshotMap}; use syntax::ast::Ident; -use ty::subst::{Subst, Substs}; -use ty::{self, ToPredicate, ToPolyTraitRef, Ty, TyCtxt}; -use ty::fold::{TypeFoldable, TypeFolder}; -use util::common::FN_OUTPUT_NAME; +use crate::ty::subst::{Subst, Substs}; +use crate::ty::{self, ToPredicate, ToPolyTraitRef, Ty, TyCtxt}; +use crate::ty::fold::{TypeFoldable, TypeFolder}; +use crate::util::common::FN_OUTPUT_NAME; /// Depending on the stage of compilation, we want projection to be /// more or less conservative. diff --git a/src/librustc/traits/query/dropck_outlives.rs b/src/librustc/traits/query/dropck_outlives.rs index 1fd2172212d3c..47ca416e6b5aa 100644 --- a/src/librustc/traits/query/dropck_outlives.rs +++ b/src/librustc/traits/query/dropck_outlives.rs @@ -1,10 +1,10 @@ -use infer::at::At; -use infer::InferOk; -use infer::canonical::OriginalQueryValues; +use crate::infer::at::At; +use crate::infer::InferOk; +use crate::infer::canonical::OriginalQueryValues; use std::iter::FromIterator; use syntax::source_map::Span; -use ty::subst::Kind; -use ty::{self, Ty, TyCtxt}; +use crate::ty::subst::Kind; +use crate::ty::{self, Ty, TyCtxt}; impl<'cx, 'gcx, 'tcx> At<'cx, 'gcx, 'tcx> { /// Given a type `ty` of some value being dropped, computes a set diff --git a/src/librustc/traits/query/evaluate_obligation.rs b/src/librustc/traits/query/evaluate_obligation.rs index fdae7d833734e..d5230f15c2565 100644 --- a/src/librustc/traits/query/evaluate_obligation.rs +++ b/src/librustc/traits/query/evaluate_obligation.rs @@ -1,6 +1,6 @@ -use infer::InferCtxt; -use infer::canonical::OriginalQueryValues; -use traits::{EvaluationResult, PredicateObligation, SelectionContext, +use crate::infer::InferCtxt; +use crate::infer::canonical::OriginalQueryValues; +use crate::traits::{EvaluationResult, PredicateObligation, SelectionContext, TraitQueryMode, OverflowError}; impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> { diff --git a/src/librustc/traits/query/method_autoderef.rs b/src/librustc/traits/query/method_autoderef.rs index b4984e1237857..6b9bdfd63f4d0 100644 --- a/src/librustc/traits/query/method_autoderef.rs +++ b/src/librustc/traits/query/method_autoderef.rs @@ -1,6 +1,6 @@ use rustc_data_structures::sync::Lrc; -use infer::canonical::{Canonical, QueryResponse}; -use ty::Ty; +use crate::infer::canonical::{Canonical, QueryResponse}; +use crate::ty::Ty; #[derive(Debug)] pub struct CandidateStep<'tcx> { diff --git a/src/librustc/traits/query/mod.rs b/src/librustc/traits/query/mod.rs index 59f786025b224..112a1d0e09c94 100644 --- a/src/librustc/traits/query/mod.rs +++ b/src/librustc/traits/query/mod.rs @@ -5,9 +5,9 @@ //! The providers for the queries defined here can be found in //! `librustc_traits`. -use infer::canonical::Canonical; -use ty::error::TypeError; -use ty::{self, Ty}; +use crate::infer::canonical::Canonical; +use crate::ty::error::TypeError; +use crate::ty::{self, Ty}; pub mod dropck_outlives; pub mod evaluate_obligation; diff --git a/src/librustc/traits/query/normalize.rs b/src/librustc/traits/query/normalize.rs index be05445cfc61a..f477f161bbb32 100644 --- a/src/librustc/traits/query/normalize.rs +++ b/src/librustc/traits/query/normalize.rs @@ -2,15 +2,15 @@ //! which folds deeply, invoking the underlying //! `normalize_projection_ty` query when it encounters projections. -use infer::at::At; -use infer::canonical::OriginalQueryValues; -use infer::{InferCtxt, InferOk}; -use mir::interpret::GlobalId; -use traits::project::Normalized; -use traits::{Obligation, ObligationCause, PredicateObligation, Reveal}; -use ty::fold::{TypeFoldable, TypeFolder}; -use ty::subst::{Subst, Substs}; -use ty::{self, Ty, TyCtxt}; +use crate::infer::at::At; +use crate::infer::canonical::OriginalQueryValues; +use crate::infer::{InferCtxt, InferOk}; +use crate::mir::interpret::GlobalId; +use crate::traits::project::Normalized; +use crate::traits::{Obligation, ObligationCause, PredicateObligation, Reveal}; +use crate::ty::fold::{TypeFoldable, TypeFolder}; +use crate::ty::subst::{Subst, Substs}; +use crate::ty::{self, Ty, TyCtxt}; use super::NoSolution; diff --git a/src/librustc/traits/query/normalize_erasing_regions.rs b/src/librustc/traits/query/normalize_erasing_regions.rs index e7034065bdf2e..4fc61077e268a 100644 --- a/src/librustc/traits/query/normalize_erasing_regions.rs +++ b/src/librustc/traits/query/normalize_erasing_regions.rs @@ -7,8 +7,8 @@ //! `normalize_ty_after_erasing_regions` query for each type found //! within. (This underlying query is what is cached.) -use ty::{self, Ty, TyCtxt}; -use ty::fold::{TypeFoldable, TypeFolder}; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::fold::{TypeFoldable, TypeFolder}; impl<'cx, 'tcx> TyCtxt<'cx, 'tcx, 'tcx> { /// Erase the regions in `value` and then fully normalize all the diff --git a/src/librustc/traits/query/outlives_bounds.rs b/src/librustc/traits/query/outlives_bounds.rs index 1134cb1b2f5d0..e57236b999bab 100644 --- a/src/librustc/traits/query/outlives_bounds.rs +++ b/src/librustc/traits/query/outlives_bounds.rs @@ -1,12 +1,12 @@ -use infer::InferCtxt; -use infer::canonical::OriginalQueryValues; +use crate::infer::InferCtxt; +use crate::infer::canonical::OriginalQueryValues; use syntax::ast; use syntax::source_map::Span; -use traits::{FulfillmentContext, ObligationCause, TraitEngine, TraitEngineExt}; -use traits::query::NoSolution; -use ty::{self, Ty, TyCtxt}; +use crate::traits::{FulfillmentContext, ObligationCause, TraitEngine, TraitEngineExt}; +use crate::traits::query::NoSolution; +use crate::ty::{self, Ty, TyCtxt}; -use ich::StableHashingContext; +use crate::ich::StableHashingContext; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; use std::mem; diff --git a/src/librustc/traits/query/type_op/ascribe_user_type.rs b/src/librustc/traits/query/type_op/ascribe_user_type.rs index 15f627b3ee8c4..d9f573eb7e291 100644 --- a/src/librustc/traits/query/type_op/ascribe_user_type.rs +++ b/src/librustc/traits/query/type_op/ascribe_user_type.rs @@ -1,8 +1,8 @@ -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; -use traits::query::Fallible; -use hir::def_id::DefId; -use ty::{ParamEnvAnd, Ty, TyCtxt}; -use ty::subst::UserSubsts; +use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; +use crate::traits::query::Fallible; +use crate::hir::def_id::DefId; +use crate::ty::{ParamEnvAnd, Ty, TyCtxt}; +use crate::ty::subst::UserSubsts; #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] pub struct AscribeUserType<'tcx> { diff --git a/src/librustc/traits/query/type_op/custom.rs b/src/librustc/traits/query/type_op/custom.rs index 0756d2eed8aea..7e38282cc1adc 100644 --- a/src/librustc/traits/query/type_op/custom.rs +++ b/src/librustc/traits/query/type_op/custom.rs @@ -1,12 +1,12 @@ -use infer::{InferCtxt, InferOk}; +use crate::infer::{InferCtxt, InferOk}; use std::fmt; -use traits::query::Fallible; +use crate::traits::query::Fallible; -use infer::canonical::query_response; -use infer::canonical::QueryRegionConstraint; +use crate::infer::canonical::query_response; +use crate::infer::canonical::QueryRegionConstraint; use std::rc::Rc; use syntax::source_map::DUMMY_SP; -use traits::{ObligationCause, TraitEngine, TraitEngineExt}; +use crate::traits::{ObligationCause, TraitEngine, TraitEngineExt}; pub struct CustomTypeOp { closure: F, diff --git a/src/librustc/traits/query/type_op/eq.rs b/src/librustc/traits/query/type_op/eq.rs index 7acb8ccb0d319..5c3ccc9a99537 100644 --- a/src/librustc/traits/query/type_op/eq.rs +++ b/src/librustc/traits/query/type_op/eq.rs @@ -1,6 +1,6 @@ -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; -use traits::query::Fallible; -use ty::{ParamEnvAnd, Ty, TyCtxt}; +use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; +use crate::traits::query::Fallible; +use crate::ty::{ParamEnvAnd, Ty, TyCtxt}; #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] pub struct Eq<'tcx> { diff --git a/src/librustc/traits/query/type_op/implied_outlives_bounds.rs b/src/librustc/traits/query/type_op/implied_outlives_bounds.rs index f4a825a669b48..c48ca33b13fbc 100644 --- a/src/librustc/traits/query/type_op/implied_outlives_bounds.rs +++ b/src/librustc/traits/query/type_op/implied_outlives_bounds.rs @@ -1,7 +1,7 @@ -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; -use traits::query::outlives_bounds::OutlivesBound; -use traits::query::Fallible; -use ty::{ParamEnvAnd, Ty, TyCtxt}; +use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; +use crate::traits::query::outlives_bounds::OutlivesBound; +use crate::traits::query::Fallible; +use crate::ty::{ParamEnvAnd, Ty, TyCtxt}; #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] pub struct ImpliedOutlivesBounds<'tcx> { diff --git a/src/librustc/traits/query/type_op/mod.rs b/src/librustc/traits/query/type_op/mod.rs index 6e5a6080976c0..fd13acc7796f8 100644 --- a/src/librustc/traits/query/type_op/mod.rs +++ b/src/librustc/traits/query/type_op/mod.rs @@ -1,14 +1,14 @@ -use infer::canonical::{ +use crate::infer::canonical::{ Canonical, Canonicalized, CanonicalizedQueryResponse, OriginalQueryValues, QueryRegionConstraint, QueryResponse, }; -use infer::{InferCtxt, InferOk}; +use crate::infer::{InferCtxt, InferOk}; use std::fmt; use std::rc::Rc; -use traits::query::Fallible; -use traits::ObligationCause; -use ty::fold::TypeFoldable; -use ty::{Lift, ParamEnvAnd, TyCtxt}; +use crate::traits::query::Fallible; +use crate::traits::ObligationCause; +use crate::ty::fold::TypeFoldable; +use crate::ty::{Lift, ParamEnvAnd, TyCtxt}; pub mod ascribe_user_type; pub mod custom; diff --git a/src/librustc/traits/query/type_op/normalize.rs b/src/librustc/traits/query/type_op/normalize.rs index 98afe2abdbf05..346c18516234c 100644 --- a/src/librustc/traits/query/type_op/normalize.rs +++ b/src/librustc/traits/query/type_op/normalize.rs @@ -1,8 +1,8 @@ -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; +use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; use std::fmt; -use traits::query::Fallible; -use ty::fold::TypeFoldable; -use ty::{self, Lift, ParamEnvAnd, Ty, TyCtxt}; +use crate::traits::query::Fallible; +use crate::ty::fold::TypeFoldable; +use crate::ty::{self, Lift, ParamEnvAnd, Ty, TyCtxt}; #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] pub struct Normalize { diff --git a/src/librustc/traits/query/type_op/outlives.rs b/src/librustc/traits/query/type_op/outlives.rs index 108aa373e039c..fc0c1c022fc80 100644 --- a/src/librustc/traits/query/type_op/outlives.rs +++ b/src/librustc/traits/query/type_op/outlives.rs @@ -1,8 +1,8 @@ -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; -use traits::query::dropck_outlives::trivial_dropck_outlives; -use traits::query::dropck_outlives::DropckOutlivesResult; -use traits::query::Fallible; -use ty::{ParamEnvAnd, Ty, TyCtxt}; +use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; +use crate::traits::query::dropck_outlives::trivial_dropck_outlives; +use crate::traits::query::dropck_outlives::DropckOutlivesResult; +use crate::traits::query::Fallible; +use crate::ty::{ParamEnvAnd, Ty, TyCtxt}; #[derive(Copy, Clone, Debug)] pub struct DropckOutlives<'tcx> { diff --git a/src/librustc/traits/query/type_op/prove_predicate.rs b/src/librustc/traits/query/type_op/prove_predicate.rs index d9eb89c9fc7c8..50dedf6e87f40 100644 --- a/src/librustc/traits/query/type_op/prove_predicate.rs +++ b/src/librustc/traits/query/type_op/prove_predicate.rs @@ -1,6 +1,6 @@ -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; -use traits::query::Fallible; -use ty::{ParamEnvAnd, Predicate, TyCtxt}; +use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; +use crate::traits::query::Fallible; +use crate::ty::{ParamEnvAnd, Predicate, TyCtxt}; #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] pub struct ProvePredicate<'tcx> { diff --git a/src/librustc/traits/query/type_op/subtype.rs b/src/librustc/traits/query/type_op/subtype.rs index f001c7ea10a17..c45fb06313e16 100644 --- a/src/librustc/traits/query/type_op/subtype.rs +++ b/src/librustc/traits/query/type_op/subtype.rs @@ -1,6 +1,6 @@ -use infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; -use traits::query::Fallible; -use ty::{ParamEnvAnd, Ty, TyCtxt}; +use crate::infer::canonical::{Canonical, Canonicalized, CanonicalizedQueryResponse, QueryResponse}; +use crate::traits::query::Fallible; +use crate::ty::{ParamEnvAnd, Ty, TyCtxt}; #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)] pub struct Subtype<'tcx> { diff --git a/src/librustc/traits/select.rs b/src/librustc/traits/select.rs index 6fe4a7a52be86..1e4cd145e1760 100644 --- a/src/librustc/traits/select.rs +++ b/src/librustc/traits/select.rs @@ -27,17 +27,17 @@ use super::{ VtableGeneratorData, VtableImplData, VtableObjectData, VtableTraitAliasData, }; -use dep_graph::{DepKind, DepNodeIndex}; -use hir::def_id::DefId; -use infer::{InferCtxt, InferOk, TypeFreshener}; -use middle::lang_items; -use mir::interpret::GlobalId; -use ty::fast_reject; -use ty::relate::TypeRelation; -use ty::subst::{Subst, Substs}; -use ty::{self, ToPolyTraitRef, ToPredicate, Ty, TyCtxt, TypeFoldable}; - -use hir; +use crate::dep_graph::{DepKind, DepNodeIndex}; +use crate::hir::def_id::DefId; +use crate::infer::{InferCtxt, InferOk, TypeFreshener}; +use crate::middle::lang_items; +use crate::mir::interpret::GlobalId; +use crate::ty::fast_reject; +use crate::ty::relate::TypeRelation; +use crate::ty::subst::{Subst, Substs}; +use crate::ty::{self, ToPolyTraitRef, ToPredicate, Ty, TyCtxt, TypeFoldable}; + +use crate::hir; use rustc_data_structures::bit_set::GrowableBitSet; use rustc_data_structures::sync::Lock; use rustc_target::spec::abi::Abi; @@ -45,7 +45,7 @@ use std::cmp; use std::fmt::{self, Display}; use std::iter; use std::rc::Rc; -use util::nodemap::{FxHashMap, FxHashSet}; +use crate::util::nodemap::{FxHashMap, FxHashSet}; pub struct SelectionContext<'cx, 'gcx: 'cx + 'tcx, 'tcx: 'cx> { infcx: &'cx InferCtxt<'cx, 'gcx, 'tcx>, @@ -103,7 +103,7 @@ impl IntercrateAmbiguityCause { /// See #23980 for details. pub fn add_intercrate_ambiguity_hint<'a, 'tcx>( &self, - err: &mut ::errors::DiagnosticBuilder<'_>, + err: &mut crate::errors::DiagnosticBuilder<'_>, ) { err.note(&self.intercrate_ambiguity_hint()); } diff --git a/src/librustc/traits/specialize/mod.rs b/src/librustc/traits/specialize/mod.rs index e5ed16e755860..e7187005c132a 100644 --- a/src/librustc/traits/specialize/mod.rs +++ b/src/librustc/traits/specialize/mod.rs @@ -11,16 +11,16 @@ pub mod specialization_graph; -use hir::def_id::DefId; -use infer::{InferCtxt, InferOk}; -use lint; -use traits::{self, coherence, FutureCompatOverlapErrorKind, ObligationCause, TraitEngine}; +use crate::hir::def_id::DefId; +use crate::infer::{InferCtxt, InferOk}; +use crate::lint; +use crate::traits::{self, coherence, FutureCompatOverlapErrorKind, ObligationCause, TraitEngine}; use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::sync::Lrc; use syntax_pos::DUMMY_SP; -use traits::select::IntercrateAmbiguityCause; -use ty::{self, TyCtxt, TypeFoldable}; -use ty::subst::{Subst, Substs}; +use crate::traits::select::IntercrateAmbiguityCause; +use crate::ty::{self, TyCtxt, TypeFoldable}; +use crate::ty::subst::{Subst, Substs}; use super::{SelectionContext, FulfillmentContext}; use super::util::impl_trait_ref_and_oblig; diff --git a/src/librustc/traits/specialize/specialization_graph.rs b/src/librustc/traits/specialize/specialization_graph.rs index e5780a26a1918..010555744b6c3 100644 --- a/src/librustc/traits/specialize/specialization_graph.rs +++ b/src/librustc/traits/specialize/specialization_graph.rs @@ -1,16 +1,16 @@ use super::OverlapError; -use hir::def_id::DefId; -use ich::{self, StableHashingContext}; +use crate::hir::def_id::DefId; +use crate::ich::{self, StableHashingContext}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; -use traits; -use ty::{self, TyCtxt, TypeFoldable}; -use ty::fast_reject::{self, SimplifiedType}; +use crate::traits; +use crate::ty::{self, TyCtxt, TypeFoldable}; +use crate::ty::fast_reject::{self, SimplifiedType}; use rustc_data_structures::sync::Lrc; use syntax::ast::Ident; -use util::captures::Captures; -use util::nodemap::{DefIdMap, FxHashMap}; +use crate::util::captures::Captures; +use crate::util::nodemap::{DefIdMap, FxHashMap}; /// A per-trait graph of impls in specialization order. At the moment, this /// graph forms a tree rooted with the trait itself, with all other nodes @@ -489,7 +489,7 @@ impl<'a, 'gcx, 'tcx> Ancestors { trait_def_id: DefId, ) -> impl Iterator> + Captures<'gcx> + Captures<'tcx> + 'a { self.flat_map(move |node| { - use ty::AssociatedKind::*; + use crate::ty::AssociatedKind::*; node.items(tcx).filter(move |impl_item| match (trait_item_kind, impl_item.kind) { | (Const, Const) | (Method, Method) diff --git a/src/librustc/traits/structural_impls.rs b/src/librustc/traits/structural_impls.rs index 2f5df022218fe..c5cc9e8b40182 100644 --- a/src/librustc/traits/structural_impls.rs +++ b/src/librustc/traits/structural_impls.rs @@ -1,9 +1,9 @@ use chalk_engine; use smallvec::SmallVec; -use traits; -use traits::project::Normalized; -use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; -use ty::{self, Lift, TyCtxt}; +use crate::traits; +use crate::traits::project::Normalized; +use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; +use crate::ty::{self, Lift, TyCtxt}; use syntax::symbol::InternedString; use std::fmt; @@ -163,7 +163,7 @@ impl<'tcx> fmt::Debug for traits::MismatchedProjectionTypes<'tcx> { impl<'tcx> fmt::Display for traits::WhereClause<'tcx> { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - use traits::WhereClause::*; + use crate::traits::WhereClause::*; // Bypass ppaux because it does not print out anonymous regions. fn write_region_name<'tcx>( @@ -206,7 +206,7 @@ impl<'tcx> fmt::Display for traits::WhereClause<'tcx> { impl<'tcx> fmt::Display for traits::WellFormed<'tcx> { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - use traits::WellFormed::*; + use crate::traits::WellFormed::*; match self { Trait(trait_ref) => write!(fmt, "WellFormed({})", trait_ref), @@ -217,7 +217,7 @@ impl<'tcx> fmt::Display for traits::WellFormed<'tcx> { impl<'tcx> fmt::Display for traits::FromEnv<'tcx> { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - use traits::FromEnv::*; + use crate::traits::FromEnv::*; match self { Trait(trait_ref) => write!(fmt, "FromEnv({})", trait_ref), @@ -228,7 +228,7 @@ impl<'tcx> fmt::Display for traits::FromEnv<'tcx> { impl<'tcx> fmt::Display for traits::DomainGoal<'tcx> { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - use traits::DomainGoal::*; + use crate::traits::DomainGoal::*; match self { Holds(wc) => write!(fmt, "{}", wc), @@ -246,7 +246,7 @@ impl<'tcx> fmt::Display for traits::DomainGoal<'tcx> { impl fmt::Display for traits::QuantifierKind { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - use traits::QuantifierKind::*; + use crate::traits::QuantifierKind::*; match self { Universal => write!(fmt, "forall"), @@ -361,7 +361,7 @@ impl<'tcx> TypeVisitor<'tcx> for BoundNamesCollector { impl<'tcx> fmt::Display for traits::Goal<'tcx> { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - use traits::GoalKind::*; + use crate::traits::GoalKind::*; match self { Implies(hypotheses, goal) => { @@ -420,7 +420,7 @@ impl<'tcx> fmt::Display for traits::ProgramClause<'tcx> { impl<'tcx> fmt::Display for traits::Clause<'tcx> { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { - use traits::Clause::*; + use crate::traits::Clause::*; match self { Implies(clause) => write!(fmt, "{}", clause), diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs index 5b7ba5386725e..67c919ac91610 100644 --- a/src/librustc/traits/util.rs +++ b/src/librustc/traits/util.rs @@ -1,10 +1,10 @@ -use hir; -use hir::def_id::DefId; -use traits::specialize::specialization_graph::NodeItem; -use ty::{self, Ty, TyCtxt, ToPredicate, ToPolyTraitRef}; -use ty::outlives::Component; -use ty::subst::{Kind, Subst, Substs}; -use util::nodemap::FxHashSet; +use crate::hir; +use crate::hir::def_id::DefId; +use crate::traits::specialize::specialization_graph::NodeItem; +use crate::ty::{self, Ty, TyCtxt, ToPredicate, ToPolyTraitRef}; +use crate::ty::outlives::Component; +use crate::ty::subst::{Kind, Subst, Substs}; +use crate::util::nodemap::FxHashSet; use super::{Obligation, ObligationCause, PredicateObligation, SelectionContext, Normalized}; diff --git a/src/librustc/ty/_match.rs b/src/librustc/ty/_match.rs index 34b94d4217d8b..07fa441bb8076 100644 --- a/src/librustc/ty/_match.rs +++ b/src/librustc/ty/_match.rs @@ -1,6 +1,6 @@ -use ty::{self, Ty, TyCtxt}; -use ty::error::TypeError; -use ty::relate::{self, Relate, TypeRelation, RelateResult}; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::error::TypeError; +use crate::ty::relate::{self, Relate, TypeRelation, RelateResult}; /// A type "A" *matches* "B" if the fresh types in B could be /// substituted with values so as to make it equal to A. Matching is diff --git a/src/librustc/ty/adjustment.rs b/src/librustc/ty/adjustment.rs index 117112c0c75f4..68e7bd6e16abe 100644 --- a/src/librustc/ty/adjustment.rs +++ b/src/librustc/ty/adjustment.rs @@ -1,7 +1,7 @@ -use hir; -use hir::def_id::DefId; -use ty::{self, Ty, TyCtxt}; -use ty::subst::Substs; +use crate::hir; +use crate::hir::def_id::DefId; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::subst::Substs; /// Represents coercing a value to a different type of value. diff --git a/src/librustc/ty/binding.rs b/src/librustc/ty/binding.rs index 2ab14642406b1..1290141b0a6b0 100644 --- a/src/librustc/ty/binding.rs +++ b/src/librustc/ty/binding.rs @@ -1,6 +1,6 @@ -use hir::BindingAnnotation::*; -use hir::BindingAnnotation; -use hir::Mutability; +use crate::hir::BindingAnnotation::*; +use crate::hir::BindingAnnotation; +use crate::hir::Mutability; #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum BindingMode { diff --git a/src/librustc/ty/cast.rs b/src/librustc/ty/cast.rs index 0f067de3649bf..0b2112f42d595 100644 --- a/src/librustc/ty/cast.rs +++ b/src/librustc/ty/cast.rs @@ -1,7 +1,7 @@ // Helpers for handling cast expressions, used in both // typeck and codegen. -use ty::{self, Ty}; +use crate::ty::{self, Ty}; use syntax::ast; diff --git a/src/librustc/ty/codec.rs b/src/librustc/ty/codec.rs index e0e4d9c362a6c..c9775b1029315 100644 --- a/src/librustc/ty/codec.rs +++ b/src/librustc/ty/codec.rs @@ -6,15 +6,15 @@ // The functionality in here is shared between persisting to crate metadata and // persisting to incr. comp. caches. -use hir::def_id::{DefId, CrateNum}; -use infer::canonical::{CanonicalVarInfo, CanonicalVarInfos}; +use crate::hir::def_id::{DefId, CrateNum}; +use crate::infer::canonical::{CanonicalVarInfo, CanonicalVarInfos}; use rustc_data_structures::fx::FxHashMap; -use rustc_serialize::{Decodable, Decoder, Encoder, Encodable, opaque}; +use crate::rustc_serialize::{Decodable, Decoder, Encoder, Encodable, opaque}; use std::hash::Hash; use std::intrinsics; -use ty::{self, Ty, TyCtxt}; -use ty::subst::Substs; -use mir::interpret::Allocation; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::subst::Substs; +use crate::mir::interpret::Allocation; /// The shorthand encoding uses an enum's variant index `usize` /// and is offset by this value so it never matches a real variant. @@ -283,7 +283,7 @@ macro_rules! implement_ty_decoder { use $crate::ty::codec::*; use $crate::ty::subst::Substs; use $crate::hir::def_id::{CrateNum}; - use rustc_serialize::{Decoder, SpecializedDecoder}; + use crate::rustc_serialize::{Decoder, SpecializedDecoder}; use std::borrow::Cow; impl<$($typaram ),*> Decoder for $DecoderName<$($typaram),*> { diff --git a/src/librustc/ty/constness.rs b/src/librustc/ty/constness.rs index 3741f4051b896..1bb6386728917 100644 --- a/src/librustc/ty/constness.rs +++ b/src/librustc/ty/constness.rs @@ -1,9 +1,9 @@ -use ty::query::Providers; -use hir::def_id::DefId; -use hir; -use ty::TyCtxt; +use crate::ty::query::Providers; +use crate::hir::def_id::DefId; +use crate::hir; +use crate::ty::TyCtxt; use syntax_pos::symbol::Symbol; -use hir::map::blocks::FnLikeNode; +use crate::hir::map::blocks::FnLikeNode; use syntax::attr; impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> { diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index b379b5ba02494..140c772256d3f 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -1,48 +1,48 @@ //! type context book-keeping -use dep_graph::DepGraph; -use dep_graph::{DepNode, DepConstructor}; -use errors::DiagnosticBuilder; -use session::Session; -use session::config::{BorrowckMode, OutputFilenames}; -use session::config::CrateType; -use middle; -use hir::{TraitCandidate, HirId, ItemKind, ItemLocalId, Node}; -use hir::def::{Def, Export}; -use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE}; -use hir::map as hir_map; -use hir::map::DefPathHash; -use lint::{self, Lint}; -use ich::{StableHashingContext, NodeIdHashingMode}; -use infer::canonical::{Canonical, CanonicalVarInfo, CanonicalVarInfos}; -use infer::outlives::free_region_map::FreeRegionMap; -use middle::cstore::CrateStoreDyn; -use middle::cstore::EncodedMetadata; -use middle::lang_items; -use middle::resolve_lifetime::{self, ObjectLifetimeDefault}; -use middle::stability; -use mir::{self, Mir, interpret, ProjectionKind}; -use mir::interpret::Allocation; -use ty::subst::{Kind, Substs, Subst}; -use ty::ReprOptions; -use traits; -use traits::{Clause, Clauses, GoalKind, Goal, Goals}; -use ty::{self, Ty, TypeAndMut}; -use ty::{TyS, TyKind, List}; -use ty::{AdtKind, AdtDef, ClosureSubsts, GeneratorSubsts, Region, Const, LazyConst}; -use ty::{PolyFnSig, InferTy, ParamTy, ProjectionTy, ExistentialPredicate, Predicate}; -use ty::RegionKind; -use ty::{TyVar, TyVid, IntVar, IntVid, FloatVar, FloatVid}; -use ty::TyKind::*; -use ty::GenericParamDefKind; -use ty::layout::{LayoutDetails, TargetDataLayout, VariantIdx}; -use ty::query; -use ty::steal::Steal; -use ty::subst::{UserSubsts, UnpackedKind}; -use ty::{BoundVar, BindingMode}; -use ty::CanonicalPolyFnSig; -use util::nodemap::{DefIdMap, DefIdSet, ItemLocalMap}; -use util::nodemap::{FxHashMap, FxHashSet}; +use crate::dep_graph::DepGraph; +use crate::dep_graph::{DepNode, DepConstructor}; +use crate::errors::DiagnosticBuilder; +use crate::session::Session; +use crate::session::config::{BorrowckMode, OutputFilenames}; +use crate::session::config::CrateType; +use crate::middle; +use crate::hir::{TraitCandidate, HirId, ItemKind, ItemLocalId, Node}; +use crate::hir::def::{Def, Export}; +use crate::hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE}; +use crate::hir::map as hir_map; +use crate::hir::map::DefPathHash; +use crate::lint::{self, Lint}; +use crate::ich::{StableHashingContext, NodeIdHashingMode}; +use crate::infer::canonical::{Canonical, CanonicalVarInfo, CanonicalVarInfos}; +use crate::infer::outlives::free_region_map::FreeRegionMap; +use crate::middle::cstore::CrateStoreDyn; +use crate::middle::cstore::EncodedMetadata; +use crate::middle::lang_items; +use crate::middle::resolve_lifetime::{self, ObjectLifetimeDefault}; +use crate::middle::stability; +use crate::mir::{self, Mir, interpret, ProjectionKind}; +use crate::mir::interpret::Allocation; +use crate::ty::subst::{Kind, Substs, Subst}; +use crate::ty::ReprOptions; +use crate::traits; +use crate::traits::{Clause, Clauses, GoalKind, Goal, Goals}; +use crate::ty::{self, Ty, TypeAndMut}; +use crate::ty::{TyS, TyKind, List}; +use crate::ty::{AdtKind, AdtDef, ClosureSubsts, GeneratorSubsts, Region, Const, LazyConst}; +use crate::ty::{PolyFnSig, InferTy, ParamTy, ProjectionTy, ExistentialPredicate, Predicate}; +use crate::ty::RegionKind; +use crate::ty::{TyVar, TyVid, IntVar, IntVid, FloatVar, FloatVid}; +use crate::ty::TyKind::*; +use crate::ty::GenericParamDefKind; +use crate::ty::layout::{LayoutDetails, TargetDataLayout, VariantIdx}; +use crate::ty::query; +use crate::ty::steal::Steal; +use crate::ty::subst::{UserSubsts, UnpackedKind}; +use crate::ty::{BoundVar, BindingMode}; +use crate::ty::CanonicalPolyFnSig; +use crate::util::nodemap::{DefIdMap, DefIdSet, ItemLocalMap}; +use crate::util::nodemap::{FxHashMap, FxHashSet}; use rustc_data_structures::interner::HashInterner; use smallvec::SmallVec; use rustc_data_structures::stable_hasher::{HashStable, hash_stable_hashmap, @@ -73,7 +73,7 @@ use syntax::feature_gate; use syntax::symbol::{Symbol, keywords, InternedString}; use syntax_pos::Span; -use hir; +use crate::hir; pub struct AllArenas<'tcx> { pub global: WorkerLocal>, @@ -1822,18 +1822,18 @@ pub mod tls { use std::marker::PhantomData; use std::ptr; use syntax_pos; - use ty::query; - use errors::{Diagnostic, TRACK_DIAGNOSTICS}; + use crate::ty::query; + use crate::errors::{Diagnostic, TRACK_DIAGNOSTICS}; use rustc_data_structures::OnDrop; use rustc_data_structures::sync::{self, Lrc, Lock}; use rustc_data_structures::thin_vec::ThinVec; - use dep_graph::TaskDeps; + use crate::dep_graph::TaskDeps; #[cfg(not(parallel_compiler))] use std::cell::Cell; #[cfg(parallel_compiler)] - use rayon_core; + use rustc_rayon_core as rayon_core; /// This is the implicit state of rustc. It contains the current /// TyCtxt and query. It is updated when creating a local interner or @@ -2114,8 +2114,8 @@ macro_rules! sty_debug_print { // variable names. #[allow(non_snake_case)] mod inner { - use ty::{self, TyCtxt}; - use ty::context::Interned; + use crate::ty::{self, TyCtxt}; + use crate::ty::context::Interned; #[derive(Copy, Clone)] struct DebugStat { diff --git a/src/librustc/ty/erase_regions.rs b/src/librustc/ty/erase_regions.rs index da7e021b2d54b..0431afcc76c9e 100644 --- a/src/librustc/ty/erase_regions.rs +++ b/src/librustc/ty/erase_regions.rs @@ -1,5 +1,5 @@ -use ty::{self, Ty, TyCtxt, TypeFlags}; -use ty::fold::{TypeFolder, TypeFoldable}; +use crate::ty::{self, Ty, TyCtxt, TypeFlags}; +use crate::ty::fold::{TypeFolder, TypeFoldable}; pub(super) fn provide(providers: &mut ty::query::Providers<'_>) { *providers = ty::query::Providers { diff --git a/src/librustc/ty/error.rs b/src/librustc/ty/error.rs index f444013e2a3bd..d0c9677ea6ecb 100644 --- a/src/librustc/ty/error.rs +++ b/src/librustc/ty/error.rs @@ -1,13 +1,13 @@ -use hir::def_id::DefId; -use ty::{self, Region, Ty, TyCtxt}; +use crate::hir::def_id::DefId; +use crate::ty::{self, Region, Ty, TyCtxt}; use std::borrow::Cow; use std::fmt; use rustc_target::spec::abi; use syntax::ast; -use errors::{Applicability, DiagnosticBuilder}; +use crate::errors::{Applicability, DiagnosticBuilder}; use syntax_pos::Span; -use hir; +use crate::hir; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct ExpectedFound { diff --git a/src/librustc/ty/fast_reject.rs b/src/librustc/ty/fast_reject.rs index 2b41fc4fe341f..59ab4561f2c87 100644 --- a/src/librustc/ty/fast_reject.rs +++ b/src/librustc/ty/fast_reject.rs @@ -1,12 +1,12 @@ -use hir::def_id::DefId; -use ich::StableHashingContext; +use crate::hir::def_id::DefId; +use crate::ich::StableHashingContext; use rustc_data_structures::stable_hasher::{StableHasher, StableHasherResult, HashStable}; use std::fmt::Debug; use std::hash::Hash; use std::mem; use syntax::ast; -use ty::{self, Ty, TyCtxt}; +use crate::ty::{self, Ty, TyCtxt}; use self::SimplifiedTypeGen::*; diff --git a/src/librustc/ty/flags.rs b/src/librustc/ty/flags.rs index 4fa13a01d5a92..25ec3e49cdf67 100644 --- a/src/librustc/ty/flags.rs +++ b/src/librustc/ty/flags.rs @@ -1,5 +1,5 @@ -use ty::subst::Substs; -use ty::{self, Ty, TypeFlags, TypeFoldable}; +use crate::ty::subst::Substs; +use crate::ty::{self, Ty, TypeFlags, TypeFoldable}; #[derive(Debug)] pub struct FlagComputation { diff --git a/src/librustc/ty/fold.rs b/src/librustc/ty/fold.rs index 28b6f010ce09c..306c69666e596 100644 --- a/src/librustc/ty/fold.rs +++ b/src/librustc/ty/fold.rs @@ -29,12 +29,12 @@ //! These methods return true to indicate that the visitor has found what it is looking for //! and does not need to visit anything else. -use hir::def_id::DefId; -use ty::{self, Binder, Ty, TyCtxt, TypeFlags}; +use crate::hir::def_id::DefId; +use crate::ty::{self, Binder, Ty, TyCtxt, TypeFlags}; use std::collections::BTreeMap; use std::fmt; -use util::nodemap::FxHashSet; +use crate::util::nodemap::FxHashSet; /// The TypeFoldable trait is implemented for every type that can be folded. /// Basically, every type that has a corresponding method in TypeFolder. diff --git a/src/librustc/ty/inhabitedness/def_id_forest.rs b/src/librustc/ty/inhabitedness/def_id_forest.rs index 41fd88607e893..73b7d74d9dafe 100644 --- a/src/librustc/ty/inhabitedness/def_id_forest.rs +++ b/src/librustc/ty/inhabitedness/def_id_forest.rs @@ -1,8 +1,8 @@ use std::mem; use smallvec::SmallVec; use syntax::ast::CRATE_NODE_ID; -use ty::context::TyCtxt; -use ty::{DefId, DefIdTree}; +use crate::ty::context::TyCtxt; +use crate::ty::{DefId, DefIdTree}; /// Represents a forest of DefIds closed under the ancestor relation. That is, /// if a DefId representing a module is contained in the forest then all diff --git a/src/librustc/ty/inhabitedness/mod.rs b/src/librustc/ty/inhabitedness/mod.rs index 6dfc9681cfd86..601ffe70eec18 100644 --- a/src/librustc/ty/inhabitedness/mod.rs +++ b/src/librustc/ty/inhabitedness/mod.rs @@ -1,8 +1,8 @@ -use ty::context::TyCtxt; -use ty::{AdtDef, VariantDef, FieldDef, Ty, TyS}; -use ty::{self, DefId, Substs}; -use ty::{AdtKind, Visibility}; -use ty::TyKind::*; +use crate::ty::context::TyCtxt; +use crate::ty::{AdtDef, VariantDef, FieldDef, Ty, TyS}; +use crate::ty::{self, DefId, Substs}; +use crate::ty::{AdtKind, Visibility}; +use crate::ty::TyKind::*; pub use self::def_id_forest::DefIdForest; diff --git a/src/librustc/ty/instance.rs b/src/librustc/ty/instance.rs index bc43fedef0f34..e4fe93d5deaea 100644 --- a/src/librustc/ty/instance.rs +++ b/src/librustc/ty/instance.rs @@ -1,9 +1,9 @@ -use hir::Unsafety; -use hir::def_id::DefId; -use ty::{self, Ty, PolyFnSig, TypeFoldable, Substs, TyCtxt}; -use traits; +use crate::hir::Unsafety; +use crate::hir::def_id::DefId; +use crate::ty::{self, Ty, PolyFnSig, TypeFoldable, Substs, TyCtxt}; +use crate::traits; use rustc_target::spec::abi::Abi; -use util::ppaux; +use crate::util::ppaux; use std::fmt; use std::iter; @@ -141,7 +141,7 @@ impl<'tcx> InstanceDef<'tcx> { &self, tcx: TyCtxt<'a, 'tcx, 'tcx> ) -> bool { - use hir::map::DefPathData; + use crate::hir::map::DefPathData; let def_id = match *self { ty::InstanceDef::Item(def_id) => def_id, ty::InstanceDef::DropGlue(_, Some(_)) => return false, diff --git a/src/librustc/ty/item_path.rs b/src/librustc/ty/item_path.rs index adb7e1fb3e322..f89e50d696945 100644 --- a/src/librustc/ty/item_path.rs +++ b/src/librustc/ty/item_path.rs @@ -1,8 +1,8 @@ -use hir; -use hir::map::DefPathData; -use hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE}; -use ty::{self, DefIdTree, Ty, TyCtxt}; -use middle::cstore::{ExternCrate, ExternCrateSource}; +use crate::hir; +use crate::hir::map::DefPathData; +use crate::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE}; +use crate::ty::{self, DefIdTree, Ty, TyCtxt}; +use crate::middle::cstore::{ExternCrate, ExternCrateSource}; use syntax::ast; use syntax::symbol::{keywords, LocalInternedString, Symbol}; diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs index 1162bff852cbb..8401d0861cad2 100644 --- a/src/librustc/ty/layout.rs +++ b/src/librustc/ty/layout.rs @@ -1,5 +1,5 @@ -use session::{self, DataTypeKind}; -use ty::{self, Ty, TyCtxt, TypeFoldable, ReprOptions}; +use crate::session::{self, DataTypeKind}; +use crate::ty::{self, Ty, TyCtxt, TypeFoldable, ReprOptions}; use syntax::ast::{self, Ident, IntTy, UintTy}; use syntax::attr; @@ -12,7 +12,7 @@ use std::iter; use std::mem; use std::ops::Bound; -use ich::StableHashingContext; +use crate::ich::StableHashingContext; use rustc_data_structures::indexed_vec::{IndexVec, Idx}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; @@ -1872,7 +1872,7 @@ impl<'a> HashStable> for Variants { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use ty::layout::Variants::*; + use crate::ty::layout::Variants::*; mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -1908,7 +1908,7 @@ impl<'a> HashStable> for FieldPlacement { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use ty::layout::FieldPlacement::*; + use crate::ty::layout::FieldPlacement::*; mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -1941,7 +1941,7 @@ impl<'a> HashStable> for Abi { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use ty::layout::Abi::*; + use crate::ty::layout::Abi::*; mem::discriminant(self).hash_stable(hcx, hasher); match *self { @@ -1975,7 +1975,7 @@ impl<'a> HashStable> for Scalar { } } -impl_stable_hash_for!(struct ::ty::layout::LayoutDetails { +impl_stable_hash_for!(struct crate::ty::layout::LayoutDetails { variants, fields, abi, @@ -1983,7 +1983,7 @@ impl_stable_hash_for!(struct ::ty::layout::LayoutDetails { align }); -impl_stable_hash_for!(enum ::ty::layout::Integer { +impl_stable_hash_for!(enum crate::ty::layout::Integer { I8, I16, I32, @@ -1991,13 +1991,13 @@ impl_stable_hash_for!(enum ::ty::layout::Integer { I128 }); -impl_stable_hash_for!(enum ::ty::layout::Primitive { +impl_stable_hash_for!(enum crate::ty::layout::Primitive { Int(integer, signed), Float(fty), Pointer }); -impl_stable_hash_for!(struct ::ty::layout::AbiAndPrefAlign { +impl_stable_hash_for!(struct crate::ty::layout::AbiAndPrefAlign { abi, pref }); @@ -2023,7 +2023,7 @@ impl<'a, 'gcx> HashStable> for LayoutError<'gcx> fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { - use ty::layout::LayoutError::*; + use crate::ty::layout::LayoutError::*; mem::discriminant(self).hash_stable(hcx, hasher); match *self { diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index c9089428b2324..60e3ac673a0a0 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -4,31 +4,31 @@ pub use self::BorrowKind::*; pub use self::IntVarValue::*; pub use self::fold::TypeFoldable; -use hir::{map as hir_map, FreevarMap, GlobMap, TraitMap}; -use hir::Node; -use hir::def::{Def, CtorKind, ExportMap}; -use hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE}; -use hir::map::DefPathData; +use crate::hir::{map as hir_map, FreevarMap, GlobMap, TraitMap}; +use crate::hir::Node; +use crate::hir::def::{Def, CtorKind, ExportMap}; +use crate::hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE}; +use crate::hir::map::DefPathData; use rustc_data_structures::svh::Svh; -use ich::Fingerprint; -use ich::StableHashingContext; -use infer::canonical::Canonical; -use middle::lang_items::{FnTraitLangItem, FnMutTraitLangItem, FnOnceTraitLangItem}; -use middle::resolve_lifetime::ObjectLifetimeDefault; -use mir::Mir; -use mir::interpret::{GlobalId, ErrorHandled}; -use mir::GeneratorLayout; -use session::CrateDisambiguator; -use traits::{self, Reveal}; -use ty; -use ty::layout::VariantIdx; -use ty::subst::{Subst, Substs}; -use ty::util::{IntTypeExt, Discr}; -use ty::walk::TypeWalker; -use util::captures::Captures; -use util::nodemap::{NodeSet, DefIdMap, FxHashMap}; +use crate::ich::Fingerprint; +use crate::ich::StableHashingContext; +use crate::infer::canonical::Canonical; +use crate::middle::lang_items::{FnTraitLangItem, FnMutTraitLangItem, FnOnceTraitLangItem}; +use crate::middle::resolve_lifetime::ObjectLifetimeDefault; +use crate::mir::Mir; +use crate::mir::interpret::{GlobalId, ErrorHandled}; +use crate::mir::GeneratorLayout; +use crate::session::CrateDisambiguator; +use crate::traits::{self, Reveal}; +use crate::ty; +use crate::ty::layout::VariantIdx; +use crate::ty::subst::{Subst, Substs}; +use crate::ty::util::{IntTypeExt, Discr}; +use crate::ty::walk::TypeWalker; +use crate::util::captures::Captures; +use crate::util::nodemap::{NodeSet, DefIdMap, FxHashMap}; use arena::SyncDroplessArena; -use session::DataTypeKind; +use crate::session::DataTypeKind; use serialize::{self, Encodable, Encoder}; use std::cell::RefCell; @@ -50,7 +50,7 @@ use rustc_data_structures::indexed_vec::{Idx, IndexVec}; use rustc_data_structures::stable_hasher::{StableHasher, StableHasherResult, HashStable}; -use hir; +use crate::hir; pub use self::sty::{Binder, BoundTy, BoundTyKind, BoundVar, DebruijnIndex, INNERMOST}; pub use self::sty::{FnSig, GenSig, CanonicalPolyFnSig, PolyFnSig, PolyGenSig}; @@ -2277,7 +2277,7 @@ impl<'a, 'gcx, 'tcx> AdtDef { }) } else { info!("invalid enum discriminant: {:#?}", val); - ::mir::interpret::struct_error( + crate::mir::interpret::struct_error( tcx.at(tcx.def_span(expr_did)), "constant evaluation of enum discriminant resulted in non-integer", ).emit(); diff --git a/src/librustc/ty/outlives.rs b/src/librustc/ty/outlives.rs index ca2d5cd718c64..5b21ed5abd77b 100644 --- a/src/librustc/ty/outlives.rs +++ b/src/librustc/ty/outlives.rs @@ -3,7 +3,7 @@ // RFC for reference. use smallvec::SmallVec; -use ty::{self, Ty, TyCtxt, TypeFoldable}; +use crate::ty::{self, Ty, TyCtxt, TypeFoldable}; #[derive(Debug)] pub enum Component<'tcx> { diff --git a/src/librustc/ty/query/config.rs b/src/librustc/ty/query/config.rs index 495cce4d2feac..255e39eaccd6d 100644 --- a/src/librustc/ty/query/config.rs +++ b/src/librustc/ty/query/config.rs @@ -1,19 +1,19 @@ -use dep_graph::SerializedDepNodeIndex; -use dep_graph::DepNode; -use hir::def_id::{CrateNum, DefId, DefIndex}; -use mir::interpret::GlobalId; -use traits; -use traits::query::{ +use crate::dep_graph::SerializedDepNodeIndex; +use crate::dep_graph::DepNode; +use crate::hir::def_id::{CrateNum, DefId, DefIndex}; +use crate::mir::interpret::GlobalId; +use crate::traits; +use crate::traits::query::{ CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal, CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpNormalizeGoal, CanonicalTypeOpProvePredicateGoal, CanonicalTypeOpSubtypeGoal, }; -use ty::{self, ParamEnvAnd, Ty, TyCtxt}; -use ty::subst::Substs; -use ty::query::queries; -use ty::query::Query; -use ty::query::QueryCache; -use util::profiling::ProfileCategory; +use crate::ty::{self, ParamEnvAnd, Ty, TyCtxt}; +use crate::ty::subst::Substs; +use crate::ty::query::queries; +use crate::ty::query::Query; +use crate::ty::query::QueryCache; +use crate::util::profiling::ProfileCategory; use std::borrow::Cow; use std::hash::Hash; @@ -21,7 +21,7 @@ use std::fmt::Debug; use syntax_pos::symbol::InternedString; use rustc_data_structures::sync::Lock; use rustc_data_structures::stable_hasher::HashStable; -use ich::StableHashingContext; +use crate::ich::StableHashingContext; // Query configuration and description traits. @@ -901,7 +901,7 @@ impl<'tcx> QueryDescription<'tcx> for queries::optimized_mir<'tcx> { fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, id: SerializedDepNodeIndex) -> Option { - let mir: Option<::mir::Mir<'tcx>> = tcx.queries.on_disk_cache + let mir: Option> = tcx.queries.on_disk_cache .try_load_query_result(tcx, id); mir.map(|x| tcx.alloc_mir(x)) } diff --git a/src/librustc/ty/query/job.rs b/src/librustc/ty/query/job.rs index abbf74a7761ef..0793366e6d479 100644 --- a/src/librustc/ty/query/job.rs +++ b/src/librustc/ty/query/job.rs @@ -1,25 +1,27 @@ #![allow(warnings)] use std::mem; +use std::process; +use std::{fmt, ptr}; + use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::sync::{Lock, LockGuard, Lrc, Weak}; use rustc_data_structures::OnDrop; use syntax_pos::Span; -use ty::tls; -use ty::query::Query; -use ty::query::plumbing::CycleError; + +use crate::ty::tls; +use crate::ty::query::Query; +use crate::ty::query::plumbing::CycleError; #[cfg(not(parallel_compiler))] -use ty::query::{ +use crate::ty::query::{ plumbing::TryGetJob, config::QueryDescription, }; -use ty::context::TyCtxt; -use std::process; -use std::{fmt, ptr}; +use crate::ty::context::TyCtxt; #[cfg(parallel_compiler)] use { - rayon_core, + rustc_rayon_core as rayon_core, parking_lot::{Mutex, Condvar}, std::sync::atomic::Ordering, std::thread, @@ -89,7 +91,7 @@ impl<'tcx> QueryJob<'tcx> { /// For single threaded rustc there's no concurrent jobs running, so if we are waiting for any /// query that means that there is a query cycle, thus this always running a cycle error. #[cfg(parallel_compiler)] - pub(super) fn await<'lcx>( + pub(super) fn r#await<'lcx>( &self, tcx: TyCtxt<'_, 'tcx, 'lcx>, span: Span, @@ -101,7 +103,7 @@ impl<'tcx> QueryJob<'tcx> { cycle: Lock::new(None), condvar: Condvar::new(), }); - self.latch.await(&waiter); + self.latch.r#await(&waiter); // FIXME: Get rid of this lock. We have ownership of the QueryWaiter // although another thread may still have a Lrc reference so we cannot // use Lrc::get_mut @@ -200,7 +202,7 @@ impl<'tcx> QueryLatch<'tcx> { } /// Awaits the caller on this latch by blocking the current thread. - fn await(&self, waiter: &Lrc>) { + fn r#await(&self, waiter: &Lrc>) { let mut info = self.info.lock(); if !info.complete { // We push the waiter on to the `waiters` list. It can be accessed inside diff --git a/src/librustc/ty/query/keys.rs b/src/librustc/ty/query/keys.rs index af6f5a00dee5c..f5eb7374cc19b 100644 --- a/src/librustc/ty/query/keys.rs +++ b/src/librustc/ty/query/keys.rs @@ -1,12 +1,12 @@ //! Defines the set of legal keys that can be used in queries. -use infer::canonical::Canonical; -use hir::def_id::{CrateNum, DefId, LOCAL_CRATE, DefIndex}; -use traits; -use ty::{self, Ty, TyCtxt}; -use ty::subst::Substs; -use ty::fast_reject::SimplifiedType; -use mir; +use crate::infer::canonical::Canonical; +use crate::hir::def_id::{CrateNum, DefId, LOCAL_CRATE, DefIndex}; +use crate::traits; +use crate::ty::{self, Ty, TyCtxt}; +use crate::ty::subst::Substs; +use crate::ty::fast_reject::SimplifiedType; +use crate::mir; use std::fmt::Debug; use std::hash::Hash; diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs index d4884e712b860..20a700bb58dd1 100644 --- a/src/librustc/ty/query/mod.rs +++ b/src/librustc/ty/query/mod.rs @@ -1,48 +1,48 @@ -use dep_graph::{DepConstructor, DepNode}; -use errors::DiagnosticBuilder; -use hir::def_id::{CrateNum, DefId, DefIndex}; -use hir::def::{Def, Export}; -use hir::{self, TraitCandidate, ItemLocalId, CodegenFnAttrs}; +use crate::dep_graph::{DepConstructor, DepNode}; +use crate::errors::DiagnosticBuilder; +use crate::hir::def_id::{CrateNum, DefId, DefIndex}; +use crate::hir::def::{Def, Export}; +use crate::hir::{self, TraitCandidate, ItemLocalId, CodegenFnAttrs}; use rustc_data_structures::svh::Svh; -use infer::canonical::{self, Canonical}; -use lint; -use middle::borrowck::BorrowCheckResult; -use middle::cstore::{ExternCrate, LinkagePreference, NativeLibrary, ForeignModule}; -use middle::cstore::{NativeLibraryKind, DepKind, CrateSource}; -use middle::privacy::AccessLevels; -use middle::reachable::ReachableSet; -use middle::region; -use middle::resolve_lifetime::{ResolveLifetimes, Region, ObjectLifetimeDefault}; -use middle::stability::{self, DeprecationEntry}; -use middle::lib_features::LibFeatures; -use middle::lang_items::{LanguageItems, LangItem}; -use middle::exported_symbols::{SymbolExportLevel, ExportedSymbol}; -use mir::interpret::{ConstEvalRawResult, ConstEvalResult}; -use mir::mono::CodegenUnit; -use mir; -use mir::interpret::GlobalId; -use session::{CompileResult, CrateDisambiguator}; -use session::config::{EntryFnType, OutputFilenames, OptLevel}; -use traits::{self, Vtable}; -use traits::query::{ +use crate::infer::canonical::{self, Canonical}; +use crate::lint; +use crate::middle::borrowck::BorrowCheckResult; +use crate::middle::cstore::{ExternCrate, LinkagePreference, NativeLibrary, ForeignModule}; +use crate::middle::cstore::{NativeLibraryKind, DepKind, CrateSource}; +use crate::middle::privacy::AccessLevels; +use crate::middle::reachable::ReachableSet; +use crate::middle::region; +use crate::middle::resolve_lifetime::{ResolveLifetimes, Region, ObjectLifetimeDefault}; +use crate::middle::stability::{self, DeprecationEntry}; +use crate::middle::lib_features::LibFeatures; +use crate::middle::lang_items::{LanguageItems, LangItem}; +use crate::middle::exported_symbols::{SymbolExportLevel, ExportedSymbol}; +use crate::mir::interpret::{ConstEvalRawResult, ConstEvalResult}; +use crate::mir::mono::CodegenUnit; +use crate::mir; +use crate::mir::interpret::GlobalId; +use crate::session::{CompileResult, CrateDisambiguator}; +use crate::session::config::{EntryFnType, OutputFilenames, OptLevel}; +use crate::traits::{self, Vtable}; +use crate::traits::query::{ CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal, CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpSubtypeGoal, CanonicalTypeOpProvePredicateGoal, CanonicalTypeOpNormalizeGoal, NoSolution, }; -use traits::query::method_autoderef::MethodAutoderefStepsResult; -use traits::query::dropck_outlives::{DtorckConstraint, DropckOutlivesResult}; -use traits::query::normalize::NormalizationResult; -use traits::query::outlives_bounds::OutlivesBound; -use traits::specialization_graph; -use traits::Clauses; -use ty::{self, CrateInherentImpls, ParamEnvAnd, Ty, TyCtxt}; -use ty::steal::Steal; -use ty::subst::Substs; -use util::nodemap::{DefIdSet, DefIdMap, ItemLocalSet}; -use util::common::{ErrorReported}; -use util::profiling::ProfileCategory::*; -use session::Session; +use crate::traits::query::method_autoderef::MethodAutoderefStepsResult; +use crate::traits::query::dropck_outlives::{DtorckConstraint, DropckOutlivesResult}; +use crate::traits::query::normalize::NormalizationResult; +use crate::traits::query::outlives_bounds::OutlivesBound; +use crate::traits::specialization_graph; +use crate::traits::Clauses; +use crate::ty::{self, CrateInherentImpls, ParamEnvAnd, Ty, TyCtxt}; +use crate::ty::steal::Steal; +use crate::ty::subst::Substs; +use crate::util::nodemap::{DefIdSet, DefIdMap, ItemLocalSet}; +use crate::util::common::{ErrorReported}; +use crate::util::profiling::ProfileCategory::*; +use crate::session::Session; use rustc_data_structures::bit_set::BitSet; use rustc_data_structures::indexed_vec::IndexVec; diff --git a/src/librustc/ty/query/on_disk_cache.rs b/src/librustc/ty/query/on_disk_cache.rs index a3f49de0d078b..9c9bc0f6aa11c 100644 --- a/src/librustc/ty/query/on_disk_cache.rs +++ b/src/librustc/ty/query/on_disk_cache.rs @@ -1,28 +1,28 @@ -use dep_graph::{DepNodeIndex, SerializedDepNodeIndex}; -use errors::Diagnostic; -use hir; -use hir::def_id::{CrateNum, DefIndex, DefId, LocalDefId, LOCAL_CRATE}; -use hir::map::definitions::DefPathHash; -use ich::{CachingSourceMapView, Fingerprint}; -use mir::{self, interpret}; -use mir::interpret::{AllocDecodingSession, AllocDecodingState}; +use crate::dep_graph::{DepNodeIndex, SerializedDepNodeIndex}; +use crate::errors::Diagnostic; +use crate::hir; +use crate::hir::def_id::{CrateNum, DefIndex, DefId, LocalDefId, LOCAL_CRATE}; +use crate::hir::map::definitions::DefPathHash; +use crate::ich::{CachingSourceMapView, Fingerprint}; +use crate::mir::{self, interpret}; +use crate::mir::interpret::{AllocDecodingSession, AllocDecodingState}; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::thin_vec::ThinVec; use rustc_data_structures::sync::{Lrc, Lock, HashMapExt, Once}; use rustc_data_structures::indexed_vec::{IndexVec, Idx}; -use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque, +use crate::rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque, SpecializedDecoder, SpecializedEncoder, UseSpecializedDecodable, UseSpecializedEncodable}; -use session::{CrateDisambiguator, Session}; +use crate::session::{CrateDisambiguator, Session}; use std::mem; use syntax::ast::NodeId; use syntax::source_map::{SourceMap, StableSourceFileId}; use syntax_pos::{BytePos, Span, DUMMY_SP, SourceFile}; use syntax_pos::hygiene::{Mark, SyntaxContext, ExpnInfo}; -use ty; -use ty::codec::{self as ty_codec, TyDecoder, TyEncoder}; -use ty::context::TyCtxt; -use util::common::time; +use crate::ty; +use crate::ty::codec::{self as ty_codec, TyDecoder, TyEncoder}; +use crate::ty::context::TyCtxt; +use crate::util::common::time; const TAG_FILE_FOOTER: u128 = 0xC0FFEE_C0FFEE_C0FFEE_C0FFEE_C0FFEE; @@ -202,7 +202,7 @@ impl<'sess> OnDiskCache<'sess> { let mut query_result_index = EncodedQueryResultIndex::new(); time(tcx.sess, "encode query results", || { - use ty::query::queries::*; + use crate::ty::query::queries::*; let enc = &mut encoder; let qri = &mut query_result_index; @@ -225,11 +225,11 @@ impl<'sess> OnDiskCache<'sess> { encode_query_results::, _>(tcx, enc, qri)?; // const eval is special, it only encodes successfully evaluated constants - use ty::query::QueryAccessors; + use crate::ty::query::QueryAccessors; let cache = const_eval::query_cache(tcx).borrow(); assert!(cache.active.is_empty()); for (key, entry) in cache.results.iter() { - use ty::query::config::QueryDescription; + use crate::ty::query::config::QueryDescription; if const_eval::cache_on_disk(tcx, key.clone()) { if let Ok(ref value) = entry.value { let dep_node = SerializedDepNodeIndex::new(entry.index.index()); @@ -777,7 +777,7 @@ impl<'enc, 'a, 'tcx, E> CacheEncoder<'enc, 'a, 'tcx, E> value: &V) -> Result<(), E::Error> { - use ty::codec::TyEncoder; + use crate::ty::codec::TyEncoder; let start_pos = self.position(); tag.encode(self)?; diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs index 69bff8d25b024..a26b21a1059fe 100644 --- a/src/librustc/ty/query/plumbing.rs +++ b/src/librustc/ty/query/plumbing.rs @@ -2,19 +2,19 @@ //! that generate the actual methods on tcx which find and execute the //! provider, manage the caches, and so forth. -use dep_graph::{DepNodeIndex, DepNode, DepKind, SerializedDepNodeIndex}; -use errors::DiagnosticBuilder; -use errors::Level; -use errors::Diagnostic; -use errors::FatalError; -use ty::tls; -use ty::{TyCtxt}; -use ty::query::Query; -use ty::query::config::{QueryConfig, QueryDescription}; -use ty::query::job::{QueryJob, QueryResult, QueryInfo}; -use ty::item_path; - -use util::common::{profq_msg, ProfileQueriesMsg, QueryMsg}; +use crate::dep_graph::{DepNodeIndex, DepNode, DepKind, SerializedDepNodeIndex}; +use crate::errors::DiagnosticBuilder; +use crate::errors::Level; +use crate::errors::Diagnostic; +use crate::errors::FatalError; +use crate::ty::tls; +use crate::ty::{TyCtxt}; +use crate::ty::query::Query; +use crate::ty::query::config::{QueryConfig, QueryDescription}; +use crate::ty::query::job::{QueryJob, QueryResult, QueryInfo}; +use crate::ty::item_path; + +use crate::util::common::{profq_msg, ProfileQueriesMsg, QueryMsg}; use rustc_data_structures::fx::{FxHashMap}; use rustc_data_structures::sync::{Lrc, Lock}; @@ -160,7 +160,7 @@ impl<'a, 'tcx, Q: QueryDescription<'tcx>> JobOwner<'a, 'tcx, Q> { // thread #[cfg(parallel_compiler)] { - if let Err(cycle) = job.await(tcx, span) { + if let Err(cycle) = job.r#await(tcx, span) { return TryGetJob::JobCompleted(Err(cycle)); } } @@ -367,7 +367,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { // Fast path for when incr. comp. is off. `to_dep_node` is // expensive for some DepKinds. if !self.dep_graph.is_fully_enabled() { - let null_dep_node = DepNode::new_no_params(::dep_graph::DepKind::Null); + let null_dep_node = DepNode::new_no_params(crate::dep_graph::DepKind::Null); return Ok(self.force_query_with_job::(key, job, null_dep_node).0); } @@ -500,7 +500,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { dep_node_index: DepNodeIndex, ) { use rustc_data_structures::stable_hasher::{StableHasher, HashStable}; - use ich::Fingerprint; + use crate::ich::Fingerprint; assert!(Some(self.dep_graph.fingerprint_of(dep_node_index)) == self.dep_graph.prev_fingerprint_of(dep_node), @@ -566,7 +566,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { self.dep_graph.mark_loaded_from_cache(dep_node_index, false); } - if dep_node.kind != ::dep_graph::DepKind::Null { + if dep_node.kind != crate::dep_graph::DepKind::Null { if unlikely!(!diagnostics.is_empty()) { self.queries.on_disk_cache .store_diagnostics(dep_node_index, diagnostics); @@ -698,13 +698,13 @@ macro_rules! define_queries_inner { #[cfg(parallel_compiler)] use ty::query::job::QueryResult; use rustc_data_structures::sync::Lock; - use { + use crate::{ rustc_data_structures::stable_hasher::HashStable, rustc_data_structures::stable_hasher::StableHasherResult, rustc_data_structures::stable_hasher::StableHasher, ich::StableHashingContext }; - use util::profiling::ProfileCategory; + use crate::util::profiling::ProfileCategory; define_queries_struct! { tcx: $tcx, @@ -947,7 +947,7 @@ macro_rules! define_queries_inner { #[allow(unused)] #[inline(always)] fn to_dep_node(tcx: TyCtxt<'_, $tcx, '_>, key: &Self::Key) -> DepNode { - use dep_graph::DepConstructor::*; + use crate::dep_graph::DepConstructor::*; DepNode::new(tcx, $node(*key)) } @@ -1127,7 +1127,7 @@ macro_rules! define_provider_struct { pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>, dep_node: &DepNode) -> bool { - use hir::def_id::LOCAL_CRATE; + use crate::hir::def_id::LOCAL_CRATE; // We must avoid ever having to call force_from_dep_node() for a // DepNode::CodegenUnit: @@ -1167,7 +1167,7 @@ pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>, macro_rules! force { ($query:ident, $key:expr) => { { - tcx.force_query::<::ty::query::queries::$query<'_>>($key, DUMMY_SP, *dep_node); + tcx.force_query::>($key, DUMMY_SP, *dep_node); } } }; @@ -1437,8 +1437,8 @@ macro_rules! impl_load_from_cache { // Check whether the query invocation corresponding to the given // DepNode is eligible for on-disk-caching. pub fn cache_on_disk(&self, tcx: TyCtxt<'_, '_, '_>) -> bool { - use ty::query::queries; - use ty::query::QueryDescription; + use crate::ty::query::queries; + use crate::ty::query::QueryDescription; match self.kind { $(DepKind::$dep_kind => { diff --git a/src/librustc/ty/query/values.rs b/src/librustc/ty/query/values.rs index 3f84f1bc78972..11f55208d6e48 100644 --- a/src/librustc/ty/query/values.rs +++ b/src/librustc/ty/query/values.rs @@ -1,4 +1,4 @@ -use ty::{self, Ty, TyCtxt}; +use crate::ty::{self, Ty, TyCtxt}; use syntax::symbol::Symbol; diff --git a/src/librustc/ty/relate.rs b/src/librustc/ty/relate.rs index a16d6fea74c0b..3dbd0dc1d97f7 100644 --- a/src/librustc/ty/relate.rs +++ b/src/librustc/ty/relate.rs @@ -4,18 +4,18 @@ //! types or regions but can be other things. Examples of type relations are //! subtyping, type equality, etc. -use hir::def_id::DefId; -use ty::subst::{Kind, UnpackedKind, Substs}; -use ty::{self, Ty, TyCtxt, TypeFoldable}; -use ty::error::{ExpectedFound, TypeError}; -use mir::interpret::GlobalId; -use util::common::ErrorReported; +use crate::hir::def_id::DefId; +use crate::ty::subst::{Kind, UnpackedKind, Substs}; +use crate::ty::{self, Ty, TyCtxt, TypeFoldable}; +use crate::ty::error::{ExpectedFound, TypeError}; +use crate::mir::interpret::GlobalId; +use crate::util::common::ErrorReported; use syntax_pos::DUMMY_SP; use std::rc::Rc; use std::iter; use rustc_target::spec::abi; -use hir as ast; -use traits; +use crate::hir as ast; +use crate::traits; pub type RelateResult<'tcx, T> = Result>; @@ -588,7 +588,7 @@ impl<'tcx> Relate<'tcx> for &'tcx ty::List> { let tcx = relation.tcx(); let v = a.iter().zip(b.iter()).map(|(ep_a, ep_b)| { - use ty::ExistentialPredicate::*; + use crate::ty::ExistentialPredicate::*; match (*ep_a, *ep_b) { (Trait(ref a), Trait(ref b)) => Ok(Trait(relation.relate(a, b)?)), (Projection(ref a), Projection(ref b)) => Ok(Projection(relation.relate(a, b)?)), @@ -746,7 +746,7 @@ impl<'tcx> Relate<'tcx> for traits::WhereClause<'tcx> { ) -> RelateResult<'tcx, traits::WhereClause<'tcx>> where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'tcx, 'tcx: 'a { - use traits::WhereClause::*; + use crate::traits::WhereClause::*; match (a, b) { (Implemented(a_pred), Implemented(b_pred)) => { Ok(Implemented(relation.relate(a_pred, b_pred)?)) @@ -783,7 +783,7 @@ impl<'tcx> Relate<'tcx> for traits::WellFormed<'tcx> { ) -> RelateResult<'tcx, traits::WellFormed<'tcx>> where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'tcx, 'tcx: 'a { - use traits::WellFormed::*; + use crate::traits::WellFormed::*; match (a, b) { (Trait(a_pred), Trait(b_pred)) => Ok(Trait(relation.relate(a_pred, b_pred)?)), (Ty(a_ty), Ty(b_ty)) => Ok(Ty(relation.relate(a_ty, b_ty)?)), @@ -800,7 +800,7 @@ impl<'tcx> Relate<'tcx> for traits::FromEnv<'tcx> { ) -> RelateResult<'tcx, traits::FromEnv<'tcx>> where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'tcx, 'tcx: 'a { - use traits::FromEnv::*; + use crate::traits::FromEnv::*; match (a, b) { (Trait(a_pred), Trait(b_pred)) => Ok(Trait(relation.relate(a_pred, b_pred)?)), (Ty(a_ty), Ty(b_ty)) => Ok(Ty(relation.relate(a_ty, b_ty)?)), @@ -817,7 +817,7 @@ impl<'tcx> Relate<'tcx> for traits::DomainGoal<'tcx> { ) -> RelateResult<'tcx, traits::DomainGoal<'tcx>> where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'tcx, 'tcx: 'a { - use traits::DomainGoal::*; + use crate::traits::DomainGoal::*; match (a, b) { (Holds(a_wc), Holds(b_wc)) => Ok(Holds(relation.relate(a_wc, b_wc)?)), (WellFormed(a_wf), WellFormed(b_wf)) => Ok(WellFormed(relation.relate(a_wf, b_wf)?)), @@ -840,7 +840,7 @@ impl<'tcx> Relate<'tcx> for traits::Goal<'tcx> { ) -> RelateResult<'tcx, traits::Goal<'tcx>> where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'tcx, 'tcx: 'a { - use traits::GoalKind::*; + use crate::traits::GoalKind::*; match (a, b) { (Implies(a_clauses, a_goal), Implies(b_clauses, b_goal)) => { let clauses = relation.relate(a_clauses, b_clauses)?; @@ -904,7 +904,7 @@ impl<'tcx> Relate<'tcx> for traits::Clause<'tcx> { ) -> RelateResult<'tcx, traits::Clause<'tcx>> where R: TypeRelation<'a, 'gcx, 'tcx>, 'gcx: 'tcx, 'tcx: 'a { - use traits::Clause::*; + use crate::traits::Clause::*; match (a, b) { (Implies(a_clause), Implies(b_clause)) => { let clause = relation.relate(a_clause, b_clause)?; diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs index 28f5a65374d98..62a49238ebf3d 100644 --- a/src/librustc/ty/structural_impls.rs +++ b/src/librustc/ty/structural_impls.rs @@ -3,13 +3,13 @@ //! hand, though we've recently added some macros (e.g., //! `BraceStructLiftImpl!`) to help with the tedium. -use mir::ProjectionKind; -use mir::interpret::ConstValue; -use ty::{self, Lift, Ty, TyCtxt}; -use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; +use crate::mir::ProjectionKind; +use crate::mir::interpret::ConstValue; +use crate::ty::{self, Lift, Ty, TyCtxt}; +use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; use rustc_data_structures::indexed_vec::{IndexVec, Idx}; use smallvec::SmallVec; -use mir::interpret; +use crate::mir::interpret; use std::rc::Rc; @@ -23,35 +23,35 @@ CloneTypeFoldableAndLiftImpls! { (), bool, usize, - ::ty::layout::VariantIdx, + crate::ty::layout::VariantIdx, u64, String, - ::middle::region::Scope, + crate::middle::region::Scope, ::syntax::ast::FloatTy, ::syntax::ast::NodeId, ::syntax_pos::symbol::Symbol, - ::hir::def::Def, - ::hir::def_id::DefId, - ::hir::InlineAsm, - ::hir::MatchSource, - ::hir::Mutability, - ::hir::Unsafety, + crate::hir::def::Def, + crate::hir::def_id::DefId, + crate::hir::InlineAsm, + crate::hir::MatchSource, + crate::hir::Mutability, + crate::hir::Unsafety, ::rustc_target::spec::abi::Abi, - ::mir::Local, - ::mir::Promoted, - ::traits::Reveal, - ::ty::adjustment::AutoBorrowMutability, - ::ty::AdtKind, + crate::mir::Local, + crate::mir::Promoted, + crate::traits::Reveal, + crate::ty::adjustment::AutoBorrowMutability, + crate::ty::AdtKind, // Including `BoundRegion` is a *bit* dubious, but direct // references to bound region appear in `ty::Error`, and aren't // really meant to be folded. In general, we can only fold a fully // general `Region`. - ::ty::BoundRegion, - ::ty::ClosureKind, - ::ty::IntVarValue, - ::ty::ParamTy, - ::ty::UniverseIndex, - ::ty::Variance, + crate::ty::BoundRegion, + crate::ty::ClosureKind, + crate::ty::IntVarValue, + crate::ty::ParamTy, + crate::ty::UniverseIndex, + crate::ty::Variance, ::syntax_pos::Span, } @@ -421,7 +421,7 @@ impl<'tcx, T: Lift<'tcx>> Lift<'tcx> for ty::error::ExpectedFound { impl<'a, 'tcx> Lift<'tcx> for ty::error::TypeError<'a> { type Lifted = ty::error::TypeError<'tcx>; fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option { - use ty::error::TypeError::*; + use crate::ty::error::TypeError::*; Some(match *self { Mismatch => Mismatch, @@ -651,7 +651,7 @@ impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::List> { impl<'tcx> TypeFoldable<'tcx> for ty::instance::Instance<'tcx> { fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { - use ty::InstanceDef::*; + use crate::ty::InstanceDef::*; Self { substs: self.substs.fold_with(folder), def: match self.def { @@ -682,7 +682,7 @@ impl<'tcx> TypeFoldable<'tcx> for ty::instance::Instance<'tcx> { } fn super_visit_with>(&self, visitor: &mut V) -> bool { - use ty::InstanceDef::*; + use crate::ty::InstanceDef::*; self.substs.visit_with(visitor) || match self.def { Item(did) | VtableShim(did) | Intrinsic(did) | Virtual(did, _) => { diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index 671a0fc2d5d7a..790cc15ca17b6 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -1,17 +1,17 @@ //! This module contains `TyKind` and its major components. -use hir; -use hir::def_id::DefId; -use infer::canonical::Canonical; -use mir::interpret::ConstValue; -use middle::region; +use crate::hir; +use crate::hir::def_id::DefId; +use crate::infer::canonical::Canonical; +use crate::mir::interpret::ConstValue; +use crate::middle::region; use polonius_engine::Atom; use rustc_data_structures::indexed_vec::Idx; -use ty::subst::{Substs, Subst, Kind, UnpackedKind}; -use ty::{self, AdtDef, TypeFlags, Ty, TyCtxt, TypeFoldable}; -use ty::{List, TyS, ParamEnvAnd, ParamEnv}; -use util::captures::Captures; -use mir::interpret::{Scalar, Pointer}; +use crate::ty::subst::{Substs, Subst, Kind, UnpackedKind}; +use crate::ty::{self, AdtDef, TypeFlags, Ty, TyCtxt, TypeFoldable}; +use crate::ty::{List, TyS, ParamEnvAnd, ParamEnv}; +use crate::util::captures::Captures; +use crate::mir::interpret::{Scalar, Pointer}; use smallvec::SmallVec; use std::iter; @@ -550,7 +550,7 @@ impl<'a, 'gcx, 'tcx> ExistentialPredicate<'tcx> { impl<'a, 'gcx, 'tcx> Binder> { pub fn with_self_ty(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, self_ty: Ty<'tcx>) -> ty::Predicate<'tcx> { - use ty::ToPredicate; + use crate::ty::ToPredicate; match *self.skip_binder() { ExistentialPredicate::Trait(tr) => Binder(tr).with_self_ty(tcx, self_ty).to_predicate(), ExistentialPredicate::Projection(p) => diff --git a/src/librustc/ty/subst.rs b/src/librustc/ty/subst.rs index 64e7af815b4bf..d7c322d0f8402 100644 --- a/src/librustc/ty/subst.rs +++ b/src/librustc/ty/subst.rs @@ -1,9 +1,9 @@ // Type substitutions. -use hir::def_id::DefId; -use infer::canonical::Canonical; -use ty::{self, Lift, List, Ty, TyCtxt}; -use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; +use crate::hir::def_id::DefId; +use crate::infer::canonical::Canonical; +use crate::ty::{self, Lift, List, Ty, TyCtxt}; +use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; use serialize::{self, Encodable, Encoder, Decodable, Decoder}; use syntax_pos::{Span, DUMMY_SP}; diff --git a/src/librustc/ty/trait_def.rs b/src/librustc/ty/trait_def.rs index 37ec560d6c19f..5429a2504b97b 100644 --- a/src/librustc/ty/trait_def.rs +++ b/src/librustc/ty/trait_def.rs @@ -1,11 +1,11 @@ -use hir; -use hir::def_id::DefId; -use hir::map::DefPathHash; -use ich::{self, StableHashingContext}; -use traits::specialization_graph; -use ty::fast_reject; -use ty::fold::TypeFoldable; -use ty::{Ty, TyCtxt}; +use crate::hir; +use crate::hir::def_id::DefId; +use crate::hir::map::DefPathHash; +use crate::ich::{self, StableHashingContext}; +use crate::traits::specialization_graph; +use crate::ty::fast_reject; +use crate::ty::fold::TypeFoldable; +use crate::ty::{Ty, TyCtxt}; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::stable_hasher::{HashStable, StableHasher, diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs index 2fe47b2f032f8..61544932b4329 100644 --- a/src/librustc/ty/util.rs +++ b/src/librustc/ty/util.rs @@ -1,18 +1,18 @@ //! misc. type-system utilities too small to deserve their own file -use hir::def::Def; -use hir::def_id::DefId; -use hir::map::DefPathData; -use hir::{self, Node}; -use ich::NodeIdHashingMode; -use traits::{self, ObligationCause}; -use ty::{self, Ty, TyCtxt, GenericParamDefKind, TypeFoldable}; -use ty::subst::{Subst, Substs, UnpackedKind}; -use ty::query::TyCtxtAt; -use ty::TyKind::*; -use ty::layout::{Integer, IntegerExt}; -use util::common::ErrorReported; -use middle::lang_items; +use crate::hir::def::Def; +use crate::hir::def_id::DefId; +use crate::hir::map::DefPathData; +use crate::hir::{self, Node}; +use crate::ich::NodeIdHashingMode; +use crate::traits::{self, ObligationCause}; +use crate::ty::{self, Ty, TyCtxt, GenericParamDefKind, TypeFoldable}; +use crate::ty::subst::{Subst, Substs, UnpackedKind}; +use crate::ty::query::TyCtxtAt; +use crate::ty::TyKind::*; +use crate::ty::layout::{Integer, IntegerExt}; +use crate::util::common::ErrorReported; +use crate::middle::lang_items; use rustc_data_structures::stable_hasher::{StableHasher, HashStable}; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; diff --git a/src/librustc/ty/walk.rs b/src/librustc/ty/walk.rs index 6887d092fcd62..126f5290af513 100644 --- a/src/librustc/ty/walk.rs +++ b/src/librustc/ty/walk.rs @@ -1,7 +1,7 @@ //! An iterator over the type substructure. //! WARNING: this does not keep track of the region depth. -use ty::{self, Ty}; +use crate::ty::{self, Ty}; use smallvec::{self, SmallVec}; // The TypeWalker's stack is hot enough that it's worth going to some effort to diff --git a/src/librustc/ty/wf.rs b/src/librustc/ty/wf.rs index ef68394029680..2aae953c1c40a 100644 --- a/src/librustc/ty/wf.rs +++ b/src/librustc/ty/wf.rs @@ -1,12 +1,12 @@ -use hir::def_id::DefId; -use infer::InferCtxt; -use ty::subst::Substs; -use traits; -use ty::{self, ToPredicate, Ty, TyCtxt, TypeFoldable}; +use crate::hir::def_id::DefId; +use crate::infer::InferCtxt; +use crate::ty::subst::Substs; +use crate::traits; +use crate::ty::{self, ToPredicate, Ty, TyCtxt, TypeFoldable}; use std::iter::once; use syntax::ast; use syntax_pos::Span; -use middle::lang_items; +use crate::middle::lang_items; /// Returns the set of obligations needed to make `ty` well-formed. /// If `ty` contains unresolved inference variables, this may include diff --git a/src/librustc/util/bug.rs b/src/librustc/util/bug.rs index 7698f5ece98cc..02ddfab6d826e 100644 --- a/src/librustc/util/bug.rs +++ b/src/librustc/util/bug.rs @@ -1,6 +1,6 @@ // These functions are used by macro expansion for bug! and span_bug! -use ty::tls; +use crate::ty::tls; use std::fmt; use syntax_pos::{Span, MultiSpan}; diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index cc0ca165053d3..f6743ed75d92e 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -12,10 +12,10 @@ use std::time::{Duration, Instant}; use std::sync::mpsc::{Sender}; use syntax_pos::{SpanData}; -use ty::TyCtxt; -use dep_graph::{DepNode}; +use crate::ty::TyCtxt; +use crate::dep_graph::{DepNode}; use lazy_static; -use session::Session; +use crate::session::Session; // The name of the associated type for `Fn` return types pub const FN_OUTPUT_NAME: &str = "Output"; diff --git a/src/librustc/util/nodemap.rs b/src/librustc/util/nodemap.rs index fe6ab075a1a8a..6969b2f872ade 100644 --- a/src/librustc/util/nodemap.rs +++ b/src/librustc/util/nodemap.rs @@ -1,7 +1,7 @@ //! An efficient hash map for node IDs -use hir::def_id::DefId; -use hir::{HirId, ItemLocalId}; +use crate::hir::def_id::DefId; +use crate::hir::{HirId, ItemLocalId}; use syntax::ast; pub use rustc_data_structures::fx::FxHashMap; diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 51e9192cd290d..2cd82d44af3aa 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -1,15 +1,15 @@ -use hir::def_id::DefId; -use hir::map::definitions::DefPathData; -use middle::region; -use ty::subst::{self, Subst}; -use ty::{BrAnon, BrEnv, BrFresh, BrNamed}; -use ty::{Bool, Char, Adt}; -use ty::{Error, Str, Array, Slice, Float, FnDef, FnPtr}; -use ty::{Param, Bound, RawPtr, Ref, Never, Tuple}; -use ty::{Closure, Generator, GeneratorWitness, Foreign, Projection, Opaque}; -use ty::{Placeholder, UnnormalizedProjection, Dynamic, Int, Uint, Infer}; -use ty::{self, Ty, TyCtxt, TypeFoldable, GenericParamCount, GenericParamDefKind}; -use util::nodemap::FxHashSet; +use crate::hir::def_id::DefId; +use crate::hir::map::definitions::DefPathData; +use crate::middle::region; +use crate::ty::subst::{self, Subst}; +use crate::ty::{BrAnon, BrEnv, BrFresh, BrNamed}; +use crate::ty::{Bool, Char, Adt}; +use crate::ty::{Error, Str, Array, Slice, Float, FnDef, FnPtr}; +use crate::ty::{Param, Bound, RawPtr, Ref, Never, Tuple}; +use crate::ty::{Closure, Generator, GeneratorWitness, Foreign, Projection, Opaque}; +use crate::ty::{Placeholder, UnnormalizedProjection, Dynamic, Int, Uint, Infer}; +use crate::ty::{self, Ty, TyCtxt, TypeFoldable, GenericParamCount, GenericParamDefKind}; +use crate::util::nodemap::FxHashSet; use std::cell::Cell; use std::fmt; @@ -18,7 +18,7 @@ use std::usize; use rustc_target::spec::abi::Abi; use syntax::ast::CRATE_NODE_ID; use syntax::symbol::{Symbol, InternedString}; -use hir; +use crate::hir; /// The "region highlights" are used to control region printing during /// specific error messages. When a "region highlight" is enabled, it diff --git a/src/librustc/util/profiling.rs b/src/librustc/util/profiling.rs index d31a06d6cb82d..0e03946f82a5c 100644 --- a/src/librustc/util/profiling.rs +++ b/src/librustc/util/profiling.rs @@ -1,4 +1,4 @@ -use session::config::Options; +use crate::session::config::Options; use std::fs; use std::io::{self, StderrLock, Write}; From 55917ba0e74c44d13bd0ffc9cd134f8379959f28 Mon Sep 17 00:00:00 2001 From: Eric Huss Date: Sun, 3 Feb 2019 14:42:29 -0800 Subject: [PATCH 091/278] Update cargo --- Cargo.lock | 30 +++++++++++++++--------------- src/tools/cargo | 2 +- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b52f2094584ce..4cea89ea0415f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -75,8 +75,8 @@ dependencies = [ "colored 1.6.0 (registry+https://github.com/rust-lang/crates.io-index)", "difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "environment 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", - "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", - "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", + "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", + "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -237,7 +237,7 @@ dependencies = [ "curl 0.4.19 (registry+https://github.com/rust-lang/crates.io-index)", "curl-sys 0.4.15 (registry+https://github.com/rust-lang/crates.io-index)", "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)", - "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", + "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "filetime 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)", "flate2 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)", "fs2 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)", @@ -530,7 +530,7 @@ name = "crates-io" version = "0.23.0" dependencies = [ "curl 0.4.19 (registry+https://github.com/rust-lang/crates.io-index)", - "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", + "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)", "serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)", "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)", @@ -841,16 +841,16 @@ dependencies = [ [[package]] name = "failure" -version = "0.1.3" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "backtrace 0.3.11 (registry+https://github.com/rust-lang/crates.io-index)", - "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", + "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "failure_derive" -version = "0.1.3" +version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)", @@ -1677,8 +1677,8 @@ name = "opener" version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", - "failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", + "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", + "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)", ] @@ -2254,7 +2254,7 @@ dependencies = [ "crossbeam-channel 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)", "difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)", "env_logger 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)", - "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", + "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "futures 0.1.21 (registry+https://github.com/rust-lang/crates.io-index)", "home 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)", "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -3014,7 +3014,7 @@ name = "rustfix" version = "0.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ - "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", + "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.82 (registry+https://github.com/rust-lang/crates.io-index)", "serde_derive 1.0.81 (registry+https://github.com/rust-lang/crates.io-index)", @@ -3032,7 +3032,7 @@ dependencies = [ "derive-new 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)", "diff 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)", "env_logger 0.5.13 (registry+https://github.com/rust-lang/crates.io-index)", - "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", + "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", "getopts 0.2.17 (registry+https://github.com/rust-lang/crates.io-index)", "itertools 0.7.8 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)", @@ -3818,7 +3818,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" dependencies = [ "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)", - "failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", + "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] @@ -3997,8 +3997,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" "checksum environment 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "1f4b14e20978669064c33b4c1e0fb4083412e40fe56cbea2eae80fd7591503ee" "checksum error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ff511d5dc435d703f4971bc399647c9bc38e20cb41452e3b9feb4765419ed3f3" "checksum error-chain 0.12.0 (registry+https://github.com/rust-lang/crates.io-index)" = "07e791d3be96241c77c43846b665ef1384606da2cd2a48730abe606a12906e02" -"checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7" -"checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596" +"checksum failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "795bd83d3abeb9220f257e597aa0080a508b27533824adf336529648f6abf7e2" +"checksum failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "ea1063915fd7ef4309e222a5a07cf9c319fb9c7836b1f89b85458672dbb127e1" "checksum fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed" "checksum filetime 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "a2df5c1a8c4be27e7707789dc42ae65976e60b394afd293d1419ab915833e646" "checksum fixedbitset 0.1.9 (registry+https://github.com/rust-lang/crates.io-index)" = "86d4de0081402f5e88cdac65c8dcdcc73118c1a7a465e2a05f0da05843a8ea33" diff --git a/src/tools/cargo b/src/tools/cargo index 245818076052d..4e74e2fc09085 160000 --- a/src/tools/cargo +++ b/src/tools/cargo @@ -1 +1 @@ -Subproject commit 245818076052dd7178f5bb7585f5aec5b6c1e03e +Subproject commit 4e74e2fc0908524d17735c768067117d3e84ee9c From 8d6e5fc20f1c69f453ea7a786a6e47b2da85ed28 Mon Sep 17 00:00:00 2001 From: ljedrz Date: Mon, 4 Feb 2019 16:27:09 +0100 Subject: [PATCH 092/278] rustc: partially HirIdify --- src/librustc/infer/error_reporting/mod.rs | 18 ++++++++---------- src/librustc/infer/error_reporting/note.rs | 6 ++---- src/librustc/middle/reachable.rs | 4 ++-- src/librustc/middle/resolve_lifetime.rs | 8 ++++---- src/librustc/traits/error_reporting.rs | 3 ++- src/librustc/traits/util.rs | 6 +++--- src/librustc/ty/item_path.rs | 4 ++-- src/librustc/ty/mod.rs | 12 ++++++------ src/librustc/util/ppaux.rs | 2 +- 9 files changed, 30 insertions(+), 33 deletions(-) diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs index 66e4cd49c807f..dda079e295ec5 100644 --- a/src/librustc/infer/error_reporting/mod.rs +++ b/src/librustc/infer/error_reporting/mod.rs @@ -56,7 +56,6 @@ use hir::def_id::DefId; use hir::Node; use middle::region; use std::{cmp, fmt}; -use syntax::ast::DUMMY_NODE_ID; use syntax_pos::{Pos, Span}; use traits::{ObligationCause, ObligationCauseCode}; use ty::error::TypeError; @@ -182,8 +181,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { let cm = self.sess.source_map(); let scope = region.free_region_binding_scope(self); - let node = self.hir().as_local_node_id(scope).unwrap_or(DUMMY_NODE_ID); - let tag = match self.hir().find(node) { + let node = self.hir().as_local_hir_id(scope).unwrap_or(hir::DUMMY_HIR_ID); + let tag = match self.hir().find_by_hir_id(node) { Some(Node::Block(_)) | Some(Node::Expr(_)) => "body", Some(Node::Item(it)) => Self::item_scope_tag(&it), Some(Node::TraitItem(it)) => Self::trait_item_scope_tag(&it), @@ -192,7 +191,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { }; let (prefix, span) = match *region { ty::ReEarlyBound(ref br) => { - let mut sp = cm.def_span(self.hir().span(node)); + let mut sp = cm.def_span(self.hir().span_by_hir_id(node)); if let Some(param) = self.hir() .get_generics(scope) .and_then(|generics| generics.get_named(&br.name)) @@ -205,7 +204,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { bound_region: ty::BoundRegion::BrNamed(_, ref name), .. }) => { - let mut sp = cm.def_span(self.hir().span(node)); + let mut sp = cm.def_span(self.hir().span_by_hir_id(node)); if let Some(param) = self.hir() .get_generics(scope) .and_then(|generics| generics.get_named(&name)) @@ -217,15 +216,15 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { ty::ReFree(ref fr) => match fr.bound_region { ty::BrAnon(idx) => ( format!("the anonymous lifetime #{} defined on", idx + 1), - self.hir().span(node), + self.hir().span_by_hir_id(node), ), ty::BrFresh(_) => ( "an anonymous lifetime defined on".to_owned(), - self.hir().span(node), + self.hir().span_by_hir_id(node), ), _ => ( format!("the lifetime {} as defined on", fr.bound_region), - cm.def_span(self.hir().span(node)), + cm.def_span(self.hir().span_by_hir_id(node)), ), }, _ => bug!(), @@ -1451,8 +1450,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { format!(" for lifetime parameter `{}` in coherence check", name) } infer::UpvarRegion(ref upvar_id, _) => { - let var_node_id = self.tcx.hir().hir_to_node_id(upvar_id.var_path.hir_id); - let var_name = self.tcx.hir().name(var_node_id); + let var_name = self.tcx.hir().name_by_hir_id(upvar_id.var_path.hir_id); format!(" for capture of `{}` by closure", var_name) } infer::NLL(..) => bug!("NLL variable found in lexical phase"), diff --git a/src/librustc/infer/error_reporting/note.rs b/src/librustc/infer/error_reporting/note.rs index e45a4b17cdd9c..397081292b91f 100644 --- a/src/librustc/infer/error_reporting/note.rs +++ b/src/librustc/infer/error_reporting/note.rs @@ -31,8 +31,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { "...so that reference does not outlive borrowed content"); } infer::ReborrowUpvar(span, ref upvar_id) => { - let var_node_id = self.tcx.hir().hir_to_node_id(upvar_id.var_path.hir_id); - let var_name = self.tcx.hir().name(var_node_id); + let var_name = self.tcx.hir().name_by_hir_id(upvar_id.var_path.hir_id); err.span_note(span, &format!("...so that closure can access `{}`", var_name)); } @@ -164,8 +163,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { err } infer::ReborrowUpvar(span, ref upvar_id) => { - let var_node_id = self.tcx.hir().hir_to_node_id(upvar_id.var_path.hir_id); - let var_name = self.tcx.hir().name(var_node_id); + let var_name = self.tcx.hir().name_by_hir_id(upvar_id.var_path.hir_id); let mut err = struct_span_err!(self.tcx.sess, span, E0313, diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs index 10deca836fff3..96f07ef835141 100644 --- a/src/librustc/middle/reachable.rs +++ b/src/librustc/middle/reachable.rs @@ -177,8 +177,8 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> { // Check the impl. If the generics on the self // type of the impl require inlining, this method // does too. - let impl_node_id = self.tcx.hir().as_local_node_id(impl_did).unwrap(); - match self.tcx.hir().expect_item(impl_node_id).node { + let impl_hir_id = self.tcx.hir().as_local_hir_id(impl_did).unwrap(); + match self.tcx.hir().expect_item_by_hir_id(impl_hir_id).node { hir::ItemKind::Impl(..) => { let generics = self.tcx.generics_of(impl_did); generics.requires_monomorphization(self.tcx) diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index 34db30a1706b9..c9d0ddc3fb4e4 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -1248,12 +1248,12 @@ fn extract_labels(ctxt: &mut LifetimeContext<'_, '_>, body: &hir::Body) { } => { // FIXME (#24278): non-hygienic comparison if let Some(def) = lifetimes.get(&hir::ParamName::Plain(label.modern())) { - let node_id = tcx.hir().as_local_node_id(def.id().unwrap()).unwrap(); + let hir_id = tcx.hir().as_local_hir_id(def.id().unwrap()).unwrap(); signal_shadowing_problem( tcx, label.name, - original_lifetime(tcx.hir().span(node_id)), + original_lifetime(tcx.hir().span_by_hir_id(hir_id)), shadower_label(label.span), ); return; @@ -2593,12 +2593,12 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { ref lifetimes, s, .. } => { if let Some(&def) = lifetimes.get(¶m.name.modern()) { - let node_id = self.tcx.hir().as_local_node_id(def.id().unwrap()).unwrap(); + let hir_id = self.tcx.hir().as_local_hir_id(def.id().unwrap()).unwrap(); signal_shadowing_problem( self.tcx, param.name.ident().name, - original_lifetime(self.tcx.hir().span(node_id)), + original_lifetime(self.tcx.hir().span_by_hir_id(hir_id)), shadower_lifetime(¶m), ); return; diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs index ea3ea59c7613f..c026ca6ec8f1e 100644 --- a/src/librustc/traits/error_reporting.rs +++ b/src/librustc/traits/error_reporting.rs @@ -1035,7 +1035,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { ).collect::>()) } Node::StructCtor(ref variant_data) => { - (self.tcx.sess.source_map().def_span(self.tcx.hir().span(variant_data.id())), + (self.tcx.sess.source_map().def_span( + self.tcx.hir().span_by_hir_id(variant_data.hir_id())), vec![ArgKind::empty(); variant_data.fields().len()]) } _ => panic!("non-FnLike node found: {:?}", node), diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs index 5b7ba5386725e..8e8deeb7a6bde 100644 --- a/src/librustc/traits/util.rs +++ b/src/librustc/traits/util.rs @@ -525,9 +525,9 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } pub fn impl_is_default(self, node_item_def_id: DefId) -> bool { - match self.hir().as_local_node_id(node_item_def_id) { - Some(node_id) => { - let item = self.hir().expect_item(node_id); + match self.hir().as_local_hir_id(node_item_def_id) { + Some(hir_id) => { + let item = self.hir().expect_item_by_hir_id(hir_id); if let hir::ItemKind::Impl(_, _, defaultness, ..) = item.node { defaultness.is_default() } else { diff --git a/src/librustc/ty/item_path.rs b/src/librustc/ty/item_path.rs index adb7e1fb3e322..c7b81824113b8 100644 --- a/src/librustc/ty/item_path.rs +++ b/src/librustc/ty/item_path.rs @@ -461,8 +461,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { // only occur very early in the compiler pipeline. let parent_def_id = self.parent_def_id(impl_def_id).unwrap(); self.push_item_path(buffer, parent_def_id, pushed_prelude_crate); - let node_id = self.hir().as_local_node_id(impl_def_id).unwrap(); - let item = self.hir().expect_item(node_id); + let hir_id = self.hir().as_local_hir_id(impl_def_id).unwrap(); + let item = self.hir().expect_item_by_hir_id(hir_id); let span_str = self.sess.source_map().span_to_string(item.span); buffer.push(&format!("", span_str)); } diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index c9089428b2324..263724998d7d5 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -2939,8 +2939,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { /// Get the attributes of a definition. pub fn get_attrs(self, did: DefId) -> Attributes<'gcx> { - if let Some(id) = self.hir().as_local_node_id(did) { - Attributes::Borrowed(self.hir().attrs(id)) + if let Some(id) = self.hir().as_local_hir_id(did) { + Attributes::Borrowed(self.hir().attrs_by_hir_id(id)) } else { Attributes::Owned(self.item_attrs(did)) } @@ -2991,8 +2991,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { /// with the name of the crate containing the impl. pub fn span_of_impl(self, impl_did: DefId) -> Result { if impl_did.is_local() { - let node_id = self.hir().as_local_node_id(impl_did).unwrap(); - Ok(self.hir().span(node_id)) + let hir_id = self.hir().as_local_hir_id(impl_did).unwrap(); + Ok(self.hir().span_by_hir_id(hir_id)) } else { Err(self.crate_name(impl_did.krate)) } @@ -3110,8 +3110,8 @@ fn adt_sized_constraint<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, fn associated_item_def_ids<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Lrc> { - let id = tcx.hir().as_local_node_id(def_id).unwrap(); - let item = tcx.hir().expect_item(id); + let id = tcx.hir().as_local_hir_id(def_id).unwrap(); + let item = tcx.hir().expect_item_by_hir_id(id); let vec: Vec<_> = match item.node { hir::ItemKind::Trait(.., ref trait_item_refs) => { trait_item_refs.iter() diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 51e9192cd290d..5830a0bab2743 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -801,7 +801,7 @@ impl fmt::Debug for ty::UpvarId { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "UpvarId({:?};`{}`;{:?})", self.var_path.hir_id, - ty::tls::with(|tcx| tcx.hir().name(tcx.hir().hir_to_node_id(self.var_path.hir_id))), + ty::tls::with(|tcx| tcx.hir().name_by_hir_id(self.var_path.hir_id)), self.closure_expr_id) } } From 44752c260bc338999c74e8b2324ef26f489c8632 Mon Sep 17 00:00:00 2001 From: ljedrz Date: Mon, 4 Feb 2019 16:35:52 +0100 Subject: [PATCH 093/278] mir: partially HirIdify --- src/librustc_mir/borrow_check/error_reporting.rs | 4 ++-- src/librustc_mir/borrow_check/move_errors.rs | 5 ++--- .../nll/region_infer/error_reporting/region_name.rs | 6 +++--- .../nll/region_infer/error_reporting/var_name.rs | 7 +++---- src/librustc_mir/borrow_check/nll/universal_regions.rs | 5 ++--- src/librustc_mir/build/mod.rs | 6 +++--- src/librustc_mir/hair/cx/block.rs | 2 +- src/librustc_mir/monomorphize/collector.rs | 8 ++++---- 8 files changed, 20 insertions(+), 23 deletions(-) diff --git a/src/librustc_mir/borrow_check/error_reporting.rs b/src/librustc_mir/borrow_check/error_reporting.rs index b070031756798..248ac84237a2c 100644 --- a/src/librustc_mir/borrow_check/error_reporting.rs +++ b/src/librustc_mir/borrow_check/error_reporting.rs @@ -833,13 +833,13 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { format!("`{}` would have to be valid for `{}`...", name, region_name), ); - if let Some(fn_node_id) = self.infcx.tcx.hir().as_local_node_id(self.mir_def_id) { + if let Some(fn_hir_id) = self.infcx.tcx.hir().as_local_hir_id(self.mir_def_id) { err.span_label( drop_span, format!( "...but `{}` will be dropped here, when the function `{}` returns", name, - self.infcx.tcx.hir().name(fn_node_id), + self.infcx.tcx.hir().name_by_hir_id(fn_hir_id), ), ); diff --git a/src/librustc_mir/borrow_check/move_errors.rs b/src/librustc_mir/borrow_check/move_errors.rs index 8539b5c26cee8..52003f01f9c3e 100644 --- a/src/librustc_mir/borrow_check/move_errors.rs +++ b/src/librustc_mir/borrow_check/move_errors.rs @@ -308,9 +308,8 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> { let upvar_decl = &self.mir.upvar_decls[field.index()]; let upvar_hir_id = upvar_decl.var_hir_id.assert_crate_local(); - let upvar_node_id = - self.infcx.tcx.hir().hir_to_node_id(upvar_hir_id); - let upvar_span = self.infcx.tcx.hir().span(upvar_node_id); + let upvar_span = self.infcx.tcx.hir().span_by_hir_id( + upvar_hir_id); diag.span_label(upvar_span, "captured outer variable"); break; } diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs index bff8015511242..f164cfb08766b 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs @@ -10,7 +10,7 @@ use rustc::ty::subst::{Substs, UnpackedKind}; use rustc::ty::{self, RegionKind, RegionVid, Ty, TyCtxt}; use rustc::util::ppaux::RegionHighlightMode; use rustc_errors::DiagnosticBuilder; -use syntax::ast::{Name, DUMMY_NODE_ID}; +use syntax::ast::Name; use syntax::symbol::keywords; use syntax_pos::Span; use syntax_pos::symbol::InternedString; @@ -293,9 +293,9 @@ impl<'tcx> RegionInferenceContext<'tcx> { name: &InternedString, ) -> Span { let scope = error_region.free_region_binding_scope(tcx); - let node = tcx.hir().as_local_node_id(scope).unwrap_or(DUMMY_NODE_ID); + let node = tcx.hir().as_local_hir_id(scope).unwrap_or(hir::DUMMY_HIR_ID); - let span = tcx.sess.source_map().def_span(tcx.hir().span(node)); + let span = tcx.sess.source_map().def_span(tcx.hir().span_by_hir_id(node)); if let Some(param) = tcx.hir() .get_generics(scope) .and_then(|generics| generics.get_named(name)) diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs index c2f2e99c0a55b..b6dfb2da77994 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs @@ -71,11 +71,10 @@ impl<'tcx> RegionInferenceContext<'tcx> { upvar_index: usize, ) -> (Symbol, Span) { let upvar_hir_id = mir.upvar_decls[upvar_index].var_hir_id.assert_crate_local(); - let upvar_node_id = tcx.hir().hir_to_node_id(upvar_hir_id); - debug!("get_upvar_name_and_span_for_region: upvar_node_id={:?}", upvar_node_id); + debug!("get_upvar_name_and_span_for_region: upvar_hir_id={:?}", upvar_hir_id); - let upvar_name = tcx.hir().name(upvar_node_id); - let upvar_span = tcx.hir().span(upvar_node_id); + let upvar_name = tcx.hir().name_by_hir_id(upvar_hir_id); + let upvar_span = tcx.hir().span_by_hir_id(upvar_hir_id); debug!("get_upvar_name_and_span_for_region: upvar_name={:?} upvar_span={:?}", upvar_name, upvar_span); diff --git a/src/librustc_mir/borrow_check/nll/universal_regions.rs b/src/librustc_mir/borrow_check/nll/universal_regions.rs index 0a214e60bdd78..ad4444e0df24c 100644 --- a/src/librustc_mir/borrow_check/nll/universal_regions.rs +++ b/src/librustc_mir/borrow_check/nll/universal_regions.rs @@ -771,9 +771,8 @@ fn for_each_late_bound_region_defined_on<'tcx>( owner: fn_def_id.index, local_id: *late_bound, }; - let region_node_id = tcx.hir().hir_to_node_id(hir_id); - let name = tcx.hir().name(region_node_id).as_interned_str(); - let region_def_id = tcx.hir().local_def_id(region_node_id); + let name = tcx.hir().name_by_hir_id(hir_id).as_interned_str(); + let region_def_id = tcx.hir().local_def_id_from_hir_id(hir_id); let liberated_region = tcx.mk_region(ty::ReFree(ty::FreeRegion { scope: fn_def_id, bound_region: ty::BoundRegion::BrNamed(region_def_id, name), diff --git a/src/librustc_mir/build/mod.rs b/src/librustc_mir/build/mod.rs index f38648fda0e36..b1a745b6980fb 100644 --- a/src/librustc_mir/build/mod.rs +++ b/src/librustc_mir/build/mod.rs @@ -64,8 +64,8 @@ pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'t ) => { (*body_id, ty.span) } - Node::AnonConst(hir::AnonConst { body, id, .. }) => { - (*body, tcx.hir().span(*id)) + Node::AnonConst(hir::AnonConst { body, hir_id, .. }) => { + (*body, tcx.hir().span_by_hir_id(*hir_id)) } _ => span_bug!(tcx.hir().span(id), "can't build MIR for {:?}", def_id), @@ -114,7 +114,7 @@ pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'t let self_arg; if let Some(ref fn_decl) = tcx.hir().fn_decl(owner_id) { let ty_hir_id = fn_decl.inputs[index].hir_id; - let ty_span = tcx.hir().span(tcx.hir().hir_to_node_id(ty_hir_id)); + let ty_span = tcx.hir().span_by_hir_id(ty_hir_id); opt_ty_info = Some(ty_span); self_arg = if index == 0 && fn_decl.implicit_self.has_implicit_self() { match fn_decl.implicit_self { diff --git a/src/librustc_mir/hair/cx/block.rs b/src/librustc_mir/hair/cx/block.rs index 518ae978ae17a..466bdd1d25587 100644 --- a/src/librustc_mir/hair/cx/block.rs +++ b/src/librustc_mir/hair/cx/block.rs @@ -48,7 +48,7 @@ fn mirror_stmts<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>, for (index, stmt) in stmts.iter().enumerate() { let hir_id = stmt.hir_id; let opt_dxn_ext = cx.region_scope_tree.opt_destruction_scope(hir_id.local_id); - let stmt_span = StatementSpan(cx.tcx.hir().span(stmt.id)); + let stmt_span = StatementSpan(cx.tcx.hir().span_by_hir_id(hir_id)); match stmt.node { hir::StmtKind::Expr(ref expr) | hir::StmtKind::Semi(ref expr) => { diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index e713ab17c3af5..57cbc7002acba 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -450,8 +450,8 @@ fn check_recursion_limit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, if recursion_depth > *tcx.sess.recursion_limit.get() { let error = format!("reached the recursion limit while instantiating `{}`", instance); - if let Some(node_id) = tcx.hir().as_local_node_id(def_id) { - tcx.sess.span_fatal(tcx.hir().span(node_id), &error); + if let Some(hir_id) = tcx.hir().as_local_hir_id(def_id) { + tcx.sess.span_fatal(tcx.hir().span_by_hir_id(hir_id), &error); } else { tcx.sess.fatal(&error); } @@ -482,8 +482,8 @@ fn check_type_length_limit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let instance_name = instance.to_string(); let msg = format!("reached the type-length limit while instantiating `{:.64}...`", instance_name); - let mut diag = if let Some(node_id) = tcx.hir().as_local_node_id(instance.def_id()) { - tcx.sess.struct_span_fatal(tcx.hir().span(node_id), &msg) + let mut diag = if let Some(hir_id) = tcx.hir().as_local_hir_id(instance.def_id()) { + tcx.sess.struct_span_fatal(tcx.hir().span_by_hir_id(hir_id), &msg) } else { tcx.sess.struct_fatal(&msg) }; From 6da9129b3676e88029e682faed5dbfaf4572758a Mon Sep 17 00:00:00 2001 From: ljedrz Date: Mon, 4 Feb 2019 16:45:04 +0100 Subject: [PATCH 094/278] typeck: partially HirIdify --- src/librustc/hir/map/mod.rs | 8 ++++++-- src/librustc_metadata/encoder.rs | 2 +- src/librustc_typeck/astconv.rs | 13 +++++++------ src/librustc_typeck/check/compare_method.rs | 6 +++--- src/librustc_typeck/check/dropck.rs | 4 ++-- src/librustc_typeck/check/mod.rs | 14 +++++++------- src/librustc_typeck/check/upvar.rs | 3 +-- src/librustc_typeck/check/wfcheck.rs | 10 +++++----- src/librustc_typeck/check/writeback.rs | 10 ++++------ src/librustc_typeck/coherence/builtin.rs | 8 ++++---- src/librustc_typeck/collect.rs | 12 ++++++------ src/librustc_typeck/variance/mod.rs | 6 +++--- 12 files changed, 49 insertions(+), 47 deletions(-) diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index d35306ba353a3..58c0380816bcc 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -931,7 +931,9 @@ impl<'hir> Map<'hir> { } } - pub fn expect_variant_data(&self, id: NodeId) -> &'hir VariantData { + pub fn expect_variant_data(&self, id: HirId) -> &'hir VariantData { + let id = self.hir_to_node_id(id); // FIXME(@ljedrz): remove when possible + match self.find(id) { Some(Node::Item(i)) => { match i.node { @@ -946,7 +948,9 @@ impl<'hir> Map<'hir> { } } - pub fn expect_variant(&self, id: NodeId) -> &'hir Variant { + pub fn expect_variant(&self, id: HirId) -> &'hir Variant { + let id = self.hir_to_node_id(id); // FIXME(@ljedrz): remove when possible + match self.find(id) { Some(Node::Variant(variant)) => variant, _ => bug!("expected variant, found {}", self.node_to_string(id)), diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index 3b212f3b7472d..6963c54b50358 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -673,7 +673,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { let def_id = field.did; debug!("IsolatedEncoder::encode_field({:?})", def_id); - let variant_id = tcx.hir().as_local_node_id(variant.did).unwrap(); + let variant_id = tcx.hir().as_local_hir_id(variant.did).unwrap(); let variant_data = tcx.hir().expect_variant_data(variant_id); Entry { diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 8da0b6dcbeac3..210a3886e92a0 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -111,7 +111,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o { { let tcx = self.tcx(); let lifetime_name = |def_id| { - tcx.hir().name(tcx.hir().as_local_node_id(def_id).unwrap()).as_interned_str() + tcx.hir().name_by_hir_id(tcx.hir().as_local_hir_id(def_id).unwrap()).as_interned_str() }; let r = match tcx.named_region(lifetime.hir_id) { @@ -1682,12 +1682,13 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o { assert_eq!(opt_self_ty, None); self.prohibit_generics(&path.segments); - let node_id = tcx.hir().as_local_node_id(did).unwrap(); - let item_id = tcx.hir().get_parent_node(node_id); - let item_def_id = tcx.hir().local_def_id(item_id); + let hir_id = tcx.hir().as_local_hir_id(did).unwrap(); + let item_id = tcx.hir().get_parent_node_by_hir_id(hir_id); + let item_def_id = tcx.hir().local_def_id_from_hir_id(item_id); let generics = tcx.generics_of(item_def_id); - let index = generics.param_def_id_to_index[&tcx.hir().local_def_id(node_id)]; - tcx.mk_ty_param(index, tcx.hir().name(node_id).as_interned_str()) + let index = generics.param_def_id_to_index[ + &tcx.hir().local_def_id_from_hir_id(hir_id)]; + tcx.mk_ty_param(index, tcx.hir().name_by_hir_id(hir_id).as_interned_str()) } Def::SelfTy(_, Some(def_id)) => { // `Self` in impl (we know the concrete type). diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index 0eb8d7d06b1f6..0cc5071dbdd4f 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -736,8 +736,8 @@ fn compare_synthetic_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, in impl_m_type_params.zip(trait_m_type_params) { if impl_synthetic != trait_synthetic { - let impl_node_id = tcx.hir().as_local_node_id(impl_def_id).unwrap(); - let impl_span = tcx.hir().span(impl_node_id); + let impl_hir_id = tcx.hir().as_local_hir_id(impl_def_id).unwrap(); + let impl_span = tcx.hir().span_by_hir_id(impl_hir_id); let trait_span = tcx.def_span(trait_def_id); let mut err = struct_span_err!(tcx.sess, impl_span, @@ -840,7 +840,7 @@ fn compare_synthetic_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, match param.kind { GenericParamKind::Lifetime { .. } => None, GenericParamKind::Type { .. } => { - if param.id == impl_node_id { + if param.hir_id == impl_hir_id { Some(¶m.bounds) } else { None diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index 60b5db0d12cc4..e210909127b2a 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -184,7 +184,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'a, 'tcx>( // absent. So we report an error that the Drop impl injected a // predicate that is not present on the struct definition. - let self_type_node_id = tcx.hir().as_local_node_id(self_type_did).unwrap(); + let self_type_hir_id = tcx.hir().as_local_hir_id(self_type_did).unwrap(); let drop_impl_span = tcx.def_span(drop_impl_did); @@ -216,7 +216,7 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'a, 'tcx>( // repeated `contains` calls. if !assumptions_in_impl_context.contains(&predicate) { - let item_span = tcx.hir().span(self_type_node_id); + let item_span = tcx.hir().span_by_hir_id(self_type_hir_id); struct_span_err!( tcx.sess, drop_impl_span, diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 3e2a9d720f1c1..bd45369f6014b 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1883,14 +1883,14 @@ pub fn check_enum<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // Check for duplicate discriminant values if let Some(i) = disr_vals.iter().position(|&x| x.val == discr.val) { let variant_did = def.variants[VariantIdx::new(i)].did; - let variant_i_node_id = tcx.hir().as_local_node_id(variant_did).unwrap(); - let variant_i = tcx.hir().expect_variant(variant_i_node_id); + let variant_i_hir_id = tcx.hir().as_local_hir_id(variant_did).unwrap(); + let variant_i = tcx.hir().expect_variant(variant_i_hir_id); let i_span = match variant_i.node.disr_expr { - Some(ref expr) => tcx.hir().span(expr.id), - None => tcx.hir().span(variant_i_node_id) + Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id), + None => tcx.hir().span_by_hir_id(variant_i_hir_id) }; let span = match v.node.disr_expr { - Some(ref expr) => tcx.hir().span(expr.id), + Some(ref expr) => tcx.hir().span_by_hir_id(expr.hir_id), None => v.span }; struct_span_err!(tcx.sess, span, E0081, @@ -5703,8 +5703,8 @@ pub fn check_bounds_are_used<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, }); for (&used, param) in types_used.iter().zip(types) { if !used { - let id = tcx.hir().as_local_node_id(param.def_id).unwrap(); - let span = tcx.hir().span(id); + let id = tcx.hir().as_local_hir_id(param.def_id).unwrap(); + let span = tcx.hir().span_by_hir_id(id); struct_span_err!(tcx.sess, span, E0091, "type parameter `{}` is unused", param.name) .span_label(span, "unused type parameter") .emit(); diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index ffd7c2114e5ab..15ae0166b93cb 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -650,6 +650,5 @@ impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for InferBorrowKind<'a, 'gcx, 'tcx> { } fn var_name(tcx: TyCtxt, var_hir_id: hir::HirId) -> ast::Name { - let var_node_id = tcx.hir().hir_to_node_id(var_hir_id); - tcx.hir().name(var_node_id) + tcx.hir().name_by_hir_id(var_hir_id) } diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 97881708b0a07..1206c8eb1eaa5 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -62,11 +62,11 @@ impl<'a, 'gcx, 'tcx> CheckWfFcxBuilder<'a, 'gcx, 'tcx> { /// not included it frequently leads to confusing errors in fn bodies. So it's better to check /// the types first. pub fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) { - let node_id = tcx.hir().as_local_node_id(def_id).unwrap(); - let item = tcx.hir().expect_item(node_id); + let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); + let item = tcx.hir().expect_item_by_hir_id(hir_id); - debug!("check_item_well_formed(it.id={}, it.name={})", - item.id, + debug!("check_item_well_formed(it.hir_id={:?}, it.name={})", + item.hir_id, tcx.item_path_str(def_id)); match item.node { @@ -88,7 +88,7 @@ pub fn check_item_well_formed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: Def // won't be allowed unless there's an *explicit* implementation of `Send` // for `T` hir::ItemKind::Impl(_, polarity, defaultness, _, ref trait_ref, ref self_ty, _) => { - let is_auto = tcx.impl_trait_ref(tcx.hir().local_def_id(item.id)) + let is_auto = tcx.impl_trait_ref(tcx.hir().local_def_id_from_hir_id(item.hir_id)) .map_or(false, |trait_ref| tcx.trait_is_auto(trait_ref.def_id)); if let (hir::Defaultness::Default { .. }, true) = (defaultness, is_auto) { tcx.sess.span_err(item.span, "impls of auto traits cannot be default"); diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 238b087fe32f8..29f531201e4d8 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -407,8 +407,7 @@ impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> { if let ty::UserType::TypeOf(_, user_substs) = c_ty.value { if self.rustc_dump_user_substs { // This is a unit-testing mechanism. - let node_id = self.tcx().hir().hir_to_node_id(hir_id); - let span = self.tcx().hir().span(node_id); + let span = self.tcx().hir().span_by_hir_id(hir_id); // We need to buffer the errors in order to guarantee a consistent // order when emitting them. let err = self.tcx().sess.struct_span_err( @@ -739,15 +738,14 @@ impl Locatable for ast::NodeId { impl Locatable for DefIndex { fn to_span(&self, tcx: &TyCtxt) -> Span { - let node_id = tcx.hir().def_index_to_node_id(*self); - tcx.hir().span(node_id) + let hir_id = tcx.hir().def_index_to_hir_id(*self); + tcx.hir().span_by_hir_id(hir_id) } } impl Locatable for hir::HirId { fn to_span(&self, tcx: &TyCtxt) -> Span { - let node_id = tcx.hir().hir_to_node_id(*self); - tcx.hir().span(node_id) + tcx.hir().span_by_hir_id(*self) } } diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs index bd2373d1659c9..3ec08f221f576 100644 --- a/src/librustc_typeck/coherence/builtin.rs +++ b/src/librustc_typeck/coherence/builtin.rs @@ -76,7 +76,7 @@ fn visit_implementation_of_drop<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_did: fn visit_implementation_of_copy<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_did: DefId) { debug!("visit_implementation_of_copy: impl_did={:?}", impl_did); - let impl_node_id = if let Some(n) = tcx.hir().as_local_node_id(impl_did) { + let impl_hir_id = if let Some(n) = tcx.hir().as_local_hir_id(impl_did) { n } else { debug!("visit_implementation_of_copy(): impl not in this crate"); @@ -87,7 +87,7 @@ fn visit_implementation_of_copy<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_did: debug!("visit_implementation_of_copy: self_type={:?} (bound)", self_type); - let span = tcx.hir().span(impl_node_id); + let span = tcx.hir().span_by_hir_id(impl_hir_id); let param_env = tcx.param_env(impl_did); assert!(!self_type.has_escaping_bound_vars()); @@ -97,7 +97,7 @@ fn visit_implementation_of_copy<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_did: match param_env.can_type_implement_copy(tcx, self_type) { Ok(()) => {} Err(CopyImplementationError::InfrigingFields(fields)) => { - let item = tcx.hir().expect_item(impl_node_id); + let item = tcx.hir().expect_item_by_hir_id(impl_hir_id); let span = if let ItemKind::Impl(.., Some(ref tr), _, _) = item.node { tr.path.span } else { @@ -114,7 +114,7 @@ fn visit_implementation_of_copy<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, impl_did: err.emit() } Err(CopyImplementationError::NotAnAdt) => { - let item = tcx.hir().expect_item(impl_node_id); + let item = tcx.hir().expect_item_by_hir_id(impl_hir_id); let span = if let ItemKind::Impl(.., ref ty, _) = item.node { ty.span } else { diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 9dc74c5d63a4e..f5e50678040f6 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -737,8 +737,8 @@ fn super_predicates_of<'a, 'tcx>( } fn trait_def<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx ty::TraitDef { - let node_id = tcx.hir().as_local_node_id(def_id).unwrap(); - let item = tcx.hir().expect_item(node_id); + let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); + let item = tcx.hir().expect_item_by_hir_id(hir_id); let (is_auto, unsafety) = match item.node { hir::ItemKind::Trait(is_auto, unsafety, ..) => (is_auto == hir::IsAuto::Yes, unsafety), @@ -1509,8 +1509,8 @@ fn impl_trait_ref<'a, 'tcx>( ) -> Option> { let icx = ItemCtxt::new(tcx, def_id); - let node_id = tcx.hir().as_local_node_id(def_id).unwrap(); - match tcx.hir().expect_item(node_id).node { + let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); + match tcx.hir().expect_item_by_hir_id(hir_id).node { hir::ItemKind::Impl(.., ref opt_trait_ref, _, _) => { opt_trait_ref.as_ref().map(|ast_trait_ref| { let selfty = tcx.type_of(def_id); @@ -1522,8 +1522,8 @@ fn impl_trait_ref<'a, 'tcx>( } fn impl_polarity<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> hir::ImplPolarity { - let node_id = tcx.hir().as_local_node_id(def_id).unwrap(); - match tcx.hir().expect_item(node_id).node { + let hir_id = tcx.hir().as_local_hir_id(def_id).unwrap(); + match tcx.hir().expect_item_by_hir_id(hir_id).node { hir::ItemKind::Impl(_, polarity, ..) => polarity, ref item => bug!("impl_polarity: {:?} not an impl", item), } diff --git a/src/librustc_typeck/variance/mod.rs b/src/librustc_typeck/variance/mod.rs index afb6a68482013..347422780d516 100644 --- a/src/librustc_typeck/variance/mod.rs +++ b/src/librustc_typeck/variance/mod.rs @@ -46,12 +46,12 @@ fn crate_variances<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) fn variances_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, item_def_id: DefId) -> Lrc> { - let id = tcx.hir().as_local_node_id(item_def_id).expect("expected local def-id"); + let id = tcx.hir().as_local_hir_id(item_def_id).expect("expected local def-id"); let unsupported = || { // Variance not relevant. - span_bug!(tcx.hir().span(id), "asked to compute variance for wrong kind of item") + span_bug!(tcx.hir().span_by_hir_id(id), "asked to compute variance for wrong kind of item") }; - match tcx.hir().get(id) { + match tcx.hir().get_by_hir_id(id) { Node::Item(item) => match item.node { hir::ItemKind::Enum(..) | hir::ItemKind::Struct(..) | From 9204497c2999ce4a3df9802d48cb990be7ee1164 Mon Sep 17 00:00:00 2001 From: Patrick McCarter Date: Tue, 5 Feb 2019 15:36:31 -0500 Subject: [PATCH 095/278] Allow const assignment for int saturating_add() calls for #58030 --- src/libcore/num/mod.rs | 57 +++++++++++++++---- src/librustc/mir/interpret/mod.rs | 2 +- src/librustc_mir/interpret/intrinsics.rs | 29 +++++++++- src/librustc_mir/transform/qualify_consts.rs | 1 + .../transform/qualify_min_const_fn.rs | 1 + .../run-pass/const-int-saturating-arith.rs | 13 +++++ 6 files changed, 91 insertions(+), 12 deletions(-) create mode 100644 src/test/run-pass/const-int-saturating-arith.rs diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index f80f839282781..55de04db028e1 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -882,17 +882,37 @@ $EndFeature, " ```"), #[stable(feature = "rust1", since = "1.0.0")] #[inline] + #[cfg(stage0)] pub fn saturating_add(self, rhs: Self) -> Self { - #[cfg(stage0)] match self.checked_add(rhs) { Some(x) => x, None if rhs >= 0 => Self::max_value(), None => Self::min_value(), } - #[cfg(not(stage0))] - { - intrinsics::saturating_add(self, rhs) - } + } + + } + + doc_comment! { + concat!("Saturating integer addition. Computes `self + rhs`, saturating at the numeric +bounds instead of overflowing. + +# Examples + +Basic usage: + +``` +", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101); +assert_eq!(", stringify!($SelfT), "::max_value().saturating_add(100), ", stringify!($SelfT), +"::max_value());", +$EndFeature, " +```"), + + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + #[cfg(not(stage0))] + pub const fn saturating_add(self, rhs: Self) -> Self { + intrinsics::saturating_add(self, rhs) } } @@ -2753,16 +2773,33 @@ assert_eq!(200u8.saturating_add(127), 255);", $EndFeature, " ```"), #[stable(feature = "rust1", since = "1.0.0")] #[inline] + #[cfg(stage0)] pub fn saturating_add(self, rhs: Self) -> Self { - #[cfg(stage0)] match self.checked_add(rhs) { Some(x) => x, None => Self::max_value(), } - #[cfg(not(stage0))] - { - intrinsics::saturating_add(self, rhs) - } + } + } + + doc_comment! { + concat!("Saturating integer addition. Computes `self + rhs`, saturating at +the numeric bounds instead of overflowing. + +# Examples + +Basic usage: + +``` +", $Feature, "assert_eq!(100", stringify!($SelfT), ".saturating_add(1), 101); +assert_eq!(200u8.saturating_add(127), 255);", $EndFeature, " +```"), + + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + #[cfg(not(stage0))] + pub const fn saturating_add(self, rhs: Self) -> Self { + intrinsics::saturating_add(self, rhs) } } diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs index e6a560b2ad7b6..4013cfb9558e1 100644 --- a/src/librustc/mir/interpret/mod.rs +++ b/src/librustc/mir/interpret/mod.rs @@ -418,4 +418,4 @@ pub fn truncate(value: u128, size: Size) -> u128 { let shift = 128 - size; // truncate (shift left to drop out leftover values, shift right to fill with zeroes) (value << shift) >> shift -} +} \ No newline at end of file diff --git a/src/librustc_mir/interpret/intrinsics.rs b/src/librustc_mir/interpret/intrinsics.rs index d8778dfeef7a1..64be3969640e5 100644 --- a/src/librustc_mir/interpret/intrinsics.rs +++ b/src/librustc_mir/interpret/intrinsics.rs @@ -4,7 +4,7 @@ use syntax::symbol::Symbol; use rustc::ty; -use rustc::ty::layout::{LayoutOf, Primitive}; +use rustc::ty::layout::{LayoutOf, Primitive, Size}; use rustc::mir::BinOp; use rustc::mir::interpret::{ EvalResult, EvalErrorKind, Scalar, @@ -122,6 +122,33 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> self.binop_with_overflow(bin_op, lhs, rhs, dest)?; } } + "saturating_add" => { + let l = self.read_immediate(args[0])?; + let r = self.read_immediate(args[1])?; + let (val, overflowed) = self.binary_op_imm(BinOp::Add, l, r)?; + if overflowed { + let first_term: u128 = l.to_scalar()?.to_bits(l.layout.size)?; + let num_bits = l.layout.size.bits(); + let val = if l.layout.abi.is_signed() { + // For signed addition the saturated value depends on the sign of either term + if first_term & (1 << (num_bits-1)) == 0 { // signed term is positive + Scalar::from_uint((1u128 << (num_bits - 1)) - 1, Size::from_bits(num_bits)) // max signed val + } else { // signed term is negative + Scalar::from_uint(1u128 << (num_bits - 1), Size::from_bits(num_bits)) // min signed val + } + } else { + if num_bits == 128 { // General bit shift method causes overflow for u128 terms + Scalar::from_uint(u128::max_value(), Size::from_bits(128)) + } else { + Scalar::from_uint(u128::max_value() & ((1 << num_bits) - 1), + Size::from_bits(num_bits)) + } + }; + self.write_scalar(val, dest)?; + } else { + self.write_scalar(val, dest)?; + } + } "unchecked_shl" | "unchecked_shr" => { let l = self.read_immediate(args[0])?; let r = self.read_immediate(args[1])?; diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs index 2d941902debc3..ac75a95dbe0fa 100644 --- a/src/librustc_mir/transform/qualify_consts.rs +++ b/src/librustc_mir/transform/qualify_consts.rs @@ -820,6 +820,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> { | "add_with_overflow" | "sub_with_overflow" | "mul_with_overflow" + | "saturating_add" // no need to check feature gates, intrinsics are only callable // from the libstd or with forever unstable feature gates => is_const_fn = true, diff --git a/src/librustc_mir/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs index 85bf1e70ebf42..bb7fe0dab548a 100644 --- a/src/librustc_mir/transform/qualify_min_const_fn.rs +++ b/src/librustc_mir/transform/qualify_min_const_fn.rs @@ -374,6 +374,7 @@ fn is_intrinsic_whitelisted(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> bool | "overflowing_add" // ~> .wrapping_add | "overflowing_sub" // ~> .wrapping_sub | "overflowing_mul" // ~> .wrapping_mul + | "saturating_add" // ~> .saturating_add | "unchecked_shl" // ~> .wrapping_shl | "unchecked_shr" // ~> .wrapping_shr | "rotate_left" // ~> .rotate_left diff --git a/src/test/run-pass/const-int-saturating-arith.rs b/src/test/run-pass/const-int-saturating-arith.rs new file mode 100644 index 0000000000000..3ff6a1fc08aa2 --- /dev/null +++ b/src/test/run-pass/const-int-saturating-arith.rs @@ -0,0 +1,13 @@ +const INT_U32_NO: u32 = (42 as u32).saturating_add(2); +const INT_U32: u32 = u32::max_value().saturating_add(1); +const INT_U128: u128 = u128::max_value().saturating_add(1); +const INT_I128: i128 = i128::max_value().saturating_add(1); +const INT_I128_NEG: i128 = i128::min_value().saturating_add(-1); + +fn main() { + assert_eq!(INT_U32_NO, 44); + assert_eq!(INT_U32, u32::max_value()); + assert_eq!(INT_U128, u128::max_value()); + assert_eq!(INT_I128, i128::max_value()); + assert_eq!(INT_I128_NEG, i128::min_value()); +} \ No newline at end of file From d371bcefb58d28caa585e77258747bcb0aba89b9 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Tue, 5 Feb 2019 21:22:11 +0100 Subject: [PATCH 096/278] fix test case --- src/test/run-pass/panic-uninitialized-zeroed.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/test/run-pass/panic-uninitialized-zeroed.rs b/src/test/run-pass/panic-uninitialized-zeroed.rs index d47ff6c630d11..31c0d2994d415 100644 --- a/src/test/run-pass/panic-uninitialized-zeroed.rs +++ b/src/test/run-pass/panic-uninitialized-zeroed.rs @@ -36,7 +36,7 @@ fn main() { assert_eq!( panic::catch_unwind(|| { - mem::MaybeUninit::::uninitialized().into_inner() + mem::MaybeUninit::::uninitialized().into_initialized() }).err().and_then(|a| a.downcast_ref::().map(|s| { s == "Attempted to instantiate uninhabited type !" })), @@ -63,7 +63,7 @@ fn main() { assert_eq!( panic::catch_unwind(|| { - mem::MaybeUninit::::uninitialized().into_inner() + mem::MaybeUninit::::uninitialized().into_initialized() }).err().and_then(|a| a.downcast_ref::().map(|s| { s == "Attempted to instantiate uninhabited type Foo" })), @@ -90,7 +90,7 @@ fn main() { assert_eq!( panic::catch_unwind(|| { - mem::MaybeUninit::::uninitialized().into_inner() + mem::MaybeUninit::::uninitialized().into_initialized() }).err().and_then(|a| a.downcast_ref::().map(|s| { s == "Attempted to instantiate uninhabited type Bar" })), From 80c052bed76d7b7406e956747012bc8a929fe909 Mon Sep 17 00:00:00 2001 From: Dan Robertson Date: Tue, 5 Feb 2019 15:52:54 +0000 Subject: [PATCH 097/278] Do not ICE in codegen given a extern_type static The layout of a extern_type static is unsized, but may pass the Well-Formed check in typeck. As a result, we cannot assume that a static is sized when generating the `Place` for an r-value. --- src/librustc_codegen_ssa/mir/place.rs | 19 ++++++++++++++++++- .../static-extern-type/Makefile | 5 +++++ .../static-extern-type/define-foo.c | 11 +++++++++++ .../static-extern-type/use-foo.rs | 14 ++++++++++++++ 4 files changed, 48 insertions(+), 1 deletion(-) create mode 100644 src/test/run-make-fulldeps/static-extern-type/Makefile create mode 100644 src/test/run-make-fulldeps/static-extern-type/define-foo.c create mode 100644 src/test/run-make-fulldeps/static-extern-type/use-foo.rs diff --git a/src/librustc_codegen_ssa/mir/place.rs b/src/librustc_codegen_ssa/mir/place.rs index b10611e5ac797..596f97a038892 100644 --- a/src/librustc_codegen_ssa/mir/place.rs +++ b/src/librustc_codegen_ssa/mir/place.rs @@ -41,6 +41,21 @@ impl<'a, 'tcx: 'a, V: CodegenObject> PlaceRef<'tcx, V> { } } + fn new_thin_place>( + bx: &mut Bx, + llval: V, + layout: TyLayout<'tcx>, + align: Align, + ) -> PlaceRef<'tcx, V> { + assert!(!bx.cx().type_has_metadata(layout.ty)); + PlaceRef { + llval, + llextra: None, + layout, + align + } + } + pub fn alloca>( bx: &mut Bx, layout: TyLayout<'tcx>, @@ -421,8 +436,10 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { } } mir::Place::Static(box mir::Static { def_id, ty }) => { + // NB: The layout of a static may be unsized as is the case when working + // with a static that is an extern_type. let layout = cx.layout_of(self.monomorphize(&ty)); - PlaceRef::new_sized(bx.get_static(def_id), layout, layout.align.abi) + PlaceRef::new_thin_place(bx, bx.get_static(def_id), layout, layout.align.abi) }, mir::Place::Projection(box mir::Projection { ref base, diff --git a/src/test/run-make-fulldeps/static-extern-type/Makefile b/src/test/run-make-fulldeps/static-extern-type/Makefile new file mode 100644 index 0000000000000..5879fc0ce7781 --- /dev/null +++ b/src/test/run-make-fulldeps/static-extern-type/Makefile @@ -0,0 +1,5 @@ +-include ../tools.mk + +all: $(call NATIVE_STATICLIB,define-foo) + $(RUSTC) -ldefine-foo use-foo.rs + $(call RUN,use-foo) || exit 1 diff --git a/src/test/run-make-fulldeps/static-extern-type/define-foo.c b/src/test/run-make-fulldeps/static-extern-type/define-foo.c new file mode 100644 index 0000000000000..39be5acfa1118 --- /dev/null +++ b/src/test/run-make-fulldeps/static-extern-type/define-foo.c @@ -0,0 +1,11 @@ +#include + +struct Foo { + uint8_t x; +}; + +struct Foo FOO = { 42 }; + +uint8_t bar(const struct Foo* foo) { + return foo->x; +} diff --git a/src/test/run-make-fulldeps/static-extern-type/use-foo.rs b/src/test/run-make-fulldeps/static-extern-type/use-foo.rs new file mode 100644 index 0000000000000..932b5b5944bc7 --- /dev/null +++ b/src/test/run-make-fulldeps/static-extern-type/use-foo.rs @@ -0,0 +1,14 @@ +#![feature(extern_types)] + +extern "C" { + type Foo; + static FOO: Foo; + fn bar(foo: *const Foo) -> u8; +} + +fn main() { + unsafe { + let foo = &FOO; + assert_eq!(bar(foo), 42); + } +} From b331b86d308d09398cf6202f367ea0f02babe523 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Tue, 5 Feb 2019 22:26:30 +0100 Subject: [PATCH 098/278] extend box-maybe-uninit test --- src/test/codegen/box-maybe-uninit.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/test/codegen/box-maybe-uninit.rs b/src/test/codegen/box-maybe-uninit.rs index a7fb74c04731d..ad1d259a0da21 100644 --- a/src/test/codegen/box-maybe-uninit.rs +++ b/src/test/codegen/box-maybe-uninit.rs @@ -9,5 +9,8 @@ use std::mem::MaybeUninit; pub fn box_uninitialized() -> Box> { // CHECK-LABEL: @box_uninitialized // CHECK-NOT: store + // CHECK-NOT: alloca + // CHECK-NOT: memcpy + // CHECK-NOT: memset Box::new(MaybeUninit::uninitialized()) } From 9fcb1658ab13a7f722e4747c5a4b691291e88a3b Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 5 Feb 2019 15:20:55 +1100 Subject: [PATCH 099/278] Overhaul `syntax::fold::Folder`. This commit changes `syntax::fold::Folder` from a functional style (where most methods take a `T` and produce a new `T`) to a more imperative style (where most methods take and modify a `&mut T`), and renames it `syntax::mut_visit::MutVisitor`. The first benefit is speed. The functional style does not require any reallocations, due to the use of `P::map` and `MoveMap::move_{,flat_}map`. However, every field in the AST must be overwritten; even those fields that are unchanged are overwritten with the same value. This causes a lot of unnecessary memory writes. The imperative style reduces instruction counts by 1--3% across a wide range of workloads, particularly incremental workloads. The second benefit is conciseness; the imperative style is usually more concise. E.g. compare the old functional style: ``` fn fold_abc(&mut self, abc: ABC) { ABC { a: fold_a(abc.a), b: fold_b(abc.b), c: abc.c, } } ``` with the imperative style: ``` fn visit_abc(&mut self, ABC { a, b, c: _ }: &mut ABC) { visit_a(a); visit_b(b); } ``` (The reductions get larger in more complex examples.) Overall, the patch removes over 200 lines of code -- even though the new code has more comments -- and a lot of the remaining lines have fewer characters. Some notes: - The old style used methods called `fold_*`. The new style mostly uses methods called `visit_*`, but there are a few methods that map a `T` to something other than a `T`, which are called `flat_map_*` (`T` maps to multiple `T`s) or `filter_map_*` (`T` maps to 0 or 1 `T`s). - `move_map.rs`/`MoveMap`/`move_map`/`move_flat_map` are renamed `map_in_place.rs`/`MapInPlace`/`map_in_place`/`flat_map_in_place` to reflect their slightly changed signatures. - Although this commit renames the `fold` module as `mut_visit`, it keeps it in the `fold.rs` file, so as not to confuse git. The next commit will rename the file. --- src/librustc_allocator/expand.rs | 27 +- src/librustc_data_structures/thin_vec.rs | 9 + src/librustc_driver/driver.rs | 12 +- src/librustc_driver/lib.rs | 9 +- src/librustc_driver/pretty.rs | 42 +- src/libsyntax/attr/mod.rs | 60 +- src/libsyntax/config.rs | 166 +- src/libsyntax/ext/base.rs | 48 +- src/libsyntax/ext/derive.rs | 7 +- src/libsyntax/ext/expand.rs | 290 +-- src/libsyntax/ext/placeholders.rs | 79 +- src/libsyntax/ext/tt/transcribe.rs | 6 +- src/libsyntax/fold.rs | 2002 ++++++++--------- src/libsyntax/lib.rs | 4 +- src/libsyntax/parse/parser.rs | 3 +- src/libsyntax/parse/token.rs | 2 +- src/libsyntax/test.rs | 64 +- src/libsyntax/tokenstream.rs | 2 +- .../util/{move_map.rs => map_in_place.rs} | 29 +- src/libsyntax_ext/deriving/generic/mod.rs | 12 +- src/libsyntax_ext/proc_macro_decls.rs | 4 +- .../pprust-expr-roundtrip.rs | 52 +- src/test/ui/issues/issue-49934.rs | 4 +- 23 files changed, 1417 insertions(+), 1516 deletions(-) rename src/libsyntax/util/{move_map.rs => map_in_place.rs} (82%) diff --git a/src/librustc_allocator/expand.rs b/src/librustc_allocator/expand.rs index 73a35c7cdcd5f..1fb1794d5147d 100644 --- a/src/librustc_allocator/expand.rs +++ b/src/librustc_allocator/expand.rs @@ -16,7 +16,7 @@ use syntax::{ expand::ExpansionConfig, hygiene::{self, Mark, SyntaxContext}, }, - fold::{self, Folder}, + mut_visit::{self, MutVisitor}, parse::ParseSess, ptr::P, symbol::Symbol @@ -28,10 +28,10 @@ use {AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS}; pub fn modify( sess: &ParseSess, resolver: &mut dyn Resolver, - krate: Crate, + krate: &mut Crate, crate_name: String, handler: &rustc_errors::Handler, -) -> ast::Crate { +) { ExpandAllocatorDirectives { handler, sess, @@ -39,7 +39,7 @@ pub fn modify( found: false, crate_name: Some(crate_name), in_submod: -1, // -1 to account for the "root" module - }.fold_crate(krate) + }.visit_crate(krate); } struct ExpandAllocatorDirectives<'a> { @@ -54,14 +54,14 @@ struct ExpandAllocatorDirectives<'a> { in_submod: isize, } -impl<'a> Folder for ExpandAllocatorDirectives<'a> { - fn fold_item(&mut self, item: P) -> SmallVec<[P; 1]> { +impl<'a> MutVisitor for ExpandAllocatorDirectives<'a> { + fn flat_map_item(&mut self, item: P) -> SmallVec<[P; 1]> { debug!("in submodule {}", self.in_submod); let name = if attr::contains_name(&item.attrs, "global_allocator") { "global_allocator" } else { - return fold::noop_fold_item(item, self); + return mut_visit::noop_flat_map_item(item, self); }; match item.node { ItemKind::Static(..) => {} @@ -139,25 +139,24 @@ impl<'a> Folder for ExpandAllocatorDirectives<'a> { let name = f.kind.fn_name("allocator_abi"); let allocator_abi = Ident::with_empty_ctxt(Symbol::gensym(&name)); let module = f.cx.item_mod(span, span, allocator_abi, Vec::new(), items); - let module = f.cx.monotonic_expander().fold_item(module).pop().unwrap(); + let module = f.cx.monotonic_expander().flat_map_item(module).pop().unwrap(); // Return the item and new submodule smallvec![item, module] } // If we enter a submodule, take note. - fn fold_mod(&mut self, m: Mod) -> Mod { + fn visit_mod(&mut self, m: &mut Mod) { debug!("enter submodule"); self.in_submod += 1; - let ret = fold::noop_fold_mod(m, self); + mut_visit::noop_visit_mod(m, self); self.in_submod -= 1; debug!("exit submodule"); - ret } - // `fold_mac` is disabled by default. Enable it here. - fn fold_mac(&mut self, mac: Mac) -> Mac { - fold::noop_fold_mac(mac, self) + // `visit_mac` is disabled by default. Enable it here. + fn visit_mac(&mut self, mac: &mut Mac) { + mut_visit::noop_visit_mac(mac, self) } } diff --git a/src/librustc_data_structures/thin_vec.rs b/src/librustc_data_structures/thin_vec.rs index 359f9b7842da3..ed57c528f51e0 100644 --- a/src/librustc_data_structures/thin_vec.rs +++ b/src/librustc_data_structures/thin_vec.rs @@ -39,6 +39,15 @@ impl ::std::ops::Deref for ThinVec { } } +impl ::std::ops::DerefMut for ThinVec { + fn deref_mut(&mut self) -> &mut [T] { + match *self { + ThinVec(None) => &mut [], + ThinVec(Some(ref mut vec)) => vec, + } + } +} + impl Extend for ThinVec { fn extend>(&mut self, iter: I) { match *self { diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index d3412ec2dd93d..4549b20899dd5 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -32,7 +32,7 @@ use rustc_typeck as typeck; use syntax::{self, ast, attr, diagnostics, visit}; use syntax::early_buffered_lints::BufferedEarlyLint; use syntax::ext::base::ExtCtxt; -use syntax::fold::Folder; +use syntax::mut_visit::MutVisitor; use syntax::parse::{self, PResult}; use syntax::util::node_count::NodeCounter; use syntax::util::lev_distance::find_best_match_for_name; @@ -1000,12 +1000,12 @@ where }); sess.profiler(|p| p.end_activity(ProfileCategory::Expansion)); - krate = time(sess, "maybe building test harness", || { + time(sess, "maybe building test harness", || { syntax::test::modify_for_testing( &sess.parse_sess, &mut resolver, sess.opts.test, - krate, + &mut krate, sess.diagnostic(), &sess.features_untracked(), ) @@ -1014,7 +1014,7 @@ where // If we're actually rustdoc then there's no need to actually compile // anything, so switch everything to just looping if sess.opts.actually_rustdoc { - krate = ReplaceBodyWithLoop::new(sess).fold_crate(krate); + ReplaceBodyWithLoop::new(sess).visit_crate(&mut krate); } let (has_proc_macro_decls, has_global_allocator) = time(sess, "AST validation", || { @@ -1045,11 +1045,11 @@ where if has_global_allocator { // Expand global allocators, which are treated as an in-tree proc macro - krate = time(sess, "creating allocators", || { + time(sess, "creating allocators", || { allocator::expand::modify( &sess.parse_sess, &mut resolver, - krate, + &mut krate, crate_name.to_string(), sess.diagnostic(), ) diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index a95ce810ffaeb..d0dc7799c7b72 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -870,9 +870,9 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { control.after_hir_lowering.stop = Compilation::Stop; control.after_parse.callback = box move |state| { - state.krate = Some(pretty::fold_crate(state.session, - state.krate.take().unwrap(), - ppm)); + let mut krate = state.krate.take().unwrap(); + pretty::visit_crate(state.session, &mut krate, ppm); + state.krate = Some(krate); }; control.after_hir_lowering.callback = box move |state| { pretty::print_after_hir_lowering(state.session, @@ -891,7 +891,8 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { control.after_parse.stop = Compilation::Stop; control.after_parse.callback = box move |state| { - let krate = pretty::fold_crate(state.session, state.krate.take().unwrap(), ppm); + let mut krate = state.krate.take().unwrap(); + pretty::visit_crate(state.session, &mut krate, ppm); pretty::print_after_parsing(state.session, state.input, &krate, diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index d980c5a3d29c3..4caf2ec676f07 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -16,7 +16,7 @@ use rustc_metadata::cstore::CStore; use rustc_mir::util::{write_mir_pretty, write_mir_graphviz}; use syntax::ast::{self, BlockCheckMode}; -use syntax::fold::{self, Folder}; +use syntax::mut_visit::{*, MutVisitor, visit_clobber}; use syntax::print::{pprust}; use syntax::print::pprust::PrintState; use syntax::ptr::P; @@ -28,6 +28,7 @@ use smallvec::SmallVec; use std::cell::Cell; use std::fs::File; use std::io::{self, Write}; +use std::ops::DerefMut; use std::option; use std::path::Path; use std::str::FromStr; @@ -703,42 +704,42 @@ impl<'a> ReplaceBodyWithLoop<'a> { } } -impl<'a> fold::Folder for ReplaceBodyWithLoop<'a> { - fn fold_item_kind(&mut self, i: ast::ItemKind) -> ast::ItemKind { +impl<'a> MutVisitor for ReplaceBodyWithLoop<'a> { + fn visit_item_kind(&mut self, i: &mut ast::ItemKind) { let is_const = match i { ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => true, ast::ItemKind::Fn(ref decl, ref header, _, _) => header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl), _ => false, }; - self.run(is_const, |s| fold::noop_fold_item_kind(i, s)) + self.run(is_const, |s| noop_visit_item_kind(i, s)) } - fn fold_trait_item(&mut self, i: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> { + fn flat_map_trait_item(&mut self, i: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> { let is_const = match i.node { ast::TraitItemKind::Const(..) => true, ast::TraitItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) => header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl), _ => false, }; - self.run(is_const, |s| fold::noop_fold_trait_item(i, s)) + self.run(is_const, |s| noop_flat_map_trait_item(i, s)) } - fn fold_impl_item(&mut self, i: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> { + fn flat_map_impl_item(&mut self, i: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> { let is_const = match i.node { ast::ImplItemKind::Const(..) => true, ast::ImplItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) => header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl), _ => false, }; - self.run(is_const, |s| fold::noop_fold_impl_item(i, s)) + self.run(is_const, |s| noop_flat_map_impl_item(i, s)) } - fn fold_anon_const(&mut self, c: ast::AnonConst) -> ast::AnonConst { - self.run(true, |s| fold::noop_fold_anon_const(c, s)) + fn visit_anon_const(&mut self, c: &mut ast::AnonConst) { + self.run(true, |s| noop_visit_anon_const(c, s)) } - fn fold_block(&mut self, b: P) -> P { + fn visit_block(&mut self, b: &mut P) { fn stmt_to_block(rules: ast::BlockCheckMode, s: Option, sess: &Session) -> ast::Block { @@ -780,14 +781,14 @@ impl<'a> fold::Folder for ReplaceBodyWithLoop<'a> { }; if self.within_static_or_const { - fold::noop_fold_block(b, self) + noop_visit_block(b, self) } else { - b.map(|b| { + visit_clobber(b.deref_mut(), |b| { let mut stmts = vec![]; for s in b.stmts { let old_blocks = self.nested_blocks.replace(vec![]); - stmts.extend(self.fold_stmt(s).into_iter().filter(|s| s.is_item())); + stmts.extend(self.flat_map_stmt(s).into_iter().filter(|s| s.is_item())); // we put a Some in there earlier with that replace(), so this is valid let new_blocks = self.nested_blocks.take().unwrap(); @@ -818,9 +819,9 @@ impl<'a> fold::Folder for ReplaceBodyWithLoop<'a> { } // in general the pretty printer processes unexpanded code, so - // we override the default `fold_mac` method which panics. - fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac { - fold::noop_fold_mac(mac, self) + // we override the default `visit_mac` method which panics. + fn visit_mac(&mut self, mac: &mut ast::Mac) { + noop_visit_mac(mac, self) } } @@ -889,12 +890,9 @@ fn print_flowgraph<'a, 'tcx, W: Write>(variants: Vec, } } -pub fn fold_crate(sess: &Session, krate: ast::Crate, ppm: PpMode) -> ast::Crate { +pub fn visit_crate(sess: &Session, krate: &mut ast::Crate, ppm: PpMode) { if let PpmSource(PpmEveryBodyLoops) = ppm { - let mut fold = ReplaceBodyWithLoop::new(sess); - fold.fold_crate(krate) - } else { - krate + ReplaceBodyWithLoop::new(sess).visit_crate(krate); } } diff --git a/src/libsyntax/attr/mod.rs b/src/libsyntax/attr/mod.rs index 58be7c3e085c3..c5a397e048078 100644 --- a/src/libsyntax/attr/mod.rs +++ b/src/libsyntax/attr/mod.rs @@ -15,6 +15,7 @@ use ast; use ast::{AttrId, Attribute, AttrStyle, Name, Ident, Path, PathSegment}; use ast::{MetaItem, MetaItemKind, NestedMetaItem, NestedMetaItemKind}; use ast::{Lit, LitKind, Expr, ExprKind, Item, Local, Stmt, StmtKind, GenericParam}; +use mut_visit::visit_clobber; use source_map::{BytePos, Spanned, respan, dummy_spanned}; use syntax_pos::{FileName, Span}; use parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration}; @@ -28,6 +29,7 @@ use tokenstream::{TokenStream, TokenTree, DelimSpan}; use GLOBALS; use std::iter; +use std::ops::DerefMut; pub fn mark_used(attr: &Attribute) { debug!("Marking {:?} as used.", attr); @@ -695,13 +697,13 @@ impl LitKind { pub trait HasAttrs: Sized { fn attrs(&self) -> &[ast::Attribute]; - fn map_attrs) -> Vec>(self, f: F) -> Self; + fn visit_attrs)>(&mut self, f: F); } impl HasAttrs for Spanned { fn attrs(&self) -> &[ast::Attribute] { self.node.attrs() } - fn map_attrs) -> Vec>(self, f: F) -> Self { - respan(self.span, self.node.map_attrs(f)) + fn visit_attrs)>(&mut self, f: F) { + self.node.visit_attrs(f); } } @@ -709,7 +711,7 @@ impl HasAttrs for Vec { fn attrs(&self) -> &[Attribute] { self } - fn map_attrs) -> Vec>(self, f: F) -> Self { + fn visit_attrs)>(&mut self, f: F) { f(self) } } @@ -718,8 +720,12 @@ impl HasAttrs for ThinVec { fn attrs(&self) -> &[Attribute] { self } - fn map_attrs) -> Vec>(self, f: F) -> Self { - f(self.into()).into() + fn visit_attrs)>(&mut self, f: F) { + visit_clobber(self, |this| { + let mut vec = this.into(); + f(&mut vec); + vec.into() + }); } } @@ -727,8 +733,8 @@ impl HasAttrs for P { fn attrs(&self) -> &[Attribute] { (**self).attrs() } - fn map_attrs) -> Vec>(self, f: F) -> Self { - self.map(|t| t.map_attrs(f)) + fn visit_attrs)>(&mut self, f: F) { + (**self).visit_attrs(f); } } @@ -745,23 +751,27 @@ impl HasAttrs for StmtKind { } } - fn map_attrs) -> Vec>(self, f: F) -> Self { + fn visit_attrs)>(&mut self, f: F) { match self { - StmtKind::Local(local) => StmtKind::Local(local.map_attrs(f)), - StmtKind::Item(..) => self, - StmtKind::Expr(expr) => StmtKind::Expr(expr.map_attrs(f)), - StmtKind::Semi(expr) => StmtKind::Semi(expr.map_attrs(f)), - StmtKind::Mac(mac) => StmtKind::Mac(mac.map(|(mac, style, attrs)| { - (mac, style, attrs.map_attrs(f)) - })), + StmtKind::Local(local) => local.visit_attrs(f), + StmtKind::Item(..) => {} + StmtKind::Expr(expr) => expr.visit_attrs(f), + StmtKind::Semi(expr) => expr.visit_attrs(f), + StmtKind::Mac(mac) => { + let (_mac, _style, attrs) = mac.deref_mut(); + attrs.visit_attrs(f); + } } } } impl HasAttrs for Stmt { - fn attrs(&self) -> &[ast::Attribute] { self.node.attrs() } - fn map_attrs) -> Vec>(self, f: F) -> Self { - Stmt { id: self.id, node: self.node.map_attrs(f), span: self.span } + fn attrs(&self) -> &[ast::Attribute] { + self.node.attrs() + } + + fn visit_attrs)>(&mut self, f: F) { + self.node.visit_attrs(f); } } @@ -770,9 +780,8 @@ impl HasAttrs for GenericParam { &self.attrs } - fn map_attrs) -> Vec>(mut self, f: F) -> Self { - self.attrs = self.attrs.map_attrs(f); - self + fn visit_attrs)>(&mut self, f: F) { + self.attrs.visit_attrs(f); } } @@ -783,11 +792,8 @@ macro_rules! derive_has_attrs { &self.attrs } - fn map_attrs(mut self, f: F) -> Self - where F: FnOnce(Vec) -> Vec, - { - self.attrs = self.attrs.map_attrs(f); - self + fn visit_attrs)>(&mut self, f: F) { + self.attrs.visit_attrs(f); } } )* } diff --git a/src/libsyntax/config.rs b/src/libsyntax/config.rs index b35730bf2381b..fce2601e3aa84 100644 --- a/src/libsyntax/config.rs +++ b/src/libsyntax/config.rs @@ -6,16 +6,15 @@ use feature_gate::{ get_features, GateIssue, }; -use {fold, attr}; +use attr; use ast; -use source_map::Spanned; use edition::Edition; -use parse::{token, ParseSess}; -use smallvec::SmallVec; use errors::Applicability; -use util::move_map::MoveMap; - +use mut_visit::*; +use parse::{token, ParseSess}; use ptr::P; +use smallvec::SmallVec; +use util::map_in_place::MapInPlace; /// A folder that strips out items that do not belong in the current configuration. pub struct StripUnconfigured<'a> { @@ -65,8 +64,8 @@ macro_rules! configure { } impl<'a> StripUnconfigured<'a> { - pub fn configure(&mut self, node: T) -> Option { - let node = self.process_cfg_attrs(node); + pub fn configure(&mut self, mut node: T) -> Option { + self.process_cfg_attrs(&mut node); if self.in_cfg(node.attrs()) { Some(node) } else { None } } @@ -76,10 +75,10 @@ impl<'a> StripUnconfigured<'a> { /// Gives compiler warnigns if any `cfg_attr` does not contain any /// attributes and is in the original source code. Gives compiler errors if /// the syntax of any `cfg_attr` is incorrect. - pub fn process_cfg_attrs(&mut self, node: T) -> T { - node.map_attrs(|attrs| { - attrs.into_iter().flat_map(|attr| self.process_cfg_attr(attr)).collect() - }) + pub fn process_cfg_attrs(&mut self, node: &mut T) { + node.visit_attrs(|attrs| { + attrs.flat_map_in_place(|attr| self.process_cfg_attr(attr)); + }); } /// Parse and expand a single `cfg_attr` attribute into a list of attributes @@ -218,70 +217,47 @@ impl<'a> StripUnconfigured<'a> { } } - pub fn configure_foreign_mod(&mut self, foreign_mod: ast::ForeignMod) -> ast::ForeignMod { - ast::ForeignMod { - abi: foreign_mod.abi, - items: foreign_mod.items.move_flat_map(|item| self.configure(item)), - } + pub fn configure_foreign_mod(&mut self, foreign_mod: &mut ast::ForeignMod) { + let ast::ForeignMod { abi: _, items } = foreign_mod; + items.flat_map_in_place(|item| self.configure(item)); } - fn configure_variant_data(&mut self, vdata: ast::VariantData) -> ast::VariantData { + fn configure_variant_data(&mut self, vdata: &mut ast::VariantData) { match vdata { - ast::VariantData::Struct(fields, id) => { - let fields = fields.move_flat_map(|field| self.configure(field)); - ast::VariantData::Struct(fields, id) - } - ast::VariantData::Tuple(fields, id) => { - let fields = fields.move_flat_map(|field| self.configure(field)); - ast::VariantData::Tuple(fields, id) - } - ast::VariantData::Unit(id) => ast::VariantData::Unit(id) + ast::VariantData::Struct(fields, _id) | + ast::VariantData::Tuple(fields, _id) => + fields.flat_map_in_place(|field| self.configure(field)), + ast::VariantData::Unit(_id) => {} } } - pub fn configure_item_kind(&mut self, item: ast::ItemKind) -> ast::ItemKind { + pub fn configure_item_kind(&mut self, item: &mut ast::ItemKind) { match item { - ast::ItemKind::Struct(def, generics) => { - ast::ItemKind::Struct(self.configure_variant_data(def), generics) - } - ast::ItemKind::Union(def, generics) => { - ast::ItemKind::Union(self.configure_variant_data(def), generics) - } - ast::ItemKind::Enum(def, generics) => { - let variants = def.variants.move_flat_map(|v| { - self.configure(v).map(|v| { - Spanned { - node: ast::Variant_ { - ident: v.node.ident, - attrs: v.node.attrs, - data: self.configure_variant_data(v.node.data), - disr_expr: v.node.disr_expr, - }, - span: v.span - } - }) - }); - ast::ItemKind::Enum(ast::EnumDef { variants }, generics) + ast::ItemKind::Struct(def, _generics) | + ast::ItemKind::Union(def, _generics) => self.configure_variant_data(def), + ast::ItemKind::Enum(ast::EnumDef { variants }, _generics) => { + variants.flat_map_in_place(|variant| self.configure(variant)); + for variant in variants { + self.configure_variant_data(&mut variant.node.data); + } } - item => item, + _ => {} } } - pub fn configure_expr_kind(&mut self, expr_kind: ast::ExprKind) -> ast::ExprKind { + pub fn configure_expr_kind(&mut self, expr_kind: &mut ast::ExprKind) { match expr_kind { - ast::ExprKind::Match(m, arms) => { - let arms = arms.move_flat_map(|a| self.configure(a)); - ast::ExprKind::Match(m, arms) + ast::ExprKind::Match(_m, arms) => { + arms.flat_map_in_place(|arm| self.configure(arm)); } - ast::ExprKind::Struct(path, fields, base) => { - let fields = fields.move_flat_map(|field| self.configure(field)); - ast::ExprKind::Struct(path, fields, base) + ast::ExprKind::Struct(_path, fields, _base) => { + fields.flat_map_in_place(|field| self.configure(field)); } - _ => expr_kind, + _ => {} } } - pub fn configure_expr(&mut self, expr: P) -> P { + pub fn configure_expr(&mut self, expr: &mut P) { self.visit_expr_attrs(expr.attrs()); // If an expr is valid to cfg away it will have been removed by the @@ -289,8 +265,8 @@ impl<'a> StripUnconfigured<'a> { // Anything else is always required, and thus has to error out // in case of a cfg attr. // - // N.B., this is intentionally not part of the fold_expr() function - // in order for fold_opt_expr() to be able to avoid this check + // N.B., this is intentionally not part of the visit_expr() function + // in order for filter_map_expr() to be able to avoid this check if let Some(attr) = expr.attrs().iter().find(|a| is_cfg(a)) { let msg = "removing an expression is not supported in this position"; self.sess.span_diagnostic.span_err(attr.span, msg); @@ -299,14 +275,10 @@ impl<'a> StripUnconfigured<'a> { self.process_cfg_attrs(expr) } - pub fn configure_pat(&mut self, pattern: P) -> P { - pattern.map(|mut pattern| { - if let ast::PatKind::Struct(path, fields, etc) = pattern.node { - let fields = fields.move_flat_map(|field| self.configure(field)); - pattern.node = ast::PatKind::Struct(path, fields, etc); - } - pattern - }) + pub fn configure_pat(&mut self, pat: &mut P) { + if let ast::PatKind::Struct(_path, fields, _etc) = &mut pat.node { + fields.flat_map_in_place(|field| self.configure(field)); + } } // deny #[cfg] on generic parameters until we decide what to do with it. @@ -326,54 +298,54 @@ impl<'a> StripUnconfigured<'a> { } } -impl<'a> fold::Folder for StripUnconfigured<'a> { - fn fold_foreign_mod(&mut self, foreign_mod: ast::ForeignMod) -> ast::ForeignMod { - let foreign_mod = self.configure_foreign_mod(foreign_mod); - fold::noop_fold_foreign_mod(foreign_mod, self) +impl<'a> MutVisitor for StripUnconfigured<'a> { + fn visit_foreign_mod(&mut self, foreign_mod: &mut ast::ForeignMod) { + self.configure_foreign_mod(foreign_mod); + noop_visit_foreign_mod(foreign_mod, self); } - fn fold_item_kind(&mut self, item: ast::ItemKind) -> ast::ItemKind { - let item = self.configure_item_kind(item); - fold::noop_fold_item_kind(item, self) + fn visit_item_kind(&mut self, item: &mut ast::ItemKind) { + self.configure_item_kind(item); + noop_visit_item_kind(item, self); } - fn fold_expr(&mut self, expr: P) -> P { - let mut expr = self.configure_expr(expr).into_inner(); - expr.node = self.configure_expr_kind(expr.node); - P(fold::noop_fold_expr(expr, self)) + fn visit_expr(&mut self, expr: &mut P) { + self.configure_expr(expr); + self.configure_expr_kind(&mut expr.node); + noop_visit_expr(expr, self); } - fn fold_opt_expr(&mut self, expr: P) -> Option> { - let mut expr = configure!(self, expr).into_inner(); - expr.node = self.configure_expr_kind(expr.node); - Some(P(fold::noop_fold_expr(expr, self))) + fn filter_map_expr(&mut self, expr: P) -> Option> { + let mut expr = configure!(self, expr); + self.configure_expr_kind(&mut expr.node); + noop_visit_expr(&mut expr, self); + Some(expr) } - fn fold_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> { - fold::noop_fold_stmt(configure!(self, stmt), self) + fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> { + noop_flat_map_stmt(configure!(self, stmt), self) } - fn fold_item(&mut self, item: P) -> SmallVec<[P; 1]> { - fold::noop_fold_item(configure!(self, item), self) + fn flat_map_item(&mut self, item: P) -> SmallVec<[P; 1]> { + noop_flat_map_item(configure!(self, item), self) } - fn fold_impl_item(&mut self, item: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> - { - fold::noop_fold_impl_item(configure!(self, item), self) + fn flat_map_impl_item(&mut self, item: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> { + noop_flat_map_impl_item(configure!(self, item), self) } - fn fold_trait_item(&mut self, item: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> { - fold::noop_fold_trait_item(configure!(self, item), self) + fn flat_map_trait_item(&mut self, item: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> { + noop_flat_map_trait_item(configure!(self, item), self) } - fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac { + fn visit_mac(&mut self, _mac: &mut ast::Mac) { // Don't configure interpolated AST (cf. issue #34171). // Interpolated AST will get configured once the surrounding tokens are parsed. - mac } - fn fold_pat(&mut self, pattern: P) -> P { - fold::noop_fold_pat(self.configure_pat(pattern), self) + fn visit_pat(&mut self, pat: &mut P) { + self.configure_pat(pat); + noop_visit_pat(pat, self) } } diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 09e7e57f78cfa..b53068f5bc2a4 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -8,7 +8,7 @@ use edition::Edition; use errors::{DiagnosticBuilder, DiagnosticId}; use ext::expand::{self, AstFragment, Invocation}; use ext::hygiene::{self, Mark, SyntaxContext, Transparency}; -use fold::{self, Folder}; +use mut_visit::{self, MutVisitor}; use parse::{self, parser, DirectoryOwnership}; use parse::token; use ptr::P; @@ -47,15 +47,14 @@ impl HasAttrs for Annotatable { } } - fn map_attrs) -> Vec>(self, f: F) -> Self { + fn visit_attrs)>(&mut self, f: F) { match self { - Annotatable::Item(item) => Annotatable::Item(item.map_attrs(f)), - Annotatable::TraitItem(trait_item) => Annotatable::TraitItem(trait_item.map_attrs(f)), - Annotatable::ImplItem(impl_item) => Annotatable::ImplItem(impl_item.map_attrs(f)), - Annotatable::ForeignItem(foreign_item) => - Annotatable::ForeignItem(foreign_item.map_attrs(f)), - Annotatable::Stmt(stmt) => Annotatable::Stmt(stmt.map_attrs(f)), - Annotatable::Expr(expr) => Annotatable::Expr(expr.map_attrs(f)), + Annotatable::Item(item) => item.visit_attrs(f), + Annotatable::TraitItem(trait_item) => trait_item.visit_attrs(f), + Annotatable::ImplItem(impl_item) => impl_item.visit_attrs(f), + Annotatable::ForeignItem(foreign_item) => foreign_item.visit_attrs(f), + Annotatable::Stmt(stmt) => stmt.visit_attrs(f), + Annotatable::Expr(expr) => expr.visit_attrs(f), } } } @@ -263,24 +262,24 @@ impl TTMacroExpander for F ) -> Box { struct AvoidInterpolatedIdents; - impl Folder for AvoidInterpolatedIdents { - fn fold_tt(&mut self, tt: tokenstream::TokenTree) -> tokenstream::TokenTree { - if let tokenstream::TokenTree::Token(_, token::Interpolated(ref nt)) = tt { + impl MutVisitor for AvoidInterpolatedIdents { + fn visit_tt(&mut self, tt: &mut tokenstream::TokenTree) { + if let tokenstream::TokenTree::Token(_, token::Interpolated(nt)) = tt { if let token::NtIdent(ident, is_raw) = nt.0 { - return tokenstream::TokenTree::Token(ident.span, - token::Ident(ident, is_raw)); + *tt = tokenstream::TokenTree::Token(ident.span, + token::Ident(ident, is_raw)); } } - fold::noop_fold_tt(tt, self) + mut_visit::noop_visit_tt(tt, self) } - fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac { - fold::noop_fold_mac(mac, self) + fn visit_mac(&mut self, mac: &mut ast::Mac) { + mut_visit::noop_visit_mac(mac, self) } } let input: Vec<_> = - input.trees().map(|tt| AvoidInterpolatedIdents.fold_tt(tt)).collect(); + input.trees().map(|mut tt| { AvoidInterpolatedIdents.visit_tt(&mut tt); tt }).collect(); (*self)(ecx, span, &input) } } @@ -981,17 +980,14 @@ impl<'a> ExtCtxt<'a> { /// compilation on error, merely emits a non-fatal error and returns None. pub fn expr_to_spanned_string<'a>( cx: &'a mut ExtCtxt, - expr: P, + mut expr: P, err_msg: &str, ) -> Result, Option>> { // Update `expr.span`'s ctxt now in case expr is an `include!` macro invocation. - let expr = expr.map(|mut expr| { - expr.span = expr.span.apply_mark(cx.current_expansion.mark); - expr - }); + expr.span = expr.span.apply_mark(cx.current_expansion.mark); // we want to be able to handle e.g., `concat!("foo", "bar")` - let expr = cx.expander().fold_expr(expr); + cx.expander().visit_expr(&mut expr); Err(match expr.node { ast::ExprKind::Lit(ref l) => match l.node { ast::LitKind::Str(s, style) => return Ok(respan(expr.span, (s, style))), @@ -1055,7 +1051,9 @@ pub fn get_exprs_from_tts(cx: &mut ExtCtxt, let mut p = cx.new_parser_from_tts(tts); let mut es = Vec::new(); while p.token != token::Eof { - es.push(cx.expander().fold_expr(panictry!(p.parse_expr()))); + let mut expr = panictry!(p.parse_expr()); + cx.expander().visit_expr(&mut expr); + es.push(expr); if p.eat(&token::Comma) { continue; } diff --git a/src/libsyntax/ext/derive.rs b/src/libsyntax/ext/derive.rs index 7ef09ce5fbd40..fa8cf6c496a39 100644 --- a/src/libsyntax/ext/derive.rs +++ b/src/libsyntax/ext/derive.rs @@ -40,7 +40,7 @@ pub fn collect_derives(cx: &mut ExtCtxt, attrs: &mut Vec) -> Vec result } -pub fn add_derived_markers(cx: &mut ExtCtxt, span: Span, traits: &[ast::Path], item: T) -> T +pub fn add_derived_markers(cx: &mut ExtCtxt, span: Span, traits: &[ast::Path], item: &mut T) where T: HasAttrs, { let (mut names, mut pretty_name) = (FxHashSet::default(), "derive(".to_owned()); @@ -64,7 +64,7 @@ pub fn add_derived_markers(cx: &mut ExtCtxt, span: Span, traits: &[ast::Path] }); let span = span.with_ctxt(cx.backtrace()); - item.map_attrs(|mut attrs| { + item.visit_attrs(|attrs| { if names.contains(&Symbol::intern("Eq")) && names.contains(&Symbol::intern("PartialEq")) { let meta = cx.meta_word(span, Symbol::intern("structural_match")); attrs.push(cx.attribute(span, meta)); @@ -73,6 +73,5 @@ pub fn add_derived_markers(cx: &mut ExtCtxt, span: Span, traits: &[ast::Path] let meta = cx.meta_word(span, Symbol::intern("rustc_copy_clone_marker")); attrs.push(cx.attribute(span, meta)); } - attrs - }) + }); } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 2effd910e8545..a0ccce986592a 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -9,7 +9,7 @@ use ext::derive::{add_derived_markers, collect_derives}; use ext::hygiene::{self, Mark, SyntaxContext}; use ext::placeholders::{placeholder, PlaceholderExpander}; use feature_gate::{self, Features, GateIssue, is_builtin_attr, emit_feature_err}; -use fold::*; +use mut_visit::*; use parse::{DirectoryOwnership, PResult, ParseSess}; use parse::token::{self, Token}; use parse::parser::Parser; @@ -21,11 +21,13 @@ use syntax_pos::{Span, DUMMY_SP, FileName}; use syntax_pos::hygiene::ExpnFormat; use tokenstream::{TokenStream, TokenTree}; use visit::{self, Visitor}; +use util::map_in_place::MapInPlace; use rustc_data_structures::fx::FxHashMap; use std::fs; use std::io::ErrorKind; use std::{iter, mem}; +use std::ops::DerefMut; use std::rc::Rc; use std::path::PathBuf; @@ -35,8 +37,8 @@ macro_rules! ast_fragments { $kind_name:expr; // FIXME: HACK: this should be `$(one ...)?` and `$(many ...)?` but `?` macro // repetition was removed from 2015 edition in #51587 because of ambiguities. - $(one fn $fold_ast:ident; fn $visit_ast:ident;)* - $(many fn $fold_ast_elt:ident; fn $visit_ast_elt:ident;)* + $(one fn $mut_visit_ast:ident; fn $visit_ast:ident;)* + $(many fn $flat_map_ast_elt:ident; fn $visit_ast_elt:ident;)* fn $make_ast:ident; })* ) => { @@ -86,16 +88,20 @@ macro_rules! ast_fragments { } })* - pub fn fold_with(self, folder: &mut F) -> Self { + pub fn mut_visit_with(&mut self, vis: &mut F) { match self { - AstFragment::OptExpr(expr) => - AstFragment::OptExpr(expr.and_then(|expr| folder.fold_opt_expr(expr))), - $($(AstFragment::$Kind(ast) => - AstFragment::$Kind(folder.$fold_ast(ast)),)*)* + AstFragment::OptExpr(opt_expr) => { + visit_clobber(opt_expr, |opt_expr| { + if let Some(expr) = opt_expr { + vis.filter_map_expr(expr) + } else { + None + } + }); + } + $($(AstFragment::$Kind(ast) => vis.$mut_visit_ast(ast),)*)* $($(AstFragment::$Kind(ast) => - AstFragment::$Kind(ast.into_iter() - .flat_map(|ast| folder.$fold_ast_elt(ast)) - .collect()),)*)* + ast.flat_map_in_place(|ast| vis.$flat_map_ast_elt(ast)),)*)* } } @@ -111,14 +117,14 @@ macro_rules! ast_fragments { } } - impl<'a, 'b> Folder for MacroExpander<'a, 'b> { - fn fold_opt_expr(&mut self, expr: P) -> Option> { + impl<'a, 'b> MutVisitor for MacroExpander<'a, 'b> { + fn filter_map_expr(&mut self, expr: P) -> Option> { self.expand_fragment(AstFragment::OptExpr(Some(expr))).make_opt_expr() } - $($(fn $fold_ast(&mut self, ast: $AstTy) -> $AstTy { - self.expand_fragment(AstFragment::$Kind(ast)).$make_ast() + $($(fn $mut_visit_ast(&mut self, ast: &mut $AstTy) { + visit_clobber(ast, |ast| self.expand_fragment(AstFragment::$Kind(ast)).$make_ast()); })*)* - $($(fn $fold_ast_elt(&mut self, ast_elt: <$AstTy as IntoIterator>::Item) -> $AstTy { + $($(fn $flat_map_ast_elt(&mut self, ast_elt: <$AstTy as IntoIterator>::Item) -> $AstTy { self.expand_fragment(AstFragment::$Kind(smallvec![ast_elt])).$make_ast() })*)* } @@ -133,23 +139,23 @@ macro_rules! ast_fragments { } ast_fragments! { - Expr(P) { "expression"; one fn fold_expr; fn visit_expr; fn make_expr; } - Pat(P) { "pattern"; one fn fold_pat; fn visit_pat; fn make_pat; } - Ty(P) { "type"; one fn fold_ty; fn visit_ty; fn make_ty; } + Expr(P) { "expression"; one fn visit_expr; fn visit_expr; fn make_expr; } + Pat(P) { "pattern"; one fn visit_pat; fn visit_pat; fn make_pat; } + Ty(P) { "type"; one fn visit_ty; fn visit_ty; fn make_ty; } Stmts(SmallVec<[ast::Stmt; 1]>) { - "statement"; many fn fold_stmt; fn visit_stmt; fn make_stmts; + "statement"; many fn flat_map_stmt; fn visit_stmt; fn make_stmts; } Items(SmallVec<[P; 1]>) { - "item"; many fn fold_item; fn visit_item; fn make_items; + "item"; many fn flat_map_item; fn visit_item; fn make_items; } TraitItems(SmallVec<[ast::TraitItem; 1]>) { - "trait item"; many fn fold_trait_item; fn visit_trait_item; fn make_trait_items; + "trait item"; many fn flat_map_trait_item; fn visit_trait_item; fn make_trait_items; } ImplItems(SmallVec<[ast::ImplItem; 1]>) { - "impl item"; many fn fold_impl_item; fn visit_impl_item; fn make_impl_items; + "impl item"; many fn flat_map_impl_item; fn visit_impl_item; fn make_impl_items; } ForeignItems(SmallVec<[ast::ForeignItem; 1]>) { - "foreign item"; many fn fold_foreign_item; fn visit_foreign_item; fn make_foreign_items; + "foreign item"; many fn flat_map_foreign_item; fn visit_foreign_item; fn make_foreign_items; } } @@ -297,7 +303,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { self.cx.current_expansion.depth = 0; // Collect all macro invocations and replace them with placeholders. - let (fragment_with_placeholders, mut invocations) + let (mut fragment_with_placeholders, mut invocations) = self.collect_invocations(input_fragment, &[]); // Optimization: if we resolve all imports now, @@ -369,10 +375,10 @@ impl<'a, 'b> MacroExpander<'a, 'b> { err.emit(); } - let item = self.fully_configure(item) - .map_attrs(|mut attrs| { attrs.retain(|a| a.path != "derive"); attrs }); - let item_with_markers = - add_derived_markers(&mut self.cx, item.span(), &traits, item.clone()); + let mut item = self.fully_configure(item); + item.visit_attrs(|attrs| attrs.retain(|a| a.path != "derive")); + let mut item_with_markers = item.clone(); + add_derived_markers(&mut self.cx, item.span(), &traits, &mut item_with_markers); let derives = derives.entry(invoc.expansion_data.mark).or_default(); derives.reserve(traits.len()); @@ -427,7 +433,8 @@ impl<'a, 'b> MacroExpander<'a, 'b> { expanded_fragment, derives); } } - fragment_with_placeholders.fold_with(&mut placeholder_expander) + fragment_with_placeholders.mut_visit_with(&mut placeholder_expander); + fragment_with_placeholders } fn resolve_imports(&mut self) { @@ -440,12 +447,12 @@ impl<'a, 'b> MacroExpander<'a, 'b> { /// them with "placeholders" - dummy macro invocations with specially crafted `NodeId`s. /// Then call into resolver that builds a skeleton ("reduced graph") of the fragment and /// prepares data for resolving paths of macro invocations. - fn collect_invocations(&mut self, fragment: AstFragment, derives: &[Mark]) + fn collect_invocations(&mut self, mut fragment: AstFragment, derives: &[Mark]) -> (AstFragment, Vec) { // Resolve `$crate`s in the fragment for pretty-printing. self.cx.resolver.resolve_dollar_crates(&fragment); - let (fragment_with_placeholders, invocations) = { + let invocations = { let mut collector = InvocationCollector { cfg: StripUnconfigured { sess: self.cx.parse_sess, @@ -455,16 +462,16 @@ impl<'a, 'b> MacroExpander<'a, 'b> { invocations: Vec::new(), monotonic: self.monotonic, }; - (fragment.fold_with(&mut collector), collector.invocations) + fragment.mut_visit_with(&mut collector); + collector.invocations }; if self.monotonic { self.cx.resolver.visit_ast_fragment_with_placeholders( - self.cx.current_expansion.mark, &fragment_with_placeholders, derives - ); + self.cx.current_expansion.mark, &fragment, derives); } - (fragment_with_placeholders, invocations) + (fragment, invocations) } fn fully_configure(&mut self, item: Annotatable) -> Annotatable { @@ -476,24 +483,25 @@ impl<'a, 'b> MacroExpander<'a, 'b> { // we know that fold result vector will contain exactly one element match item { Annotatable::Item(item) => { - Annotatable::Item(cfg.fold_item(item).pop().unwrap()) + Annotatable::Item(cfg.flat_map_item(item).pop().unwrap()) } Annotatable::TraitItem(item) => { - Annotatable::TraitItem(item.map(|item| cfg.fold_trait_item(item).pop().unwrap())) + Annotatable::TraitItem( + item.map(|item| cfg.flat_map_trait_item(item).pop().unwrap())) } Annotatable::ImplItem(item) => { - Annotatable::ImplItem(item.map(|item| cfg.fold_impl_item(item).pop().unwrap())) + Annotatable::ImplItem(item.map(|item| cfg.flat_map_impl_item(item).pop().unwrap())) } Annotatable::ForeignItem(item) => { Annotatable::ForeignItem( - item.map(|item| cfg.fold_foreign_item(item).pop().unwrap()) + item.map(|item| cfg.flat_map_foreign_item(item).pop().unwrap()) ) } Annotatable::Stmt(stmt) => { - Annotatable::Stmt(stmt.map(|stmt| cfg.fold_stmt(stmt).pop().unwrap())) + Annotatable::Stmt(stmt.map(|stmt| cfg.flat_map_stmt(stmt).pop().unwrap())) } - Annotatable::Expr(expr) => { - Annotatable::Expr(cfg.fold_expr(expr)) + Annotatable::Expr(mut expr) => { + Annotatable::Expr({ cfg.visit_expr(&mut expr); expr }) } } } @@ -535,7 +543,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { invoc: Invocation, ext: &SyntaxExtension) -> Option { - let (attr, item) = match invoc.kind { + let (attr, mut item) = match invoc.kind { InvocationKind::Attr { attr, item, .. } => (attr?, item), _ => unreachable!(), }; @@ -558,7 +566,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { match *ext { NonMacroAttr { .. } => { attr::mark_known(&attr); - let item = item.map_attrs(|mut attrs| { attrs.push(attr); attrs }); + item.visit_attrs(|attrs| attrs.push(attr)); Some(invoc.fragment_kind.expect_from_annotatables(iter::once(item))) } MultiModifier(ref mac) => { @@ -1113,34 +1121,32 @@ impl<'a, 'b> InvocationCollector<'a, 'b> { } /// If `item` is an attr invocation, remove and return the macro attribute and derive traits. - fn classify_item(&mut self, mut item: T) - -> (Option, Vec, T, /* after_derive */ bool) + fn classify_item(&mut self, item: &mut T) + -> (Option, Vec, /* after_derive */ bool) where T: HasAttrs, { let (mut attr, mut traits, mut after_derive) = (None, Vec::new(), false); - item = item.map_attrs(|mut attrs| { + item.visit_attrs(|mut attrs| { attr = self.find_attr_invoc(&mut attrs, &mut after_derive); traits = collect_derives(&mut self.cx, &mut attrs); - attrs }); - (attr, traits, item, after_derive) + (attr, traits, after_derive) } - /// Alternative of `classify_item()` that ignores `#[derive]` so invocations fallthrough + /// Alternative to `classify_item()` that ignores `#[derive]` so invocations fallthrough /// to the unused-attributes lint (making it an error on statements and expressions /// is a breaking change) - fn classify_nonitem(&mut self, mut item: T) - -> (Option, T, /* after_derive */ bool) { + fn classify_nonitem(&mut self, nonitem: &mut T) + -> (Option, /* after_derive */ bool) { let (mut attr, mut after_derive) = (None, false); - item = item.map_attrs(|mut attrs| { + nonitem.visit_attrs(|mut attrs| { attr = self.find_attr_invoc(&mut attrs, &mut after_derive); - attrs }); - (attr, item, after_derive) + (attr, after_derive) } fn configure(&mut self, node: T) -> Option { @@ -1173,14 +1179,14 @@ impl<'a, 'b> InvocationCollector<'a, 'b> { } } -impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { - fn fold_expr(&mut self, expr: P) -> P { - let expr = self.cfg.configure_expr(expr); - expr.map(|mut expr| { - expr.node = self.cfg.configure_expr_kind(expr.node); +impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> { + fn visit_expr(&mut self, expr: &mut P) { + self.cfg.configure_expr(expr); + visit_clobber(expr.deref_mut(), |mut expr| { + self.cfg.configure_expr_kind(&mut expr.node); // ignore derives so they remain unused - let (attr, expr, after_derive) = self.classify_nonitem(expr); + let (attr, after_derive) = self.classify_nonitem(&mut expr); if attr.is_some() { // Collect the invoc regardless of whether or not attributes are permitted here @@ -1189,7 +1195,7 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { // AstFragmentKind::Expr requires the macro to emit an expression. return self.collect_attr(attr, vec![], Annotatable::Expr(P(expr)), - AstFragmentKind::Expr, after_derive) + AstFragmentKind::Expr, after_derive) .make_expr() .into_inner() } @@ -1200,18 +1206,19 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { .make_expr() .into_inner() } else { - noop_fold_expr(expr, self) + noop_visit_expr(&mut expr, self); + expr } - }) + }); } - fn fold_opt_expr(&mut self, expr: P) -> Option> { + fn filter_map_expr(&mut self, expr: P) -> Option> { let expr = configure!(self, expr); expr.filter_map(|mut expr| { - expr.node = self.cfg.configure_expr_kind(expr.node); + self.cfg.configure_expr_kind(&mut expr.node); // Ignore derives so they remain unused. - let (attr, expr, after_derive) = self.classify_nonitem(expr); + let (attr, after_derive) = self.classify_nonitem(&mut expr); if attr.is_some() { attr.as_ref().map(|a| self.cfg.maybe_emit_expr_attr_err(a)); @@ -1228,44 +1235,45 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { .make_opt_expr() .map(|expr| expr.into_inner()) } else { - Some(noop_fold_expr(expr, self)) + Some({ noop_visit_expr(&mut expr, self); expr }) } }) } - fn fold_pat(&mut self, pat: P) -> P { - let pat = self.cfg.configure_pat(pat); + fn visit_pat(&mut self, pat: &mut P) { + self.cfg.configure_pat(pat); match pat.node { PatKind::Mac(_) => {} - _ => return noop_fold_pat(pat, self), + _ => return noop_visit_pat(pat, self), } - pat.and_then(|pat| match pat.node { - PatKind::Mac(mac) => self.collect_bang(mac, pat.span, AstFragmentKind::Pat).make_pat(), - _ => unreachable!(), - }) + visit_clobber(pat, |mut pat| { + match mem::replace(&mut pat.node, PatKind::Wild) { + PatKind::Mac(mac) => + self.collect_bang(mac, pat.span, AstFragmentKind::Pat).make_pat(), + _ => unreachable!(), + } + }); } - fn fold_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> { + fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> { let mut stmt = configure!(self, stmt); // we'll expand attributes on expressions separately if !stmt.is_expr() { - let (attr, derives, stmt_, after_derive) = if stmt.is_item() { - self.classify_item(stmt) + let (attr, derives, after_derive) = if stmt.is_item() { + self.classify_item(&mut stmt) } else { // ignore derives on non-item statements so it falls through // to the unused-attributes lint - let (attr, stmt, after_derive) = self.classify_nonitem(stmt); - (attr, vec![], stmt, after_derive) + let (attr, after_derive) = self.classify_nonitem(&mut stmt); + (attr, vec![], after_derive) }; if attr.is_some() || !derives.is_empty() { - return self.collect_attr(attr, derives, Annotatable::Stmt(P(stmt_)), + return self.collect_attr(attr, derives, Annotatable::Stmt(P(stmt)), AstFragmentKind::Stmts, after_derive).make_stmts(); } - - stmt = stmt_; } if let StmtKind::Mac(mac) = stmt.node { @@ -1287,24 +1295,23 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { // The placeholder expander gives ids to statements, so we avoid folding the id here. let ast::Stmt { id, node, span } = stmt; - noop_fold_stmt_kind(node, self).into_iter().map(|node| { + noop_flat_map_stmt_kind(node, self).into_iter().map(|node| { ast::Stmt { id, node, span } }).collect() } - fn fold_block(&mut self, block: P) -> P { + fn visit_block(&mut self, block: &mut P) { let old_directory_ownership = self.cx.current_expansion.directory_ownership; self.cx.current_expansion.directory_ownership = DirectoryOwnership::UnownedViaBlock; - let result = noop_fold_block(block, self); + noop_visit_block(block, self); self.cx.current_expansion.directory_ownership = old_directory_ownership; - result } - fn fold_item(&mut self, item: P) -> SmallVec<[P; 1]> { - let item = configure!(self, item); + fn flat_map_item(&mut self, item: P) -> SmallVec<[P; 1]> { + let mut item = configure!(self, item); - let (attr, traits, item, after_derive) = self.classify_item(item); + let (attr, traits, after_derive) = self.classify_item(&mut item); if attr.is_some() || !traits.is_empty() { return self.collect_attr(attr, traits, Annotatable::Item(item), AstFragmentKind::Items, after_derive).make_items(); @@ -1326,7 +1333,7 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { } ast::ItemKind::Mod(ast::Mod { inner, .. }) => { if item.ident == keywords::Invalid.ident() { - return noop_fold_item(item, self); + return noop_flat_map_item(item, self); } let orig_directory_ownership = self.cx.current_expansion.directory_ownership; @@ -1366,20 +1373,20 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { let orig_module = mem::replace(&mut self.cx.current_expansion.module, Rc::new(module)); - let result = noop_fold_item(item, self); + let result = noop_flat_map_item(item, self); self.cx.current_expansion.module = orig_module; self.cx.current_expansion.directory_ownership = orig_directory_ownership; result } - _ => noop_fold_item(item, self), + _ => noop_flat_map_item(item, self), } } - fn fold_trait_item(&mut self, item: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> { - let item = configure!(self, item); + fn flat_map_trait_item(&mut self, item: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> { + let mut item = configure!(self, item); - let (attr, traits, item, after_derive) = self.classify_item(item); + let (attr, traits, after_derive) = self.classify_item(&mut item); if attr.is_some() || !traits.is_empty() { return self.collect_attr(attr, traits, Annotatable::TraitItem(P(item)), AstFragmentKind::TraitItems, after_derive).make_trait_items() @@ -1391,14 +1398,14 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { self.check_attributes(&attrs); self.collect_bang(mac, span, AstFragmentKind::TraitItems).make_trait_items() } - _ => noop_fold_trait_item(item, self), + _ => noop_flat_map_trait_item(item, self), } } - fn fold_impl_item(&mut self, item: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> { - let item = configure!(self, item); + fn flat_map_impl_item(&mut self, item: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> { + let mut item = configure!(self, item); - let (attr, traits, item, after_derive) = self.classify_item(item); + let (attr, traits, after_derive) = self.classify_item(&mut item); if attr.is_some() || !traits.is_empty() { return self.collect_attr(attr, traits, Annotatable::ImplItem(P(item)), AstFragmentKind::ImplItems, after_derive).make_impl_items(); @@ -1410,30 +1417,34 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { self.check_attributes(&attrs); self.collect_bang(mac, span, AstFragmentKind::ImplItems).make_impl_items() } - _ => noop_fold_impl_item(item, self), + _ => noop_flat_map_impl_item(item, self), } } - fn fold_ty(&mut self, ty: P) -> P { - let ty = match ty.node { - ast::TyKind::Mac(_) => ty.into_inner(), - _ => return noop_fold_ty(ty, self), + fn visit_ty(&mut self, ty: &mut P) { + match ty.node { + ast::TyKind::Mac(_) => {} + _ => return noop_visit_ty(ty, self), }; - match ty.node { - ast::TyKind::Mac(mac) => self.collect_bang(mac, ty.span, AstFragmentKind::Ty).make_ty(), - _ => unreachable!(), - } + visit_clobber(ty, |mut ty| { + match mem::replace(&mut ty.node, ast::TyKind::Err) { + ast::TyKind::Mac(mac) => + self.collect_bang(mac, ty.span, AstFragmentKind::Ty).make_ty(), + _ => unreachable!(), + } + }); } - fn fold_foreign_mod(&mut self, foreign_mod: ast::ForeignMod) -> ast::ForeignMod { - noop_fold_foreign_mod(self.cfg.configure_foreign_mod(foreign_mod), self) + fn visit_foreign_mod(&mut self, foreign_mod: &mut ast::ForeignMod) { + self.cfg.configure_foreign_mod(foreign_mod); + noop_visit_foreign_mod(foreign_mod, self); } - fn fold_foreign_item(&mut self, foreign_item: ast::ForeignItem) + fn flat_map_foreign_item(&mut self, mut foreign_item: ast::ForeignItem) -> SmallVec<[ast::ForeignItem; 1]> { - let (attr, traits, foreign_item, after_derive) = self.classify_item(foreign_item); + let (attr, traits, after_derive) = self.classify_item(&mut foreign_item); if attr.is_some() || !traits.is_empty() { return self.collect_attr(attr, traits, Annotatable::ForeignItem(P(foreign_item)), @@ -1447,38 +1458,41 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { .make_foreign_items(); } - noop_fold_foreign_item(foreign_item, self) + noop_flat_map_foreign_item(foreign_item, self) } - fn fold_item_kind(&mut self, item: ast::ItemKind) -> ast::ItemKind { + fn visit_item_kind(&mut self, item: &mut ast::ItemKind) { match item { - ast::ItemKind::MacroDef(..) => item, - _ => noop_fold_item_kind(self.cfg.configure_item_kind(item), self), + ast::ItemKind::MacroDef(..) => {} + _ => { + self.cfg.configure_item_kind(item); + noop_visit_item_kind(item, self); + } } } - fn fold_generic_param(&mut self, param: ast::GenericParam) -> ast::GenericParam { + fn visit_generic_param(&mut self, param: &mut ast::GenericParam) { self.cfg.disallow_cfg_on_generic_param(¶m); - noop_fold_generic_param(param, self) + noop_visit_generic_param(param, self) } - fn fold_attribute(&mut self, at: ast::Attribute) -> ast::Attribute { + fn visit_attribute(&mut self, at: &mut ast::Attribute) { // turn `#[doc(include="filename")]` attributes into `#[doc(include(file="filename", // contents="file contents")]` attributes if !at.check_name("doc") { - return noop_fold_attribute(at, self); + return noop_visit_attribute(at, self); } if let Some(list) = at.meta_item_list() { if !list.iter().any(|it| it.check_name("include")) { - return noop_fold_attribute(at, self); + return noop_visit_attribute(at, self); } let mut items = vec![]; - for it in list { + for mut it in list { if !it.check_name("include") { - items.push(noop_fold_meta_list_item(it, self)); + items.push({ noop_visit_meta_list_item(&mut it, self); it }); continue; } @@ -1487,7 +1501,7 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { self.check_attribute(&at); if self.cx.parse_sess.span_diagnostic.err_count() > err_count { // avoid loading the file if they haven't enabled the feature - return noop_fold_attribute(at, self); + return noop_visit_attribute(at, self); } let filename = self.cx.root_path.join(file.to_string()); @@ -1582,20 +1596,18 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> { let meta = attr::mk_list_item(DUMMY_SP, Ident::from_str("doc"), items); match at.style { - ast::AttrStyle::Inner => attr::mk_spanned_attr_inner(at.span, at.id, meta), - ast::AttrStyle::Outer => attr::mk_spanned_attr_outer(at.span, at.id, meta), + ast::AttrStyle::Inner => *at = attr::mk_spanned_attr_inner(at.span, at.id, meta), + ast::AttrStyle::Outer => *at = attr::mk_spanned_attr_outer(at.span, at.id, meta), } } else { - noop_fold_attribute(at, self) + noop_visit_attribute(at, self) } } - fn new_id(&mut self, id: ast::NodeId) -> ast::NodeId { + fn visit_id(&mut self, id: &mut ast::NodeId) { if self.monotonic { - assert_eq!(id, ast::DUMMY_NODE_ID); - self.cx.resolver.next_node_id() - } else { - id + debug_assert_eq!(*id, ast::DUMMY_NODE_ID); + *id = self.cx.resolver.next_node_id() } } } @@ -1660,12 +1672,12 @@ impl<'feat> ExpansionConfig<'feat> { #[derive(Debug)] pub struct Marker(pub Mark); -impl Folder for Marker { - fn new_span(&mut self, span: Span) -> Span { - span.apply_mark(self.0) +impl MutVisitor for Marker { + fn visit_span(&mut self, span: &mut Span) { + *span = span.apply_mark(self.0) } - fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac { - noop_fold_mac(mac, self) + fn visit_mac(&mut self, mac: &mut ast::Mac) { + noop_visit_mac(mac, self) } } diff --git a/src/libsyntax/ext/placeholders.rs b/src/libsyntax/ext/placeholders.rs index 0928bc804041d..23b34c2660bda 100644 --- a/src/libsyntax/ext/placeholders.rs +++ b/src/libsyntax/ext/placeholders.rs @@ -4,12 +4,11 @@ use ext::base::ExtCtxt; use ext::expand::{AstFragment, AstFragmentKind}; use ext::hygiene::Mark; use tokenstream::TokenStream; -use fold::*; +use mut_visit::*; use ptr::P; use smallvec::SmallVec; use symbol::keywords; use ThinVec; -use util::move_map::MoveMap; use rustc_data_structures::fx::FxHashMap; @@ -85,8 +84,8 @@ impl<'a, 'b> PlaceholderExpander<'a, 'b> { } } - pub fn add(&mut self, id: ast::NodeId, fragment: AstFragment, derives: Vec) { - let mut fragment = fragment.fold_with(self); + pub fn add(&mut self, id: ast::NodeId, mut fragment: AstFragment, derives: Vec) { + fragment.mut_visit_with(self); if let AstFragment::Items(mut items) = fragment { for derive in derives { match self.remove(NodeId::placeholder_from_mark(derive)) { @@ -104,56 +103,56 @@ impl<'a, 'b> PlaceholderExpander<'a, 'b> { } } -impl<'a, 'b> Folder for PlaceholderExpander<'a, 'b> { - fn fold_item(&mut self, item: P) -> SmallVec<[P; 1]> { +impl<'a, 'b> MutVisitor for PlaceholderExpander<'a, 'b> { + fn flat_map_item(&mut self, item: P) -> SmallVec<[P; 1]> { match item.node { ast::ItemKind::Mac(_) => return self.remove(item.id).make_items(), ast::ItemKind::MacroDef(_) => return smallvec![item], _ => {} } - noop_fold_item(item, self) + noop_flat_map_item(item, self) } - fn fold_trait_item(&mut self, item: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> { + fn flat_map_trait_item(&mut self, item: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> { match item.node { ast::TraitItemKind::Macro(_) => self.remove(item.id).make_trait_items(), - _ => noop_fold_trait_item(item, self), + _ => noop_flat_map_trait_item(item, self), } } - fn fold_impl_item(&mut self, item: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> { + fn flat_map_impl_item(&mut self, item: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> { match item.node { ast::ImplItemKind::Macro(_) => self.remove(item.id).make_impl_items(), - _ => noop_fold_impl_item(item, self), + _ => noop_flat_map_impl_item(item, self), } } - fn fold_foreign_item(&mut self, item: ast::ForeignItem) -> SmallVec<[ast::ForeignItem; 1]> { + fn flat_map_foreign_item(&mut self, item: ast::ForeignItem) -> SmallVec<[ast::ForeignItem; 1]> { match item.node { ast::ForeignItemKind::Macro(_) => self.remove(item.id).make_foreign_items(), - _ => noop_fold_foreign_item(item, self), + _ => noop_flat_map_foreign_item(item, self), } } - fn fold_expr(&mut self, expr: P) -> P { + fn visit_expr(&mut self, expr: &mut P) { match expr.node { - ast::ExprKind::Mac(_) => self.remove(expr.id).make_expr(), - _ => expr.map(|expr| noop_fold_expr(expr, self)), + ast::ExprKind::Mac(_) => *expr = self.remove(expr.id).make_expr(), + _ => noop_visit_expr(expr, self), } } - fn fold_opt_expr(&mut self, expr: P) -> Option> { + fn filter_map_expr(&mut self, expr: P) -> Option> { match expr.node { ast::ExprKind::Mac(_) => self.remove(expr.id).make_opt_expr(), - _ => noop_fold_opt_expr(expr, self), + _ => noop_filter_map_expr(expr, self), } } - fn fold_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> { + fn flat_map_stmt(&mut self, stmt: ast::Stmt) -> SmallVec<[ast::Stmt; 1]> { let (style, mut stmts) = match stmt.node { ast::StmtKind::Mac(mac) => (mac.1, self.remove(stmt.id).make_stmts()), - _ => return noop_fold_stmt(stmt, self), + _ => return noop_flat_map_stmt(stmt, self), }; if style == ast::MacStmtStyle::Semicolon { @@ -165,44 +164,40 @@ impl<'a, 'b> Folder for PlaceholderExpander<'a, 'b> { stmts } - fn fold_pat(&mut self, pat: P) -> P { + fn visit_pat(&mut self, pat: &mut P) { match pat.node { - ast::PatKind::Mac(_) => self.remove(pat.id).make_pat(), - _ => noop_fold_pat(pat, self), + ast::PatKind::Mac(_) => *pat = self.remove(pat.id).make_pat(), + _ => noop_visit_pat(pat, self), } } - fn fold_ty(&mut self, ty: P) -> P { + fn visit_ty(&mut self, ty: &mut P) { match ty.node { - ast::TyKind::Mac(_) => self.remove(ty.id).make_ty(), - _ => noop_fold_ty(ty, self), + ast::TyKind::Mac(_) => *ty = self.remove(ty.id).make_ty(), + _ => noop_visit_ty(ty, self), } } - fn fold_block(&mut self, block: P) -> P { - noop_fold_block(block, self).map(|mut block| { - block.stmts = block.stmts.move_map(|mut stmt| { - if self.monotonic { - assert_eq!(stmt.id, ast::DUMMY_NODE_ID); - stmt.id = self.cx.resolver.next_node_id(); - } - stmt - }); + fn visit_block(&mut self, block: &mut P) { + noop_visit_block(block, self); - block - }) + for stmt in block.stmts.iter_mut() { + if self.monotonic { + assert_eq!(stmt.id, ast::DUMMY_NODE_ID); + stmt.id = self.cx.resolver.next_node_id(); + } + } } - fn fold_mod(&mut self, module: ast::Mod) -> ast::Mod { - let mut module = noop_fold_mod(module, self); + fn visit_mod(&mut self, module: &mut ast::Mod) { + noop_visit_mod(module, self); module.items.retain(|item| match item.node { ast::ItemKind::Mac(_) if !self.cx.ecfg.keep_macs => false, // remove macro definitions _ => true, }); - module } - fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac { - mac + fn visit_mac(&mut self, _mac: &mut ast::Mac) { + // Do nothing. } } diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 0ef2d3b749d81..08f34b22328b6 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -3,7 +3,7 @@ use ext::base::ExtCtxt; use ext::expand::Marker; use ext::tt::macro_parser::{NamedMatch, MatchedSeq, MatchedNonterminal}; use ext::tt::quoted; -use fold::noop_fold_tt; +use mut_visit::noop_visit_tt; use parse::token::{self, Token, NtTT}; use smallvec::SmallVec; use syntax_pos::DUMMY_SP; @@ -170,7 +170,9 @@ pub fn transcribe(cx: &ExtCtxt, } quoted::TokenTree::Token(sp, tok) => { let mut marker = Marker(cx.current_expansion.mark); - result.push(noop_fold_tt(TokenTree::Token(sp, tok), &mut marker).into()) + let mut tt = TokenTree::Token(sp, tok); + noop_visit_tt(&mut tt, &mut marker); + result.push(tt.into()); } quoted::TokenTree::MetaVarDecl(..) => panic!("unexpected `TokenTree::MetaVarDecl"), } diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 5fb0132ad4566..93fedb73d271a 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -1,11 +1,10 @@ -//! A Folder represents an AST->AST fold; it accepts an AST piece, -//! and returns a piece of the same type. So, for instance, macro -//! expansion is a Folder that walks over an AST and produces another -//! AST. +//! A MutVisitor represents an AST modification; it accepts an AST piece and +//! and mutates it in place. So, for instance, macro expansion is a MutVisitor +//! that walks over an AST and modifies it. //! -//! Note: using a Folder (other than the MacroExpander Folder) on +//! Note: using a MutVisitor (other than the MacroExpander MutVisitor) on //! an AST before macro expansion is probably a bad idea. For instance, -//! a folder renaming item names in a module will miss all of those +//! a MutVisitor renaming item names in a module will miss all of those //! that are created by the expansion of a macro. use ast::*; @@ -14,10 +13,11 @@ use source_map::{Spanned, respan}; use parse::token::{self, Token}; use ptr::P; use smallvec::{Array, SmallVec}; +use std::ops::DerefMut; use symbol::keywords; use ThinVec; use tokenstream::*; -use util::move_map::MoveMap; +use util::map_in_place::MapInPlace; use rustc_data_structures::sync::Lrc; @@ -32,1308 +32,1225 @@ impl ExpectOne for SmallVec { } } -pub trait Folder : Sized { - // Any additions to this trait should happen in form - // of a call to a public `noop_*` function that only calls - // out to the folder again, not other `noop_*` functions. +pub trait MutVisitor: Sized { + // Methods in this trait have one of three forms: // - // This is a necessary API workaround to the problem of not - // being able to call out to the super default method - // in an overridden default method. + // fn visit_t(&mut self, t: &mut T); // common + // fn flat_map_t(&mut self, t: T) -> SmallVec<[T; 1]>; // rare + // fn filter_map_t(&mut self, t: T) -> Option; // rarest + // + // Any additions to this trait should happen in form of a call to a public + // `noop_*` function that only calls out to the visitor again, not other + // `noop_*` functions. This is a necessary API workaround to the problem of + // not being able to call out to the super default method in an overridden + // default method. + // + // When writing these methods, it is better to use destructuring like this: + // + // fn visit_abc(&mut self, ABC { a, b, c: _ }: &mut ABC) { + // visit_a(a); + // visit_b(b); + // } + // + // than to use field access like this: + // + // fn visit_abc(&mut self, abc: &mut ABC) { + // visit_a(&mut abc.a); + // visit_b(&mut abc.b); + // // ignore abc.c + // } + // + // As well as being more concise, the former is explicit about which fields + // are skipped. Furthermore, if a new field is added, the destructuring + // version will cause a compile error, which is good. In comparison, the + // field access version will continue working and it would be easy to + // forget to add handling for it. - fn fold_crate(&mut self, c: Crate) -> Crate { - noop_fold_crate(c, self) + fn visit_crate(&mut self, c: &mut Crate) { + noop_visit_crate(c, self) } - fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem { - noop_fold_meta_list_item(list_item, self) + fn visit_meta_list_item(&mut self, list_item: &mut NestedMetaItem) { + noop_visit_meta_list_item(list_item, self); } - fn fold_meta_item(&mut self, meta_item: MetaItem) -> MetaItem { - noop_fold_meta_item(meta_item, self) + fn visit_meta_item(&mut self, meta_item: &mut MetaItem) { + noop_visit_meta_item(meta_item, self); } - fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree { - noop_fold_use_tree(use_tree, self) + fn visit_use_tree(&mut self, use_tree: &mut UseTree) { + noop_visit_use_tree(use_tree, self); } - fn fold_foreign_item(&mut self, ni: ForeignItem) -> SmallVec<[ForeignItem; 1]> { - noop_fold_foreign_item(ni, self) + fn flat_map_foreign_item(&mut self, ni: ForeignItem) -> SmallVec<[ForeignItem; 1]> { + noop_flat_map_foreign_item(ni, self) } - fn fold_item(&mut self, i: P) -> SmallVec<[P; 1]> { - noop_fold_item(i, self) + fn flat_map_item(&mut self, i: P) -> SmallVec<[P; 1]> { + noop_flat_map_item(i, self) } - fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader { - noop_fold_fn_header(header, self) + fn visit_fn_header(&mut self, header: &mut FnHeader) { + noop_visit_fn_header(header, self); } - fn fold_struct_field(&mut self, sf: StructField) -> StructField { - noop_fold_struct_field(sf, self) + fn visit_struct_field(&mut self, sf: &mut StructField) { + noop_visit_struct_field(sf, self); } - fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind { - noop_fold_item_kind(i, self) + fn visit_item_kind(&mut self, i: &mut ItemKind) { + noop_visit_item_kind(i, self); } - fn fold_trait_item(&mut self, i: TraitItem) -> SmallVec<[TraitItem; 1]> { - noop_fold_trait_item(i, self) + fn flat_map_trait_item(&mut self, i: TraitItem) -> SmallVec<[TraitItem; 1]> { + noop_flat_map_trait_item(i, self) } - fn fold_impl_item(&mut self, i: ImplItem) -> SmallVec<[ImplItem; 1]> { - noop_fold_impl_item(i, self) + fn flat_map_impl_item(&mut self, i: ImplItem) -> SmallVec<[ImplItem; 1]> { + noop_flat_map_impl_item(i, self) } - fn fold_fn_decl(&mut self, d: P) -> P { - noop_fold_fn_decl(d, self) + fn visit_fn_decl(&mut self, d: &mut P) { + noop_visit_fn_decl(d, self); } - fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync { - noop_fold_asyncness(a, self) + fn visit_asyncness(&mut self, a: &mut IsAsync) { + noop_visit_asyncness(a, self); } - fn fold_block(&mut self, b: P) -> P { - noop_fold_block(b, self) + fn visit_block(&mut self, b: &mut P) { + noop_visit_block(b, self); } - fn fold_stmt(&mut self, s: Stmt) -> SmallVec<[Stmt; 1]> { - noop_fold_stmt(s, self) + fn flat_map_stmt(&mut self, s: Stmt) -> SmallVec<[Stmt; 1]> { + noop_flat_map_stmt(s, self) } - fn fold_arm(&mut self, a: Arm) -> Arm { - noop_fold_arm(a, self) + fn visit_arm(&mut self, a: &mut Arm) { + noop_visit_arm(a, self); } - fn fold_guard(&mut self, g: Guard) -> Guard { - noop_fold_guard(g, self) + fn visit_guard(&mut self, g: &mut Guard) { + noop_visit_guard(g, self); } - fn fold_pat(&mut self, p: P) -> P { - noop_fold_pat(p, self) + fn visit_pat(&mut self, p: &mut P) { + noop_visit_pat(p, self); } - fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst { - noop_fold_anon_const(c, self) + fn visit_anon_const(&mut self, c: &mut AnonConst) { + noop_visit_anon_const(c, self); } - fn fold_expr(&mut self, e: P) -> P { - e.map(|e| noop_fold_expr(e, self)) + fn visit_expr(&mut self, e: &mut P) { + noop_visit_expr(e, self); } - fn fold_opt_expr(&mut self, e: P) -> Option> { - noop_fold_opt_expr(e, self) + fn filter_map_expr(&mut self, e: P) -> Option> { + noop_filter_map_expr(e, self) } - fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg { - match arg { - GenericArg::Lifetime(lt) => GenericArg::Lifetime(self.fold_lifetime(lt)), - GenericArg::Type(ty) => GenericArg::Type(self.fold_ty(ty)), - } + fn visit_generic_arg(&mut self, arg: &mut GenericArg) { + noop_visit_generic_arg(arg, self); } - fn fold_ty(&mut self, t: P) -> P { - noop_fold_ty(t, self) + fn visit_ty(&mut self, t: &mut P) { + noop_visit_ty(t, self); } - fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime { - noop_fold_lifetime(l, self) + fn visit_lifetime(&mut self, l: &mut Lifetime) { + noop_visit_lifetime(l, self); } - fn fold_ty_binding(&mut self, t: TypeBinding) -> TypeBinding { - noop_fold_ty_binding(t, self) + fn visit_ty_binding(&mut self, t: &mut TypeBinding) { + noop_visit_ty_binding(t, self); } - fn fold_mod(&mut self, m: Mod) -> Mod { - noop_fold_mod(m, self) + fn visit_mod(&mut self, m: &mut Mod) { + noop_visit_mod(m, self); } - fn fold_foreign_mod(&mut self, nm: ForeignMod) -> ForeignMod { - noop_fold_foreign_mod(nm, self) + fn visit_foreign_mod(&mut self, nm: &mut ForeignMod) { + noop_visit_foreign_mod(nm, self); } - fn fold_variant(&mut self, v: Variant) -> Variant { - noop_fold_variant(v, self) + fn visit_variant(&mut self, v: &mut Variant) { + noop_visit_variant(v, self); } - fn fold_ident(&mut self, i: Ident) -> Ident { - noop_fold_ident(i, self) + fn visit_ident(&mut self, i: &mut Ident) { + noop_visit_ident(i, self); } - fn fold_path(&mut self, p: Path) -> Path { - noop_fold_path(p, self) + fn visit_path(&mut self, p: &mut Path) { + noop_visit_path(p, self); } - fn fold_qself(&mut self, qs: Option) -> Option { - noop_fold_qself(qs, self) + fn visit_qself(&mut self, qs: &mut Option) { + noop_visit_qself(qs, self); } - fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs { - noop_fold_generic_args(p, self) + fn visit_generic_args(&mut self, p: &mut GenericArgs) { + noop_visit_generic_args(p, self); } - fn fold_angle_bracketed_parameter_data(&mut self, p: AngleBracketedArgs) - -> AngleBracketedArgs - { - noop_fold_angle_bracketed_parameter_data(p, self) + fn visit_angle_bracketed_parameter_data(&mut self, p: &mut AngleBracketedArgs) { + noop_visit_angle_bracketed_parameter_data(p, self); } - fn fold_parenthesized_parameter_data(&mut self, p: ParenthesizedArgs) - -> ParenthesizedArgs - { - noop_fold_parenthesized_parameter_data(p, self) + fn visit_parenthesized_parameter_data(&mut self, p: &mut ParenthesizedArgs) { + noop_visit_parenthesized_parameter_data(p, self); } - fn fold_local(&mut self, l: P) -> P { - noop_fold_local(l, self) + fn visit_local(&mut self, l: &mut P) { + noop_visit_local(l, self); } - fn fold_mac(&mut self, _mac: Mac) -> Mac { - panic!("fold_mac disabled by default"); - // N.B., see note about macros above. - // if you really want a folder that - // works on macros, use this - // definition in your trait impl: - // fold::noop_fold_mac(_mac, self) + fn visit_mac(&mut self, _mac: &mut Mac) { + panic!("visit_mac disabled by default"); + // N.B., see note about macros above. If you really want a visitor that + // works on macros, use this definition in your trait impl: + // mut_visit::noop_visit_mac(_mac, self); } - fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef { - noop_fold_macro_def(def, self) + fn visit_macro_def(&mut self, def: &mut MacroDef) { + noop_visit_macro_def(def, self); } - fn fold_label(&mut self, label: Label) -> Label { - noop_fold_label(label, self) + fn visit_label(&mut self, label: &mut Label) { + noop_visit_label(label, self); } - fn fold_attribute(&mut self, at: Attribute) -> Attribute { - noop_fold_attribute(at, self) + fn visit_attribute(&mut self, at: &mut Attribute) { + noop_visit_attribute(at, self); } - fn fold_arg(&mut self, a: Arg) -> Arg { - noop_fold_arg(a, self) + fn visit_arg(&mut self, a: &mut Arg) { + noop_visit_arg(a, self); } - fn fold_generics(&mut self, generics: Generics) -> Generics { - noop_fold_generics(generics, self) + fn visit_generics(&mut self, generics: &mut Generics) { + noop_visit_generics(generics, self); } - fn fold_trait_ref(&mut self, p: TraitRef) -> TraitRef { - noop_fold_trait_ref(p, self) + fn visit_trait_ref(&mut self, tr: &mut TraitRef) { + noop_visit_trait_ref(tr, self); } - fn fold_poly_trait_ref(&mut self, p: PolyTraitRef) -> PolyTraitRef { - noop_fold_poly_trait_ref(p, self) + fn visit_poly_trait_ref(&mut self, p: &mut PolyTraitRef) { + noop_visit_poly_trait_ref(p, self); } - fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData { - noop_fold_variant_data(vdata, self) + fn visit_variant_data(&mut self, vdata: &mut VariantData) { + noop_visit_variant_data(vdata, self); } - fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam { - noop_fold_generic_param(param, self) + fn visit_generic_param(&mut self, param: &mut GenericParam) { + noop_visit_generic_param(param, self); } - fn fold_generic_params(&mut self, params: Vec) -> Vec { - noop_fold_generic_params(params, self) + fn visit_generic_params(&mut self, params: &mut Vec) { + noop_visit_generic_params(params, self); } - fn fold_tt(&mut self, tt: TokenTree) -> TokenTree { - noop_fold_tt(tt, self) + fn visit_tt(&mut self, tt: &mut TokenTree) { + noop_visit_tt(tt, self); } - fn fold_tts(&mut self, tts: TokenStream) -> TokenStream { - noop_fold_tts(tts, self) + fn visit_tts(&mut self, tts: &mut TokenStream) { + noop_visit_tts(tts, self); } - fn fold_token(&mut self, t: token::Token) -> token::Token { - noop_fold_token(t, self) + fn visit_token(&mut self, t: &mut Token) { + noop_visit_token(t, self); } - fn fold_interpolated(&mut self, nt: token::Nonterminal) -> token::Nonterminal { - noop_fold_interpolated(nt, self) + fn visit_interpolated(&mut self, nt: &mut token::Nonterminal) { + noop_visit_interpolated(nt, self); } - fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound { - noop_fold_param_bound(tpb, self) + fn visit_param_bound(&mut self, tpb: &mut GenericBound) { + noop_visit_param_bound(tpb, self); } - fn fold_mt(&mut self, mt: MutTy) -> MutTy { - noop_fold_mt(mt, self) + fn visit_mt(&mut self, mt: &mut MutTy) { + noop_visit_mt(mt, self); } - fn fold_field(&mut self, field: Field) -> Field { - noop_fold_field(field, self) + fn visit_field(&mut self, field: &mut Field) { + noop_visit_field(field, self); } - fn fold_where_clause(&mut self, where_clause: WhereClause) - -> WhereClause { - noop_fold_where_clause(where_clause, self) + fn visit_where_clause(&mut self, where_clause: &mut WhereClause) { + noop_visit_where_clause(where_clause, self); } - fn fold_where_predicate(&mut self, where_predicate: WherePredicate) - -> WherePredicate { - noop_fold_where_predicate(where_predicate, self) + fn visit_where_predicate(&mut self, where_predicate: &mut WherePredicate) { + noop_visit_where_predicate(where_predicate, self); } - fn fold_vis(&mut self, vis: Visibility) -> Visibility { - noop_fold_vis(vis, self) + fn visit_vis(&mut self, vis: &mut Visibility) { + noop_visit_vis(vis, self); } - fn new_id(&mut self, i: NodeId) -> NodeId { - i + fn visit_id(&mut self, _id: &mut NodeId) { + // Do nothing. } - fn new_span(&mut self, sp: Span) -> Span { - sp + fn visit_span(&mut self, _sp: &mut Span) { + // Do nothing. } } -// No `noop_` prefix because there isn't a corresponding method in `Folder`. -fn fold_attrs(attrs: Vec, fld: &mut T) -> Vec { - attrs.move_map(|x| fld.fold_attribute(x)) +/// Use a map-style function (`FnOnce(T) -> T`) to overwrite a `&mut T`. Useful +/// when using a `flat_map_*` or `filter_map_*` method within a `visit_` +/// method. +// +// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. +pub fn visit_clobber(t: &mut T, f: F) where F: FnOnce(T) -> T { + unsafe { std::ptr::write(t, f(std::ptr::read(t))); } } -// No `noop_` prefix because there isn't a corresponding method in `Folder`. -fn fold_thin_attrs(attrs: ThinVec, fld: &mut T) -> ThinVec { - fold_attrs(attrs.into(), fld).into() +// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. +#[inline] +pub fn visit_vec(elems: &mut Vec, mut visit_elem: F) where F: FnMut(&mut T) { + for elem in elems { + visit_elem(elem); + } } -// No `noop_` prefix because there isn't a corresponding method in `Folder`. -fn fold_exprs(es: Vec>, fld: &mut T) -> Vec> { - es.move_flat_map(|e| fld.fold_opt_expr(e)) +// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. +#[inline] +pub fn visit_opt(opt: &mut Option, mut visit_elem: F) where F: FnMut(&mut T) { + if let Some(elem) = opt { + visit_elem(elem); + } } -// No `noop_` prefix because there isn't a corresponding method in `Folder`. -fn fold_bounds(bounds: GenericBounds, folder: &mut T) -> GenericBounds { - bounds.move_map(|bound| folder.fold_param_bound(bound)) +// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. +pub fn visit_attrs(attrs: &mut Vec, vis: &mut T) { + visit_vec(attrs, |attr| vis.visit_attribute(attr)); } -// No `noop_` prefix because there isn't a corresponding method in `Folder`. -fn fold_method_sig(sig: MethodSig, folder: &mut T) -> MethodSig { - MethodSig { - header: folder.fold_fn_header(sig.header), - decl: folder.fold_fn_decl(sig.decl) +// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. +pub fn visit_thin_attrs(attrs: &mut ThinVec, vis: &mut T) { + for attr in attrs.iter_mut() { + vis.visit_attribute(attr); } } -pub fn noop_fold_use_tree(use_tree: UseTree, fld: &mut T) -> UseTree { - UseTree { - span: fld.new_span(use_tree.span), - prefix: fld.fold_path(use_tree.prefix), - kind: match use_tree.kind { - UseTreeKind::Simple(rename, id1, id2) => - UseTreeKind::Simple(rename.map(|ident| fld.fold_ident(ident)), - fld.new_id(id1), fld.new_id(id2)), - UseTreeKind::Glob => UseTreeKind::Glob, - UseTreeKind::Nested(items) => UseTreeKind::Nested(items.move_map(|(tree, id)| { - (fld.fold_use_tree(tree), fld.new_id(id)) - })), - }, - } +// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. +pub fn visit_exprs(exprs: &mut Vec>, vis: &mut T) { + exprs.flat_map_in_place(|expr| vis.filter_map_expr(expr)) } -pub fn noop_fold_arm(Arm {attrs, pats, guard, body}: Arm, - fld: &mut T) -> Arm { - Arm { - attrs: fold_attrs(attrs, fld), - pats: pats.move_map(|x| fld.fold_pat(x)), - guard: guard.map(|x| fld.fold_guard(x)), - body: fld.fold_expr(body), - } +// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. +pub fn visit_bounds(bounds: &mut GenericBounds, vis: &mut T) { + visit_vec(bounds, |bound| vis.visit_param_bound(bound)); } -pub fn noop_fold_guard(g: Guard, fld: &mut T) -> Guard { - match g { - Guard::If(e) => Guard::If(fld.fold_expr(e)), - } +// No `noop_` prefix because there isn't a corresponding method in `MutVisitor`. +pub fn visit_method_sig(MethodSig { header, decl }: &mut MethodSig, vis: &mut T) { + vis.visit_fn_header(header); + vis.visit_fn_decl(decl); } -pub fn noop_fold_ty_binding(b: TypeBinding, fld: &mut T) -> TypeBinding { - TypeBinding { - id: fld.new_id(b.id), - ident: fld.fold_ident(b.ident), - ty: fld.fold_ty(b.ty), - span: fld.new_span(b.span), +pub fn noop_visit_use_tree(use_tree: &mut UseTree, vis: &mut T) { + let UseTree { prefix, kind, span } = use_tree; + vis.visit_path(prefix); + match kind { + UseTreeKind::Simple(rename, id1, id2) => { + visit_opt(rename, |rename| vis.visit_ident(rename)); + vis.visit_id(id1); + vis.visit_id(id2); + } + UseTreeKind::Nested(items) => { + for (tree, id) in items { + vis.visit_use_tree(tree); + vis.visit_id(id); + } + } + UseTreeKind::Glob => {} } + vis.visit_span(span); } -pub fn noop_fold_ty(t: P, fld: &mut T) -> P { - t.map(|Ty {id, node, span}| Ty { - id: fld.new_id(id), - node: match node { - TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err => node, - TyKind::Slice(ty) => TyKind::Slice(fld.fold_ty(ty)), - TyKind::Ptr(mt) => TyKind::Ptr(fld.fold_mt(mt)), - TyKind::Rptr(region, mt) => { - TyKind::Rptr(region.map(|lt| noop_fold_lifetime(lt, fld)), fld.fold_mt(mt)) - } - TyKind::BareFn(f) => { - TyKind::BareFn(f.map(|BareFnTy {generic_params, unsafety, abi, decl}| BareFnTy { - generic_params: fld.fold_generic_params(generic_params), - unsafety, - abi, - decl: fld.fold_fn_decl(decl) - })) - } - TyKind::Never => node, - TyKind::Tup(tys) => TyKind::Tup(tys.move_map(|ty| fld.fold_ty(ty))), - TyKind::Paren(ty) => TyKind::Paren(fld.fold_ty(ty)), - TyKind::Path(qself, path) => { - TyKind::Path(fld.fold_qself(qself), fld.fold_path(path)) - } - TyKind::Array(ty, length) => { - TyKind::Array(fld.fold_ty(ty), fld.fold_anon_const(length)) - } - TyKind::Typeof(expr) => { - TyKind::Typeof(fld.fold_anon_const(expr)) - } - TyKind::TraitObject(bounds, syntax) => { - TyKind::TraitObject(bounds.move_map(|b| fld.fold_param_bound(b)), syntax) - } - TyKind::ImplTrait(id, bounds) => { - TyKind::ImplTrait(fld.new_id(id), bounds.move_map(|b| fld.fold_param_bound(b))) - } - TyKind::Mac(mac) => { - TyKind::Mac(fld.fold_mac(mac)) - } - }, - span: fld.new_span(span) - }) +pub fn noop_visit_arm(Arm { attrs, pats, guard, body }: &mut Arm, vis: &mut T) { + visit_attrs(attrs, vis); + visit_vec(pats, |pat| vis.visit_pat(pat)); + visit_opt(guard, |guard| vis.visit_guard(guard)); + vis.visit_expr(body); } -pub fn noop_fold_foreign_mod(ForeignMod {abi, items}: ForeignMod, - fld: &mut T) -> ForeignMod { - ForeignMod { - abi, - items: items.move_flat_map(|x| fld.fold_foreign_item(x)), +pub fn noop_visit_guard(g: &mut Guard, vis: &mut T) { + match g { + Guard::If(e) => vis.visit_expr(e), } } -pub fn noop_fold_variant(v: Variant, fld: &mut T) -> Variant { - Spanned { - node: Variant_ { - ident: fld.fold_ident(v.node.ident), - attrs: fold_attrs(v.node.attrs, fld), - data: fld.fold_variant_data(v.node.data), - disr_expr: v.node.disr_expr.map(|e| fld.fold_anon_const(e)), - }, - span: fld.new_span(v.span), +pub fn noop_visit_ty_binding(TypeBinding { id, ident, ty, span }: &mut TypeBinding, + vis: &mut T) { + vis.visit_id(id); + vis.visit_ident(ident); + vis.visit_ty(ty); + vis.visit_span(span); +} + +pub fn noop_visit_ty(ty: &mut P, vis: &mut T) { + let Ty { id, node, span } = ty.deref_mut(); + vis.visit_id(id); + match node { + TyKind::Infer | TyKind::ImplicitSelf | TyKind::Err | TyKind::Never => {} + TyKind::Slice(ty) => vis.visit_ty(ty), + TyKind::Ptr(mt) => vis.visit_mt(mt), + TyKind::Rptr(lt, mt) => { + visit_opt(lt, |lt| noop_visit_lifetime(lt, vis)); + vis.visit_mt(mt); + } + TyKind::BareFn(bft) => { + let BareFnTy { unsafety: _, abi: _, generic_params, decl } = bft.deref_mut(); + vis.visit_generic_params(generic_params); + vis.visit_fn_decl(decl); + } + TyKind::Tup(tys) => visit_vec(tys, |ty| vis.visit_ty(ty)), + TyKind::Paren(ty) => vis.visit_ty(ty), + TyKind::Path(qself, path) => { + vis.visit_qself(qself); + vis.visit_path(path); + } + TyKind::Array(ty, length) => { + vis.visit_ty(ty); + vis.visit_anon_const(length); + } + TyKind::Typeof(expr) => vis.visit_anon_const(expr), + TyKind::TraitObject(bounds, _syntax) => + visit_vec(bounds, |bound| vis.visit_param_bound(bound)), + TyKind::ImplTrait(id, bounds) => { + vis.visit_id(id); + visit_vec(bounds, |bound| vis.visit_param_bound(bound)); + } + TyKind::Mac(mac) => vis.visit_mac(mac), } + vis.visit_span(span); +} + +pub fn noop_visit_foreign_mod(foreign_mod: &mut ForeignMod, vis: &mut T) { + let ForeignMod { abi: _, items} = foreign_mod; + items.flat_map_in_place(|item| vis.flat_map_foreign_item(item)); +} + +pub fn noop_visit_variant(variant: &mut Variant, vis: &mut T) { + let Spanned { node: Variant_ { ident, attrs, data, disr_expr }, span } = variant; + vis.visit_ident(ident); + visit_attrs(attrs, vis); + vis.visit_variant_data(data); + visit_opt(disr_expr, |disr_expr| vis.visit_anon_const(disr_expr)); + vis.visit_span(span); } -pub fn noop_fold_ident(ident: Ident, fld: &mut T) -> Ident { - Ident::new(ident.name, fld.new_span(ident.span)) +pub fn noop_visit_ident(Ident { name: _, span }: &mut Ident, vis: &mut T) { + vis.visit_span(span); } -pub fn noop_fold_path(Path { segments, span }: Path, fld: &mut T) -> Path { - Path { - segments: segments.move_map(|PathSegment { ident, id, args }| PathSegment { - ident: fld.fold_ident(ident), - id: fld.new_id(id), - args: args.map(|args| args.map(|args| fld.fold_generic_args(args))), - }), - span: fld.new_span(span) +pub fn noop_visit_path(Path { segments, span }: &mut Path, vis: &mut T) { + vis.visit_span(span); + for PathSegment { ident, id, args } in segments { + vis.visit_ident(ident); + vis.visit_id(id); + visit_opt(args, |args| vis.visit_generic_args(args)); } } -pub fn noop_fold_qself(qself: Option, fld: &mut T) -> Option { - qself.map(|QSelf { ty, path_span, position }| { - QSelf { - ty: fld.fold_ty(ty), - path_span: fld.new_span(path_span), - position, - } +pub fn noop_visit_qself(qself: &mut Option, vis: &mut T) { + visit_opt(qself, |QSelf { ty, path_span, position: _ }| { + vis.visit_ty(ty); + vis.visit_span(path_span); }) } -pub fn noop_fold_generic_args(generic_args: GenericArgs, fld: &mut T) -> GenericArgs -{ +pub fn noop_visit_generic_args(generic_args: &mut GenericArgs, vis: &mut T) { match generic_args { - GenericArgs::AngleBracketed(data) => { - GenericArgs::AngleBracketed(fld.fold_angle_bracketed_parameter_data(data)) - } - GenericArgs::Parenthesized(data) => { - GenericArgs::Parenthesized(fld.fold_parenthesized_parameter_data(data)) - } + GenericArgs::AngleBracketed(data) => vis.visit_angle_bracketed_parameter_data(data), + GenericArgs::Parenthesized(data) => vis.visit_parenthesized_parameter_data(data), } } -pub fn noop_fold_angle_bracketed_parameter_data(data: AngleBracketedArgs, - fld: &mut T) - -> AngleBracketedArgs -{ - let AngleBracketedArgs { args, bindings, span } = data; - AngleBracketedArgs { - args: args.move_map(|arg| fld.fold_generic_arg(arg)), - bindings: bindings.move_map(|b| fld.fold_ty_binding(b)), - span: fld.new_span(span) +pub fn noop_visit_generic_arg(arg: &mut GenericArg, vis: &mut T) { + match arg { + GenericArg::Lifetime(lt) => vis.visit_lifetime(lt), + GenericArg::Type(ty) => vis.visit_ty(ty), } } -pub fn noop_fold_parenthesized_parameter_data(data: ParenthesizedArgs, - fld: &mut T) - -> ParenthesizedArgs -{ - let ParenthesizedArgs { inputs, output, span } = data; - ParenthesizedArgs { - inputs: inputs.move_map(|ty| fld.fold_ty(ty)), - output: output.map(|ty| fld.fold_ty(ty)), - span: fld.new_span(span) - } -} - -pub fn noop_fold_local(l: P, fld: &mut T) -> P { - l.map(|Local {id, pat, ty, init, span, attrs}| Local { - id: fld.new_id(id), - pat: fld.fold_pat(pat), - ty: ty.map(|t| fld.fold_ty(t)), - init: init.map(|e| fld.fold_expr(e)), - span: fld.new_span(span), - attrs: fold_attrs(attrs.into(), fld).into(), - }) +pub fn noop_visit_angle_bracketed_parameter_data(data: &mut AngleBracketedArgs, + vis: &mut T) { + let AngleBracketedArgs { args, bindings, span } = data; + visit_vec(args, |arg| vis.visit_generic_arg(arg)); + visit_vec(bindings, |binding| vis.visit_ty_binding(binding)); + vis.visit_span(span); } -pub fn noop_fold_attribute(attr: Attribute, fld: &mut T) -> Attribute { - Attribute { - id: attr.id, - style: attr.style, - path: fld.fold_path(attr.path), - tokens: fld.fold_tts(attr.tokens), - is_sugared_doc: attr.is_sugared_doc, - span: fld.new_span(attr.span), - } +pub fn noop_visit_parenthesized_parameter_data(args: &mut ParenthesizedArgs, + vis: &mut T) { + let ParenthesizedArgs { inputs, output, span } = args; + visit_vec(inputs, |input| vis.visit_ty(input)); + visit_opt(output, |output| vis.visit_ty(output)); + vis.visit_span(span); } -pub fn noop_fold_mac(Spanned {node, span}: Mac, fld: &mut T) -> Mac { - Spanned { - node: Mac_ { - tts: fld.fold_tts(node.stream()).into(), - path: fld.fold_path(node.path), - delim: node.delim, - }, - span: fld.new_span(span) - } +pub fn noop_visit_local(local: &mut P, vis: &mut T) { + let Local { id, pat, ty, init, span, attrs } = local.deref_mut(); + vis.visit_id(id); + vis.visit_pat(pat); + visit_opt(ty, |ty| vis.visit_ty(ty)); + visit_opt(init, |init| vis.visit_expr(init)); + vis.visit_span(span); + visit_thin_attrs(attrs, vis); } -pub fn noop_fold_macro_def(def: MacroDef, fld: &mut T) -> MacroDef { - MacroDef { - tokens: fld.fold_tts(def.tokens.into()).into(), - legacy: def.legacy, - } +pub fn noop_visit_attribute(attr: &mut Attribute, vis: &mut T) { + let Attribute { id: _, style: _, path, tokens, is_sugared_doc: _, span } = attr; + vis.visit_path(path); + vis.visit_tts(tokens); + vis.visit_span(span); } -pub fn noop_fold_meta_list_item(li: NestedMetaItem, fld: &mut T) - -> NestedMetaItem { - Spanned { - node: match li.node { - NestedMetaItemKind::MetaItem(mi) => { - NestedMetaItemKind::MetaItem(fld.fold_meta_item(mi)) - }, - NestedMetaItemKind::Literal(lit) => NestedMetaItemKind::Literal(lit) - }, - span: fld.new_span(li.span) - } +pub fn noop_visit_mac(Spanned { node, span }: &mut Mac, vis: &mut T) { + let Mac_ { path, delim: _, tts } = node; + vis.visit_path(path); + vis.visit_tts(tts); + vis.visit_span(span); } -pub fn noop_fold_meta_item(mi: MetaItem, fld: &mut T) -> MetaItem { - MetaItem { - ident: mi.ident, - node: match mi.node { - MetaItemKind::Word => MetaItemKind::Word, - MetaItemKind::List(mis) => { - MetaItemKind::List(mis.move_map(|e| fld.fold_meta_list_item(e))) - }, - MetaItemKind::NameValue(s) => MetaItemKind::NameValue(s), - }, - span: fld.new_span(mi.span) +pub fn noop_visit_macro_def(macro_def: &mut MacroDef, vis: &mut T) { + let MacroDef { tokens, legacy: _ } = macro_def; + vis.visit_tts(tokens); +} + +pub fn noop_visit_meta_list_item(li: &mut NestedMetaItem, vis: &mut T) { + let Spanned { node, span } = li; + match node { + NestedMetaItemKind::MetaItem(mi) => vis.visit_meta_item(mi), + NestedMetaItemKind::Literal(_lit) => {} } + vis.visit_span(span); } -pub fn noop_fold_arg(Arg {id, pat, ty}: Arg, fld: &mut T) -> Arg { - Arg { - id: fld.new_id(id), - pat: fld.fold_pat(pat), - ty: fld.fold_ty(ty) +pub fn noop_visit_meta_item(mi: &mut MetaItem, vis: &mut T) { + let MetaItem { ident: _, node, span } = mi; + match node { + MetaItemKind::Word => {} + MetaItemKind::List(mis) => visit_vec(mis, |mi| vis.visit_meta_list_item(mi)), + MetaItemKind::NameValue(_s) => {} } + vis.visit_span(span); +} + +pub fn noop_visit_arg(Arg { id, pat, ty }: &mut Arg, vis: &mut T) { + vis.visit_id(id); + vis.visit_pat(pat); + vis.visit_ty(ty); } -pub fn noop_fold_tt(tt: TokenTree, fld: &mut T) -> TokenTree { +pub fn noop_visit_tt(tt: &mut TokenTree, vis: &mut T) { match tt { - TokenTree::Token(span, tok) => - TokenTree::Token(fld.new_span(span), fld.fold_token(tok)), - TokenTree::Delimited(span, delim, tts) => TokenTree::Delimited( - DelimSpan::from_pair(fld.new_span(span.open), fld.new_span(span.close)), - delim, - fld.fold_tts(tts).into(), - ), + TokenTree::Token(span, tok) => { + vis.visit_span(span); + vis.visit_token(tok); + } + TokenTree::Delimited(DelimSpan { open, close }, _delim, tts) => { + vis.visit_span(open); + vis.visit_span(close); + vis.visit_tts(tts); + } } } -pub fn noop_fold_tts(tts: TokenStream, fld: &mut T) -> TokenStream { - tts.map(|tt| fld.fold_tt(tt)) +pub fn noop_visit_tts(TokenStream(tts): &mut TokenStream, vis: &mut T) { + visit_opt(tts, |tts| { + let tts = Lrc::make_mut(tts); + visit_vec(tts, |(tree, _is_joint)| vis.visit_tt(tree)); + }) } -// apply ident folder if it's an ident, apply other folds to interpolated nodes -pub fn noop_fold_token(t: token::Token, fld: &mut T) -> token::Token { +// apply ident visitor if it's an ident, apply other visits to interpolated nodes +pub fn noop_visit_token(t: &mut Token, vis: &mut T) { match t { - token::Ident(id, is_raw) => token::Ident(fld.fold_ident(id), is_raw), - token::Lifetime(id) => token::Lifetime(fld.fold_ident(id)), + token::Ident(id, _is_raw) => vis.visit_ident(id), + token::Lifetime(id) => vis.visit_ident(id), token::Interpolated(nt) => { - let nt = match Lrc::try_unwrap(nt) { - Ok(nt) => nt, - Err(nt) => (*nt).clone(), - }; - Token::interpolated(fld.fold_interpolated(nt.0)) + let nt = Lrc::make_mut(nt); + vis.visit_interpolated(&mut nt.0); + nt.1 = token::LazyTokenStream::new(); } - _ => t + _ => {} } } -/// apply folder to elements of interpolated nodes +/// Apply visitor to elements of interpolated nodes. // -// N.B., this can occur only when applying a fold to partially expanded code, where -// parsed pieces have gotten implanted ito *other* macro invocations. This is relevant -// for macro hygiene, but possibly not elsewhere. +// N.B., this can occur only when applying a visitor to partially expanded +// code, where parsed pieces have gotten implanted ito *other* macro +// invocations. This is relevant for macro hygiene, but possibly not elsewhere. // -// One problem here occurs because the types for fold_item, fold_stmt, etc. allow the -// folder to return *multiple* items; this is a problem for the nodes here, because -// they insist on having exactly one piece. One solution would be to mangle the fold -// trait to include one-to-many and one-to-one versions of these entry points, but that -// would probably confuse a lot of people and help very few. Instead, I'm just going -// to put in dynamic checks. I think the performance impact of this will be pretty much -// nonexistent. The danger is that someone will apply a fold to a partially expanded -// node, and will be confused by the fact that their "fold_item" or "fold_stmt" isn't -// getting called on NtItem or NtStmt nodes. Hopefully they'll wind up reading this -// comment, and doing something appropriate. +// One problem here occurs because the types for flat_map_item, flat_map_stmt, +// etc. allow the visitor to return *multiple* items; this is a problem for the +// nodes here, because they insist on having exactly one piece. One solution +// would be to mangle the MutVisitor trait to include one-to-many and +// one-to-one versions of these entry points, but that would probably confuse a +// lot of people and help very few. Instead, I'm just going to put in dynamic +// checks. I think the performance impact of this will be pretty much +// nonexistent. The danger is that someone will apply a MutVisitor to a +// partially expanded node, and will be confused by the fact that their +// "flat_map_item" or "flat_map_stmt" isn't getting called on NtItem or NtStmt +// nodes. Hopefully they'll wind up reading this comment, and doing something +// appropriate. // -// BTW, design choice: I considered just changing the type of, e.g., NtItem to contain -// multiple items, but decided against it when I looked at parse_item_or_view_item and -// tried to figure out what I would do with multiple items there.... -pub fn noop_fold_interpolated(nt: token::Nonterminal, fld: &mut T) - -> token::Nonterminal { +// BTW, design choice: I considered just changing the type of, e.g., NtItem to +// contain multiple items, but decided against it when I looked at +// parse_item_or_view_item and tried to figure out what I would do with +// multiple items there.... +pub fn noop_visit_interpolated(nt: &mut token::Nonterminal, vis: &mut T) { match nt { token::NtItem(item) => - token::NtItem(fld.fold_item(item) - // this is probably okay, because the only folds likely - // to peek inside interpolated nodes will be renamings/markings, - // which map single items to single items - .expect_one("expected fold to produce exactly one item")), - token::NtBlock(block) => token::NtBlock(fld.fold_block(block)), + visit_clobber(item, |item| { + // This is probably okay, because the only visitors likely to + // peek inside interpolated nodes will be renamings/markings, + // which map single items to single items. + vis.flat_map_item(item).expect_one("expected visitor to produce exactly one item") + }), + token::NtBlock(block) => vis.visit_block(block), token::NtStmt(stmt) => - token::NtStmt(fld.fold_stmt(stmt) - // this is probably okay, because the only folds likely - // to peek inside interpolated nodes will be renamings/markings, - // which map single items to single items - .expect_one("expected fold to produce exactly one statement")), - token::NtPat(pat) => token::NtPat(fld.fold_pat(pat)), - token::NtExpr(expr) => token::NtExpr(fld.fold_expr(expr)), - token::NtTy(ty) => token::NtTy(fld.fold_ty(ty)), - token::NtIdent(ident, is_raw) => token::NtIdent(fld.fold_ident(ident), is_raw), - token::NtLifetime(ident) => token::NtLifetime(fld.fold_ident(ident)), - token::NtLiteral(expr) => token::NtLiteral(fld.fold_expr(expr)), - token::NtMeta(meta) => token::NtMeta(fld.fold_meta_item(meta)), - token::NtPath(path) => token::NtPath(fld.fold_path(path)), - token::NtTT(tt) => token::NtTT(fld.fold_tt(tt)), - token::NtArm(arm) => token::NtArm(fld.fold_arm(arm)), + visit_clobber(stmt, |stmt| { + // See reasoning above. + vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item") + }), + token::NtPat(pat) => vis.visit_pat(pat), + token::NtExpr(expr) => vis.visit_expr(expr), + token::NtTy(ty) => vis.visit_ty(ty), + token::NtIdent(ident, _is_raw) => vis.visit_ident(ident), + token::NtLifetime(ident) => vis.visit_ident(ident), + token::NtLiteral(expr) => vis.visit_expr(expr), + token::NtMeta(meta) => vis.visit_meta_item(meta), + token::NtPath(path) => vis.visit_path(path), + token::NtTT(tt) => vis.visit_tt(tt), + token::NtArm(arm) => vis.visit_arm(arm), token::NtImplItem(item) => - token::NtImplItem(fld.fold_impl_item(item) - .expect_one("expected fold to produce exactly one item")), + visit_clobber(item, |item| { + // See reasoning above. + vis.flat_map_impl_item(item) + .expect_one("expected visitor to produce exactly one item") + }), token::NtTraitItem(item) => - token::NtTraitItem(fld.fold_trait_item(item) - .expect_one("expected fold to produce exactly one item")), - token::NtGenerics(generics) => token::NtGenerics(fld.fold_generics(generics)), - token::NtWhereClause(where_clause) => - token::NtWhereClause(fld.fold_where_clause(where_clause)), - token::NtArg(arg) => token::NtArg(fld.fold_arg(arg)), - token::NtVis(vis) => token::NtVis(fld.fold_vis(vis)), - token::NtForeignItem(ni) => - token::NtForeignItem(fld.fold_foreign_item(ni) - // see reasoning above - .expect_one("expected fold to produce exactly one item")), - } -} - -pub fn noop_fold_asyncness(asyncness: IsAsync, fld: &mut T) -> IsAsync { + visit_clobber(item, |item| { + // See reasoning above. + vis.flat_map_trait_item(item) + .expect_one("expected visitor to produce exactly one item") + }), + token::NtGenerics(generics) => vis.visit_generics(generics), + token::NtWhereClause(where_clause) => vis.visit_where_clause(where_clause), + token::NtArg(arg) => vis.visit_arg(arg), + token::NtVis(visib) => vis.visit_vis(visib), + token::NtForeignItem(item) => + visit_clobber(item, |item| { + // See reasoning above. + vis.flat_map_foreign_item(item) + .expect_one("expected visitor to produce exactly one item") + }), + } +} + +pub fn noop_visit_asyncness(asyncness: &mut IsAsync, vis: &mut T) { match asyncness { - IsAsync::Async { closure_id, return_impl_trait_id } => IsAsync::Async { - closure_id: fld.new_id(closure_id), - return_impl_trait_id: fld.new_id(return_impl_trait_id), - }, - IsAsync::NotAsync => IsAsync::NotAsync, + IsAsync::Async { closure_id, return_impl_trait_id } => { + vis.visit_id(closure_id); + vis.visit_id(return_impl_trait_id); + } + IsAsync::NotAsync => {} } } -pub fn noop_fold_fn_decl(decl: P, fld: &mut T) -> P { - decl.map(|FnDecl {inputs, output, variadic}| FnDecl { - inputs: inputs.move_map(|x| fld.fold_arg(x)), - output: match output { - FunctionRetTy::Ty(ty) => FunctionRetTy::Ty(fld.fold_ty(ty)), - FunctionRetTy::Default(span) => FunctionRetTy::Default(fld.new_span(span)), - }, - variadic, - }) +pub fn noop_visit_fn_decl(decl: &mut P, vis: &mut T) { + let FnDecl { inputs, output, variadic: _ } = decl.deref_mut(); + visit_vec(inputs, |input| vis.visit_arg(input)); + match output { + FunctionRetTy::Default(span) => vis.visit_span(span), + FunctionRetTy::Ty(ty) => vis.visit_ty(ty), + } } -pub fn noop_fold_param_bound(pb: GenericBound, fld: &mut T) -> GenericBound where T: Folder { +pub fn noop_visit_param_bound(pb: &mut GenericBound, vis: &mut T) { match pb { - GenericBound::Trait(ty, modifier) => { - GenericBound::Trait(fld.fold_poly_trait_ref(ty), modifier) - } - GenericBound::Outlives(lifetime) => { - GenericBound::Outlives(noop_fold_lifetime(lifetime, fld)) - } + GenericBound::Trait(ty, _modifier) => vis.visit_poly_trait_ref(ty), + GenericBound::Outlives(lifetime) => noop_visit_lifetime(lifetime, vis), } } -pub fn noop_fold_generic_param(param: GenericParam, fld: &mut T) -> GenericParam { - GenericParam { - ident: fld.fold_ident(param.ident), - id: fld.new_id(param.id), - attrs: fold_thin_attrs(param.attrs, fld), - bounds: param.bounds.move_map(|l| noop_fold_param_bound(l, fld)), - kind: match param.kind { - GenericParamKind::Lifetime => GenericParamKind::Lifetime, - GenericParamKind::Type { default } => GenericParamKind::Type { - default: default.map(|ty| fld.fold_ty(ty)) - } +pub fn noop_visit_generic_param(param: &mut GenericParam, vis: &mut T) { + let GenericParam { id, ident, attrs, bounds, kind } = param; + vis.visit_id(id); + vis.visit_ident(ident); + visit_thin_attrs(attrs, vis); + visit_vec(bounds, |bound| noop_visit_param_bound(bound, vis)); + match kind { + GenericParamKind::Lifetime => {} + GenericParamKind::Type { default } => { + visit_opt(default, |default| vis.visit_ty(default)); } } } -pub fn noop_fold_generic_params( - params: Vec, - fld: &mut T -) -> Vec { - params.move_map(|p| fld.fold_generic_param(p)) +pub fn noop_visit_generic_params(params: &mut Vec, vis: &mut T){ + visit_vec(params, |param| vis.visit_generic_param(param)); } -pub fn noop_fold_label(label: Label, fld: &mut T) -> Label { - Label { - ident: fld.fold_ident(label.ident), - } +pub fn noop_visit_label(Label { ident }: &mut Label, vis: &mut T) { + vis.visit_ident(ident); } -fn noop_fold_lifetime(l: Lifetime, fld: &mut T) -> Lifetime { - Lifetime { - id: fld.new_id(l.id), - ident: fld.fold_ident(l.ident), - } +fn noop_visit_lifetime(Lifetime { id, ident }: &mut Lifetime, vis: &mut T) { + vis.visit_id(id); + vis.visit_ident(ident); } -pub fn noop_fold_generics(Generics { params, where_clause, span }: Generics, - fld: &mut T) -> Generics { - Generics { - params: fld.fold_generic_params(params), - where_clause: fld.fold_where_clause(where_clause), - span: fld.new_span(span), - } +pub fn noop_visit_generics(generics: &mut Generics, vis: &mut T) { + let Generics { params, where_clause, span } = generics; + vis.visit_generic_params(params); + vis.visit_where_clause(where_clause); + vis.visit_span(span); } -pub fn noop_fold_where_clause( - WhereClause {id, predicates, span}: WhereClause, - fld: &mut T) - -> WhereClause { - WhereClause { - id: fld.new_id(id), - predicates: predicates.move_map(|predicate| { - fld.fold_where_predicate(predicate) - }), - span: fld.new_span(span), - } +pub fn noop_visit_where_clause(wc: &mut WhereClause, vis: &mut T) { + let WhereClause { id, predicates, span } = wc; + vis.visit_id(id); + visit_vec(predicates, |predicate| vis.visit_where_predicate(predicate)); + vis.visit_span(span); } -pub fn noop_fold_where_predicate( - pred: WherePredicate, - fld: &mut T) - -> WherePredicate { +pub fn noop_visit_where_predicate(pred: &mut WherePredicate, vis: &mut T) { match pred { - WherePredicate::BoundPredicate(WhereBoundPredicate { bound_generic_params, - bounded_ty, - bounds, - span }) => { - WherePredicate::BoundPredicate(WhereBoundPredicate { - bound_generic_params: fld.fold_generic_params(bound_generic_params), - bounded_ty: fld.fold_ty(bounded_ty), - bounds: bounds.move_map(|x| fld.fold_param_bound(x)), - span: fld.new_span(span) - }) - } - WherePredicate::RegionPredicate(WhereRegionPredicate { lifetime, bounds, span }) => { - WherePredicate::RegionPredicate(WhereRegionPredicate { - span: fld.new_span(span), - lifetime: noop_fold_lifetime(lifetime, fld), - bounds: bounds.move_map(|bound| noop_fold_param_bound(bound, fld)) - }) - } - WherePredicate::EqPredicate(WhereEqPredicate { id, lhs_ty, rhs_ty, span }) => { - WherePredicate::EqPredicate(WhereEqPredicate{ - id: fld.new_id(id), - lhs_ty: fld.fold_ty(lhs_ty), - rhs_ty: fld.fold_ty(rhs_ty), - span: fld.new_span(span) - }) - } - } -} - -pub fn noop_fold_variant_data(vdata: VariantData, fld: &mut T) -> VariantData { - match vdata { - VariantData::Struct(fields, id) => { - VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id)) + WherePredicate::BoundPredicate(bp) => { + let WhereBoundPredicate { span, bound_generic_params, bounded_ty, bounds } = bp; + vis.visit_span(span); + vis.visit_generic_params(bound_generic_params); + vis.visit_ty(bounded_ty); + visit_vec(bounds, |bound| vis.visit_param_bound(bound)); } - VariantData::Tuple(fields, id) => { - VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id)) + WherePredicate::RegionPredicate(rp) => { + let WhereRegionPredicate { span, lifetime, bounds } = rp; + vis.visit_span(span); + noop_visit_lifetime(lifetime, vis); + visit_vec(bounds, |bound| noop_visit_param_bound(bound, vis)); + } + WherePredicate::EqPredicate(ep) => { + let WhereEqPredicate { id, span, lhs_ty, rhs_ty } = ep; + vis.visit_id(id); + vis.visit_span(span); + vis.visit_ty(lhs_ty); + vis.visit_ty(rhs_ty); } - VariantData::Unit(id) => VariantData::Unit(fld.new_id(id)) } } -pub fn noop_fold_trait_ref(p: TraitRef, fld: &mut T) -> TraitRef { - let id = fld.new_id(p.ref_id); - let TraitRef { - path, - ref_id: _, - } = p; - TraitRef { - path: fld.fold_path(path), - ref_id: id, +pub fn noop_visit_variant_data(vdata: &mut VariantData, vis: &mut T) { + match vdata { + VariantData::Struct(fields, id) | + VariantData::Tuple(fields, id) => { + visit_vec(fields, |field| vis.visit_struct_field(field)); + vis.visit_id(id); + } + VariantData::Unit(id) => vis.visit_id(id), } } -pub fn noop_fold_poly_trait_ref(p: PolyTraitRef, fld: &mut T) -> PolyTraitRef { - PolyTraitRef { - bound_generic_params: fld.fold_generic_params(p.bound_generic_params), - trait_ref: fld.fold_trait_ref(p.trait_ref), - span: fld.new_span(p.span), - } +pub fn noop_visit_trait_ref(TraitRef { path, ref_id }: &mut TraitRef, vis: &mut T) { + vis.visit_path(path); + vis.visit_id(ref_id); } -pub fn noop_fold_struct_field(f: StructField, fld: &mut T) -> StructField { - StructField { - span: fld.new_span(f.span), - id: fld.new_id(f.id), - ident: f.ident.map(|ident| fld.fold_ident(ident)), - vis: fld.fold_vis(f.vis), - ty: fld.fold_ty(f.ty), - attrs: fold_attrs(f.attrs, fld), - } +pub fn noop_visit_poly_trait_ref(p: &mut PolyTraitRef, vis: &mut T) { + let PolyTraitRef { bound_generic_params, trait_ref, span } = p; + vis.visit_generic_params(bound_generic_params); + vis.visit_trait_ref(trait_ref); + vis.visit_span(span); } -pub fn noop_fold_field(f: Field, folder: &mut T) -> Field { - Field { - ident: folder.fold_ident(f.ident), - expr: folder.fold_expr(f.expr), - span: folder.new_span(f.span), - is_shorthand: f.is_shorthand, - attrs: fold_thin_attrs(f.attrs, folder), - } +pub fn noop_visit_struct_field(f: &mut StructField, visitor: &mut T) { + let StructField { span, ident, vis, id, ty, attrs } = f; + visitor.visit_span(span); + visit_opt(ident, |ident| visitor.visit_ident(ident)); + visitor.visit_vis(vis); + visitor.visit_id(id); + visitor.visit_ty(ty); + visit_attrs(attrs, visitor); } -pub fn noop_fold_mt(MutTy {ty, mutbl}: MutTy, folder: &mut T) -> MutTy { - MutTy { - ty: folder.fold_ty(ty), - mutbl, - } +pub fn noop_visit_field(f: &mut Field, vis: &mut T) { + let Field { ident, expr, span, is_shorthand: _, attrs } = f; + vis.visit_ident(ident); + vis.visit_expr(expr); + vis.visit_span(span); + visit_thin_attrs(attrs, vis); } -pub fn noop_fold_block(b: P, folder: &mut T) -> P { - b.map(|Block {id, stmts, rules, span}| Block { - id: folder.new_id(id), - stmts: stmts.move_flat_map(|s| folder.fold_stmt(s).into_iter()), - rules, - span: folder.new_span(span), - }) +pub fn noop_visit_mt(MutTy { ty, mutbl: _ }: &mut MutTy, vis: &mut T) { + vis.visit_ty(ty); } -pub fn noop_fold_item_kind(i: ItemKind, folder: &mut T) -> ItemKind { - match i { - ItemKind::ExternCrate(orig_name) => ItemKind::ExternCrate(orig_name), - ItemKind::Use(use_tree) => { - ItemKind::Use(use_tree.map(|tree| folder.fold_use_tree(tree))) - } - ItemKind::Static(t, m, e) => { - ItemKind::Static(folder.fold_ty(t), m, folder.fold_expr(e)) +pub fn noop_visit_block(block: &mut P, vis: &mut T) { + let Block { id, stmts, rules: _, span } = block.deref_mut(); + vis.visit_id(id); + stmts.flat_map_in_place(|stmt| vis.flat_map_stmt(stmt)); + vis.visit_span(span); +} + +pub fn noop_visit_item_kind(kind: &mut ItemKind, vis: &mut T) { + match kind { + ItemKind::ExternCrate(_orig_name) => {} + ItemKind::Use(use_tree) => vis.visit_use_tree(use_tree), + ItemKind::Static(ty, _mut, expr) => { + vis.visit_ty(ty); + vis.visit_expr(expr); } - ItemKind::Const(t, e) => { - ItemKind::Const(folder.fold_ty(t), folder.fold_expr(e)) + ItemKind::Const(ty, expr) => { + vis.visit_ty(ty); + vis.visit_expr(expr); } ItemKind::Fn(decl, header, generics, body) => { - let generics = folder.fold_generics(generics); - let header = folder.fold_fn_header(header); - let decl = folder.fold_fn_decl(decl); - let body = folder.fold_block(body); - ItemKind::Fn(decl, header, generics, body) - } - ItemKind::Mod(m) => ItemKind::Mod(folder.fold_mod(m)), - ItemKind::ForeignMod(nm) => ItemKind::ForeignMod(folder.fold_foreign_mod(nm)), - ItemKind::GlobalAsm(ga) => ItemKind::GlobalAsm(ga), - ItemKind::Ty(t, generics) => { - ItemKind::Ty(folder.fold_ty(t), folder.fold_generics(generics)) - } - ItemKind::Existential(bounds, generics) => ItemKind::Existential( - fold_bounds(bounds, folder), - folder.fold_generics(generics), - ), - ItemKind::Enum(enum_definition, generics) => { - let generics = folder.fold_generics(generics); - let variants = enum_definition.variants.move_map(|x| folder.fold_variant(x)); - ItemKind::Enum(EnumDef { variants }, generics) - } - ItemKind::Struct(struct_def, generics) => { - let generics = folder.fold_generics(generics); - ItemKind::Struct(folder.fold_variant_data(struct_def), generics) - } - ItemKind::Union(struct_def, generics) => { - let generics = folder.fold_generics(generics); - ItemKind::Union(folder.fold_variant_data(struct_def), generics) - } - ItemKind::Impl(unsafety, - polarity, - defaultness, - generics, - ifce, - ty, - impl_items) => ItemKind::Impl( - unsafety, - polarity, - defaultness, - folder.fold_generics(generics), - ifce.map(|trait_ref| folder.fold_trait_ref(trait_ref)), - folder.fold_ty(ty), - impl_items.move_flat_map(|item| folder.fold_impl_item(item)), - ), - ItemKind::Trait(is_auto, unsafety, generics, bounds, items) => ItemKind::Trait( - is_auto, - unsafety, - folder.fold_generics(generics), - fold_bounds(bounds, folder), - items.move_flat_map(|item| folder.fold_trait_item(item)), - ), - ItemKind::TraitAlias(generics, bounds) => ItemKind::TraitAlias( - folder.fold_generics(generics), - fold_bounds(bounds, folder)), - ItemKind::Mac(m) => ItemKind::Mac(folder.fold_mac(m)), - ItemKind::MacroDef(def) => ItemKind::MacroDef(folder.fold_macro_def(def)), - } -} - -pub fn noop_fold_trait_item(i: TraitItem, folder: &mut T) -> SmallVec<[TraitItem; 1]> { - smallvec![TraitItem { - id: folder.new_id(i.id), - ident: folder.fold_ident(i.ident), - attrs: fold_attrs(i.attrs, folder), - generics: folder.fold_generics(i.generics), - node: match i.node { - TraitItemKind::Const(ty, default) => { - TraitItemKind::Const(folder.fold_ty(ty), - default.map(|x| folder.fold_expr(x))) - } - TraitItemKind::Method(sig, body) => { - TraitItemKind::Method(fold_method_sig(sig, folder), - body.map(|x| folder.fold_block(x))) - } - TraitItemKind::Type(bounds, default) => { - TraitItemKind::Type(fold_bounds(bounds, folder), - default.map(|x| folder.fold_ty(x))) - } - TraitItemKind::Macro(mac) => { - TraitItemKind::Macro(folder.fold_mac(mac)) - } - }, - span: folder.new_span(i.span), - tokens: i.tokens, - }] -} - -pub fn noop_fold_impl_item(i: ImplItem, folder: &mut T)-> SmallVec<[ImplItem; 1]> { - smallvec![ImplItem { - id: folder.new_id(i.id), - vis: folder.fold_vis(i.vis), - ident: folder.fold_ident(i.ident), - attrs: fold_attrs(i.attrs, folder), - generics: folder.fold_generics(i.generics), - defaultness: i.defaultness, - node: match i.node { - ImplItemKind::Const(ty, expr) => { - ImplItemKind::Const(folder.fold_ty(ty), folder.fold_expr(expr)) - } - ImplItemKind::Method(sig, body) => { - ImplItemKind::Method(fold_method_sig(sig, folder), - folder.fold_block(body)) - } - ImplItemKind::Type(ty) => ImplItemKind::Type(folder.fold_ty(ty)), - ImplItemKind::Existential(bounds) => { - ImplItemKind::Existential(fold_bounds(bounds, folder)) - }, - ImplItemKind::Macro(mac) => ImplItemKind::Macro(folder.fold_mac(mac)) - }, - span: folder.new_span(i.span), - tokens: i.tokens, - }] -} - -pub fn noop_fold_fn_header(mut header: FnHeader, folder: &mut T) -> FnHeader { - header.asyncness = folder.fold_asyncness(header.asyncness); - header + vis.visit_fn_decl(decl); + vis.visit_fn_header(header); + vis.visit_generics(generics); + vis.visit_block(body); + } + ItemKind::Mod(m) => vis.visit_mod(m), + ItemKind::ForeignMod(nm) => vis.visit_foreign_mod(nm), + ItemKind::GlobalAsm(_ga) => {} + ItemKind::Ty(ty, generics) => { + vis.visit_ty(ty); + vis.visit_generics(generics); + } + ItemKind::Existential(bounds, generics) => { + visit_bounds(bounds, vis); + vis.visit_generics(generics); + } + ItemKind::Enum(EnumDef { variants }, generics) => { + visit_vec(variants, |variant| vis.visit_variant(variant)); + vis.visit_generics(generics); + } + ItemKind::Struct(variant_data, generics) | + ItemKind::Union(variant_data, generics) => { + vis.visit_variant_data(variant_data); + vis.visit_generics(generics); + } + ItemKind::Impl(_unsafety, _polarity, _defaultness, generics, trait_ref, ty, items) => { + vis.visit_generics(generics); + visit_opt(trait_ref, |trait_ref| vis.visit_trait_ref(trait_ref)); + vis.visit_ty(ty); + items.flat_map_in_place(|item| vis.flat_map_impl_item(item)); + } + ItemKind::Trait(_is_auto, _unsafety, generics, bounds, items) => { + vis.visit_generics(generics); + visit_bounds(bounds, vis); + items.flat_map_in_place(|item| vis.flat_map_trait_item(item)); + } + ItemKind::TraitAlias(generics, bounds) => { + vis.visit_generics(generics); + visit_bounds(bounds, vis); + } + ItemKind::Mac(m) => vis.visit_mac(m), + ItemKind::MacroDef(def) => vis.visit_macro_def(def), + } } -pub fn noop_fold_mod(Mod {inner, items, inline}: Mod, folder: &mut T) -> Mod { - Mod { - inner: folder.new_span(inner), - items: items.move_flat_map(|x| folder.fold_item(x)), - inline: inline, +pub fn noop_flat_map_trait_item(mut item: TraitItem, vis: &mut T) + -> SmallVec<[TraitItem; 1]> +{ + let TraitItem { id, ident, attrs, generics, node, span, tokens: _ } = &mut item; + vis.visit_id(id); + vis.visit_ident(ident); + visit_attrs(attrs, vis); + vis.visit_generics(generics); + match node { + TraitItemKind::Const(ty, default) => { + vis.visit_ty(ty); + visit_opt(default, |default| vis.visit_expr(default)); + } + TraitItemKind::Method(sig, body) => { + visit_method_sig(sig, vis); + visit_opt(body, |body| vis.visit_block(body)); + } + TraitItemKind::Type(bounds, default) => { + visit_bounds(bounds, vis); + visit_opt(default, |default| vis.visit_ty(default)); + } + TraitItemKind::Macro(mac) => { + vis.visit_mac(mac); + } } -} + vis.visit_span(span); -pub fn noop_fold_crate(Crate {module, attrs, span}: Crate, - folder: &mut T) -> Crate { - let item = P(Item { - ident: keywords::Invalid.ident(), - attrs, - id: DUMMY_NODE_ID, - vis: respan(span.shrink_to_lo(), VisibilityKind::Public), - span, - node: ItemKind::Mod(module), - tokens: None, - }); - let items = folder.fold_item(item); + smallvec![item] +} - let len = items.len(); - if len == 0 { - let module = Mod { inner: span, items: vec![], inline: true }; - Crate { module, attrs: vec![], span } - } else if len == 1 { - let Item { attrs, span, node, .. } = items.into_iter().next().unwrap().into_inner(); - match node { - ItemKind::Mod(module) => Crate { module, attrs, span }, - _ => panic!("fold converted a module to not a module"), +pub fn noop_flat_map_impl_item(mut item: ImplItem, visitor: &mut T) + -> SmallVec<[ImplItem; 1]> +{ + let ImplItem { id, ident, vis, defaultness: _, attrs, generics, node, span, tokens: _ } = + &mut item; + visitor.visit_id(id); + visitor.visit_ident(ident); + visitor.visit_vis(vis); + visit_attrs(attrs, visitor); + visitor.visit_generics(generics); + match node { + ImplItemKind::Const(ty, expr) => { + visitor.visit_ty(ty); + visitor.visit_expr(expr); } - } else { - panic!("a crate cannot expand to more than one item"); - } + ImplItemKind::Method(sig, body) => { + visit_method_sig(sig, visitor); + visitor.visit_block(body); + } + ImplItemKind::Type(ty) => visitor.visit_ty(ty), + ImplItemKind::Existential(bounds) => visit_bounds(bounds, visitor), + ImplItemKind::Macro(mac) => visitor.visit_mac(mac), + } + visitor.visit_span(span); + + smallvec![item] +} + +pub fn noop_visit_fn_header(header: &mut FnHeader, vis: &mut T) { + let FnHeader { unsafety: _, asyncness, constness: _, abi: _ } = header; + vis.visit_asyncness(asyncness); +} + +pub fn noop_visit_mod(Mod { inner, items, inline: _ }: &mut Mod, vis: &mut T) { + vis.visit_span(inner); + items.flat_map_in_place(|item| vis.flat_map_item(item)); +} + +pub fn noop_visit_crate(krate: &mut Crate, vis: &mut T) { + visit_clobber(krate, |Crate { module, attrs, span }| { + let item = P(Item { + ident: keywords::Invalid.ident(), + attrs, + id: DUMMY_NODE_ID, + vis: respan(span.shrink_to_lo(), VisibilityKind::Public), + span, + node: ItemKind::Mod(module), + tokens: None, + }); + let items = vis.flat_map_item(item); + + let len = items.len(); + if len == 0 { + let module = Mod { inner: span, items: vec![], inline: true }; + Crate { module, attrs: vec![], span } + } else if len == 1 { + let Item { attrs, span, node, .. } = items.into_iter().next().unwrap().into_inner(); + match node { + ItemKind::Mod(module) => Crate { module, attrs, span }, + _ => panic!("visitor converted a module to not a module"), + } + } else { + panic!("a crate cannot expand to more than one item"); + } + }); } -// fold one item into possibly many items -pub fn noop_fold_item(i: P, folder: &mut T) -> SmallVec<[P; 1]> { - smallvec![i.map(|i| { - let Item {id, ident, attrs, node, vis, span, tokens} = i; - Item { - id: folder.new_id(id), - vis: folder.fold_vis(vis), - ident: folder.fold_ident(ident), - attrs: fold_attrs(attrs, folder), - node: folder.fold_item_kind(node), - span: folder.new_span(span), +// Mutate one item into possibly many items. +pub fn noop_flat_map_item(mut item: P, visitor: &mut T) + -> SmallVec<[P; 1]> { + let Item { ident, attrs, id, node, vis, span, tokens: _ } = item.deref_mut(); + visitor.visit_ident(ident); + visit_attrs(attrs, visitor); + visitor.visit_id(id); + visitor.visit_item_kind(node); + visitor.visit_vis(vis); + visitor.visit_span(span); - // FIXME: if this is replaced with a call to `folder.fold_tts` it causes - // an ICE during resolve... odd! - tokens, - } - })] + // FIXME: if `tokens` is modified with a call to `vis.visit_tts` it causes + // an ICE during resolve... odd! + + smallvec![item] } -pub fn noop_fold_foreign_item(ni: ForeignItem, folder: &mut T) +pub fn noop_flat_map_foreign_item(mut item: ForeignItem, visitor: &mut T) -> SmallVec<[ForeignItem; 1]> { - smallvec![ForeignItem { - id: folder.new_id(ni.id), - vis: folder.fold_vis(ni.vis), - ident: folder.fold_ident(ni.ident), - attrs: fold_attrs(ni.attrs, folder), - node: match ni.node { - ForeignItemKind::Fn(fdec, generics) => { - ForeignItemKind::Fn(folder.fold_fn_decl(fdec), folder.fold_generics(generics)) - } - ForeignItemKind::Static(t, m) => { - ForeignItemKind::Static(folder.fold_ty(t), m) - } - ForeignItemKind::Ty => ForeignItemKind::Ty, - ForeignItemKind::Macro(mac) => ForeignItemKind::Macro(folder.fold_mac(mac)), - }, - span: folder.new_span(ni.span) - }] -} - -pub fn noop_fold_pat(p: P, folder: &mut T) -> P { - p.map(|Pat {id, node, span}| Pat { - id: folder.new_id(id), - node: match node { - PatKind::Wild => PatKind::Wild, - PatKind::Ident(binding_mode, ident, sub) => { - PatKind::Ident(binding_mode, - folder.fold_ident(ident), - sub.map(|x| folder.fold_pat(x))) - } - PatKind::Lit(e) => PatKind::Lit(folder.fold_expr(e)), - PatKind::TupleStruct(pth, pats, ddpos) => { - PatKind::TupleStruct(folder.fold_path(pth), - pats.move_map(|x| folder.fold_pat(x)), ddpos) - } - PatKind::Path(qself, pth) => { - PatKind::Path(folder.fold_qself(qself), folder.fold_path(pth)) - } - PatKind::Struct(pth, fields, etc) => { - let pth = folder.fold_path(pth); - let fs = fields.move_map(|f| { - Spanned { span: folder.new_span(f.span), - node: FieldPat { - ident: folder.fold_ident(f.node.ident), - pat: folder.fold_pat(f.node.pat), - is_shorthand: f.node.is_shorthand, - attrs: fold_attrs(f.node.attrs.into(), folder).into() - }} - }); - PatKind::Struct(pth, fs, etc) - } - PatKind::Tuple(elts, ddpos) => { - PatKind::Tuple(elts.move_map(|x| folder.fold_pat(x)), ddpos) - } - PatKind::Box(inner) => PatKind::Box(folder.fold_pat(inner)), - PatKind::Ref(inner, mutbl) => PatKind::Ref(folder.fold_pat(inner), mutbl), - PatKind::Range(e1, e2, Spanned { span, node }) => { - PatKind::Range(folder.fold_expr(e1), - folder.fold_expr(e2), - Spanned { node, span: folder.new_span(span) }) - }, - PatKind::Slice(before, slice, after) => { - PatKind::Slice(before.move_map(|x| folder.fold_pat(x)), - slice.map(|x| folder.fold_pat(x)), - after.move_map(|x| folder.fold_pat(x))) - } - PatKind::Paren(inner) => PatKind::Paren(folder.fold_pat(inner)), - PatKind::Mac(mac) => PatKind::Mac(folder.fold_mac(mac)) - }, - span: folder.new_span(span) - }) + let ForeignItem { ident, attrs, node, id, span, vis } = &mut item; + visitor.visit_ident(ident); + visit_attrs(attrs, visitor); + match node { + ForeignItemKind::Fn(fdec, generics) => { + visitor.visit_fn_decl(fdec); + visitor.visit_generics(generics); + } + ForeignItemKind::Static(t, _m) => visitor.visit_ty(t), + ForeignItemKind::Ty => {} + ForeignItemKind::Macro(mac) => visitor.visit_mac(mac), + } + visitor.visit_id(id); + visitor.visit_span(span); + visitor.visit_vis(vis); + + smallvec![item] } -pub fn noop_fold_anon_const(constant: AnonConst, folder: &mut T) -> AnonConst { - let AnonConst {id, value} = constant; - AnonConst { - id: folder.new_id(id), - value: folder.fold_expr(value), +pub fn noop_visit_pat(pat: &mut P, vis: &mut T) { + let Pat { id, node, span } = pat.deref_mut(); + vis.visit_id(id); + match node { + PatKind::Wild => {} + PatKind::Ident(_binding_mode, ident, sub) => { + vis.visit_ident(ident); + visit_opt(sub, |sub| vis.visit_pat(sub)); + } + PatKind::Lit(e) => vis.visit_expr(e), + PatKind::TupleStruct(path, pats, _ddpos) => { + vis.visit_path(path); + visit_vec(pats, |pat| vis.visit_pat(pat)); + } + PatKind::Path(qself, path) => { + vis.visit_qself(qself); + vis.visit_path(path); + } + PatKind::Struct(path, fields, _etc) => { + vis.visit_path(path); + for Spanned { node: FieldPat { ident, pat, is_shorthand: _, attrs }, span } in fields { + vis.visit_ident(ident); + vis.visit_pat(pat); + visit_thin_attrs(attrs, vis); + vis.visit_span(span); + }; + } + PatKind::Tuple(elts, _ddpos) => visit_vec(elts, |elt| vis.visit_pat(elt)), + PatKind::Box(inner) => vis.visit_pat(inner), + PatKind::Ref(inner, _mutbl) => vis.visit_pat(inner), + PatKind::Range(e1, e2, Spanned { span: _, node: _ }) => { + vis.visit_expr(e1); + vis.visit_expr(e2); + vis.visit_span(span); + }, + PatKind::Slice(before, slice, after) => { + visit_vec(before, |pat| vis.visit_pat(pat)); + visit_opt(slice, |slice| vis.visit_pat(slice)); + visit_vec(after, |pat| vis.visit_pat(pat)); + } + PatKind::Paren(inner) => vis.visit_pat(inner), + PatKind::Mac(mac) => vis.visit_mac(mac), } + vis.visit_span(span); } -pub fn noop_fold_expr(Expr {id, node, span, attrs}: Expr, folder: &mut T) -> Expr { - Expr { - node: match node { - ExprKind::Box(e) => { - ExprKind::Box(folder.fold_expr(e)) - } - ExprKind::ObsoleteInPlace(a, b) => { - ExprKind::ObsoleteInPlace(folder.fold_expr(a), folder.fold_expr(b)) - } - ExprKind::Array(exprs) => { - ExprKind::Array(fold_exprs(exprs, folder)) - } - ExprKind::Repeat(expr, count) => { - ExprKind::Repeat(folder.fold_expr(expr), folder.fold_anon_const(count)) - } - ExprKind::Tup(exprs) => ExprKind::Tup(fold_exprs(exprs, folder)), - ExprKind::Call(f, args) => { - ExprKind::Call(folder.fold_expr(f), - fold_exprs(args, folder)) - } - ExprKind::MethodCall(seg, args) => { - ExprKind::MethodCall( - PathSegment { - ident: folder.fold_ident(seg.ident), - id: folder.new_id(seg.id), - args: seg.args.map(|args| { - args.map(|args| folder.fold_generic_args(args)) - }), - }, - fold_exprs(args, folder)) - } - ExprKind::Binary(binop, lhs, rhs) => { - ExprKind::Binary(binop, - folder.fold_expr(lhs), - folder.fold_expr(rhs)) - } - ExprKind::Unary(binop, ohs) => { - ExprKind::Unary(binop, folder.fold_expr(ohs)) - } - ExprKind::Lit(l) => ExprKind::Lit(l), - ExprKind::Cast(expr, ty) => { - ExprKind::Cast(folder.fold_expr(expr), folder.fold_ty(ty)) - } - ExprKind::Type(expr, ty) => { - ExprKind::Type(folder.fold_expr(expr), folder.fold_ty(ty)) - } - ExprKind::AddrOf(m, ohs) => ExprKind::AddrOf(m, folder.fold_expr(ohs)), - ExprKind::If(cond, tr, fl) => { - ExprKind::If(folder.fold_expr(cond), - folder.fold_block(tr), - fl.map(|x| folder.fold_expr(x))) - } - ExprKind::IfLet(pats, expr, tr, fl) => { - ExprKind::IfLet(pats.move_map(|pat| folder.fold_pat(pat)), - folder.fold_expr(expr), - folder.fold_block(tr), - fl.map(|x| folder.fold_expr(x))) - } - ExprKind::While(cond, body, opt_label) => { - ExprKind::While(folder.fold_expr(cond), - folder.fold_block(body), - opt_label.map(|label| folder.fold_label(label))) - } - ExprKind::WhileLet(pats, expr, body, opt_label) => { - ExprKind::WhileLet(pats.move_map(|pat| folder.fold_pat(pat)), - folder.fold_expr(expr), - folder.fold_block(body), - opt_label.map(|label| folder.fold_label(label))) - } - ExprKind::ForLoop(pat, iter, body, opt_label) => { - ExprKind::ForLoop(folder.fold_pat(pat), - folder.fold_expr(iter), - folder.fold_block(body), - opt_label.map(|label| folder.fold_label(label))) - } - ExprKind::Loop(body, opt_label) => { - ExprKind::Loop(folder.fold_block(body), - opt_label.map(|label| folder.fold_label(label))) - } - ExprKind::Match(expr, arms) => { - ExprKind::Match(folder.fold_expr(expr), - arms.move_map(|x| folder.fold_arm(x))) - } - ExprKind::Closure(capture_clause, asyncness, movability, decl, body, span) => { - ExprKind::Closure(capture_clause, - folder.fold_asyncness(asyncness), - movability, - folder.fold_fn_decl(decl), - folder.fold_expr(body), - folder.new_span(span)) - } - ExprKind::Block(blk, opt_label) => { - ExprKind::Block(folder.fold_block(blk), - opt_label.map(|label| folder.fold_label(label))) - } - ExprKind::Async(capture_clause, node_id, body) => { - ExprKind::Async( - capture_clause, - folder.new_id(node_id), - folder.fold_block(body), - ) - } - ExprKind::Assign(el, er) => { - ExprKind::Assign(folder.fold_expr(el), folder.fold_expr(er)) - } - ExprKind::AssignOp(op, el, er) => { - ExprKind::AssignOp(op, - folder.fold_expr(el), - folder.fold_expr(er)) - } - ExprKind::Field(el, ident) => { - ExprKind::Field(folder.fold_expr(el), folder.fold_ident(ident)) - } - ExprKind::Index(el, er) => { - ExprKind::Index(folder.fold_expr(el), folder.fold_expr(er)) - } - ExprKind::Range(e1, e2, lim) => { - ExprKind::Range(e1.map(|x| folder.fold_expr(x)), - e2.map(|x| folder.fold_expr(x)), - lim) - } - ExprKind::Path(qself, path) => { - ExprKind::Path(folder.fold_qself(qself), folder.fold_path(path)) - } - ExprKind::Break(opt_label, opt_expr) => { - ExprKind::Break(opt_label.map(|label| folder.fold_label(label)), - opt_expr.map(|e| folder.fold_expr(e))) - } - ExprKind::Continue(opt_label) => { - ExprKind::Continue(opt_label.map(|label| folder.fold_label(label))) - } - ExprKind::Ret(e) => ExprKind::Ret(e.map(|x| folder.fold_expr(x))), - ExprKind::InlineAsm(asm) => ExprKind::InlineAsm(asm.map(|asm| { - InlineAsm { - inputs: asm.inputs.move_map(|(c, input)| { - (c, folder.fold_expr(input)) - }), - outputs: asm.outputs.move_map(|out| { - InlineAsmOutput { - constraint: out.constraint, - expr: folder.fold_expr(out.expr), - is_rw: out.is_rw, - is_indirect: out.is_indirect, - } - }), - ..asm - } - })), - ExprKind::Mac(mac) => ExprKind::Mac(folder.fold_mac(mac)), - ExprKind::Struct(path, fields, maybe_expr) => { - ExprKind::Struct(folder.fold_path(path), - fields.move_map(|x| folder.fold_field(x)), - maybe_expr.map(|x| folder.fold_expr(x))) - }, - ExprKind::Paren(ex) => { - let sub_expr = folder.fold_expr(ex); - return Expr { - // Nodes that are equal modulo `Paren` sugar no-ops should have the same ids. - id: sub_expr.id, - node: ExprKind::Paren(sub_expr), - span: folder.new_span(span), - attrs: fold_attrs(attrs.into(), folder).into(), - }; +pub fn noop_visit_anon_const(AnonConst { id, value }: &mut AnonConst, vis: &mut T) { + vis.visit_id(id); + vis.visit_expr(value); +} + +pub fn noop_visit_expr(Expr { node, id, span, attrs }: &mut Expr, vis: &mut T) { + match node { + ExprKind::Box(expr) => vis.visit_expr(expr), + ExprKind::ObsoleteInPlace(a, b) => { + vis.visit_expr(a); + vis.visit_expr(b); + } + ExprKind::Array(exprs) => visit_exprs(exprs, vis), + ExprKind::Repeat(expr, count) => { + vis.visit_expr(expr); + vis.visit_anon_const(count); + } + ExprKind::Tup(exprs) => visit_exprs(exprs, vis), + ExprKind::Call(f, args) => { + vis.visit_expr(f); + visit_exprs(args, vis); + } + ExprKind::MethodCall(PathSegment { ident, id, args }, exprs) => { + vis.visit_ident(ident); + vis.visit_id(id); + visit_opt(args, |args| vis.visit_generic_args(args)); + visit_exprs(exprs, vis); + } + ExprKind::Binary(_binop, lhs, rhs) => { + vis.visit_expr(lhs); + vis.visit_expr(rhs); + } + ExprKind::Unary(_unop, ohs) => vis.visit_expr(ohs), + ExprKind::Lit(_lit) => {} + ExprKind::Cast(expr, ty) => { + vis.visit_expr(expr); + vis.visit_ty(ty); + } + ExprKind::Type(expr, ty) => { + vis.visit_expr(expr); + vis.visit_ty(ty); + } + ExprKind::AddrOf(_m, ohs) => vis.visit_expr(ohs), + ExprKind::If(cond, tr, fl) => { + vis.visit_expr(cond); + vis.visit_block(tr); + visit_opt(fl, |fl| vis.visit_expr(fl)); + } + ExprKind::IfLet(pats, expr, tr, fl) => { + visit_vec(pats, |pat| vis.visit_pat(pat)); + vis.visit_expr(expr); + vis.visit_block(tr); + visit_opt(fl, |fl| vis.visit_expr(fl)); + } + ExprKind::While(cond, body, label) => { + vis.visit_expr(cond); + vis.visit_block(body); + visit_opt(label, |label| vis.visit_label(label)); + } + ExprKind::WhileLet(pats, expr, body, label) => { + visit_vec(pats, |pat| vis.visit_pat(pat)); + vis.visit_expr(expr); + vis.visit_block(body); + visit_opt(label, |label| vis.visit_label(label)); + } + ExprKind::ForLoop(pat, iter, body, label) => { + vis.visit_pat(pat); + vis.visit_expr(iter); + vis.visit_block(body); + visit_opt(label, |label| vis.visit_label(label)); + } + ExprKind::Loop(body, label) => { + vis.visit_block(body); + visit_opt(label, |label| vis.visit_label(label)); + } + ExprKind::Match(expr, arms) => { + vis.visit_expr(expr); + visit_vec(arms, |arm| vis.visit_arm(arm)); + } + ExprKind::Closure(_capture_by, asyncness, _movability, decl, body, span) => { + vis.visit_asyncness(asyncness); + vis.visit_fn_decl(decl); + vis.visit_expr(body); + vis.visit_span(span); + } + ExprKind::Block(blk, label) => { + vis.visit_block(blk); + visit_opt(label, |label| vis.visit_label(label)); + } + ExprKind::Async(_capture_by, node_id, body) => { + vis.visit_id(node_id); + vis.visit_block(body); + } + ExprKind::Assign(el, er) => { + vis.visit_expr(el); + vis.visit_expr(er); + } + ExprKind::AssignOp(_op, el, er) => { + vis.visit_expr(el); + vis.visit_expr(er); + } + ExprKind::Field(el, ident) => { + vis.visit_expr(el); + vis.visit_ident(ident); + } + ExprKind::Index(el, er) => { + vis.visit_expr(el); + vis.visit_expr(er); + } + ExprKind::Range(e1, e2, _lim) => { + visit_opt(e1, |e1| vis.visit_expr(e1)); + visit_opt(e2, |e2| vis.visit_expr(e2)); + } + ExprKind::Path(qself, path) => { + vis.visit_qself(qself); + vis.visit_path(path); + } + ExprKind::Break(label, expr) => { + visit_opt(label, |label| vis.visit_label(label)); + visit_opt(expr, |expr| vis.visit_expr(expr)); + } + ExprKind::Continue(label) => { + visit_opt(label, |label| vis.visit_label(label)); + } + ExprKind::Ret(expr) => { + visit_opt(expr, |expr| vis.visit_expr(expr)); + } + ExprKind::InlineAsm(asm) => { + let InlineAsm { asm: _, asm_str_style: _, outputs, inputs, clobbers: _, volatile: _, + alignstack: _, dialect: _, ctxt: _ } = asm.deref_mut(); + for out in outputs { + let InlineAsmOutput { constraint: _, expr, is_rw: _, is_indirect: _ } = out; + vis.visit_expr(expr); } - ExprKind::Yield(ex) => ExprKind::Yield(ex.map(|x| folder.fold_expr(x))), - ExprKind::Try(ex) => ExprKind::Try(folder.fold_expr(ex)), - ExprKind::TryBlock(body) => ExprKind::TryBlock(folder.fold_block(body)), - ExprKind::Err => ExprKind::Err, + visit_vec(inputs, |(_c, expr)| vis.visit_expr(expr)); + } + ExprKind::Mac(mac) => vis.visit_mac(mac), + ExprKind::Struct(path, fields, expr) => { + vis.visit_path(path); + visit_vec(fields, |field| vis.visit_field(field)); + visit_opt(expr, |expr| vis.visit_expr(expr)); }, - id: folder.new_id(id), - span: folder.new_span(span), - attrs: fold_attrs(attrs.into(), folder).into(), + ExprKind::Paren(expr) => { + vis.visit_expr(expr); + + // Nodes that are equal modulo `Paren` sugar no-ops should have the same ids. + *id = expr.id; + vis.visit_span(span); + visit_thin_attrs(attrs, vis); + return; + } + ExprKind::Yield(expr) => { + visit_opt(expr, |expr| vis.visit_expr(expr)); + } + ExprKind::Try(expr) => vis.visit_expr(expr), + ExprKind::TryBlock(body) => vis.visit_block(body), + ExprKind::Err => {} } + vis.visit_id(id); + vis.visit_span(span); + visit_thin_attrs(attrs, vis); } -pub fn noop_fold_opt_expr(e: P, folder: &mut T) -> Option> { - Some(folder.fold_expr(e)) +pub fn noop_filter_map_expr(mut e: P, vis: &mut T) -> Option> { + Some({ vis.visit_expr(&mut e); e }) } -pub fn noop_fold_stmt(Stmt {node, span, id}: Stmt, folder: &mut T) -> SmallVec<[Stmt; 1]> +pub fn noop_flat_map_stmt(Stmt { node, mut span, mut id }: Stmt, vis: &mut T) + -> SmallVec<[Stmt; 1]> { - let id = folder.new_id(id); - let span = folder.new_span(span); - noop_fold_stmt_kind(node, folder).into_iter().map(|node| { - Stmt { id: id, node: node, span: span } + vis.visit_id(&mut id); + vis.visit_span(&mut span); + noop_flat_map_stmt_kind(node, vis).into_iter().map(|node| { + Stmt { id, node, span } }).collect() } -pub fn noop_fold_stmt_kind(node: StmtKind, folder: &mut T) -> SmallVec<[StmtKind; 1]> { +pub fn noop_flat_map_stmt_kind(node: StmtKind, vis: &mut T) + -> SmallVec<[StmtKind; 1]> { match node { - StmtKind::Local(local) => smallvec![StmtKind::Local(folder.fold_local(local))], - StmtKind::Item(item) => folder.fold_item(item).into_iter().map(StmtKind::Item).collect(), + StmtKind::Local(mut local) => + smallvec![StmtKind::Local({ vis.visit_local(&mut local); local })], + StmtKind::Item(item) => vis.flat_map_item(item).into_iter().map(StmtKind::Item).collect(), StmtKind::Expr(expr) => { - folder.fold_opt_expr(expr).into_iter().map(StmtKind::Expr).collect() + vis.filter_map_expr(expr).into_iter().map(StmtKind::Expr).collect() } StmtKind::Semi(expr) => { - folder.fold_opt_expr(expr).into_iter().map(StmtKind::Semi).collect() + vis.filter_map_expr(expr).into_iter().map(StmtKind::Semi).collect() + } + StmtKind::Mac(mut mac) => { + let (mac_, _semi, attrs) = mac.deref_mut(); + vis.visit_mac(mac_); + visit_thin_attrs(attrs, vis); + smallvec![StmtKind::Mac(mac)] } - StmtKind::Mac(mac) => smallvec![StmtKind::Mac(mac.map(|(mac, semi, attrs)| { - (folder.fold_mac(mac), semi, fold_attrs(attrs.into(), folder).into()) - }))], } } -pub fn noop_fold_vis(Spanned { node, span }: Visibility, folder: &mut T) -> Visibility { - Visibility { - node: match node { - VisibilityKind::Public => VisibilityKind::Public, - VisibilityKind::Crate(sugar) => VisibilityKind::Crate(sugar), - VisibilityKind::Restricted { path, id } => { - VisibilityKind::Restricted { - path: path.map(|path| folder.fold_path(path)), - id: folder.new_id(id), - } - } - VisibilityKind::Inherited => VisibilityKind::Inherited, - }, - span: folder.new_span(span), +pub fn noop_visit_vis(Spanned { node, span }: &mut Visibility, vis: &mut T) { + match node { + VisibilityKind::Public | VisibilityKind::Crate(_) | VisibilityKind::Inherited => {} + VisibilityKind::Restricted { path, id } => { + vis.visit_path(path); + vis.visit_id(id); + } } + vis.visit_span(span); } #[cfg(test)] @@ -1342,7 +1259,7 @@ mod tests { use ast::{self, Ident}; use util::parser_testing::{string_to_crate, matches_codepattern}; use print::pprust; - use fold; + use mut_visit; use with_globals; use super::*; @@ -1353,14 +1270,14 @@ mod tests { } // change every identifier to "zz" - struct ToZzIdentFolder; + struct ToZzIdentMutVisitor; - impl Folder for ToZzIdentFolder { - fn fold_ident(&mut self, _: ast::Ident) -> ast::Ident { - Ident::from_str("zz") + impl MutVisitor for ToZzIdentMutVisitor { + fn visit_ident(&mut self, ident: &mut ast::Ident) { + *ident = Ident::from_str("zz"); } - fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac { - fold::noop_fold_mac(mac, self) + fn visit_mac(&mut self, mac: &mut ast::Mac) { + mut_visit::noop_visit_mac(mac, self) } } @@ -1382,14 +1299,14 @@ mod tests { // make sure idents get transformed everywhere #[test] fn ident_transformation () { with_globals(|| { - let mut zz_fold = ToZzIdentFolder; - let ast = string_to_crate( + let mut zz_visitor = ToZzIdentMutVisitor; + let mut krate = string_to_crate( "#[a] mod b {fn c (d : e, f : g) {h!(i,j,k);l;m}}".to_string()); - let folded_crate = zz_fold.fold_crate(ast); + zz_visitor.visit_crate(&mut krate); assert_pred!( matches_codepattern, "matches_codepattern", - pprust::to_string(|s| fake_print_crate(s, &folded_crate)), + pprust::to_string(|s| fake_print_crate(s, &krate)), "#[zz]mod zz{fn zz(zz:zz,zz:zz){zz!(zz,zz,zz);zz;zz}}".to_string()); }) } @@ -1397,16 +1314,17 @@ mod tests { // even inside macro defs.... #[test] fn ident_transformation_in_defs () { with_globals(|| { - let mut zz_fold = ToZzIdentFolder; - let ast = string_to_crate( + let mut zz_visitor = ToZzIdentMutVisitor; + let mut krate = string_to_crate( "macro_rules! a {(b $c:expr $(d $e:token)f+ => \ (g $(d $d $e)+))} ".to_string()); - let folded_crate = zz_fold.fold_crate(ast); + zz_visitor.visit_crate(&mut krate); assert_pred!( matches_codepattern, "matches_codepattern", - pprust::to_string(|s| fake_print_crate(s, &folded_crate)), + pprust::to_string(|s| fake_print_crate(s, &krate)), "macro_rules! zz((zz$zz:zz$(zz $zz:zz)zz+=>(zz$(zz$zz$zz)+)));".to_string()); }) } } + diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index b2a3ae7f9d975..dacb0d811cedb 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -133,7 +133,7 @@ pub mod util { pub mod parser; #[cfg(test)] pub mod parser_testing; - pub mod move_map; + pub mod map_in_place; } pub mod json; @@ -151,7 +151,7 @@ pub mod source_map; pub mod config; pub mod entry; pub mod feature_gate; -pub mod fold; +#[path="fold.rs"] pub mod mut_visit; // temporary pub mod parse; pub mod ptr; pub mod show_span; diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 514b2952c5036..a9f3acecc818b 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -7046,7 +7046,8 @@ impl<'a> Parser<'a> { sess: self.sess, features: None, // don't perform gated feature checking }; - let outer_attrs = strip_unconfigured.process_cfg_attrs(outer_attrs.to_owned()); + let mut outer_attrs = outer_attrs.to_owned(); + strip_unconfigured.process_cfg_attrs(&mut outer_attrs); (!self.cfg_mods || strip_unconfigured.in_cfg(&outer_attrs), outer_attrs) }; diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index f06e975a6d95a..5181bb8f34e66 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -735,7 +735,7 @@ impl fmt::Debug for LazyTokenStream { } impl LazyTokenStream { - fn new() -> Self { + pub fn new() -> Self { LazyTokenStream(Lock::new(None)) } diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs index b352486e39a64..12f82a01dcfcd 100644 --- a/src/libsyntax/test.rs +++ b/src/libsyntax/test.rs @@ -20,10 +20,9 @@ use ext::base::{ExtCtxt, Resolver}; use ext::build::AstBuilder; use ext::expand::ExpansionConfig; use ext::hygiene::{self, Mark, SyntaxContext}; -use fold::Folder; +use mut_visit::{*, ExpectOne}; use feature_gate::Features; -use util::move_map::MoveMap; -use fold::{self, ExpectOne}; +use util::map_in_place::MapInPlace; use parse::{token, ParseSess}; use print::pprust; use ast::{self, Ident}; @@ -57,9 +56,9 @@ struct TestCtxt<'a> { pub fn modify_for_testing(sess: &ParseSess, resolver: &mut dyn Resolver, should_test: bool, - krate: ast::Crate, + krate: &mut ast::Crate, span_diagnostic: &errors::Handler, - features: &Features) -> ast::Crate { + features: &Features) { // Check for #[reexport_test_harness_main = "some_name"] which // creates a `use __test::main as some_name;`. This needs to be // unconditional, so that the attribute is still marked as used in @@ -75,8 +74,6 @@ pub fn modify_for_testing(sess: &ParseSess, if should_test { generate_test_harness(sess, resolver, reexport_test_harness_main, krate, span_diagnostic, features, test_runner) - } else { - krate } } @@ -88,21 +85,20 @@ struct TestHarnessGenerator<'a> { tested_submods: Vec<(Ident, Ident)>, } -impl<'a> fold::Folder for TestHarnessGenerator<'a> { - fn fold_crate(&mut self, c: ast::Crate) -> ast::Crate { - let mut folded = fold::noop_fold_crate(c, self); +impl<'a> MutVisitor for TestHarnessGenerator<'a> { + fn visit_crate(&mut self, c: &mut ast::Crate) { + noop_visit_crate(c, self); // Create a main function to run our tests let test_main = { let unresolved = mk_main(&mut self.cx); - self.cx.ext_cx.monotonic_expander().fold_item(unresolved).pop().unwrap() + self.cx.ext_cx.monotonic_expander().flat_map_item(unresolved).pop().unwrap() }; - folded.module.items.push(test_main); - folded + c.module.items.push(test_main); } - fn fold_item(&mut self, i: P) -> SmallVec<[P; 1]> { + fn flat_map_item(&mut self, i: P) -> SmallVec<[P; 1]> { let ident = i.ident; if ident.name != keywords::Invalid.name() { self.cx.path.push(ident); @@ -123,16 +119,16 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> { // We don't want to recurse into anything other than mods, since // mods or tests inside of functions will break things - if let ast::ItemKind::Mod(module) = item.node { + if let ast::ItemKind::Mod(mut module) = item.node { let tests = mem::replace(&mut self.tests, Vec::new()); let tested_submods = mem::replace(&mut self.tested_submods, Vec::new()); - let mut mod_folded = fold::noop_fold_mod(module, self); + noop_visit_mod(&mut module, self); let tests = mem::replace(&mut self.tests, tests); let tested_submods = mem::replace(&mut self.tested_submods, tested_submods); if !tests.is_empty() || !tested_submods.is_empty() { let (it, sym) = mk_reexport_mod(&mut self.cx, item.id, tests, tested_submods); - mod_folded.items.push(it); + module.items.push(it); if !self.cx.path.is_empty() { self.tested_submods.push((self.cx.path[self.cx.path.len()-1], sym)); @@ -141,7 +137,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> { self.cx.toplevel_reexport = Some(sym); } } - item.node = ast::ItemKind::Mod(mod_folded); + item.node = ast::ItemKind::Mod(module); } if ident.name != keywords::Invalid.name() { self.cx.path.pop(); @@ -149,7 +145,9 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> { smallvec![P(item)] } - fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac { mac } + fn visit_mac(&mut self, _mac: &mut ast::Mac) { + // Do nothing. + } } /// A folder used to remove any entry points (like fn main) because the harness @@ -159,20 +157,20 @@ struct EntryPointCleaner { depth: usize, } -impl fold::Folder for EntryPointCleaner { - fn fold_item(&mut self, i: P) -> SmallVec<[P; 1]> { +impl MutVisitor for EntryPointCleaner { + fn flat_map_item(&mut self, i: P) -> SmallVec<[P; 1]> { self.depth += 1; - let folded = fold::noop_fold_item(i, self).expect_one("noop did something"); + let item = noop_flat_map_item(i, self).expect_one("noop did something"); self.depth -= 1; // Remove any #[main] or #[start] from the AST so it doesn't // clash with the one we're going to add, but mark it as // #[allow(dead_code)] to avoid printing warnings. - let folded = match entry::entry_point_type(&folded, self.depth) { + let item = match entry::entry_point_type(&item, self.depth) { EntryPointType::MainNamed | EntryPointType::MainAttr | EntryPointType::Start => - folded.map(|ast::Item {id, ident, attrs, node, vis, span, tokens}| { + item.map(|ast::Item {id, ident, attrs, node, vis, span, tokens}| { let allow_ident = Ident::from_str("allow"); let dc_nested = attr::mk_nested_word_item(Ident::from_str("dead_code")); let allow_dead_code_item = attr::mk_list_item(DUMMY_SP, allow_ident, @@ -197,13 +195,15 @@ impl fold::Folder for EntryPointCleaner { } }), EntryPointType::None | - EntryPointType::OtherMain => folded, + EntryPointType::OtherMain => item, }; - smallvec![folded] + smallvec![item] } - fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac { mac } + fn visit_mac(&mut self, _mac: &mut ast::Mac) { + // Do nothing. + } } /// Creates an item (specifically a module) that "pub use"s the tests passed in. @@ -235,7 +235,7 @@ fn mk_reexport_mod(cx: &mut TestCtxt, let sym = Ident::with_empty_ctxt(Symbol::gensym("__test_reexports")); let parent = if parent == ast::DUMMY_NODE_ID { ast::CRATE_NODE_ID } else { parent }; cx.ext_cx.current_expansion.mark = cx.ext_cx.resolver.get_module_scope(parent); - let it = cx.ext_cx.monotonic_expander().fold_item(P(ast::Item { + let it = cx.ext_cx.monotonic_expander().flat_map_item(P(ast::Item { ident: sym, attrs: Vec::new(), id: ast::DUMMY_NODE_ID, @@ -252,13 +252,13 @@ fn mk_reexport_mod(cx: &mut TestCtxt, fn generate_test_harness(sess: &ParseSess, resolver: &mut dyn Resolver, reexport_test_harness_main: Option, - krate: ast::Crate, + krate: &mut ast::Crate, sd: &errors::Handler, features: &Features, - test_runner: Option) -> ast::Crate { + test_runner: Option) { // Remove the entry points let mut cleaner = EntryPointCleaner { depth: 0 }; - let krate = cleaner.fold_crate(krate); + cleaner.visit_crate(krate); let mark = Mark::fresh(Mark::root()); @@ -293,7 +293,7 @@ fn generate_test_harness(sess: &ParseSess, cx, tests: Vec::new(), tested_submods: Vec::new(), - }.fold_crate(krate) + }.visit_crate(krate); } /// Craft a span that will be ignored by the stability lint's diff --git a/src/libsyntax/tokenstream.rs b/src/libsyntax/tokenstream.rs index f5d2d6f18ee87..ff5978a7ee581 100644 --- a/src/libsyntax/tokenstream.rs +++ b/src/libsyntax/tokenstream.rs @@ -147,7 +147,7 @@ impl TokenTree { /// empty stream is represented with `None`; it may be represented as a `Some` /// around an empty `Vec`. #[derive(Clone, Debug)] -pub struct TokenStream(Option>>); +pub struct TokenStream(pub Option>>); pub type TreeAndJoint = (TokenTree, IsJoint); diff --git a/src/libsyntax/util/move_map.rs b/src/libsyntax/util/map_in_place.rs similarity index 82% rename from src/libsyntax/util/move_map.rs rename to src/libsyntax/util/map_in_place.rs index a0f9d39ce89b3..5724b540a0dcf 100644 --- a/src/libsyntax/util/move_map.rs +++ b/src/libsyntax/util/map_in_place.rs @@ -1,18 +1,18 @@ use std::ptr; use smallvec::{Array, SmallVec}; -pub trait MoveMap: Sized { - fn move_map(self, mut f: F) -> Self where F: FnMut(T) -> T { - self.move_flat_map(|e| Some(f(e))) +pub trait MapInPlace: Sized { + fn map_in_place(&mut self, mut f: F) where F: FnMut(T) -> T { + self.flat_map_in_place(|e| Some(f(e))) } - fn move_flat_map(self, f: F) -> Self + fn flat_map_in_place(&mut self, f: F) where F: FnMut(T) -> I, I: IntoIterator; } -impl MoveMap for Vec { - fn move_flat_map(mut self, mut f: F) -> Self +impl MapInPlace for Vec { + fn flat_map_in_place(&mut self, mut f: F) where F: FnMut(T) -> I, I: IntoIterator { @@ -53,22 +53,11 @@ impl MoveMap for Vec { // write_i tracks the number of actually written new items. self.set_len(write_i); } - - self - } -} - -impl MoveMap for ::ptr::P<[T]> { - fn move_flat_map(self, f: F) -> Self - where F: FnMut(T) -> I, - I: IntoIterator - { - ::ptr::P::from_vec(self.into_vec().move_flat_map(f)) } } -impl> MoveMap for SmallVec { - fn move_flat_map(mut self, mut f: F) -> Self +impl> MapInPlace for SmallVec { + fn flat_map_in_place(&mut self, mut f: F) where F: FnMut(T) -> I, I: IntoIterator { @@ -109,7 +98,5 @@ impl> MoveMap for SmallVec { // write_i tracks the number of actually written new items. self.set_len(write_i); } - - self } } diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs index 22643db501693..ec2c3113fab95 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -189,7 +189,7 @@ use syntax::attr; use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::source_map::{self, respan}; -use syntax::util::move_map::MoveMap; +use syntax::util::map_in_place::MapInPlace; use syntax::ptr::P; use syntax::symbol::{Symbol, keywords}; use syntax::parse::ParseSess; @@ -1184,7 +1184,7 @@ impl<'a> MethodDef<'a> { enum_def: &'b EnumDef, type_attrs: &[ast::Attribute], type_ident: Ident, - self_args: Vec>, + mut self_args: Vec>, nonself_args: &[P]) -> P { let sp = trait_.span; @@ -1417,8 +1417,8 @@ impl<'a> MethodDef<'a> { // them when they are fed as r-values into a tuple // expression; here add a layer of borrowing, turning // `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`. - let borrowed_self_args = self_args.move_map(|self_arg| cx.expr_addr_of(sp, self_arg)); - let match_arg = cx.expr(sp, ast::ExprKind::Tup(borrowed_self_args)); + self_args.map_in_place(|self_arg| cx.expr_addr_of(sp, self_arg)); + let match_arg = cx.expr(sp, ast::ExprKind::Tup(self_args)); // Lastly we create an expression which branches on all discriminants being equal // if discriminant_test { @@ -1494,8 +1494,8 @@ impl<'a> MethodDef<'a> { // them when they are fed as r-values into a tuple // expression; here add a layer of borrowing, turning // `(*self, *__arg_0, ...)` into `(&*self, &*__arg_0, ...)`. - let borrowed_self_args = self_args.move_map(|self_arg| cx.expr_addr_of(sp, self_arg)); - let match_arg = cx.expr(sp, ast::ExprKind::Tup(borrowed_self_args)); + self_args.map_in_place(|self_arg| cx.expr_addr_of(sp, self_arg)); + let match_arg = cx.expr(sp, ast::ExprKind::Tup(self_args)); cx.expr_match(sp, match_arg, match_arms) } } diff --git a/src/libsyntax_ext/proc_macro_decls.rs b/src/libsyntax_ext/proc_macro_decls.rs index 46c502965eea8..663fb12242c44 100644 --- a/src/libsyntax_ext/proc_macro_decls.rs +++ b/src/libsyntax_ext/proc_macro_decls.rs @@ -9,7 +9,7 @@ use syntax::ext::base::ExtCtxt; use syntax::ext::build::AstBuilder; use syntax::ext::expand::ExpansionConfig; use syntax::ext::hygiene::Mark; -use syntax::fold::Folder; +use syntax::mut_visit::MutVisitor; use syntax::parse::ParseSess; use syntax::ptr::P; use syntax::symbol::Symbol; @@ -412,5 +412,5 @@ fn mk_decls( i }); - cx.monotonic_expander().fold_item(module).pop().unwrap() + cx.monotonic_expander().flat_map_item(module).pop().unwrap() } diff --git a/src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs b/src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs index ce3b03efd2604..ee4ecde44f28e 100644 --- a/src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs +++ b/src/test/run-pass-fulldeps/pprust-expr-roundtrip.rs @@ -27,7 +27,7 @@ use rustc_data_structures::thin_vec::ThinVec; use syntax::ast::*; use syntax::source_map::{Spanned, DUMMY_SP, FileName}; use syntax::source_map::FilePathMapping; -use syntax::fold::{self, Folder}; +use syntax::mut_visit::{self, MutVisitor, visit_clobber}; use syntax::parse::{self, ParseSess}; use syntax::print::pprust; use syntax::ptr::P; @@ -157,32 +157,34 @@ fn iter_exprs(depth: usize, f: &mut FnMut(P)) { // Folders for manipulating the placement of `Paren` nodes. See below for why this is needed. -/// Folder that removes all `ExprKind::Paren` nodes. +/// MutVisitor that removes all `ExprKind::Paren` nodes. struct RemoveParens; -impl Folder for RemoveParens { - fn fold_expr(&mut self, e: P) -> P { - let e = match e.node { - ExprKind::Paren(ref inner) => inner.clone(), - _ => e.clone(), +impl MutVisitor for RemoveParens { + fn visit_expr(&mut self, e: &mut P) { + match e.node.clone() { + ExprKind::Paren(inner) => *e = inner, + _ => {} }; - e.map(|e| fold::noop_fold_expr(e, self)) + mut_visit::noop_visit_expr(e, self); } } -/// Folder that inserts `ExprKind::Paren` nodes around every `Expr`. +/// MutVisitor that inserts `ExprKind::Paren` nodes around every `Expr`. struct AddParens; -impl Folder for AddParens { - fn fold_expr(&mut self, e: P) -> P { - let e = e.map(|e| fold::noop_fold_expr(e, self)); - P(Expr { - id: DUMMY_NODE_ID, - node: ExprKind::Paren(e), - span: DUMMY_SP, - attrs: ThinVec::new(), - }) +impl MutVisitor for AddParens { + fn visit_expr(&mut self, e: &mut P) { + mut_visit::noop_visit_expr(e, self); + visit_clobber(e, |e| { + P(Expr { + id: DUMMY_NODE_ID, + node: ExprKind::Paren(e), + span: DUMMY_SP, + attrs: ThinVec::new(), + }) + }); } } @@ -193,13 +195,13 @@ fn main() { fn run() { let ps = ParseSess::new(FilePathMapping::empty()); - iter_exprs(2, &mut |e| { + iter_exprs(2, &mut |mut e| { // If the pretty printer is correct, then `parse(print(e))` should be identical to `e`, // modulo placement of `Paren` nodes. let printed = pprust::expr_to_string(&e); println!("printed: {}", printed); - let parsed = parse_expr(&ps, &printed); + let mut parsed = parse_expr(&ps, &printed); // We want to know if `parsed` is structurally identical to `e`, ignoring trivial // differences like placement of `Paren`s or the exact ranges of node spans. @@ -207,10 +209,12 @@ fn run() { // everywhere we can, then pretty-print. This should give an unambiguous representation of // each `Expr`, and it bypasses nearly all of the parenthesization logic, so we aren't // relying on the correctness of the very thing we're testing. - let e1 = AddParens.fold_expr(RemoveParens.fold_expr(e)); - let text1 = pprust::expr_to_string(&e1); - let e2 = AddParens.fold_expr(RemoveParens.fold_expr(parsed)); - let text2 = pprust::expr_to_string(&e2); + RemoveParens.visit_expr(&mut e); + AddParens.visit_expr(&mut e); + let text1 = pprust::expr_to_string(&e); + RemoveParens.visit_expr(&mut parsed); + AddParens.visit_expr(&mut parsed); + let text2 = pprust::expr_to_string(&parsed); assert!(text1 == text2, "exprs are not equal:\n e = {:?}\n parsed = {:?}", text1, text2); diff --git a/src/test/ui/issues/issue-49934.rs b/src/test/ui/issues/issue-49934.rs index 59ca6cc292db9..ad410f30c04d4 100644 --- a/src/test/ui/issues/issue-49934.rs +++ b/src/test/ui/issues/issue-49934.rs @@ -30,12 +30,12 @@ fn main() { #[derive(Debug)] //~ WARN unused attribute let _ = "Hello, world!"; - // fold_expr + // visit_expr let _ = #[derive(Debug)] "Hello, world!"; //~^ WARN unused attribute let _ = [ - // fold_opt_expr + // filter_map_expr #[derive(Debug)] //~ WARN unused attribute "Hello, world!" ]; From bfcbd235a28f989c0e3c1f0a7542f4e5caaf6e0d Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Wed, 6 Feb 2019 09:10:05 +1100 Subject: [PATCH 100/278] Rename `fold.rs` as `mut_visit.rs`. --- src/libsyntax/lib.rs | 2 +- src/libsyntax/{fold.rs => mut_visit.rs} | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename src/libsyntax/{fold.rs => mut_visit.rs} (100%) diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index dacb0d811cedb..f2b8f23ee8530 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -151,7 +151,7 @@ pub mod source_map; pub mod config; pub mod entry; pub mod feature_gate; -#[path="fold.rs"] pub mod mut_visit; // temporary +pub mod mut_visit; pub mod parse; pub mod ptr; pub mod show_span; diff --git a/src/libsyntax/fold.rs b/src/libsyntax/mut_visit.rs similarity index 100% rename from src/libsyntax/fold.rs rename to src/libsyntax/mut_visit.rs From f2871a9ce552cd21b1c7b8df69eefe06af6d59da Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Wed, 6 Feb 2019 11:57:11 +1100 Subject: [PATCH 101/278] Make `intern_lazy_const` actually intern its argument. Currently it just unconditionally allocates it in the arena. For a "Clean Check" build of the the `packed-simd` benchmark, this change reduces both the `max-rss` and `faults` counts by 59%; it slightly (~3%) increases the instruction counts but the `wall-time` is unchanged. For the same builds of a few other benchmarks, `max-rss` and `faults` drop by 1--5%, but instruction counts and `wall-time` changes are in the noise. Fixes #57432, fixes #57829. --- src/librustc/mir/mod.rs | 2 +- src/librustc/traits/project.rs | 4 ++-- src/librustc/traits/query/normalize.rs | 4 ++-- src/librustc/ty/codec.rs | 2 +- src/librustc/ty/context.rs | 22 ++++++++++--------- src/librustc/ty/structural_impls.rs | 2 +- src/librustc_mir/build/expr/as_rvalue.rs | 2 +- src/librustc_mir/build/matches/test.rs | 2 +- src/librustc_mir/build/misc.rs | 2 +- src/librustc_mir/hair/cx/expr.rs | 12 +++++----- src/librustc_mir/hair/cx/mod.rs | 6 ++--- src/librustc_mir/shim.rs | 6 ++--- src/librustc_mir/transform/elaborate_drops.rs | 2 +- src/librustc_mir/transform/generator.rs | 4 ++-- src/librustc_mir/util/elaborate_drops.rs | 2 +- src/librustc_typeck/astconv.rs | 2 +- src/librustc_typeck/check/mod.rs | 2 +- 17 files changed, 40 insertions(+), 38 deletions(-) diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs index 82083b4f69964..eca01d78c2a4d 100644 --- a/src/librustc/mir/mod.rs +++ b/src/librustc/mir/mod.rs @@ -2154,7 +2154,7 @@ impl<'tcx> Operand<'tcx> { span, ty, user_ty: None, - literal: tcx.intern_lazy_const( + literal: tcx.mk_lazy_const( ty::LazyConst::Evaluated(ty::Const::zero_sized(ty)), ), }) diff --git a/src/librustc/traits/project.rs b/src/librustc/traits/project.rs index bec45046cb93e..21151276e7299 100644 --- a/src/librustc/traits/project.rs +++ b/src/librustc/traits/project.rs @@ -408,7 +408,7 @@ impl<'a, 'b, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for AssociatedTypeNormalizer<'a, if let Ok(evaluated) = tcx.const_eval(param_env.and(cid)) { let substs = tcx.lift_to_global(&substs).unwrap(); let evaluated = evaluated.subst(tcx, substs); - return tcx.intern_lazy_const(ty::LazyConst::Evaluated(evaluated)); + return tcx.mk_lazy_const(ty::LazyConst::Evaluated(evaluated)); } } } else { @@ -420,7 +420,7 @@ impl<'a, 'b, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for AssociatedTypeNormalizer<'a, promoted: None }; if let Ok(evaluated) = tcx.const_eval(param_env.and(cid)) { - return tcx.intern_lazy_const(ty::LazyConst::Evaluated(evaluated)); + return tcx.mk_lazy_const(ty::LazyConst::Evaluated(evaluated)); } } } diff --git a/src/librustc/traits/query/normalize.rs b/src/librustc/traits/query/normalize.rs index be05445cfc61a..9f55bb95d259b 100644 --- a/src/librustc/traits/query/normalize.rs +++ b/src/librustc/traits/query/normalize.rs @@ -203,7 +203,7 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for QueryNormalizer<'cx, 'gcx, 'tcx if let Ok(evaluated) = tcx.const_eval(param_env.and(cid)) { let substs = tcx.lift_to_global(&substs).unwrap(); let evaluated = evaluated.subst(tcx, substs); - return tcx.intern_lazy_const(ty::LazyConst::Evaluated(evaluated)); + return tcx.mk_lazy_const(ty::LazyConst::Evaluated(evaluated)); } } } else { @@ -215,7 +215,7 @@ impl<'cx, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for QueryNormalizer<'cx, 'gcx, 'tcx promoted: None, }; if let Ok(evaluated) = tcx.const_eval(param_env.and(cid)) { - return tcx.intern_lazy_const(ty::LazyConst::Evaluated(evaluated)); + return tcx.mk_lazy_const(ty::LazyConst::Evaluated(evaluated)); } } } diff --git a/src/librustc/ty/codec.rs b/src/librustc/ty/codec.rs index e0e4d9c362a6c..a4a2471852739 100644 --- a/src/librustc/ty/codec.rs +++ b/src/librustc/ty/codec.rs @@ -252,7 +252,7 @@ pub fn decode_lazy_const<'a, 'tcx, D>(decoder: &mut D) where D: TyDecoder<'a, 'tcx>, 'tcx: 'a, { - Ok(decoder.tcx().intern_lazy_const(Decodable::decode(decoder)?)) + Ok(decoder.tcx().mk_lazy_const(Decodable::decode(decoder)?)) } #[inline] diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index b379b5ba02494..87cf52af1d182 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -127,6 +127,7 @@ pub struct CtxtInterners<'tcx> { goal: InternedSet<'tcx, GoalKind<'tcx>>, goal_list: InternedSet<'tcx, List>>, projs: InternedSet<'tcx, List>>, + lazy_const: InternedSet<'tcx, LazyConst<'tcx>>, } impl<'gcx: 'tcx, 'tcx> CtxtInterners<'tcx> { @@ -144,6 +145,7 @@ impl<'gcx: 'tcx, 'tcx> CtxtInterners<'tcx> { goal: Default::default(), goal_list: Default::default(), projs: Default::default(), + lazy_const: Default::default(), } } @@ -1096,10 +1098,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { self.global_arenas.adt_def.alloc(def) } - pub fn intern_const_alloc( - self, - alloc: Allocation, - ) -> &'gcx Allocation { + pub fn intern_const_alloc(self, alloc: Allocation) -> &'gcx Allocation { self.allocation_interner.borrow_mut().intern(alloc, |alloc| { self.global_arenas.const_allocs.alloc(alloc) }) @@ -1119,10 +1118,6 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { }) } - pub fn intern_lazy_const(self, c: ty::LazyConst<'tcx>) -> &'tcx ty::LazyConst<'tcx> { - self.global_interners.arena.alloc(c) - } - pub fn intern_layout(self, layout: LayoutDetails) -> &'gcx LayoutDetails { self.layout_interner.borrow_mut().intern(layout, |layout| { self.global_arenas.layout.alloc(layout) @@ -2271,6 +2266,12 @@ impl<'tcx: 'lcx, 'lcx> Borrow> for Interned<'tcx, GoalKind<'tcx>> } } +impl<'tcx: 'lcx, 'lcx> Borrow> for Interned<'tcx, LazyConst<'tcx>> { + fn borrow<'a>(&'a self) -> &'a LazyConst<'lcx> { + &self.0 + } +} + impl<'tcx: 'lcx, 'lcx> Borrow<[ExistentialPredicate<'lcx>]> for Interned<'tcx, List>> { fn borrow<'a>(&'a self) -> &'a [ExistentialPredicate<'lcx>] { @@ -2377,7 +2378,8 @@ pub fn keep_local<'tcx, T: ty::TypeFoldable<'tcx>>(x: &T) -> bool { direct_interners!('tcx, region: mk_region(|r: &RegionKind| r.keep_in_local_tcx()) -> RegionKind, - goal: mk_goal(|c: &GoalKind<'_>| keep_local(c)) -> GoalKind<'tcx> + goal: mk_goal(|c: &GoalKind<'_>| keep_local(c)) -> GoalKind<'tcx>, + lazy_const: mk_lazy_const(|c: &LazyConst<'_>| keep_local(&c)) -> LazyConst<'tcx> ); macro_rules! slice_interners { @@ -2562,7 +2564,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { #[inline] pub fn mk_array(self, ty: Ty<'tcx>, n: u64) -> Ty<'tcx> { - self.mk_ty(Array(ty, self.intern_lazy_const( + self.mk_ty(Array(ty, self.mk_lazy_const( ty::LazyConst::Evaluated(ty::Const::from_usize(self.global_tcx(), n)) ))) } diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs index 28f5a65374d98..f89a6ed2e768e 100644 --- a/src/librustc/ty/structural_impls.rs +++ b/src/librustc/ty/structural_impls.rs @@ -1042,7 +1042,7 @@ impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::LazyConst<'tcx> { ty::LazyConst::Unevaluated(*def_id, substs.fold_with(folder)) } }; - folder.tcx().intern_lazy_const(new) + folder.tcx().mk_lazy_const(new) } fn fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { diff --git a/src/librustc_mir/build/expr/as_rvalue.rs b/src/librustc_mir/build/expr/as_rvalue.rs index 3de2f47578650..508f6555f4afc 100644 --- a/src/librustc_mir/build/expr/as_rvalue.rs +++ b/src/librustc_mir/build/expr/as_rvalue.rs @@ -268,7 +268,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> { span: expr_span, ty: this.hir.tcx().types.u32, user_ty: None, - literal: this.hir.tcx().intern_lazy_const(ty::LazyConst::Evaluated( + literal: this.hir.tcx().mk_lazy_const(ty::LazyConst::Evaluated( ty::Const::from_bits( this.hir.tcx(), 0, diff --git a/src/librustc_mir/build/matches/test.rs b/src/librustc_mir/build/matches/test.rs index 696c173b048ad..6e836f7059b83 100644 --- a/src/librustc_mir/build/matches/test.rs +++ b/src/librustc_mir/build/matches/test.rs @@ -302,7 +302,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> { } let eq_def_id = self.hir.tcx().lang_items().eq_trait().unwrap(); let (mty, method) = self.hir.trait_method(eq_def_id, "eq", ty, &[ty.into()]); - let method = self.hir.tcx().intern_lazy_const(ty::LazyConst::Evaluated(method)); + let method = self.hir.tcx().mk_lazy_const(ty::LazyConst::Evaluated(method)); let re_erased = self.hir.tcx().types.re_erased; // take the argument by reference diff --git a/src/librustc_mir/build/misc.rs b/src/librustc_mir/build/misc.rs index c849c02242840..a7b201fc0dbc6 100644 --- a/src/librustc_mir/build/misc.rs +++ b/src/librustc_mir/build/misc.rs @@ -33,7 +33,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> { span, ty, user_ty: None, - literal: self.hir.tcx().intern_lazy_const(ty::LazyConst::Evaluated(literal)), + literal: self.hir.tcx().mk_lazy_const(ty::LazyConst::Evaluated(literal)), }; Operand::Constant(constant) } diff --git a/src/librustc_mir/hair/cx/expr.rs b/src/librustc_mir/hair/cx/expr.rs index 8d64c9e9ada89..88512fede333c 100644 --- a/src/librustc_mir/hair/cx/expr.rs +++ b/src/librustc_mir/hair/cx/expr.rs @@ -342,7 +342,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>, } hir::ExprKind::Lit(ref lit) => ExprKind::Literal { - literal: cx.tcx.intern_lazy_const(ty::LazyConst::Evaluated( + literal: cx.tcx.mk_lazy_const(ty::LazyConst::Evaluated( cx.const_eval_literal(&lit.node, expr_ty, lit.span, false) )), user_ty: None, @@ -442,7 +442,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>, } else { if let hir::ExprKind::Lit(ref lit) = arg.node { ExprKind::Literal { - literal: cx.tcx.intern_lazy_const(ty::LazyConst::Evaluated( + literal: cx.tcx.mk_lazy_const(ty::LazyConst::Evaluated( cx.const_eval_literal(&lit.node, expr_ty, lit.span, true) )), user_ty: None, @@ -702,7 +702,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>, ty: var_ty, span: expr.span, kind: ExprKind::Literal { - literal: cx.tcx.intern_lazy_const(literal), + literal: cx.tcx.mk_lazy_const(literal), user_ty: None }, }.to_ref(); @@ -856,7 +856,7 @@ fn method_callee<'a, 'gcx, 'tcx>( ty, span, kind: ExprKind::Literal { - literal: cx.tcx().intern_lazy_const(ty::LazyConst::Evaluated( + literal: cx.tcx().mk_lazy_const(ty::LazyConst::Evaluated( ty::Const::zero_sized(ty) )), user_ty, @@ -918,7 +918,7 @@ fn convert_path_expr<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>, let user_ty = user_substs_applied_to_def(cx, expr.hir_id, &def); debug!("convert_path_expr: user_ty={:?}", user_ty); ExprKind::Literal { - literal: cx.tcx.intern_lazy_const(ty::LazyConst::Evaluated(ty::Const::zero_sized( + literal: cx.tcx.mk_lazy_const(ty::LazyConst::Evaluated(ty::Const::zero_sized( cx.tables().node_id_to_type(expr.hir_id), ))), user_ty, @@ -930,7 +930,7 @@ fn convert_path_expr<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>, let user_ty = user_substs_applied_to_def(cx, expr.hir_id, &def); debug!("convert_path_expr: (const) user_ty={:?}", user_ty); ExprKind::Literal { - literal: cx.tcx.intern_lazy_const(ty::LazyConst::Unevaluated(def_id, substs)), + literal: cx.tcx.mk_lazy_const(ty::LazyConst::Unevaluated(def_id, substs)), user_ty, } }, diff --git a/src/librustc_mir/hair/cx/mod.rs b/src/librustc_mir/hair/cx/mod.rs index f514cac6326be..a726b87afa87b 100644 --- a/src/librustc_mir/hair/cx/mod.rs +++ b/src/librustc_mir/hair/cx/mod.rs @@ -110,7 +110,7 @@ impl<'a, 'gcx, 'tcx> Cx<'a, 'gcx, 'tcx> { } pub fn usize_literal(&mut self, value: u64) -> &'tcx ty::LazyConst<'tcx> { - self.tcx.intern_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_usize(self.tcx, value))) + self.tcx.mk_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_usize(self.tcx, value))) } pub fn bool_ty(&mut self) -> Ty<'tcx> { @@ -122,11 +122,11 @@ impl<'a, 'gcx, 'tcx> Cx<'a, 'gcx, 'tcx> { } pub fn true_literal(&mut self) -> &'tcx ty::LazyConst<'tcx> { - self.tcx.intern_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bool(self.tcx, true))) + self.tcx.mk_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bool(self.tcx, true))) } pub fn false_literal(&mut self) -> &'tcx ty::LazyConst<'tcx> { - self.tcx.intern_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bool(self.tcx, false))) + self.tcx.mk_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bool(self.tcx, false))) } pub fn const_eval_literal( diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs index 751815eab287b..15796186063de 100644 --- a/src/librustc_mir/shim.rs +++ b/src/librustc_mir/shim.rs @@ -459,7 +459,7 @@ impl<'a, 'tcx> CloneShimBuilder<'a, 'tcx> { span: self.span, ty: func_ty, user_ty: None, - literal: tcx.intern_lazy_const(ty::LazyConst::Evaluated( + literal: tcx.mk_lazy_const(ty::LazyConst::Evaluated( ty::Const::zero_sized(func_ty), )), }); @@ -521,7 +521,7 @@ impl<'a, 'tcx> CloneShimBuilder<'a, 'tcx> { span: self.span, ty: self.tcx.types.usize, user_ty: None, - literal: self.tcx.intern_lazy_const(ty::LazyConst::Evaluated( + literal: self.tcx.mk_lazy_const(ty::LazyConst::Evaluated( ty::Const::from_usize(self.tcx, value), )), } @@ -759,7 +759,7 @@ fn build_call_shim<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span, ty, user_ty: None, - literal: tcx.intern_lazy_const(ty::LazyConst::Evaluated( + literal: tcx.mk_lazy_const(ty::LazyConst::Evaluated( ty::Const::zero_sized(ty) )), }), diff --git a/src/librustc_mir/transform/elaborate_drops.rs b/src/librustc_mir/transform/elaborate_drops.rs index 06e16de8b43bc..9b75a70ff41d2 100644 --- a/src/librustc_mir/transform/elaborate_drops.rs +++ b/src/librustc_mir/transform/elaborate_drops.rs @@ -533,7 +533,7 @@ impl<'b, 'tcx> ElaborateDropsCtxt<'b, 'tcx> { span, ty: self.tcx.types.bool, user_ty: None, - literal: self.tcx.intern_lazy_const(ty::LazyConst::Evaluated( + literal: self.tcx.mk_lazy_const(ty::LazyConst::Evaluated( ty::Const::from_bool(self.tcx, val), )), }))) diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs index f5cc6a43e28b9..2a1188ed870ba 100644 --- a/src/librustc_mir/transform/generator.rs +++ b/src/librustc_mir/transform/generator.rs @@ -198,7 +198,7 @@ impl<'a, 'tcx> TransformVisitor<'a, 'tcx> { span: source_info.span, ty: self.tcx.types.u32, user_ty: None, - literal: self.tcx.intern_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bits( + literal: self.tcx.mk_lazy_const(ty::LazyConst::Evaluated(ty::Const::from_bits( self.tcx, state_disc.into(), ty::ParamEnv::empty().and(self.tcx.types.u32) @@ -731,7 +731,7 @@ fn insert_panic_block<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, span: mir.span, ty: tcx.types.bool, user_ty: None, - literal: tcx.intern_lazy_const(ty::LazyConst::Evaluated( + literal: tcx.mk_lazy_const(ty::LazyConst::Evaluated( ty::Const::from_bool(tcx, false), )), }), diff --git a/src/librustc_mir/util/elaborate_drops.rs b/src/librustc_mir/util/elaborate_drops.rs index 8b55a4424ae29..eedc42927c126 100644 --- a/src/librustc_mir/util/elaborate_drops.rs +++ b/src/librustc_mir/util/elaborate_drops.rs @@ -963,7 +963,7 @@ impl<'l, 'b, 'tcx, D> DropCtxt<'l, 'b, 'tcx, D> span: self.source_info.span, ty: self.tcx().types.usize, user_ty: None, - literal: self.tcx().intern_lazy_const(ty::LazyConst::Evaluated( + literal: self.tcx().mk_lazy_const(ty::LazyConst::Evaluated( ty::Const::from_usize(self.tcx(), val.into()) )), }) diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 8da0b6dcbeac3..757385aeb3edc 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -1793,7 +1793,7 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx> + 'o { let length_def_id = tcx.hir().local_def_id(length.id); let substs = Substs::identity_for_item(tcx, length_def_id); let length = ty::LazyConst::Unevaluated(length_def_id, substs); - let length = tcx.intern_lazy_const(length); + let length = tcx.mk_lazy_const(length); let array_ty = tcx.mk_ty(ty::Array(self.ast_ty_to_ty(&ty), length)); self.normalize_ty(ast_ty.span, array_ty) } diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 3e2a9d720f1c1..fb8f608812197 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -4597,7 +4597,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { if element_ty.references_error() { tcx.types.err } else if let Ok(count) = count { - tcx.mk_ty(ty::Array(t, tcx.intern_lazy_const(ty::LazyConst::Evaluated(count)))) + tcx.mk_ty(ty::Array(t, tcx.mk_lazy_const(ty::LazyConst::Evaluated(count)))) } else { tcx.types.err } From f7ed6e18160bc8fccf27a73c05f3935c9e8f672e Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Wed, 6 Feb 2019 18:02:32 +1100 Subject: [PATCH 102/278] Make an assert debug-only in `find_constraint_paths_between_regions`. This reduces instruction counts for NLL builds of `wg-grammar` by over 20%. --- .../borrow_check/nll/region_infer/error_reporting/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs index ec68ddaf3c852..550668a7ceece 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs @@ -205,7 +205,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { for constraint in self.constraint_graph .outgoing_edges(r, &self.constraints, fr_static) { - assert_eq!(constraint.sup, r); + debug_assert_eq!(constraint.sup, r); let sub_region = constraint.sub; if let Trace::NotVisited = context[sub_region] { context[sub_region] = Trace::FromOutlivesConstraint(constraint); From f3eede6870c817e2e22782ad08d31fcaa8c6b640 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Wed, 6 Feb 2019 11:14:12 +0100 Subject: [PATCH 103/278] fix doctests --- src/libcore/mem.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index 18302e36ff762..930fe737a7264 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -1045,7 +1045,7 @@ impl DerefMut for ManuallyDrop { /// ```rust,no_run /// use std::mem; /// -/// let x: &i32 = mem::zeroed(); // undefined behavior! +/// let x: &i32 = unsafe { mem::zeroed() }; // undefined behavior! /// ``` /// This is exploited by the compiler for various optimizations, such as eliding /// run-time checks and optimizing `enum` layout. @@ -1058,6 +1058,7 @@ impl DerefMut for ManuallyDrop { /// it is a signal to the compiler indicating that the data here might *not* /// be initialized: /// ```rust +/// #![feature(maybe_uninit)] /// use std::mem::MaybeUninit; /// /// // Create an explicitly uninitialized reference. From 57c92696a9727a51831bef53cebc13108a379900 Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Wed, 6 Feb 2019 11:13:06 +0100 Subject: [PATCH 104/278] Add embedded book to test such that checktools works --- src/bootstrap/test.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs index 1a46ebfcabb95..bb00f6f625130 100644 --- a/src/bootstrap/test.rs +++ b/src/bootstrap/test.rs @@ -1383,6 +1383,7 @@ test_book!( RustdocBook, "src/doc/rustdoc", "rustdoc", default=true; RustcBook, "src/doc/rustc", "rustc", default=true; RustByExample, "src/doc/rust-by-example", "rust-by-example", default=false; + EmbeddedBook, "src/doc/embedded-book", "embedded-book", default=false; TheBook, "src/doc/book", "book", default=false; UnstableBook, "src/doc/unstable-book", "unstable-book", default=true; ); From 20022f8b912f26cea45ae2dc1ed15e14d5f6b996 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Wed, 6 Feb 2019 22:28:47 +0900 Subject: [PATCH 105/278] librustc_tsan => 2018 --- src/librustc_tsan/Cargo.toml | 1 + src/librustc_tsan/build.rs | 3 --- src/librustc_tsan/lib.rs | 3 ++- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/librustc_tsan/Cargo.toml b/src/librustc_tsan/Cargo.toml index f0618275f2f6a..d805833a7efc1 100644 --- a/src/librustc_tsan/Cargo.toml +++ b/src/librustc_tsan/Cargo.toml @@ -3,6 +3,7 @@ authors = ["The Rust Project Developers"] build = "build.rs" name = "rustc_tsan" version = "0.0.0" +edition = "2018" [lib] name = "rustc_tsan" diff --git a/src/librustc_tsan/build.rs b/src/librustc_tsan/build.rs index 0db3db392dddc..ed9c37087c7e5 100644 --- a/src/librustc_tsan/build.rs +++ b/src/librustc_tsan/build.rs @@ -1,6 +1,3 @@ -extern crate build_helper; -extern crate cmake; - use std::env; use build_helper::sanitizer_lib_boilerplate; diff --git a/src/librustc_tsan/lib.rs b/src/librustc_tsan/lib.rs index d6c8e54c18db7..568bb540c4719 100644 --- a/src/librustc_tsan/lib.rs +++ b/src/librustc_tsan/lib.rs @@ -1,8 +1,9 @@ #![sanitizer_runtime] -#![feature(nll)] #![feature(sanitizer_runtime)] #![feature(staged_api)] #![no_std] #![unstable(feature = "sanitizer_runtime_lib", reason = "internal implementation detail of sanitizers", issue = "0")] + +#![deny(rust_2018_idioms)] From fb0f0bfea6a9123ebfd057e10b87fad013ffd6ed Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Wed, 6 Feb 2019 22:36:25 +0900 Subject: [PATCH 106/278] librustc_msan => 2018 --- src/librustc_msan/Cargo.toml | 1 + src/librustc_msan/build.rs | 3 --- src/librustc_msan/lib.rs | 3 ++- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/librustc_msan/Cargo.toml b/src/librustc_msan/Cargo.toml index 78c39d03e45a9..7d88aa59b3adb 100644 --- a/src/librustc_msan/Cargo.toml +++ b/src/librustc_msan/Cargo.toml @@ -3,6 +3,7 @@ authors = ["The Rust Project Developers"] build = "build.rs" name = "rustc_msan" version = "0.0.0" +edition = "2018" [lib] name = "rustc_msan" diff --git a/src/librustc_msan/build.rs b/src/librustc_msan/build.rs index 085514b5a0108..1c66b0a9cd3cf 100644 --- a/src/librustc_msan/build.rs +++ b/src/librustc_msan/build.rs @@ -1,6 +1,3 @@ -extern crate build_helper; -extern crate cmake; - use std::env; use build_helper::sanitizer_lib_boilerplate; diff --git a/src/librustc_msan/lib.rs b/src/librustc_msan/lib.rs index d6c8e54c18db7..568bb540c4719 100644 --- a/src/librustc_msan/lib.rs +++ b/src/librustc_msan/lib.rs @@ -1,8 +1,9 @@ #![sanitizer_runtime] -#![feature(nll)] #![feature(sanitizer_runtime)] #![feature(staged_api)] #![no_std] #![unstable(feature = "sanitizer_runtime_lib", reason = "internal implementation detail of sanitizers", issue = "0")] + +#![deny(rust_2018_idioms)] From 30fab05bed13c497182e0cf3cf18ea2ea12af997 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Wed, 6 Feb 2019 22:40:09 +0900 Subject: [PATCH 107/278] librustc_asan => 2018 --- src/librustc_asan/Cargo.toml | 1 + src/librustc_asan/build.rs | 3 --- src/librustc_asan/lib.rs | 3 ++- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/librustc_asan/Cargo.toml b/src/librustc_asan/Cargo.toml index 836caf22abfa5..7d9641c83ee7d 100644 --- a/src/librustc_asan/Cargo.toml +++ b/src/librustc_asan/Cargo.toml @@ -3,6 +3,7 @@ authors = ["The Rust Project Developers"] build = "build.rs" name = "rustc_asan" version = "0.0.0" +edition = "2018" [lib] name = "rustc_asan" diff --git a/src/librustc_asan/build.rs b/src/librustc_asan/build.rs index b42d775deb393..a2b4b090efb4f 100644 --- a/src/librustc_asan/build.rs +++ b/src/librustc_asan/build.rs @@ -1,6 +1,3 @@ -extern crate build_helper; -extern crate cmake; - use std::env; use build_helper::sanitizer_lib_boilerplate; diff --git a/src/librustc_asan/lib.rs b/src/librustc_asan/lib.rs index d6c8e54c18db7..568bb540c4719 100644 --- a/src/librustc_asan/lib.rs +++ b/src/librustc_asan/lib.rs @@ -1,8 +1,9 @@ #![sanitizer_runtime] -#![feature(nll)] #![feature(sanitizer_runtime)] #![feature(staged_api)] #![no_std] #![unstable(feature = "sanitizer_runtime_lib", reason = "internal implementation detail of sanitizers", issue = "0")] + +#![deny(rust_2018_idioms)] From 3893b2f04e90366a9ebad4d90b05ac51600992c7 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Wed, 6 Feb 2019 22:46:01 +0900 Subject: [PATCH 108/278] libprofiler_builtins => 2018 --- src/libprofiler_builtins/Cargo.toml | 1 + src/libprofiler_builtins/build.rs | 2 -- src/libprofiler_builtins/lib.rs | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/src/libprofiler_builtins/Cargo.toml b/src/libprofiler_builtins/Cargo.toml index 7c95cf0a0542a..0d36bd0b39d76 100644 --- a/src/libprofiler_builtins/Cargo.toml +++ b/src/libprofiler_builtins/Cargo.toml @@ -3,6 +3,7 @@ authors = ["The Rust Project Developers"] build = "build.rs" name = "profiler_builtins" version = "0.0.0" +edition = "2018" [lib] name = "profiler_builtins" diff --git a/src/libprofiler_builtins/build.rs b/src/libprofiler_builtins/build.rs index b66cd66448748..ff52a03d9dd97 100644 --- a/src/libprofiler_builtins/build.rs +++ b/src/libprofiler_builtins/build.rs @@ -2,8 +2,6 @@ //! //! See the build.rs for libcompiler_builtins crate for details. -extern crate cc; - use std::env; use std::path::Path; diff --git a/src/libprofiler_builtins/lib.rs b/src/libprofiler_builtins/lib.rs index 0d12ba01c87a2..9c8d3a13b0812 100644 --- a/src/libprofiler_builtins/lib.rs +++ b/src/libprofiler_builtins/lib.rs @@ -5,5 +5,5 @@ reason = "internal implementation detail of rustc right now", issue = "0")] #![allow(unused_features)] -#![feature(nll)] #![feature(staged_api)] +#![deny(rust_2018_idioms)] From 44b2cc0941e63cb8b12fd3a361d8eb8564504a73 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Wed, 6 Feb 2019 22:55:03 +0900 Subject: [PATCH 109/278] librustc_allocator => 2018 --- src/librustc_allocator/Cargo.toml | 1 + src/librustc_allocator/expand.rs | 10 +++++----- src/librustc_allocator/lib.rs | 11 +---------- 3 files changed, 7 insertions(+), 15 deletions(-) diff --git a/src/librustc_allocator/Cargo.toml b/src/librustc_allocator/Cargo.toml index 03d33f413c807..cf6c598bfb17b 100644 --- a/src/librustc_allocator/Cargo.toml +++ b/src/librustc_allocator/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_allocator" version = "0.0.0" +edition = "2018" [lib] path = "lib.rs" diff --git a/src/librustc_allocator/expand.rs b/src/librustc_allocator/expand.rs index 1fb1794d5147d..d302e7646d168 100644 --- a/src/librustc_allocator/expand.rs +++ b/src/librustc_allocator/expand.rs @@ -1,6 +1,6 @@ +use log::debug; use rustc::middle::allocator::AllocatorKind; -use rustc_errors; -use smallvec::SmallVec; +use smallvec::{smallvec, SmallVec}; use syntax::{ ast::{ self, Arg, Attribute, Crate, Expr, FnHeader, Generics, Ident, Item, ItemKind, @@ -23,7 +23,7 @@ use syntax::{ }; use syntax_pos::Span; -use {AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS}; +use crate::{AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS}; pub fn modify( sess: &ParseSess, @@ -54,7 +54,7 @@ struct ExpandAllocatorDirectives<'a> { in_submod: isize, } -impl<'a> MutVisitor for ExpandAllocatorDirectives<'a> { +impl MutVisitor for ExpandAllocatorDirectives<'_> { fn flat_map_item(&mut self, item: P) -> SmallVec<[P; 1]> { debug!("in submodule {}", self.in_submod); @@ -168,7 +168,7 @@ struct AllocFnFactory<'a> { cx: ExtCtxt<'a>, } -impl<'a> AllocFnFactory<'a> { +impl AllocFnFactory<'_> { fn allocator_fn(&self, method: &AllocatorMethod) -> P { let mut abi_args = Vec::new(); let mut i = 0; diff --git a/src/librustc_allocator/lib.rs b/src/librustc_allocator/lib.rs index 41c0be615956e..16b9ccfda8010 100644 --- a/src/librustc_allocator/lib.rs +++ b/src/librustc_allocator/lib.rs @@ -1,15 +1,6 @@ -#![feature(nll)] #![feature(rustc_private)] -#[macro_use] extern crate log; -extern crate rustc; -extern crate rustc_data_structures; -extern crate rustc_errors; -extern crate rustc_target; -extern crate syntax; -extern crate syntax_pos; -#[macro_use] -extern crate smallvec; +#![deny(rust_2018_idioms)] pub mod expand; From ea46f5b2d06bd4f106d67245cf2260ca33526f2b Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Wed, 6 Feb 2019 23:12:47 +0900 Subject: [PATCH 110/278] librustc_lsan => 2018 --- src/librustc_lsan/Cargo.toml | 1 + src/librustc_lsan/build.rs | 3 --- src/librustc_lsan/lib.rs | 3 ++- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/librustc_lsan/Cargo.toml b/src/librustc_lsan/Cargo.toml index a8e11df7670cf..9ad53ee6d0958 100644 --- a/src/librustc_lsan/Cargo.toml +++ b/src/librustc_lsan/Cargo.toml @@ -3,6 +3,7 @@ authors = ["The Rust Project Developers"] build = "build.rs" name = "rustc_lsan" version = "0.0.0" +edition = "2018" [lib] name = "rustc_lsan" diff --git a/src/librustc_lsan/build.rs b/src/librustc_lsan/build.rs index ad528bb03902c..b8c7b7c2d5537 100644 --- a/src/librustc_lsan/build.rs +++ b/src/librustc_lsan/build.rs @@ -1,6 +1,3 @@ -extern crate build_helper; -extern crate cmake; - use std::env; use build_helper::sanitizer_lib_boilerplate; diff --git a/src/librustc_lsan/lib.rs b/src/librustc_lsan/lib.rs index d6c8e54c18db7..568bb540c4719 100644 --- a/src/librustc_lsan/lib.rs +++ b/src/librustc_lsan/lib.rs @@ -1,8 +1,9 @@ #![sanitizer_runtime] -#![feature(nll)] #![feature(sanitizer_runtime)] #![feature(staged_api)] #![no_std] #![unstable(feature = "sanitizer_runtime_lib", reason = "internal implementation detail of sanitizers", issue = "0")] + +#![deny(rust_2018_idioms)] From 4f20348fd338609bc8101b39781fed7646b734cb Mon Sep 17 00:00:00 2001 From: Pietro Albini Date: Wed, 6 Feb 2019 15:16:50 +0100 Subject: [PATCH 111/278] Revert "Rollup merge of #58162 - pietroalbini:track-259, r=alexcrichton" This reverts commit 4c243e2c3d8f02cdcd22fe68acf6a0b3edca2078, reversing changes made to 64f0032a3739b18ae45387744340d9c7ce48b145. --- appveyor.yml | 5 +---- src/ci/run.sh | 8 +------- 2 files changed, 2 insertions(+), 11 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index 0ec4210af98b2..d70ad54b1c812 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -207,10 +207,7 @@ test_script: - sh src/ci/init_repo.sh . /c/cache/rustsrc - set SRC=. - set NO_CCACHE=1 - # Added this debugging code to try tracking down https://github.com/rust-lang/rust/issues/58160 - # Replace it with the commented line below after the issue with AppVeyor is fixed - - "sh src/ci/run.sh & set ret=%errorlevel% & echo exit code in appveyor.yml: %ret% & exit %ret%" -# - sh src/ci/run.sh + - sh src/ci/run.sh on_failure: # Dump crash log diff --git a/src/ci/run.sh b/src/ci/run.sh index 0841e70a6ed29..0f2517c7d1f55 100755 --- a/src/ci/run.sh +++ b/src/ci/run.sh @@ -127,13 +127,7 @@ if [ ! -z "$SCRIPT" ]; then set +e sh -x -c "$SCRIPT" ret=$? - echo "exit code in src/ci/run.sh: $ret" - - echo "tasklist:" - tasklist - echo -n "location of sh: " - where sh - + echo "script exited with $ret" exit $ret else do_make() { From 99599245a3cbf056ea090e34e2a3741ef8e0ae88 Mon Sep 17 00:00:00 2001 From: Pietro Albini Date: Wed, 6 Feb 2019 15:17:15 +0100 Subject: [PATCH 112/278] Revert "Auto merge of #57975 - alexcrichton:debug-exit-appveyor, r=pietroalbini" This reverts commit d3d0bf0e9f4d748b95ed143cc636d159bfcb4a6f, reversing changes made to 40e6a0bd766ca7b1c582b964131400b8c3e89d76. --- src/ci/run.sh | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/ci/run.sh b/src/ci/run.sh index 0f2517c7d1f55..42d0d7db5964c 100755 --- a/src/ci/run.sh +++ b/src/ci/run.sh @@ -121,14 +121,7 @@ fi travis_fold end log-system-info if [ ! -z "$SCRIPT" ]; then - # This `set +e` followed by capturing the return value is a temporary measure - # to help debug "error with exit 259" on AppVeyor temporarily, otherwise all - # that's needed here is the `sh` - set +e sh -x -c "$SCRIPT" - ret=$? - echo "script exited with $ret" - exit $ret else do_make() { travis_fold start "make-$1" From d4a60e01d158d508b50427167c399ef2a964bddd Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Wed, 6 Feb 2019 23:18:33 +0900 Subject: [PATCH 113/278] librustc_fs_util => 2018 --- src/librustc_fs_util/Cargo.toml | 1 + src/librustc_fs_util/lib.rs | 2 ++ 2 files changed, 3 insertions(+) diff --git a/src/librustc_fs_util/Cargo.toml b/src/librustc_fs_util/Cargo.toml index e40b44204b349..47918643f31fe 100644 --- a/src/librustc_fs_util/Cargo.toml +++ b/src/librustc_fs_util/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_fs_util" version = "0.0.0" +edition = "2018" [lib] name = "rustc_fs_util" diff --git a/src/librustc_fs_util/lib.rs b/src/librustc_fs_util/lib.rs index 74ff121f80385..340681d65c383 100644 --- a/src/librustc_fs_util/lib.rs +++ b/src/librustc_fs_util/lib.rs @@ -1,3 +1,5 @@ +#![deny(rust_2018_idioms)] + use std::path::{Path, PathBuf}; use std::ffi::CString; use std::fs; From 4deb5959a3a2cbc189e26cb4b0c59a6707a10b45 Mon Sep 17 00:00:00 2001 From: Andy Russell Date: Tue, 5 Feb 2019 10:12:43 -0500 Subject: [PATCH 114/278] display sugared return types for async functions --- src/librustdoc/clean/mod.rs | 39 +++++++++++++++++++++++++++++++++++ src/librustdoc/html/format.rs | 23 ++++++++++++++------- src/librustdoc/html/render.rs | 8 ++++--- src/test/rustdoc/async-fn.rs | 35 ++++++++++++++++++++++++------- 4 files changed, 88 insertions(+), 17 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 6eea95b61c990..9ef723db40833 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1707,6 +1707,30 @@ impl FnDecl { pub fn self_type(&self) -> Option { self.inputs.values.get(0).and_then(|v| v.to_self()) } + + /// Returns the sugared return type for an async function. + /// + /// For example, if the return type is `impl std::future::Future`, this function + /// will return `i32`. + /// + /// # Panics + /// + /// This function will panic if the return type does not match the expected sugaring for async + /// functions. + pub fn sugared_async_return_type(&self) -> FunctionRetTy { + match &self.output { + FunctionRetTy::Return(Type::ImplTrait(bounds)) => { + match &bounds[0] { + GenericBound::TraitBound(PolyTrait { trait_, .. }, ..) => { + let bindings = trait_.bindings().unwrap(); + FunctionRetTy::Return(bindings[0].ty.clone()) + } + _ => panic!("unexpected desugaring of async function"), + } + } + _ => panic!("unexpected desugaring of async function"), + } + } } #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)] @@ -2265,6 +2289,21 @@ impl Type { _ => None, } } + + pub fn bindings(&self) -> Option<&[TypeBinding]> { + match *self { + ResolvedPath { ref path, .. } => { + path.segments.last().and_then(|seg| { + if let GenericArgs::AngleBracketed { ref bindings, .. } = seg.args { + Some(&**bindings) + } else { + None + } + }) + } + _ => None + } + } } impl GetDefId for Type { diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 5a3e6984859a2..c03e679bc5194 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -5,6 +5,7 @@ //! assume that HTML output is desired, although it may be possible to redesign //! them in the future to instead emit any format desired. +use std::borrow::Cow; use std::fmt; use rustc::hir::def_id::DefId; @@ -44,14 +45,16 @@ pub struct GenericBounds<'a>(pub &'a [clean::GenericBound]); pub struct CommaSep<'a, T: 'a>(pub &'a [T]); pub struct AbiSpace(pub Abi); -/// Wrapper struct for properly emitting a method declaration. -pub struct Method<'a> { +/// Wrapper struct for properly emitting a function or method declaration. +pub struct Function<'a> { /// The declaration to emit. pub decl: &'a clean::FnDecl, /// The length of the function's "name", used to determine line-wrapping. pub name_len: usize, /// The number of spaces to indent each successive line with, if line-wrapping is necessary. pub indent: usize, + /// Whether the function is async or not. + pub asyncness: hir::IsAsync, } /// Wrapper struct for emitting a where clause from Generics. @@ -829,9 +832,9 @@ impl fmt::Display for clean::FnDecl { } } -impl<'a> fmt::Display for Method<'a> { +impl<'a> fmt::Display for Function<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let &Method { decl, name_len, indent } = self; + let &Function { decl, name_len, indent, asyncness } = self; let amp = if f.alternate() { "&" } else { "&" }; let mut args = String::new(); let mut args_plain = String::new(); @@ -891,11 +894,17 @@ impl<'a> fmt::Display for Method<'a> { args_plain.push_str(", ..."); } - let arrow_plain = format!("{:#}", decl.output); + let output = if let hir::IsAsync::Async = asyncness { + Cow::Owned(decl.sugared_async_return_type()) + } else { + Cow::Borrowed(&decl.output) + }; + + let arrow_plain = format!("{:#}", &output); let arrow = if f.alternate() { - format!("{:#}", decl.output) + format!("{:#}", &output) } else { - decl.output.to_string() + output.to_string() }; let pad = " ".repeat(name_len); diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 86fb51419c270..c8bda66d84170 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -62,7 +62,7 @@ use fold::DocFolder; use html::escape::Escape; use html::format::{AsyncSpace, ConstnessSpace}; use html::format::{GenericBounds, WhereClause, href, AbiSpace}; -use html::format::{VisSpace, Method, UnsafetySpace, MutableSpace}; +use html::format::{VisSpace, Function, UnsafetySpace, MutableSpace}; use html::format::fmt_impl_for_trait_page; use html::item_type::ItemType; use html::markdown::{self, Markdown, MarkdownHtml, MarkdownSummaryLine, ErrorCodes, IdMap}; @@ -2963,10 +2963,11 @@ fn item_function(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, name = it.name.as_ref().unwrap(), generics = f.generics, where_clause = WhereClause { gens: &f.generics, indent: 0, end_newline: true }, - decl = Method { + decl = Function { decl: &f.decl, name_len, indent: 0, + asyncness: f.header.asyncness, })?; document(w, cx, it) } @@ -3410,10 +3411,11 @@ fn render_assoc_item(w: &mut fmt::Formatter, href = href, name = name, generics = *g, - decl = Method { + decl = Function { decl: d, name_len: head_len, indent, + asyncness: header.asyncness, }, where_clause = WhereClause { gens: g, diff --git a/src/test/rustdoc/async-fn.rs b/src/test/rustdoc/async-fn.rs index a0b6c29126092..ba4997a7f9b5b 100644 --- a/src/test/rustdoc/async-fn.rs +++ b/src/test/rustdoc/async-fn.rs @@ -1,14 +1,35 @@ // edition:2018 -// compile-flags:-Z unstable-options - -// FIXME: once `--edition` is stable in rustdoc, remove that `compile-flags` directive #![feature(async_await, futures_api)] -// @has async_fn/struct.S.html -// @has - '//code' 'pub async fn f()' -pub struct S; +// @has async_fn/fn.foo.html '//pre[@class="rust fn"]' 'pub async fn foo() -> Option' +pub async fn foo() -> Option { + None +} + +// @has async_fn/fn.bar.html '//pre[@class="rust fn"]' 'pub async fn bar(a: i32, b: i32) -> i32' +pub async fn bar(a: i32, b: i32) -> i32 { + 0 +} + +// @has async_fn/fn.baz.html '//pre[@class="rust fn"]' 'pub async fn baz(a: T) -> T' +pub async fn baz(a: T) -> T { + a +} + +trait Bar {} + +impl Bar for () {} + +// @has async_fn/fn.quux.html '//pre[@class="rust fn"]' 'pub async fn quux() -> impl Bar' +pub async fn quux() -> impl Bar { + () +} + +// @has async_fn/struct.Foo.html +// @matches - '//code' 'pub async fn f\(\)$' +pub struct Foo; -impl S { +impl Foo { pub async fn f() {} } From 9f4a11c63732c2bdc623b4e66ee9bcc3f0159e95 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Wed, 6 Feb 2019 23:56:39 +0900 Subject: [PATCH 115/278] librustc_plugin => 2018 --- src/librustc_plugin/Cargo.toml | 1 + src/librustc_plugin/diagnostics.rs | 2 ++ src/librustc_plugin/lib.rs | 10 ++-------- src/librustc_plugin/load.rs | 5 +++-- 4 files changed, 8 insertions(+), 10 deletions(-) diff --git a/src/librustc_plugin/Cargo.toml b/src/librustc_plugin/Cargo.toml index d8fa1da1ce219..5e23aa0d7f74e 100644 --- a/src/librustc_plugin/Cargo.toml +++ b/src/librustc_plugin/Cargo.toml @@ -3,6 +3,7 @@ authors = ["The Rust Project Developers"] name = "rustc_plugin" version = "0.0.0" build = false +edition = "2018" [lib] name = "rustc_plugin" diff --git a/src/librustc_plugin/diagnostics.rs b/src/librustc_plugin/diagnostics.rs index 382a1edb43c4a..68462bd83ef60 100644 --- a/src/librustc_plugin/diagnostics.rs +++ b/src/librustc_plugin/diagnostics.rs @@ -1,5 +1,7 @@ #![allow(non_snake_case)] +use syntax::{register_diagnostic, register_diagnostics, register_long_diagnostics}; + register_long_diagnostics! { } diff --git a/src/librustc_plugin/lib.rs b/src/librustc_plugin/lib.rs index 7bdeae3e97854..9a31bddc1eded 100644 --- a/src/librustc_plugin/lib.rs +++ b/src/librustc_plugin/lib.rs @@ -54,19 +54,13 @@ html_favicon_url = "https://doc.rust-lang.org/favicon.ico", html_root_url = "https://doc.rust-lang.org/nightly/")] -#![feature(nll)] #![feature(rustc_diagnostic_macros)] #![recursion_limit="256"] -#[macro_use] extern crate syntax; +#![deny(rust_2018_idioms)] -extern crate rustc; -extern crate rustc_metadata; -extern crate syntax_pos; -extern crate rustc_errors as errors; - -pub use self::registry::Registry; +pub use registry::Registry; mod diagnostics; pub mod registry; diff --git a/src/librustc_plugin/load.rs b/src/librustc_plugin/load.rs index 39f580420cf03..1b88cf05f40d5 100644 --- a/src/librustc_plugin/load.rs +++ b/src/librustc_plugin/load.rs @@ -3,18 +3,19 @@ use rustc::session::Session; use rustc_metadata::creader::CrateLoader; use rustc_metadata::cstore::CStore; -use registry::Registry; +use crate::registry::Registry; use std::borrow::ToOwned; use std::env; use std::mem; use std::path::PathBuf; use syntax::ast; +use syntax::span_err; use syntax_pos::{Span, DUMMY_SP}; /// Pointer to a registrar function. pub type PluginRegistrarFun = - fn(&mut Registry); + fn(&mut Registry<'_>); pub struct PluginRegistrar { pub fun: PluginRegistrarFun, From ba0fbd763d8d6b88457c0c06f1a3f583b69fcd19 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Thu, 7 Feb 2019 01:02:00 +0900 Subject: [PATCH 116/278] librustc_save_analysis => 2018 --- src/librustc_save_analysis/Cargo.toml | 1 + src/librustc_save_analysis/dump_visitor.rs | 73 ++++++++++++---------- src/librustc_save_analysis/json_dumper.rs | 4 +- src/librustc_save_analysis/lib.rs | 30 +++------ src/librustc_save_analysis/sig.rs | 51 ++++++++------- src/librustc_save_analysis/span_utils.rs | 2 +- 6 files changed, 79 insertions(+), 82 deletions(-) diff --git a/src/librustc_save_analysis/Cargo.toml b/src/librustc_save_analysis/Cargo.toml index e47f89c64ff07..8bb2e722b5794 100644 --- a/src/librustc_save_analysis/Cargo.toml +++ b/src/librustc_save_analysis/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_save_analysis" version = "0.0.0" +edition = "2018" [lib] name = "rustc_save_analysis" diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs index 995df3802aabd..4d8bc0ad5ddf0 100644 --- a/src/librustc_save_analysis/dump_visitor.rs +++ b/src/librustc_save_analysis/dump_visitor.rs @@ -16,6 +16,7 @@ use rustc::hir::def::Def as HirDef; use rustc::hir::def_id::DefId; use rustc::session::config::Input; +use rustc::span_bug; use rustc::ty::{self, TyCtxt}; use rustc_data_structures::fx::FxHashSet; @@ -32,16 +33,20 @@ use syntax::print::pprust::{ }; use syntax::ptr::P; use syntax::source_map::{Spanned, DUMMY_SP, respan}; +use syntax::walk_list; use syntax_pos::*; -use {escape, generated_code, lower_attributes, PathCollector, SaveContext}; -use json_dumper::{Access, DumpOutput, JsonDumper}; -use span_utils::SpanUtils; -use sig; +use crate::{escape, generated_code, id_from_def_id, id_from_node_id, lower_attributes, + PathCollector, SaveContext}; +use crate::json_dumper::{Access, DumpOutput, JsonDumper}; +use crate::span_utils::SpanUtils; +use crate::sig; use rls_data::{CompilationOptions, CratePreludeData, Def, DefKind, GlobalCrateId, Import, ImportKind, Ref, RefKind, Relation, RelationKind, SpanData}; +use log::{debug, error}; + macro_rules! down_cast_data { ($id:ident, $kind:ident, $sp:expr) => { let $id = if let super::Data::$kind(data) = $id { @@ -68,7 +73,7 @@ macro_rules! access_from { }; } -pub struct DumpVisitor<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> { +pub struct DumpVisitor<'l, 'tcx: 'l, 'll, O: DumpOutput> { save_ctxt: SaveContext<'l, 'tcx>, tcx: TyCtxt<'l, 'tcx, 'tcx>, dumper: &'ll mut JsonDumper, @@ -245,7 +250,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { None => continue, }; if !self.span.filter_generated(ident.span) { - let id = ::id_from_node_id(id, &self.save_ctxt); + let id = id_from_node_id(id, &self.save_ctxt); let span = self.span_from_span(ident.span); self.dumper.dump_def( @@ -286,7 +291,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { debug!("process_method: {}:{}", id, ident); if let Some(mut method_data) = self.save_ctxt.get_method_data(id, ident, span) { - let sig_str = ::make_signature(&sig.decl, &generics); + let sig_str = crate::make_signature(&sig.decl, &generics); if body.is_some() { self.nest_tables( id, @@ -339,7 +344,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { // Append $id to name to make sure each one is unique. let qualname = format!("{}::{}${}", prefix, name, id); if !self.span.filter_generated(param_ss) { - let id = ::id_from_node_id(param.id, &self.save_ctxt); + let id = id_from_node_id(param.id, &self.save_ctxt); let span = self.span_from_span(param_ss); self.dumper.dump_def( @@ -433,12 +438,12 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { &access_from!(self.save_ctxt, vis, id), Def { kind: DefKind::Const, - id: ::id_from_node_id(id, &self.save_ctxt), + id: id_from_node_id(id, &self.save_ctxt), span, name: ident.name.to_string(), qualname, value: ty_to_string(&typ), - parent: Some(::id_from_def_id(parent_id)), + parent: Some(id_from_def_id(parent_id)), children: vec![], decl_id: None, docs: self.save_ctxt.docs_for_attrs(attrs), @@ -495,7 +500,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { value, fields .iter() - .map(|f| ::id_from_node_id(f.id, &self.save_ctxt)) + .map(|f| id_from_node_id(f.id, &self.save_ctxt)) .collect(), ) } @@ -508,7 +513,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { &access_from!(self.save_ctxt, item), Def { kind, - id: ::id_from_node_id(item.id, &self.save_ctxt), + id: id_from_node_id(item.id, &self.save_ctxt), span, name, qualname: qualname.clone(), @@ -564,8 +569,8 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { let value = format!("{}::{} {{ {} }}", enum_data.name, name, fields_str); if !self.span.filter_generated(name_span) { let span = self.span_from_span(name_span); - let id = ::id_from_node_id(variant.node.data.id(), &self.save_ctxt); - let parent = Some(::id_from_node_id(item.id, &self.save_ctxt)); + let id = id_from_node_id(variant.node.data.id(), &self.save_ctxt); + let parent = Some(id_from_node_id(item.id, &self.save_ctxt)); self.dumper.dump_def( &access, @@ -602,8 +607,8 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { } if !self.span.filter_generated(name_span) { let span = self.span_from_span(name_span); - let id = ::id_from_node_id(variant.node.data.id(), &self.save_ctxt); - let parent = Some(::id_from_node_id(item.id, &self.save_ctxt)); + let id = id_from_node_id(variant.node.data.id(), &self.save_ctxt); + let parent = Some(id_from_node_id(item.id, &self.save_ctxt)); self.dumper.dump_def( &access, @@ -686,11 +691,11 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { val.push_str(&bounds_to_string(trait_refs)); } if !self.span.filter_generated(item.ident.span) { - let id = ::id_from_node_id(item.id, &self.save_ctxt); + let id = id_from_node_id(item.id, &self.save_ctxt); let span = self.span_from_span(item.ident.span); let children = methods .iter() - .map(|i| ::id_from_node_id(i.id, &self.save_ctxt)) + .map(|i| id_from_node_id(i.id, &self.save_ctxt)) .collect(); self.dumper.dump_def( &access_from!(self.save_ctxt, item), @@ -726,14 +731,14 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { self.dumper.dump_ref(Ref { kind: RefKind::Type, span: span.clone(), - ref_id: ::id_from_def_id(id), + ref_id: id_from_def_id(id), }); self.dumper.dump_relation(Relation { kind: RelationKind::SuperTrait, span, - from: ::id_from_def_id(id), - to: ::id_from_node_id(item.id, &self.save_ctxt), + from: id_from_def_id(id), + to: id_from_node_id(item.id, &self.save_ctxt), }); } } @@ -873,7 +878,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { self.dumper.dump_ref(Ref { kind: RefKind::Variable, span, - ref_id: ::id_from_def_id(variant.fields[index].did), + ref_id: id_from_def_id(variant.fields[index].did), }); } } @@ -912,7 +917,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { if !self.span.filter_generated(ident.span) { let qualname = format!("{}${}", ident.to_string(), id); - let id = ::id_from_node_id(id, &self.save_ctxt); + let id = id_from_node_id(id, &self.save_ctxt); let span = self.span_from_span(ident.span); self.dumper.dump_def( @@ -988,7 +993,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { // Rust uses the id of the pattern for var lookups, so we'll use it too. if !self.span.filter_generated(ident.span) { let qualname = format!("{}${}", ident.to_string(), id); - let id = ::id_from_node_id(id, &self.save_ctxt); + let id = id_from_node_id(id, &self.save_ctxt); let span = self.span_from_span(ident.span); self.dumper.dump_def( @@ -1091,7 +1096,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { if !self.span.filter_generated(trait_item.ident.span) { let span = self.span_from_span(trait_item.ident.span); - let id = ::id_from_node_id(trait_item.id, &self.save_ctxt); + let id = id_from_node_id(trait_item.id, &self.save_ctxt); self.dumper.dump_def( &Access { @@ -1105,7 +1110,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { name, qualname, value: self.span.snippet(trait_item.span), - parent: Some(::id_from_def_id(trait_id)), + parent: Some(id_from_def_id(trait_id)), children: vec![], decl_id: None, docs: self.save_ctxt.docs_for_attrs(&trait_item.attrs), @@ -1196,7 +1201,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { // The parent def id of a given use tree is always the enclosing item. let parent = self.save_ctxt.tcx.hir().opt_local_def_id(id) .and_then(|id| self.save_ctxt.tcx.parent_def_id(id)) - .map(::id_from_def_id); + .map(id_from_def_id); match use_tree.kind { ast::UseTreeKind::Simple(alias, ..) => { @@ -1212,7 +1217,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { let sub_span = path.segments.last().unwrap().ident.span; if !self.span.filter_generated(sub_span) { - let ref_id = self.lookup_def_id(id).map(|id| ::id_from_def_id(id)); + let ref_id = self.lookup_def_id(id).map(|id| id_from_def_id(id)); let alias_span = alias.map(|i| self.span_from_span(i.span)); let span = self.span_from_span(sub_span); self.dumper.import(&access, Import { @@ -1298,10 +1303,10 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> Visitor<'l> for DumpVisitor<'l, 'tc let cm = self.tcx.sess.source_map(); let filename = cm.span_to_filename(span); - let data_id = ::id_from_node_id(id, &self.save_ctxt); + let data_id = id_from_node_id(id, &self.save_ctxt); let children = m.items .iter() - .map(|i| ::id_from_node_id(i.id, &self.save_ctxt)) + .map(|i| id_from_node_id(i.id, &self.save_ctxt)) .collect(); let span = self.span_from_span(span); @@ -1345,7 +1350,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> Visitor<'l> for DumpVisitor<'l, 'tc let span = self.span_from_span(name_span); let parent = self.save_ctxt.tcx.hir().opt_local_def_id(item.id) .and_then(|id| self.save_ctxt.tcx.parent_def_id(id)) - .map(::id_from_def_id); + .map(id_from_def_id); self.dumper.import( &Access { public: false, @@ -1387,7 +1392,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> Visitor<'l> for DumpVisitor<'l, 'tc let value = ty_to_string(&ty); if !self.span.filter_generated(item.ident.span) { let span = self.span_from_span(item.ident.span); - let id = ::id_from_node_id(item.id, &self.save_ctxt); + let id = id_from_node_id(item.id, &self.save_ctxt); self.dumper.dump_def( &access_from!(self.save_ctxt, item), @@ -1417,7 +1422,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> Visitor<'l> for DumpVisitor<'l, 'tc let value = String::new(); if !self.span.filter_generated(item.ident.span) { let span = self.span_from_span(item.ident.span); - let id = ::id_from_node_id(item.id, &self.save_ctxt); + let id = id_from_node_id(item.id, &self.save_ctxt); self.dumper.dump_def( &access_from!(self.save_ctxt, item), @@ -1476,7 +1481,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> Visitor<'l> for DumpVisitor<'l, 'tc self.dumper.dump_ref(Ref { kind: RefKind::Type, span, - ref_id: ::id_from_def_id(id), + ref_id: id_from_def_id(id), }); } diff --git a/src/librustc_save_analysis/json_dumper.rs b/src/librustc_save_analysis/json_dumper.rs index 3627c5577a626..1840cf652e1d5 100644 --- a/src/librustc_save_analysis/json_dumper.rs +++ b/src/librustc_save_analysis/json_dumper.rs @@ -7,6 +7,8 @@ use rls_data::{self, Analysis, CompilationOptions, CratePreludeData, Def, DefKin MacroRef, Ref, RefKind, Relation}; use rls_span::{Column, Row}; +use log::error; + #[derive(Debug)] pub struct Access { pub reachable: bool, @@ -23,7 +25,7 @@ pub trait DumpOutput { fn dump(&mut self, result: &Analysis); } -pub struct WriteOutput<'b, W: Write + 'b> { +pub struct WriteOutput<'b, W: Write> { output: &'b mut W, } diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 73eb5de5c76f0..04ff1faf032cc 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -2,28 +2,11 @@ html_favicon_url = "https://doc.rust-lang.org/favicon.ico", html_root_url = "https://doc.rust-lang.org/nightly/")] #![feature(custom_attribute)] -#![feature(nll)] +#![deny(rust_2018_idioms)] #![allow(unused_attributes)] #![recursion_limit="256"] -#[macro_use] -extern crate rustc; - -#[macro_use] -extern crate log; -extern crate rustc_data_structures; -extern crate rustc_codegen_utils; -extern crate rustc_serialize; -extern crate rustc_target; -extern crate rustc_typeck; -#[macro_use] -extern crate syntax; -extern crate syntax_pos; - -extern crate rls_data; -extern crate rls_span; - mod json_dumper; mod dump_visitor; @@ -39,6 +22,7 @@ use rustc::middle::privacy::AccessLevels; use rustc::middle::cstore::ExternCrate; use rustc::session::config::{CrateType, Input, OutputType}; use rustc::ty::{self, TyCtxt}; +use rustc::{bug, span_bug}; use rustc_typeck::hir_ty_to_ty; use rustc_codegen_utils::link::{filename_for_metadata, out_filename}; use rustc_data_structures::sync::Lrc; @@ -66,6 +50,8 @@ use rls_data::{Def, DefKind, ExternalCrateData, GlobalCrateId, MacroRef, Ref, Re RelationKind, SpanData, Impl, ImplKind}; use rls_data::config::Config; +use log::{debug, error, info}; + pub struct SaveContext<'l, 'tcx: 'l> { tcx: TyCtxt<'l, 'tcx, 'tcx>, @@ -172,7 +158,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { ast::ForeignItemKind::Static(ref ty, _) => { filter!(self.span_utils, item.ident.span); - let id = ::id_from_node_id(item.id, self); + let id = id_from_node_id(item.id, self); let span = self.span_from_span(item.ident.span); Some(Data::DefData(Def { @@ -1029,7 +1015,7 @@ impl<'a> DumpHandler<'a> { } } - fn output_file(&self, ctx: &SaveContext) -> File { + fn output_file(&self, ctx: &SaveContext<'_, '_>) -> File { let sess = &ctx.tcx.sess; let file_name = match ctx.config.output_file { Some(ref s) => PathBuf::from(s), @@ -1180,7 +1166,7 @@ fn id_from_def_id(id: DefId) -> rls_data::Id { } } -fn id_from_node_id(id: NodeId, scx: &SaveContext) -> rls_data::Id { +fn id_from_node_id(id: NodeId, scx: &SaveContext<'_, '_>) -> rls_data::Id { let def_id = scx.tcx.hir().opt_local_def_id(id); def_id.map(|id| id_from_def_id(id)).unwrap_or_else(|| { // Create a *fake* `DefId` out of a `NodeId` by subtracting the `NodeId` @@ -1200,7 +1186,7 @@ fn null_id() -> rls_data::Id { } } -fn lower_attributes(attrs: Vec, scx: &SaveContext) -> Vec { +fn lower_attributes(attrs: Vec, scx: &SaveContext<'_, '_>) -> Vec { attrs.into_iter() // Only retain real attributes. Doc comments are lowered separately. .filter(|attr| attr.path != "doc") diff --git a/src/librustc_save_analysis/sig.rs b/src/librustc_save_analysis/sig.rs index 7d4c0d0f9f56f..fcd6ad07cd88f 100644 --- a/src/librustc_save_analysis/sig.rs +++ b/src/librustc_save_analysis/sig.rs @@ -25,7 +25,7 @@ // // FIXME where clauses need implementing, defs/refs in generics are mostly missing. -use {id_from_def_id, id_from_node_id, SaveContext}; +use crate::{id_from_def_id, id_from_node_id, SaveContext}; use rls_data::{SigElement, Signature}; @@ -34,14 +34,17 @@ use syntax::ast::{self, NodeId}; use syntax::print::pprust; -pub fn item_signature(item: &ast::Item, scx: &SaveContext) -> Option { +pub fn item_signature(item: &ast::Item, scx: &SaveContext<'_, '_>) -> Option { if !scx.config.signatures { return None; } item.make(0, None, scx).ok() } -pub fn foreign_item_signature(item: &ast::ForeignItem, scx: &SaveContext) -> Option { +pub fn foreign_item_signature( + item: &ast::ForeignItem, + scx: &SaveContext<'_, '_> +) -> Option { if !scx.config.signatures { return None; } @@ -50,7 +53,7 @@ pub fn foreign_item_signature(item: &ast::ForeignItem, scx: &SaveContext) -> Opt /// Signature for a struct or tuple field declaration. /// Does not include a trailing comma. -pub fn field_signature(field: &ast::StructField, scx: &SaveContext) -> Option { +pub fn field_signature(field: &ast::StructField, scx: &SaveContext<'_, '_>) -> Option { if !scx.config.signatures { return None; } @@ -58,7 +61,7 @@ pub fn field_signature(field: &ast::StructField, scx: &SaveContext) -> Option Option { +pub fn variant_signature(variant: &ast::Variant, scx: &SaveContext<'_, '_>) -> Option { if !scx.config.signatures { return None; } @@ -70,7 +73,7 @@ pub fn method_signature( ident: ast::Ident, generics: &ast::Generics, m: &ast::MethodSig, - scx: &SaveContext, + scx: &SaveContext<'_, '_>, ) -> Option { if !scx.config.signatures { return None; @@ -83,7 +86,7 @@ pub fn assoc_const_signature( ident: ast::Name, ty: &ast::Ty, default: Option<&ast::Expr>, - scx: &SaveContext, + scx: &SaveContext<'_, '_>, ) -> Option { if !scx.config.signatures { return None; @@ -96,7 +99,7 @@ pub fn assoc_type_signature( ident: ast::Ident, bounds: Option<&ast::GenericBounds>, default: Option<&ast::Ty>, - scx: &SaveContext, + scx: &SaveContext<'_, '_>, ) -> Option { if !scx.config.signatures { return None; @@ -104,10 +107,10 @@ pub fn assoc_type_signature( make_assoc_type_signature(id, ident, bounds, default, scx).ok() } -type Result = ::std::result::Result; +type Result = std::result::Result; trait Sig { - fn make(&self, offset: usize, id: Option, scx: &SaveContext) -> Result; + fn make(&self, offset: usize, id: Option, scx: &SaveContext<'_, '_>) -> Result; } fn extend_sig( @@ -155,7 +158,7 @@ fn text_sig(text: String) -> Signature { } impl Sig for ast::Ty { - fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext) -> Result { + fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext<'_, '_>) -> Result { let id = Some(self.id); match self.node { ast::TyKind::Slice(ref ty) => { @@ -227,7 +230,7 @@ impl Sig for ast::Ty { if f.unsafety == ast::Unsafety::Unsafe { text.push_str("unsafe "); } - if f.abi != ::rustc_target::spec::abi::Abi::Rust { + if f.abi != rustc_target::spec::abi::Abi::Rust { text.push_str("extern"); text.push_str(&f.abi.to_string()); text.push(' '); @@ -317,7 +320,7 @@ impl Sig for ast::Ty { } impl Sig for ast::Item { - fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext) -> Result { + fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext<'_, '_>) -> Result { let id = Some(self.id); match self.node { @@ -381,7 +384,7 @@ impl Sig for ast::Item { if header.unsafety == ast::Unsafety::Unsafe { text.push_str("unsafe "); } - if header.abi != ::rustc_target::spec::abi::Abi::Rust { + if header.abi != rustc_target::spec::abi::Abi::Rust { text.push_str("extern"); text.push_str(&header.abi.to_string()); text.push(' '); @@ -571,7 +574,7 @@ impl Sig for ast::Item { } impl Sig for ast::Path { - fn make(&self, offset: usize, id: Option, scx: &SaveContext) -> Result { + fn make(&self, offset: usize, id: Option, scx: &SaveContext<'_, '_>) -> Result { let def = scx.get_path_def(id.ok_or("Missing id for Path")?); let (name, start, end) = match def { @@ -613,7 +616,7 @@ impl Sig for ast::Path { // This does not cover the where clause, which must be processed separately. impl Sig for ast::Generics { - fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext) -> Result { + fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext<'_, '_>) -> Result { if self.params.is_empty() { return Ok(text_sig(String::new())); } @@ -662,7 +665,7 @@ impl Sig for ast::Generics { } impl Sig for ast::StructField { - fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext) -> Result { + fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext<'_, '_>) -> Result { let mut text = String::new(); let mut defs = None; if let Some(ident) = self.ident { @@ -685,7 +688,7 @@ impl Sig for ast::StructField { impl Sig for ast::Variant_ { - fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext) -> Result { + fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext<'_, '_>) -> Result { let mut text = self.ident.to_string(); match self.data { ast::VariantData::Struct(ref fields, id) => { @@ -743,7 +746,7 @@ impl Sig for ast::Variant_ { } impl Sig for ast::ForeignItem { - fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext) -> Result { + fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext<'_, '_>) -> Result { let id = Some(self.id); match self.node { ast::ForeignItemKind::Fn(ref decl, ref generics) => { @@ -827,7 +830,7 @@ fn name_and_generics( generics: &ast::Generics, id: NodeId, name: ast::Ident, - scx: &SaveContext, + scx: &SaveContext<'_, '_>, ) -> Result { let name = name.to_string(); let def = SigElement { @@ -848,7 +851,7 @@ fn make_assoc_type_signature( ident: ast::Ident, bounds: Option<&ast::GenericBounds>, default: Option<&ast::Ty>, - scx: &SaveContext, + scx: &SaveContext<'_, '_>, ) -> Result { let mut text = "type ".to_owned(); let name = ident.to_string(); @@ -882,7 +885,7 @@ fn make_assoc_const_signature( ident: ast::Name, ty: &ast::Ty, default: Option<&ast::Expr>, - scx: &SaveContext, + scx: &SaveContext<'_, '_>, ) -> Result { let mut text = "const ".to_owned(); let name = ident.to_string(); @@ -915,7 +918,7 @@ fn make_method_signature( ident: ast::Ident, generics: &ast::Generics, m: &ast::MethodSig, - scx: &SaveContext, + scx: &SaveContext<'_, '_>, ) -> Result { // FIXME code dup with function signature let mut text = String::new(); @@ -928,7 +931,7 @@ fn make_method_signature( if m.header.unsafety == ast::Unsafety::Unsafe { text.push_str("unsafe "); } - if m.header.abi != ::rustc_target::spec::abi::Abi::Rust { + if m.header.abi != rustc_target::spec::abi::Abi::Rust { text.push_str("extern"); text.push_str(&m.header.abi.to_string()); text.push(' '); diff --git a/src/librustc_save_analysis/span_utils.rs b/src/librustc_save_analysis/span_utils.rs index 88c6012f71f69..e2c93b6d33158 100644 --- a/src/librustc_save_analysis/span_utils.rs +++ b/src/librustc_save_analysis/span_utils.rs @@ -1,6 +1,6 @@ use rustc::session::Session; -use generated_code; +use crate::generated_code; use std::cell::Cell; From edbd8a36c8820fb8a128675859c1fa76feab2bea Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Thu, 7 Feb 2019 02:15:23 +0900 Subject: [PATCH 117/278] librustc_resolve => 2018 --- src/librustc_resolve/Cargo.toml | 1 + src/librustc_resolve/build_reduced_graph.rs | 22 +++-- src/librustc_resolve/check_unused.rs | 6 +- src/librustc_resolve/diagnostics.rs | 2 + src/librustc_resolve/error_reporting.rs | 8 +- src/librustc_resolve/lib.rs | 93 ++++++++++----------- src/librustc_resolve/macros.rs | 23 ++--- src/librustc_resolve/resolve_imports.rs | 30 ++++--- 8 files changed, 96 insertions(+), 89 deletions(-) diff --git a/src/librustc_resolve/Cargo.toml b/src/librustc_resolve/Cargo.toml index 3a8e84a3280c6..0ce82f2ce521b 100644 --- a/src/librustc_resolve/Cargo.toml +++ b/src/librustc_resolve/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_resolve" version = "0.0.0" +edition = "2018" [lib] name = "rustc_resolve" diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index c5401ac3f5560..750eb35a98854 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -3,14 +3,15 @@ //! Here we build the "reduced graph": the graph of the module tree without //! any imports resolved. -use macros::{InvocationData, ParentScope, LegacyScope}; -use resolve_imports::ImportDirective; -use resolve_imports::ImportDirectiveSubclass::{self, GlobImport, SingleImport}; -use {Module, ModuleData, ModuleKind, NameBinding, NameBindingKind, Segment, ToNameBinding}; -use {ModuleOrUniformRoot, PerNS, Resolver, ResolverArenas, ExternPreludeEntry}; -use Namespace::{self, TypeNS, ValueNS, MacroNS}; -use {resolve_error, resolve_struct_error, ResolutionError}; - +use crate::macros::{InvocationData, ParentScope, LegacyScope}; +use crate::resolve_imports::ImportDirective; +use crate::resolve_imports::ImportDirectiveSubclass::{self, GlobImport, SingleImport}; +use crate::{Module, ModuleData, ModuleKind, NameBinding, NameBindingKind, Segment, ToNameBinding}; +use crate::{ModuleOrUniformRoot, PerNS, Resolver, ResolverArenas, ExternPreludeEntry}; +use crate::Namespace::{self, TypeNS, ValueNS, MacroNS}; +use crate::{resolve_error, resolve_struct_error, ResolutionError}; + +use rustc::bug; use rustc::hir::def::*; use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, LOCAL_CRATE, DefId}; use rustc::ty; @@ -21,7 +22,7 @@ use std::cell::Cell; use std::ptr; use rustc_data_structures::sync::Lrc; -use errors::Applicability; +use crate::errors::Applicability; use syntax::ast::{Name, Ident}; use syntax::attr; @@ -34,12 +35,15 @@ use syntax::ext::hygiene::Mark; use syntax::ext::tt::macro_rules; use syntax::feature_gate::is_builtin_attr; use syntax::parse::token::{self, Token}; +use syntax::span_err; use syntax::std_inject::injected_crate_name; use syntax::symbol::keywords; use syntax::visit::{self, Visitor}; use syntax_pos::{Span, DUMMY_SP}; +use log::debug; + impl<'a> ToNameBinding<'a> for (Module<'a>, ty::Visibility, Span, Mark) { fn to_name_binding(self, arenas: &'a ResolverArenas<'a>) -> &'a NameBinding<'a> { arenas.alloc_name_binding(NameBinding { diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs index 16d8a95c003f7..639960827c996 100644 --- a/src/librustc_resolve/check_unused.rs +++ b/src/librustc_resolve/check_unused.rs @@ -10,8 +10,8 @@ use std::ops::{Deref, DerefMut}; -use Resolver; -use resolve_imports::ImportDirectiveSubclass; +use crate::Resolver; +use crate::resolve_imports::ImportDirectiveSubclass; use rustc::{lint, ty}; use rustc::util::nodemap::NodeMap; @@ -113,7 +113,7 @@ impl<'a, 'b> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b> { } } -pub fn check_crate(resolver: &mut Resolver, krate: &ast::Crate) { +pub fn check_crate(resolver: &mut Resolver<'_>, krate: &ast::Crate) { for directive in resolver.potentially_unused_imports.iter() { match directive.subclass { _ if directive.used.get() || diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs index 3f9c5f4fd273c..0db8689c0c17c 100644 --- a/src/librustc_resolve/diagnostics.rs +++ b/src/librustc_resolve/diagnostics.rs @@ -1,5 +1,7 @@ #![allow(non_snake_case)] +use syntax::{register_diagnostic, register_diagnostics, register_long_diagnostics}; + // Error messages for EXXXX errors. Each message should start and end with a // new line, and be wrapped to 80 characters. In vim you can `:set tw=80` and // use `gq` to wrap paragraphs. Use `:set tw=0` to disable. diff --git a/src/librustc_resolve/error_reporting.rs b/src/librustc_resolve/error_reporting.rs index 2a8e95536b8c7..b131a6b62f9bf 100644 --- a/src/librustc_resolve/error_reporting.rs +++ b/src/librustc_resolve/error_reporting.rs @@ -1,10 +1,12 @@ -use {CrateLint, PathResult, Segment}; -use macros::ParentScope; +use crate::{CrateLint, PathResult, Segment}; +use crate::macros::ParentScope; +use crate::resolve_imports::ImportResolver; use syntax::symbol::keywords; use syntax_pos::Span; -use resolve_imports::ImportResolver; +use log::debug; + use std::cmp::Reverse; impl<'a, 'b:'a> ImportResolver<'a, 'b> { diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 3973bc2ad62de..b166b1be02f45 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -4,30 +4,19 @@ #![feature(crate_visibility_modifier)] #![feature(label_break_value)] -#![feature(nll)] #![feature(rustc_diagnostic_macros)] #![feature(slice_sort_by_cached_key)] #![recursion_limit="256"] -#[macro_use] -extern crate bitflags; -#[macro_use] -extern crate log; -#[macro_use] -extern crate syntax; -extern crate syntax_pos; -extern crate rustc_errors as errors; -extern crate arena; -#[macro_use] -extern crate rustc; -extern crate rustc_data_structures; -extern crate rustc_metadata; +#![deny(rust_2018_idioms)] + +use rustc_errors as errors; pub use rustc::hir::def::{Namespace, PerNS}; -use self::TypeParameters::*; -use self::RibKind::*; +use TypeParameters::*; +use RibKind::*; use rustc::hir::map::{Definitions, DefCollector}; use rustc::hir::{self, PrimTy, Bool, Char, Float, Int, Uint, Str}; @@ -41,6 +30,7 @@ use rustc::hir::{Freevar, FreevarMap, TraitCandidate, TraitMap, GlobMap}; use rustc::session::config::nightly_options; use rustc::ty; use rustc::util::nodemap::{NodeMap, NodeSet, FxHashMap, FxHashSet, DefIdMap}; +use rustc::{bug, span_bug}; use rustc_metadata::creader::CrateLoader; use rustc_metadata::cstore::CStore; @@ -62,10 +52,13 @@ use syntax::ast::{Item, ItemKind, ImplItem, ImplItemKind}; use syntax::ast::{Label, Local, Mutability, Pat, PatKind, Path}; use syntax::ast::{QSelf, TraitItemKind, TraitRef, Ty, TyKind}; use syntax::ptr::P; +use syntax::{span_err, struct_span_err, unwrap_or, walk_list}; use syntax_pos::{BytePos, Span, DUMMY_SP, MultiSpan}; use errors::{Applicability, DiagnosticBuilder, DiagnosticId}; +use log::debug; + use std::cell::{Cell, RefCell}; use std::{cmp, fmt, iter, mem, ptr}; use std::collections::BTreeSet; @@ -191,13 +184,13 @@ enum ResolutionError<'a> { /// /// This takes the error provided, combines it with the span and any additional spans inside the /// error and emits it. -fn resolve_error<'sess, 'a>(resolver: &'sess Resolver, +fn resolve_error<'sess, 'a>(resolver: &'sess Resolver<'_>, span: Span, resolution_error: ResolutionError<'a>) { resolve_struct_error(resolver, span, resolution_error).emit(); } -fn resolve_struct_error<'sess, 'a>(resolver: &'sess Resolver, +fn resolve_struct_error<'sess, 'a>(resolver: &'sess Resolver<'_>, span: Span, resolution_error: ResolutionError<'a>) -> DiagnosticBuilder<'sess> { @@ -1192,7 +1185,7 @@ impl<'a> ModuleData<'a> { } impl<'a> fmt::Debug for ModuleData<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{:?}", self.def()) } } @@ -1416,7 +1409,7 @@ impl<'a> NameBinding<'a> { // in some later round and screw up our previously found resolution. // See more detailed explanation in // https://github.com/rust-lang/rust/pull/53778#issuecomment-419224049 - fn may_appear_after(&self, invoc_parent_expansion: Mark, binding: &NameBinding) -> bool { + fn may_appear_after(&self, invoc_parent_expansion: Mark, binding: &NameBinding<'_>) -> bool { // self > max(invoc, binding) => !(self <= invoc || self <= binding) // Expansions are partially ordered, so "may appear after" is an inversion of // "certainly appears before or simultaneously" and includes unordered cases. @@ -1630,14 +1623,14 @@ impl<'a> ResolverArenas<'a> { } module } - fn local_modules(&'a self) -> ::std::cell::Ref<'a, Vec>> { + fn local_modules(&'a self) -> std::cell::Ref<'a, Vec>> { self.local_modules.borrow() } fn alloc_name_binding(&'a self, name_binding: NameBinding<'a>) -> &'a NameBinding<'a> { self.name_bindings.alloc(name_binding) } fn alloc_import_directive(&'a self, import_directive: ImportDirective<'a>) - -> &'a ImportDirective { + -> &'a ImportDirective<'_> { self.import_directives.alloc(import_directive) } fn alloc_name_resolution(&'a self) -> &'a RefCell> { @@ -1754,7 +1747,7 @@ impl<'a> Resolver<'a> { is_value: bool, error_callback: F, ) -> hir::Path - where F: for<'c, 'b> FnOnce(&'c mut Resolver, Span, ResolutionError<'b>) + where F: for<'c, 'b> FnOnce(&'c mut Resolver<'_>, Span, ResolutionError<'b>) { let namespace = if is_value { ValueNS } else { TypeNS }; let span = path.span; @@ -1819,7 +1812,7 @@ impl<'a> Resolver<'a> { DefCollector::new(&mut definitions, Mark::root()) .collect_root(crate_name, session.local_crate_disambiguator()); - let mut extern_prelude: FxHashMap = + let mut extern_prelude: FxHashMap> = session.opts.externs.iter().map(|kv| (Ident::from_str(kv.0), Default::default())) .collect(); @@ -2315,7 +2308,7 @@ impl<'a> Resolver<'a> { // implementations thus found, for compatibility with old resolve pass. pub fn with_scope(&mut self, id: NodeId, f: F) -> T - where F: FnOnce(&mut Resolver) -> T + where F: FnOnce(&mut Resolver<'_>) -> T { let id = self.definitions.local_def_id(id); let module = self.module_map.get(&id).cloned(); // clones a reference @@ -2342,7 +2335,7 @@ impl<'a> Resolver<'a> { /// /// Stops after meeting a closure. fn search_label(&self, mut ident: Ident, pred: P) -> Option - where P: Fn(&Rib, Ident) -> Option + where P: Fn(&Rib<'_>, Ident) -> Option { for rib in self.label_ribs.iter().rev() { match rib.kind { @@ -2527,7 +2520,7 @@ impl<'a> Resolver<'a> { } fn with_type_parameter_rib<'b, F>(&'b mut self, type_parameters: TypeParameters<'a, 'b>, f: F) - where F: FnOnce(&mut Resolver) + where F: FnOnce(&mut Resolver<'_>) { match type_parameters { HasTypeParameters(generics, rib_kind) => { @@ -2573,7 +2566,7 @@ impl<'a> Resolver<'a> { } fn with_label_rib(&mut self, f: F) - where F: FnOnce(&mut Resolver) + where F: FnOnce(&mut Resolver<'_>) { self.label_ribs.push(Rib::new(NormalRibKind)); f(self); @@ -2581,7 +2574,7 @@ impl<'a> Resolver<'a> { } fn with_item_rib(&mut self, f: F) - where F: FnOnce(&mut Resolver) + where F: FnOnce(&mut Resolver<'_>) { self.ribs[ValueNS].push(Rib::new(ItemRibKind)); self.ribs[TypeNS].push(Rib::new(ItemRibKind)); @@ -2591,7 +2584,7 @@ impl<'a> Resolver<'a> { } fn with_constant_rib(&mut self, f: F) - where F: FnOnce(&mut Resolver) + where F: FnOnce(&mut Resolver<'_>) { self.ribs[ValueNS].push(Rib::new(ConstantItemRibKind)); self.label_ribs.push(Rib::new(ConstantItemRibKind)); @@ -2601,7 +2594,7 @@ impl<'a> Resolver<'a> { } fn with_current_self_type(&mut self, self_type: &Ty, f: F) -> T - where F: FnOnce(&mut Resolver) -> T + where F: FnOnce(&mut Resolver<'_>) -> T { // Handle nested impls (inside fn bodies) let previous_value = replace(&mut self.current_self_type, Some(self_type.clone())); @@ -2611,7 +2604,7 @@ impl<'a> Resolver<'a> { } fn with_current_self_item(&mut self, self_item: &Item, f: F) -> T - where F: FnOnce(&mut Resolver) -> T + where F: FnOnce(&mut Resolver<'_>) -> T { let previous_value = replace(&mut self.current_self_item, Some(self_item.id)); let result = f(self); @@ -2621,7 +2614,7 @@ impl<'a> Resolver<'a> { /// This is called to resolve a trait reference from an `impl` (i.e., `impl Trait for Foo`) fn with_optional_trait_ref(&mut self, opt_trait_ref: Option<&TraitRef>, f: F) -> T - where F: FnOnce(&mut Resolver, Option) -> T + where F: FnOnce(&mut Resolver<'_>, Option) -> T { let mut new_val = None; let mut new_id = None; @@ -2658,7 +2651,7 @@ impl<'a> Resolver<'a> { } fn with_self_rib(&mut self, self_def: Def, f: F) - where F: FnOnce(&mut Resolver) + where F: FnOnce(&mut Resolver<'_>) { let mut self_type_rib = Rib::new(NormalRibKind); @@ -2670,7 +2663,7 @@ impl<'a> Resolver<'a> { } fn with_self_struct_ctor_rib(&mut self, impl_id: DefId, f: F) - where F: FnOnce(&mut Resolver) + where F: FnOnce(&mut Resolver<'_>) { let self_def = Def::SelfCtor(impl_id); let mut self_type_rib = Rib::new(NormalRibKind); @@ -2771,7 +2764,7 @@ impl<'a> Resolver<'a> { } fn check_trait_item(&mut self, ident: Ident, ns: Namespace, span: Span, err: F) - where F: FnOnce(Name, &str) -> ResolutionError + where F: FnOnce(Name, &str) -> ResolutionError<'_> { // If there is a TraitRef in scope for an impl, then the method must be in the // trait. @@ -3102,7 +3095,7 @@ impl<'a> Resolver<'a> { id: NodeId, qself: Option<&QSelf>, path: &Path, - source: PathSource) + source: PathSource<'_>) -> PathResolution { self.smart_resolve_path_with_crate_lint(id, qself, path, source, CrateLint::SimplePath(id)) } @@ -3120,7 +3113,7 @@ impl<'a> Resolver<'a> { id: NodeId, qself: Option<&QSelf>, path: &Path, - source: PathSource, + source: PathSource<'_>, crate_lint: CrateLint ) -> PathResolution { self.smart_resolve_path_fragment( @@ -3138,7 +3131,7 @@ impl<'a> Resolver<'a> { qself: Option<&QSelf>, path: &[Segment], span: Span, - source: PathSource, + source: PathSource<'_>, crate_lint: CrateLint) -> PathResolution { let ident_span = path.last().map_or(span, |ident| ident.ident.span); @@ -3581,7 +3574,7 @@ impl<'a> Resolver<'a> { } fn type_ascription_suggestion(&self, - err: &mut DiagnosticBuilder, + err: &mut DiagnosticBuilder<'_>, base_span: Span) { debug!("type_ascription_suggetion {:?}", base_span); let cm = self.session.source_map(); @@ -4040,7 +4033,7 @@ impl<'a> Resolver<'a> { crate_lint: CrateLint, path: &[Segment], path_span: Span, - second_binding: Option<&NameBinding>, + second_binding: Option<&NameBinding<'_>>, ) { let (diag_id, diag_span) = match crate_lint { CrateLint::No => return, @@ -4266,7 +4259,7 @@ impl<'a> Resolver<'a> { where FilterFn: Fn(Def) -> bool, { - let add_module_candidates = |module: Module, names: &mut Vec| { + let add_module_candidates = |module: Module<'_>, names: &mut Vec| { for (&(ident, _), resolution) in module.resolutions.borrow().iter() { if let Some(binding) = resolution.borrow().binding { if filter_fn(binding.def()) { @@ -4361,7 +4354,7 @@ impl<'a> Resolver<'a> { } fn with_resolved_label(&mut self, label: Option { fn outer(&self) { enum Foo { Variance(A) - //~^ ERROR can't use type parameters from outer function + //~^ ERROR can't use generic parameters from outer function } } } @@ -14,21 +14,21 @@ trait TraitA { trait TraitB { fn outer(&self) { struct Foo(A); - //~^ ERROR can't use type parameters from outer function + //~^ ERROR can't use generic parameters from outer function } } trait TraitC { fn outer(&self) { struct Foo { a: A } - //~^ ERROR can't use type parameters from outer function + //~^ ERROR can't use generic parameters from outer function } } trait TraitD { fn outer(&self) { fn foo(a: A) { } - //~^ ERROR can't use type parameters from outer function + //~^ ERROR can't use generic parameters from outer function } } diff --git a/src/test/ui/resolve/resolve-type-param-in-item-in-trait.stderr b/src/test/ui/resolve/resolve-type-param-in-item-in-trait.stderr index 8eca720d88e8c..f6b8abf4057e5 100644 --- a/src/test/ui/resolve/resolve-type-param-in-item-in-trait.stderr +++ b/src/test/ui/resolve/resolve-type-param-in-item-in-trait.stderr @@ -1,44 +1,44 @@ -error[E0401]: can't use type parameters from outer function +error[E0401]: can't use generic parameters from outer function --> $DIR/resolve-type-param-in-item-in-trait.rs:8:22 | LL | trait TraitA { | - type variable from outer function LL | fn outer(&self) { - | ----- try adding a local type parameter in this method instead + | ----- try adding a local generic parameter in this method instead LL | enum Foo { LL | Variance(A) - | ^ use of type variable from outer function + | ^ use of generic parameter from outer function -error[E0401]: can't use type parameters from outer function +error[E0401]: can't use generic parameters from outer function --> $DIR/resolve-type-param-in-item-in-trait.rs:16:23 | LL | trait TraitB { | - type variable from outer function LL | fn outer(&self) { - | ----- try adding a local type parameter in this method instead + | ----- try adding a local generic parameter in this method instead LL | struct Foo(A); - | ^ use of type variable from outer function + | ^ use of generic parameter from outer function -error[E0401]: can't use type parameters from outer function +error[E0401]: can't use generic parameters from outer function --> $DIR/resolve-type-param-in-item-in-trait.rs:23:28 | LL | trait TraitC { | - type variable from outer function LL | fn outer(&self) { - | ----- try adding a local type parameter in this method instead + | ----- try adding a local generic parameter in this method instead LL | struct Foo { a: A } - | ^ use of type variable from outer function + | ^ use of generic parameter from outer function -error[E0401]: can't use type parameters from outer function +error[E0401]: can't use generic parameters from outer function --> $DIR/resolve-type-param-in-item-in-trait.rs:30:22 | LL | trait TraitD { | - type variable from outer function LL | fn outer(&self) { LL | fn foo(a: A) { } - | ------ ^ use of type variable from outer function + | ------ ^ use of generic parameter from outer function | | - | help: try using a local type parameter instead: `foo` + | help: try using a local generic parameter instead: `foo` error: aborting due to 4 previous errors diff --git a/src/test/ui/type/type-arg-out-of-scope.rs b/src/test/ui/type/type-arg-out-of-scope.rs index b96c9bf6a0e41..d5b815f6a95e9 100644 --- a/src/test/ui/type/type-arg-out-of-scope.rs +++ b/src/test/ui/type/type-arg-out-of-scope.rs @@ -1,4 +1,4 @@ -// error-pattern:can't use type parameters from outer function +// error-pattern:can't use generic parameters from outer function fn foo(x: T) { fn bar(f: Box T>) { } } diff --git a/src/test/ui/type/type-arg-out-of-scope.stderr b/src/test/ui/type/type-arg-out-of-scope.stderr index 62b6a86662d04..645cbb33abec1 100644 --- a/src/test/ui/type/type-arg-out-of-scope.stderr +++ b/src/test/ui/type/type-arg-out-of-scope.stderr @@ -1,22 +1,22 @@ -error[E0401]: can't use type parameters from outer function +error[E0401]: can't use generic parameters from outer function --> $DIR/type-arg-out-of-scope.rs:3:25 | LL | fn foo(x: T) { | - type variable from outer function LL | fn bar(f: Box T>) { } - | --- ^ use of type variable from outer function + | --- ^ use of generic parameter from outer function | | - | help: try using a local type parameter instead: `bar` + | help: try using a local generic parameter instead: `bar` -error[E0401]: can't use type parameters from outer function +error[E0401]: can't use generic parameters from outer function --> $DIR/type-arg-out-of-scope.rs:3:31 | LL | fn foo(x: T) { | - type variable from outer function LL | fn bar(f: Box T>) { } - | --- ^ use of type variable from outer function + | --- ^ use of generic parameter from outer function | | - | help: try using a local type parameter instead: `bar` + | help: try using a local generic parameter instead: `bar` error: aborting due to 2 previous errors diff --git a/src/test/ui/use-self-in-inner-fn.rs b/src/test/ui/use-self-in-inner-fn.rs index cde96dc778bbe..eccb315feb1e2 100644 --- a/src/test/ui/use-self-in-inner-fn.rs +++ b/src/test/ui/use-self-in-inner-fn.rs @@ -4,8 +4,8 @@ impl A { //~^ NOTE `Self` type implicitly declared here, by this `impl` fn banana(&mut self) { fn peach(this: &Self) { - //~^ ERROR can't use type parameters from outer function - //~| NOTE use of type variable from outer function + //~^ ERROR can't use generic parameters from outer function + //~| NOTE use of generic parameter from outer function //~| NOTE use a type here instead } } diff --git a/src/test/ui/use-self-in-inner-fn.stderr b/src/test/ui/use-self-in-inner-fn.stderr index a613804b8038b..966093499241d 100644 --- a/src/test/ui/use-self-in-inner-fn.stderr +++ b/src/test/ui/use-self-in-inner-fn.stderr @@ -1,4 +1,4 @@ -error[E0401]: can't use type parameters from outer function +error[E0401]: can't use generic parameters from outer function --> $DIR/use-self-in-inner-fn.rs:6:25 | LL | impl A { @@ -7,7 +7,7 @@ LL | impl A { LL | fn peach(this: &Self) { | ^^^^ | | - | use of type variable from outer function + | use of generic parameter from outer function | use a type here instead error: aborting due to previous error From 1b933a5ce911616a2bf64c54c34693387eedb7e1 Mon Sep 17 00:00:00 2001 From: varkor Date: Thu, 7 Feb 2019 15:00:14 +0100 Subject: [PATCH 172/278] Add a test forbidding the use of const parameters in inner items --- .../const-param-from-outer-fn.rs | 11 ++++++++ .../const-param-from-outer-fn.stderr | 26 +++++++++++++++++++ 2 files changed, 37 insertions(+) create mode 100644 src/test/ui/const-generics/const-param-from-outer-fn.rs create mode 100644 src/test/ui/const-generics/const-param-from-outer-fn.stderr diff --git a/src/test/ui/const-generics/const-param-from-outer-fn.rs b/src/test/ui/const-generics/const-param-from-outer-fn.rs new file mode 100644 index 0000000000000..5a8dd92086f85 --- /dev/null +++ b/src/test/ui/const-generics/const-param-from-outer-fn.rs @@ -0,0 +1,11 @@ +#![feature(const_generics)] +//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash + +fn foo() { + //~^ ERROR const generics in any position are currently unsupported + fn bar() -> u32 { + X //~ ERROR can't use generic parameters from outer function + } +} + +fn main() {} diff --git a/src/test/ui/const-generics/const-param-from-outer-fn.stderr b/src/test/ui/const-generics/const-param-from-outer-fn.stderr new file mode 100644 index 0000000000000..b238b3a2aa453 --- /dev/null +++ b/src/test/ui/const-generics/const-param-from-outer-fn.stderr @@ -0,0 +1,26 @@ +warning: the feature `const_generics` is incomplete and may cause the compiler to crash + --> $DIR/const-param-from-outer-fn.rs:1:12 + | +LL | #![feature(const_generics)] + | ^^^^^^^^^^^^^^ + +error[E0401]: can't use generic parameters from outer function + --> $DIR/const-param-from-outer-fn.rs:7:9 + | +LL | fn foo() { + | - const variable from outer function +LL | //~^ ERROR const generics in any position are currently unsupported +LL | fn bar() -> u32 { + | --- try adding a local generic parameter in this method instead +LL | X //~ ERROR can't use generic parameters from outer function + | ^ use of generic parameter from outer function + +error: const generics in any position are currently unsupported + --> $DIR/const-param-from-outer-fn.rs:4:14 + | +LL | fn foo() { + | ^ + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0401`. From c54b230fa1a7365dd648e9dece87e40e838b45f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Thu, 7 Feb 2019 06:20:23 -0800 Subject: [PATCH 173/278] Add fixme --- src/libsyntax/parse/parser.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 6dd4bfbb8d5f5..0ac3b8f6bd018 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -721,7 +721,9 @@ impl<'a> Parser<'a> { // the most sense, which is immediately after the last token: // // {foo(bar {}} - // - ^ help: `)` may belong here + // - ^ + // | | + // | help: `)` may belong here (FIXME: #58270) // | // unclosed delimiter if let Some(sp) = unmatched.unclosed_span { From f2fe71c02ac7ecb29106b1a826d657ff5705ad6c Mon Sep 17 00:00:00 2001 From: varkor Date: Thu, 7 Feb 2019 16:03:12 +0100 Subject: [PATCH 174/278] Resolve incorrect diagnostic for using a non-const value in a constant --- src/librustc_resolve/lib.rs | 18 +++++++++---- src/test/ui/impl-trait/bindings.rs | 8 +++--- src/test/ui/impl-trait/bindings.stderr | 26 +++++++------------ src/test/ui/issues/issue-27433.rs | 2 +- src/test/ui/issues/issue-27433.stderr | 8 +++--- src/test/ui/issues/issue-3521-2.rs | 2 +- src/test/ui/issues/issue-3521-2.stderr | 8 +++--- src/test/ui/issues/issue-3668-2.rs | 2 +- src/test/ui/issues/issue-3668-2.stderr | 8 +++--- src/test/ui/issues/issue-3668.rs | 2 +- src/test/ui/issues/issue-3668.stderr | 8 +++--- .../ui/type/type-dependent-def-issue-49241.rs | 2 +- .../type-dependent-def-issue-49241.stderr | 10 +++---- 13 files changed, 47 insertions(+), 57 deletions(-) diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 365ba974d5aea..0d1f6328105b3 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -4164,6 +4164,9 @@ impl<'a> Resolver<'a> { span_bug!(span, "unexpected {:?} in bindings", def) } Def::Local(node_id) => { + use ResolutionError::*; + let mut res_err = None; + for rib in ribs { match rib.kind { NormalRibKind | ModuleRibKind(..) | MacroDefinition(..) | @@ -4199,21 +4202,26 @@ impl<'a> Resolver<'a> { // named function item. This is not allowed, so we // report an error. if record_used { - resolve_error(self, span, - ResolutionError::CannotCaptureDynamicEnvironmentInFnItem); + // We don't immediately trigger a resolve error, because + // we want certain other resolution errors (namely those + // emitted for `ConstantItemRibKind` below) to take + // precedence. + res_err = Some(CannotCaptureDynamicEnvironmentInFnItem); } - return Def::Err; } ConstantItemRibKind => { // Still doesn't deal with upvars if record_used { - resolve_error(self, span, - ResolutionError::AttemptToUseNonConstantValueInConstant); + resolve_error(self, span, AttemptToUseNonConstantValueInConstant); } return Def::Err; } } } + if let Some(res_err) = res_err { + resolve_error(self, span, res_err); + return Def::Err; + } } Def::TyParam(..) | Def::SelfTy(..) => { for rib in ribs { diff --git a/src/test/ui/impl-trait/bindings.rs b/src/test/ui/impl-trait/bindings.rs index 899303646d671..91d092634a901 100644 --- a/src/test/ui/impl-trait/bindings.rs +++ b/src/test/ui/impl-trait/bindings.rs @@ -2,27 +2,27 @@ fn a(x: T) { const foo: impl Clone = x; -//~^ ERROR can't capture dynamic environment in a fn item + //~^ ERROR attempt to use a non-constant value in a constant } fn b(x: T) { let _ = move || { const foo: impl Clone = x; -//~^ ERROR can't capture dynamic environment in a fn item + //~^ ERROR attempt to use a non-constant value in a constant }; } trait Foo { fn a(x: T) { const foo: impl Clone = x; -//~^ ERROR can't capture dynamic environment in a fn item + //~^ ERROR attempt to use a non-constant value in a constant } } impl Foo for i32 { fn a(x: T) { const foo: impl Clone = x; -//~^ ERROR can't capture dynamic environment in a fn item + //~^ ERROR attempt to use a non-constant value in a constant } } diff --git a/src/test/ui/impl-trait/bindings.stderr b/src/test/ui/impl-trait/bindings.stderr index 2a9be7a270a73..a5bf583afeaf6 100644 --- a/src/test/ui/impl-trait/bindings.stderr +++ b/src/test/ui/impl-trait/bindings.stderr @@ -1,35 +1,27 @@ -error[E0434]: can't capture dynamic environment in a fn item +error[E0435]: attempt to use a non-constant value in a constant --> $DIR/bindings.rs:4:29 | LL | const foo: impl Clone = x; - | ^ - | - = help: use the `|| { ... }` closure form instead + | ^ non-constant value -error[E0434]: can't capture dynamic environment in a fn item +error[E0435]: attempt to use a non-constant value in a constant --> $DIR/bindings.rs:10:33 | LL | const foo: impl Clone = x; - | ^ - | - = help: use the `|| { ... }` closure form instead + | ^ non-constant value -error[E0434]: can't capture dynamic environment in a fn item +error[E0435]: attempt to use a non-constant value in a constant --> $DIR/bindings.rs:17:33 | LL | const foo: impl Clone = x; - | ^ - | - = help: use the `|| { ... }` closure form instead + | ^ non-constant value -error[E0434]: can't capture dynamic environment in a fn item +error[E0435]: attempt to use a non-constant value in a constant --> $DIR/bindings.rs:24:33 | LL | const foo: impl Clone = x; - | ^ - | - = help: use the `|| { ... }` closure form instead + | ^ non-constant value error: aborting due to 4 previous errors -For more information about this error, try `rustc --explain E0434`. +For more information about this error, try `rustc --explain E0435`. diff --git a/src/test/ui/issues/issue-27433.rs b/src/test/ui/issues/issue-27433.rs index 2cc7d05e7c691..156ae68efe2c5 100644 --- a/src/test/ui/issues/issue-27433.rs +++ b/src/test/ui/issues/issue-27433.rs @@ -1,5 +1,5 @@ fn main() { let foo = 42u32; const FOO : u32 = foo; - //~^ ERROR can't capture dynamic environment + //~^ ERROR attempt to use a non-constant value in a constant } diff --git a/src/test/ui/issues/issue-27433.stderr b/src/test/ui/issues/issue-27433.stderr index 78a193dd99a7f..e232d17e6d7a6 100644 --- a/src/test/ui/issues/issue-27433.stderr +++ b/src/test/ui/issues/issue-27433.stderr @@ -1,11 +1,9 @@ -error[E0434]: can't capture dynamic environment in a fn item +error[E0435]: attempt to use a non-constant value in a constant --> $DIR/issue-27433.rs:3:23 | LL | const FOO : u32 = foo; - | ^^^ - | - = help: use the `|| { ... }` closure form instead + | ^^^ non-constant value error: aborting due to previous error -For more information about this error, try `rustc --explain E0434`. +For more information about this error, try `rustc --explain E0435`. diff --git a/src/test/ui/issues/issue-3521-2.rs b/src/test/ui/issues/issue-3521-2.rs index 39f7fcb833756..871394f9eaeb9 100644 --- a/src/test/ui/issues/issue-3521-2.rs +++ b/src/test/ui/issues/issue-3521-2.rs @@ -2,7 +2,7 @@ fn main() { let foo = 100; static y: isize = foo + 1; - //~^ ERROR can't capture dynamic environment + //~^ ERROR attempt to use a non-constant value in a constant println!("{}", y); } diff --git a/src/test/ui/issues/issue-3521-2.stderr b/src/test/ui/issues/issue-3521-2.stderr index 1464fd74bba69..d54bbbcdc3325 100644 --- a/src/test/ui/issues/issue-3521-2.stderr +++ b/src/test/ui/issues/issue-3521-2.stderr @@ -1,11 +1,9 @@ -error[E0434]: can't capture dynamic environment in a fn item +error[E0435]: attempt to use a non-constant value in a constant --> $DIR/issue-3521-2.rs:4:23 | LL | static y: isize = foo + 1; - | ^^^ - | - = help: use the `|| { ... }` closure form instead + | ^^^ non-constant value error: aborting due to previous error -For more information about this error, try `rustc --explain E0434`. +For more information about this error, try `rustc --explain E0435`. diff --git a/src/test/ui/issues/issue-3668-2.rs b/src/test/ui/issues/issue-3668-2.rs index 265a884ded7aa..525f6f5684e70 100644 --- a/src/test/ui/issues/issue-3668-2.rs +++ b/src/test/ui/issues/issue-3668-2.rs @@ -1,6 +1,6 @@ fn f(x:isize) { static child: isize = x + 1; - //~^ ERROR can't capture dynamic environment + //~^ ERROR attempt to use a non-constant value in a constant } fn main() {} diff --git a/src/test/ui/issues/issue-3668-2.stderr b/src/test/ui/issues/issue-3668-2.stderr index 8dd6f49d8de5a..d6a6e8379602d 100644 --- a/src/test/ui/issues/issue-3668-2.stderr +++ b/src/test/ui/issues/issue-3668-2.stderr @@ -1,11 +1,9 @@ -error[E0434]: can't capture dynamic environment in a fn item +error[E0435]: attempt to use a non-constant value in a constant --> $DIR/issue-3668-2.rs:2:27 | LL | static child: isize = x + 1; - | ^ - | - = help: use the `|| { ... }` closure form instead + | ^ non-constant value error: aborting due to previous error -For more information about this error, try `rustc --explain E0434`. +For more information about this error, try `rustc --explain E0435`. diff --git a/src/test/ui/issues/issue-3668.rs b/src/test/ui/issues/issue-3668.rs index 3f61b1b02e779..0e1f19a75baeb 100644 --- a/src/test/ui/issues/issue-3668.rs +++ b/src/test/ui/issues/issue-3668.rs @@ -6,7 +6,7 @@ trait PTrait { impl PTrait for P { fn getChildOption(&self) -> Option> { static childVal: Box

    = self.child.get(); - //~^ ERROR can't capture dynamic environment + //~^ ERROR attempt to use a non-constant value in a constant panic!(); } } diff --git a/src/test/ui/issues/issue-3668.stderr b/src/test/ui/issues/issue-3668.stderr index 7f974de9da8ea..98cd3631a5365 100644 --- a/src/test/ui/issues/issue-3668.stderr +++ b/src/test/ui/issues/issue-3668.stderr @@ -1,11 +1,9 @@ -error[E0434]: can't capture dynamic environment in a fn item +error[E0435]: attempt to use a non-constant value in a constant --> $DIR/issue-3668.rs:8:34 | LL | static childVal: Box

    = self.child.get(); - | ^^^^ - | - = help: use the `|| { ... }` closure form instead + | ^^^^ non-constant value error: aborting due to previous error -For more information about this error, try `rustc --explain E0434`. +For more information about this error, try `rustc --explain E0435`. diff --git a/src/test/ui/type/type-dependent-def-issue-49241.rs b/src/test/ui/type/type-dependent-def-issue-49241.rs index 4c366a863637c..51bd116fbd61c 100644 --- a/src/test/ui/type/type-dependent-def-issue-49241.rs +++ b/src/test/ui/type/type-dependent-def-issue-49241.rs @@ -1,6 +1,6 @@ fn main() { let v = vec![0]; - const l: usize = v.count(); //~ ERROR can't capture dynamic environment in a fn item + const l: usize = v.count(); //~ ERROR attempt to use a non-constant value in a constant let s: [u32; l] = v.into_iter().collect(); //~^ ERROR evaluation of constant value failed } diff --git a/src/test/ui/type/type-dependent-def-issue-49241.stderr b/src/test/ui/type/type-dependent-def-issue-49241.stderr index 8783959f45f5f..0af777fdcf907 100644 --- a/src/test/ui/type/type-dependent-def-issue-49241.stderr +++ b/src/test/ui/type/type-dependent-def-issue-49241.stderr @@ -1,10 +1,8 @@ -error[E0434]: can't capture dynamic environment in a fn item +error[E0435]: attempt to use a non-constant value in a constant --> $DIR/type-dependent-def-issue-49241.rs:3:22 | -LL | const l: usize = v.count(); //~ ERROR can't capture dynamic environment in a fn item - | ^ - | - = help: use the `|| { ... }` closure form instead +LL | const l: usize = v.count(); //~ ERROR attempt to use a non-constant value in a constant + | ^ non-constant value error[E0080]: evaluation of constant value failed --> $DIR/type-dependent-def-issue-49241.rs:4:18 @@ -14,5 +12,5 @@ LL | let s: [u32; l] = v.into_iter().collect(); error: aborting due to 2 previous errors -Some errors occurred: E0080, E0434. +Some errors occurred: E0080, E0435. For more information about an error, try `rustc --explain E0080`. From 5681b91fa66213677390820f45339b81c2f4eead Mon Sep 17 00:00:00 2001 From: Pietro Albini Date: Sat, 8 Dec 2018 12:45:13 +0100 Subject: [PATCH 175/278] unused_imports: make the lint machine-applicable --- src/librustc/lint/builtin.rs | 10 ++ src/librustc_resolve/check_unused.rs | 203 ++++++++++++++++++++++++--- 2 files changed, 191 insertions(+), 22 deletions(-) diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 6ae7448645a20..a659f7e9b3440 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -467,6 +467,7 @@ pub enum BuiltinLintDiagnostics { MacroExpandedMacroExportsAccessedByAbsolutePaths(Span), ElidedLifetimesInPaths(usize, Span, bool, Span, String), UnknownCrateTypes(Span, String, String), + UnusedImports(String, Vec<(Span, String)>), } impl BuiltinLintDiagnostics { @@ -548,6 +549,15 @@ impl BuiltinLintDiagnostics { BuiltinLintDiagnostics::UnknownCrateTypes(span, note, sugg) => { db.span_suggestion(span, ¬e, sugg, Applicability::MaybeIncorrect); } + BuiltinLintDiagnostics::UnusedImports(message, replaces) => { + if !replaces.is_empty() { + db.multipart_suggestion( + &message, + replaces, + Applicability::MachineApplicable, + ); + } + } } } } diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs index 639960827c996..3b6179f78558b 100644 --- a/src/librustc_resolve/check_unused.rs +++ b/src/librustc_resolve/check_unused.rs @@ -7,23 +7,52 @@ // // Unused trait imports can't be checked until the method resolution. We save // candidates here, and do the actual check in librustc_typeck/check_unused.rs. +// +// Checking for unused imports is split into three steps: +// +// - `UnusedImportCheckVisitor` walks the AST to find all the unused imports +// inside of `UseTree`s, recording their `NodeId`s and grouping them by +// the parent `use` item +// +// - `calc_unused_spans` then walks over all the `use` items marked in the +// previous step to collect the spans associated with the `NodeId`s and to +// calculate the spans that can be removed by rustfix; This is done in a +// separate step to be able to collapse the adjacent spans that rustfix +// will remove +// +// - `check_crate` finally emits the diagnostics based on the data generated +// in the last step use std::ops::{Deref, DerefMut}; use crate::Resolver; use crate::resolve_imports::ImportDirectiveSubclass; -use rustc::{lint, ty}; use rustc::util::nodemap::NodeMap; +use rustc::{lint, ty}; +use rustc_data_structures::fx::FxHashSet; use syntax::ast; use syntax::visit::{self, Visitor}; use syntax_pos::{Span, MultiSpan, DUMMY_SP}; +struct UnusedImport<'a> { + use_tree: &'a ast::UseTree, + use_tree_id: ast::NodeId, + item_span: Span, + unused: FxHashSet, +} + +impl<'a> UnusedImport<'a> { + fn add(&mut self, id: ast::NodeId) { + self.unused.insert(id); + } +} struct UnusedImportCheckVisitor<'a, 'b: 'a> { resolver: &'a mut Resolver<'b>, /// All the (so far) unused imports, grouped path list - unused_imports: NodeMap>, + unused_imports: NodeMap>, + base_use_tree: Option<&'a ast::UseTree>, base_id: ast::NodeId, item_span: Span, } @@ -46,7 +75,7 @@ impl<'a, 'b> DerefMut for UnusedImportCheckVisitor<'a, 'b> { impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> { // We have information about whether `use` (import) directives are actually // used now. If an import is not used at all, we signal a lint error. - fn check_import(&mut self, item_id: ast::NodeId, id: ast::NodeId, span: Span) { + fn check_import(&mut self, id: ast::NodeId) { let mut used = false; self.per_ns(|this, ns| used |= this.used_imports.contains(&(id, ns))); if !used { @@ -54,16 +83,31 @@ impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> { // Check later. return; } - self.unused_imports.entry(item_id).or_default().insert(id, span); + self.unused_import(self.base_id).add(id); } else { // This trait import is definitely used, in a way other than // method resolution. self.maybe_unused_trait_imports.remove(&id); - if let Some(i) = self.unused_imports.get_mut(&item_id) { - i.remove(&id); + if let Some(i) = self.unused_imports.get_mut(&self.base_id) { + i.unused.remove(&id); } } } + + fn unused_import(&mut self, id: ast::NodeId) -> &mut UnusedImport<'a> { + let use_tree_id = self.base_id; + let use_tree = self.base_use_tree.unwrap(); + let item_span = self.item_span; + + self.unused_imports + .entry(id) + .or_insert_with(|| UnusedImport { + use_tree, + use_tree_id, + item_span, + unused: FxHashSet::default(), + }) + } } impl<'a, 'b> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b> { @@ -88,31 +132,112 @@ impl<'a, 'b> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b> { // This allows the grouping of all the lints in the same item if !nested { self.base_id = id; + self.base_use_tree = Some(use_tree); } if let ast::UseTreeKind::Nested(ref items) = use_tree.kind { - // If it's the parent group, cover the entire use item - let span = if nested { - use_tree.span - } else { - self.item_span - }; - if items.is_empty() { - self.unused_imports - .entry(self.base_id) - .or_default() - .insert(id, span); + self.unused_import(self.base_id).add(id); } } else { - let base_id = self.base_id; - self.check_import(base_id, id, use_tree.span); + self.check_import(id); } visit::walk_use_tree(self, use_tree, id); } } +enum UnusedSpanResult { + Used, + FlatUnused(Span, Span), + NestedFullUnused(Vec, Span), + NestedPartialUnused(Vec, Vec), +} + +fn calc_unused_spans( + unused_import: &UnusedImport<'_>, + use_tree: &ast::UseTree, + use_tree_id: ast::NodeId, +) -> UnusedSpanResult { + // The full span is the whole item's span if this current tree is not nested inside another + // This tells rustfix to remove the whole item if all the imports are unused + let full_span = if unused_import.use_tree.span == use_tree.span { + unused_import.item_span + } else { + use_tree.span + }; + match use_tree.kind { + ast::UseTreeKind::Simple(..) | ast::UseTreeKind::Glob => { + if unused_import.unused.contains(&use_tree_id) { + UnusedSpanResult::FlatUnused(use_tree.span, full_span) + } else { + UnusedSpanResult::Used + } + } + ast::UseTreeKind::Nested(ref nested) => { + if nested.len() == 0 { + return UnusedSpanResult::FlatUnused(use_tree.span, full_span); + } + + let mut unused_spans = Vec::new(); + let mut to_remove = Vec::new(); + let mut all_nested_unused = true; + let mut previous_unused = false; + for (pos, (use_tree, use_tree_id)) in nested.iter().enumerate() { + let remove = match calc_unused_spans(unused_import, use_tree, *use_tree_id) { + UnusedSpanResult::Used => { + all_nested_unused = false; + None + } + UnusedSpanResult::FlatUnused(span, remove) => { + unused_spans.push(span); + Some(remove) + } + UnusedSpanResult::NestedFullUnused(mut spans, remove) => { + unused_spans.append(&mut spans); + Some(remove) + } + UnusedSpanResult::NestedPartialUnused(mut spans, mut to_remove_extra) => { + all_nested_unused = false; + unused_spans.append(&mut spans); + to_remove.append(&mut to_remove_extra); + None + } + }; + if let Some(remove) = remove { + let remove_span = if nested.len() == 1 { + remove + } else if pos == nested.len() - 1 || !all_nested_unused { + // Delete everything from the end of the last import, to delete the + // previous comma + nested[pos - 1].0.span.shrink_to_hi().to(use_tree.span) + } else { + // Delete everything until the next import, to delete the trailing commas + use_tree.span.to(nested[pos + 1].0.span.shrink_to_lo()) + }; + + // Try to collapse adjacent spans into a single one. This prevents all cases of + // overlapping removals, which are not supported by rustfix + if previous_unused && !to_remove.is_empty() { + let previous = to_remove.pop().unwrap(); + to_remove.push(previous.to(remove_span)); + } else { + to_remove.push(remove_span); + } + } + previous_unused = remove.is_some(); + } + if unused_spans.is_empty() { + UnusedSpanResult::Used + } else if all_nested_unused { + UnusedSpanResult::NestedFullUnused(unused_spans, full_span) + } else { + UnusedSpanResult::NestedPartialUnused(unused_spans, to_remove) + } + } + } +} + pub fn check_crate(resolver: &mut Resolver<'_>, krate: &ast::Crate) { for directive in resolver.potentially_unused_imports.iter() { match directive.subclass { @@ -152,14 +277,33 @@ pub fn check_crate(resolver: &mut Resolver<'_>, krate: &ast::Crate) { let mut visitor = UnusedImportCheckVisitor { resolver, unused_imports: Default::default(), + base_use_tree: None, base_id: ast::DUMMY_NODE_ID, item_span: DUMMY_SP, }; visit::walk_crate(&mut visitor, krate); - for (id, spans) in &visitor.unused_imports { + for unused in visitor.unused_imports.values() { + let mut fixes = Vec::new(); + let mut spans = match calc_unused_spans(unused, unused.use_tree, unused.use_tree_id) { + UnusedSpanResult::Used => continue, + UnusedSpanResult::FlatUnused(span, remove) => { + fixes.push((remove, String::new())); + vec![span] + } + UnusedSpanResult::NestedFullUnused(spans, remove) => { + fixes.push((remove, String::new())); + spans + } + UnusedSpanResult::NestedPartialUnused(spans, remove) => { + for fix in &remove { + fixes.push((*fix, String::new())); + } + spans + } + }; + let len = spans.len(); - let mut spans = spans.values().cloned().collect::>(); spans.sort(); let ms = MultiSpan::from_spans(spans.clone()); let mut span_snippets = spans.iter() @@ -177,6 +321,21 @@ pub fn check_crate(resolver: &mut Resolver<'_>, krate: &ast::Crate) { } else { String::new() }); - visitor.session.buffer_lint(lint::builtin::UNUSED_IMPORTS, *id, ms, &msg); + + let fix_msg = if fixes.len() == 1 && fixes[0].0 == unused.item_span { + "remove the whole `use` item" + } else if spans.len() > 1 { + "remove the unused imports" + } else { + "remove the unused import" + }; + + visitor.session.buffer_lint_with_diagnostic( + lint::builtin::UNUSED_IMPORTS, + unused.use_tree_id, + ms, + &msg, + lint::builtin::BuiltinLintDiagnostics::UnusedImports(fix_msg.into(), fixes), + ); } } From 81613ad7cf9889a59d0a7233af9e462715945a72 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Thu, 7 Feb 2019 18:23:44 +0100 Subject: [PATCH 176/278] disable tests in Miri --- src/liballoc/tests/arc.rs | 2 ++ src/liballoc/tests/binary_heap.rs | 1 + src/liballoc/tests/btree/mod.rs | 2 ++ src/liballoc/tests/heap.rs | 2 ++ src/liballoc/tests/rc.rs | 2 ++ src/liballoc/tests/slice.rs | 2 ++ src/liballoc/tests/str.rs | 21 +++++++++++++++++++++ src/liballoc/tests/string.rs | 2 ++ src/liballoc/tests/vec.rs | 2 ++ src/liballoc/tests/vec_deque.rs | 7 +++++++ src/libcore/tests/cell.rs | 2 ++ src/libcore/tests/fmt/mod.rs | 2 ++ src/libcore/tests/hash/mod.rs | 2 ++ src/libcore/tests/iter.rs | 8 ++++++++ src/libcore/tests/num/mod.rs | 2 ++ src/libcore/tests/option.rs | 3 +++ src/libcore/tests/ptr.rs | 2 ++ src/libcore/tests/result.rs | 3 +++ src/libcore/tests/slice.rs | 12 ++++++++++++ src/libcore/tests/time.rs | 2 ++ 20 files changed, 81 insertions(+) diff --git a/src/liballoc/tests/arc.rs b/src/liballoc/tests/arc.rs index 2759b1b1cac27..7c5a8926126e3 100644 --- a/src/liballoc/tests/arc.rs +++ b/src/liballoc/tests/arc.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + use std::any::Any; use std::sync::{Arc, Weak}; use std::cell::RefCell; diff --git a/src/liballoc/tests/binary_heap.rs b/src/liballoc/tests/binary_heap.rs index 94ae43237d19c..c1a1c5d88781f 100644 --- a/src/liballoc/tests/binary_heap.rs +++ b/src/liballoc/tests/binary_heap.rs @@ -282,6 +282,7 @@ fn assert_covariance() { // // Destructors must be called exactly once per element. #[test] +#[cfg(not(miri))] fn panic_safe() { static DROP_COUNTER: AtomicUsize = AtomicUsize::new(0); diff --git a/src/liballoc/tests/btree/mod.rs b/src/liballoc/tests/btree/mod.rs index 4c704d0f8c28f..653b3f5bcb49d 100644 --- a/src/liballoc/tests/btree/mod.rs +++ b/src/liballoc/tests/btree/mod.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + mod map; mod set; diff --git a/src/liballoc/tests/heap.rs b/src/liballoc/tests/heap.rs index 24eea1d294965..809d2bc094aee 100644 --- a/src/liballoc/tests/heap.rs +++ b/src/liballoc/tests/heap.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + use std::alloc::{Global, Alloc, Layout, System}; /// https://github.com/rust-lang/rust/issues/45955 diff --git a/src/liballoc/tests/rc.rs b/src/liballoc/tests/rc.rs index 18f82e8041008..1be01d1a7ce1a 100644 --- a/src/liballoc/tests/rc.rs +++ b/src/liballoc/tests/rc.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + use std::any::Any; use std::rc::{Rc, Weak}; use std::cell::RefCell; diff --git a/src/liballoc/tests/slice.rs b/src/liballoc/tests/slice.rs index 0300bd7f3f6d4..6d4a30fc36c7a 100644 --- a/src/liballoc/tests/slice.rs +++ b/src/liballoc/tests/slice.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + use std::cell::Cell; use std::cmp::Ordering::{Equal, Greater, Less}; use std::cmp::Ordering; diff --git a/src/liballoc/tests/str.rs b/src/liballoc/tests/str.rs index 66a1b947a7d3a..b63945ffe972f 100644 --- a/src/liballoc/tests/str.rs +++ b/src/liballoc/tests/str.rs @@ -31,6 +31,7 @@ fn test_rfind() { } #[test] +#[cfg(not(miri))] fn test_collect() { let empty = ""; let s: String = empty.chars().collect(); @@ -118,6 +119,7 @@ fn test_concat_for_different_types() { #[test] fn test_concat_for_different_lengths() { let empty: &[&str] = &[]; + #[cfg(not(miri))] test_concat!("", empty); test_concat!("a", ["a"]); test_concat!("ab", ["a", "b"]); @@ -146,6 +148,7 @@ fn test_join_for_different_types() { #[test] fn test_join_for_different_lengths() { let empty: &[&str] = &[]; + #[cfg(not(miri))] test_join!("", empty, "-"); test_join!("a", ["a"], "-"); test_join!("a-b", ["a", "b"], "-"); @@ -159,6 +162,7 @@ fn test_join_for_different_lengths_with_long_separator() { assert_eq!("～～～～～".len(), 15); let empty: &[&str] = &[]; + #[cfg(not(miri))] test_join!("", empty, "～～～～～"); test_join!("a", ["a"], "～～～～～"); test_join!("a～～～～～b", ["a", "b"], "～～～～～"); @@ -166,6 +170,7 @@ fn test_join_for_different_lengths_with_long_separator() { } #[test] +#[cfg(not(miri))] fn test_unsafe_slice() { assert_eq!("ab", unsafe {"abc".get_unchecked(0..2)}); assert_eq!("bc", unsafe {"abc".get_unchecked(1..3)}); @@ -238,6 +243,7 @@ fn test_replacen() { #[test] fn test_replace() { let a = "a"; + #[cfg(not(miri))] assert_eq!("".replace(a, "b"), ""); assert_eq!("a".replace(a, "b"), "b"); assert_eq!("ab".replace(a, "b"), "bb"); @@ -297,6 +303,7 @@ fn test_replace_pattern() { // The current implementation of SliceIndex fails to handle methods // orthogonally from range types; therefore, it is worth testing // all of the indexing operations on each input. +#[cfg(not(miri))] mod slice_index { // Test a slicing operation **that should succeed,** // testing it on all of the indexing methods. @@ -679,6 +686,7 @@ fn test_str_slice_rangetoinclusive_ok() { #[test] #[should_panic] +#[cfg(not(miri))] fn test_str_slice_rangetoinclusive_notok() { let s = "abcαβγ"; &s[..=3]; @@ -694,6 +702,7 @@ fn test_str_slicemut_rangetoinclusive_ok() { #[test] #[should_panic] +#[cfg(not(miri))] fn test_str_slicemut_rangetoinclusive_notok() { let mut s = "abcαβγ".to_owned(); let s: &mut str = &mut s; @@ -883,6 +892,7 @@ fn test_as_bytes() { #[test] #[should_panic] +#[cfg(not(miri))] fn test_as_bytes_fail() { // Don't double free. (I'm not sure if this exercises the // original problem code path anymore.) @@ -972,6 +982,7 @@ fn test_split_at_mut() { #[test] #[should_panic] +#[cfg(not(miri))] fn test_split_at_boundscheck() { let s = "ศไทย中华Việt Nam"; s.split_at(1); @@ -1066,6 +1077,7 @@ fn test_rev_iterator() { } #[test] +#[cfg(not(miri))] fn test_chars_decoding() { let mut bytes = [0; 4]; for c in (0..0x110000).filter_map(::std::char::from_u32) { @@ -1077,6 +1089,7 @@ fn test_chars_decoding() { } #[test] +#[cfg(not(miri))] fn test_chars_rev_decoding() { let mut bytes = [0; 4]; for c in (0..0x110000).filter_map(::std::char::from_u32) { @@ -1306,6 +1319,7 @@ fn test_splitator() { } #[test] +#[cfg(not(miri))] fn test_str_default() { use std::default::Default; @@ -1365,6 +1379,7 @@ fn test_bool_from_str() { assert_eq!("not even a boolean".parse::().ok(), None); } +#[cfg(not(miri))] fn check_contains_all_substrings(s: &str) { assert!(s.contains("")); for i in 0..s.len() { @@ -1375,6 +1390,7 @@ fn check_contains_all_substrings(s: &str) { } #[test] +#[cfg(not(miri))] fn strslice_issue_16589() { assert!("bananas".contains("nana")); @@ -1384,6 +1400,7 @@ fn strslice_issue_16589() { } #[test] +#[cfg(not(miri))] fn strslice_issue_16878() { assert!(!"1234567ah012345678901ah".contains("hah")); assert!(!"00abc01234567890123456789abc".contains("bcabc")); @@ -1391,6 +1408,7 @@ fn strslice_issue_16878() { #[test] +#[cfg(not(miri))] fn test_strslice_contains() { let x = "There are moments, Jeeves, when one asks oneself, 'Do trousers matter?'"; check_contains_all_substrings(x); @@ -1528,6 +1546,7 @@ fn trim_ws() { #[test] fn to_lowercase() { + #[cfg(not(miri))] assert_eq!("".to_lowercase(), ""); assert_eq!("AÉDžaé ".to_lowercase(), "aédžaé "); @@ -1561,6 +1580,7 @@ fn to_lowercase() { #[test] fn to_uppercase() { + #[cfg(not(miri))] assert_eq!("".to_uppercase(), ""); assert_eq!("aéDžßfiᾀ".to_uppercase(), "AÉDŽSSFIἈΙ"); } @@ -1592,6 +1612,7 @@ fn test_cow_from() { } #[test] +#[cfg(not(miri))] fn test_repeat() { assert_eq!("".repeat(3), ""); assert_eq!("abc".repeat(0), ""); diff --git a/src/liballoc/tests/string.rs b/src/liballoc/tests/string.rs index 8a5bfca8b7db5..7a03848a776e6 100644 --- a/src/liballoc/tests/string.rs +++ b/src/liballoc/tests/string.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + use std::borrow::Cow; use std::collections::CollectionAllocErr::*; use std::mem::size_of; diff --git a/src/liballoc/tests/vec.rs b/src/liballoc/tests/vec.rs index 0fdcf34c783a8..b214051e4883f 100644 --- a/src/liballoc/tests/vec.rs +++ b/src/liballoc/tests/vec.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + use std::borrow::Cow; use std::mem::size_of; use std::{usize, isize}; diff --git a/src/liballoc/tests/vec_deque.rs b/src/liballoc/tests/vec_deque.rs index c9d16a06b4773..43b7351ef3299 100644 --- a/src/liballoc/tests/vec_deque.rs +++ b/src/liballoc/tests/vec_deque.rs @@ -107,6 +107,7 @@ fn test_index() { #[test] #[should_panic] +#[cfg(not(miri))] fn test_index_out_of_bounds() { let mut deq = VecDeque::new(); for i in 1..4 { @@ -905,20 +906,24 @@ fn test_append() { // normal append a.append(&mut b); assert_eq!(a.iter().cloned().collect::>(), [1, 2, 3, 4, 5, 6]); + #[cfg(not(miri))] assert_eq!(b.iter().cloned().collect::>(), []); // append nothing to something a.append(&mut b); assert_eq!(a.iter().cloned().collect::>(), [1, 2, 3, 4, 5, 6]); + #[cfg(not(miri))] assert_eq!(b.iter().cloned().collect::>(), []); // append something to nothing b.append(&mut a); assert_eq!(b.iter().cloned().collect::>(), [1, 2, 3, 4, 5, 6]); + #[cfg(not(miri))] assert_eq!(a.iter().cloned().collect::>(), []); } #[test] +#[cfg(not(miri))] fn test_append_permutations() { fn construct_vec_deque( push_back: usize, @@ -1119,6 +1124,7 @@ fn test_reserve_exact_2() { } #[test] +#[cfg(not(miri))] fn test_try_reserve() { // These are the interesting cases: @@ -1220,6 +1226,7 @@ fn test_try_reserve() { } #[test] +#[cfg(not(miri))] fn test_try_reserve_exact() { // This is exactly the same as test_try_reserve with the method changed. diff --git a/src/libcore/tests/cell.rs b/src/libcore/tests/cell.rs index 56f295dff8e43..73bdaab5861e6 100644 --- a/src/libcore/tests/cell.rs +++ b/src/libcore/tests/cell.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + use core::cell::*; use core::default::Default; use std::mem::drop; diff --git a/src/libcore/tests/fmt/mod.rs b/src/libcore/tests/fmt/mod.rs index d86e21cf40b6e..b10b63fc484cb 100644 --- a/src/libcore/tests/fmt/mod.rs +++ b/src/libcore/tests/fmt/mod.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + mod builders; mod float; mod num; diff --git a/src/libcore/tests/hash/mod.rs b/src/libcore/tests/hash/mod.rs index 135f4dfcac7d5..bf3039a7e51e8 100644 --- a/src/libcore/tests/hash/mod.rs +++ b/src/libcore/tests/hash/mod.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + mod sip; use std::hash::{Hash, Hasher}; diff --git a/src/libcore/tests/iter.rs b/src/libcore/tests/iter.rs index 0fa99745d9065..9b4c78f8d3b02 100644 --- a/src/libcore/tests/iter.rs +++ b/src/libcore/tests/iter.rs @@ -190,6 +190,7 @@ fn test_iterator_step_by() { } #[test] +#[cfg(not(miri))] fn test_iterator_step_by_nth() { let mut it = (0..16).step_by(5); assert_eq!(it.nth(0), Some(0)); @@ -208,6 +209,7 @@ fn test_iterator_step_by_nth() { } #[test] +#[cfg(not(miri))] fn test_iterator_step_by_nth_overflow() { #[cfg(target_pointer_width = "8")] type Bigger = u16; @@ -253,12 +255,14 @@ fn test_iterator_step_by_nth_overflow() { #[test] #[should_panic] +#[cfg(not(miri))] fn test_iterator_step_by_zero() { let mut it = (0..).step_by(0); it.next(); } #[test] +#[cfg(not(miri))] fn test_iterator_step_by_size_hint() { struct StubSizeHint(usize, Option); impl Iterator for StubSizeHint { @@ -1413,6 +1417,7 @@ fn test_rposition() { #[test] #[should_panic] +#[cfg(not(miri))] fn test_rposition_panic() { let v: [(Box<_>, Box<_>); 4] = [(box 0, box 0), (box 0, box 0), @@ -1652,6 +1657,7 @@ fn test_range_inclusive_nth() { } #[test] +#[cfg(not(miri))] fn test_range_step() { #![allow(deprecated)] @@ -1675,6 +1681,7 @@ fn test_range_step() { } #[test] +#[cfg(not(miri))] fn test_step_by_skip() { assert_eq!((0..640).step_by(128).skip(1).collect::>(), [128, 256, 384, 512]); assert_eq!((0..=50).step_by(10).nth(3), Some(30)); @@ -1682,6 +1689,7 @@ fn test_step_by_skip() { } #[test] +#[cfg(not(miri))] fn test_range_inclusive_step() { assert_eq!((0..=50).step_by(10).collect::>(), [0, 10, 20, 30, 40, 50]); assert_eq!((0..=5).step_by(1).collect::>(), [0, 1, 2, 3, 4, 5]); diff --git a/src/libcore/tests/num/mod.rs b/src/libcore/tests/num/mod.rs index a17c094679ea8..ab638e06cc10d 100644 --- a/src/libcore/tests/num/mod.rs +++ b/src/libcore/tests/num/mod.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + use core::convert::{TryFrom, TryInto}; use core::cmp::PartialEq; use core::fmt::Debug; diff --git a/src/libcore/tests/option.rs b/src/libcore/tests/option.rs index b059b134868d9..1ba886ce037ee 100644 --- a/src/libcore/tests/option.rs +++ b/src/libcore/tests/option.rs @@ -69,6 +69,7 @@ fn test_option_dance() { } #[test] #[should_panic] +#[cfg(not(miri))] fn test_option_too_much_dance() { struct A; let mut y = Some(A); @@ -129,6 +130,7 @@ fn test_unwrap() { #[test] #[should_panic] +#[cfg(not(miri))] fn test_unwrap_panic1() { let x: Option = None; x.unwrap(); @@ -136,6 +138,7 @@ fn test_unwrap_panic1() { #[test] #[should_panic] +#[cfg(not(miri))] fn test_unwrap_panic2() { let x: Option = None; x.unwrap(); diff --git a/src/libcore/tests/ptr.rs b/src/libcore/tests/ptr.rs index 65c1a3e0254d2..5784559082266 100644 --- a/src/libcore/tests/ptr.rs +++ b/src/libcore/tests/ptr.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + use core::ptr::*; use core::cell::RefCell; diff --git a/src/libcore/tests/result.rs b/src/libcore/tests/result.rs index 1fab07526a07f..7bfd396f68d17 100644 --- a/src/libcore/tests/result.rs +++ b/src/libcore/tests/result.rs @@ -117,6 +117,7 @@ fn test_unwrap_or_else() { #[test] #[should_panic] +#[cfg(not(miri))] pub fn test_unwrap_or_else_panic() { fn handler(msg: &'static str) -> isize { if msg == "I got this." { @@ -138,6 +139,7 @@ pub fn test_expect_ok() { } #[test] #[should_panic(expected="Got expected error: \"All good\"")] +#[cfg(not(miri))] pub fn test_expect_err() { let err: Result = Err("All good"); err.expect("Got expected error"); @@ -151,6 +153,7 @@ pub fn test_expect_err_err() { } #[test] #[should_panic(expected="Got expected ok: \"All good\"")] +#[cfg(not(miri))] pub fn test_expect_err_ok() { let err: Result<&'static str, isize> = Ok("All good"); err.expect_err("Got expected ok"); diff --git a/src/libcore/tests/slice.rs b/src/libcore/tests/slice.rs index e210e83122c47..04d646ea01d03 100644 --- a/src/libcore/tests/slice.rs +++ b/src/libcore/tests/slice.rs @@ -782,6 +782,7 @@ mod slice_index { // to be used in `should_panic`) #[test] #[should_panic(expected = "out of range")] + #[cfg(not(miri))] fn assert_range_eq_can_fail_by_panic() { assert_range_eq!([0, 1, 2], 0..5, [0, 1, 2]); } @@ -791,6 +792,7 @@ mod slice_index { // to be used in `should_panic`) #[test] #[should_panic(expected = "==")] + #[cfg(not(miri))] fn assert_range_eq_can_fail_by_inequality() { assert_range_eq!([0, 1, 2], 0..2, [0, 1, 2]); } @@ -840,6 +842,7 @@ mod slice_index { #[test] #[should_panic(expected = $expect_msg)] + #[cfg(not(miri))] fn index_fail() { let v = $data; let v: &[_] = &v; @@ -848,6 +851,7 @@ mod slice_index { #[test] #[should_panic(expected = $expect_msg)] + #[cfg(not(miri))] fn index_mut_fail() { let mut v = $data; let v: &mut [_] = &mut v; @@ -1011,6 +1015,7 @@ fn test_rotate_right() { #[test] #[cfg(not(target_arch = "wasm32"))] +#[cfg(not(miri))] fn sort_unstable() { use core::cmp::Ordering::{Equal, Greater, Less}; use core::slice::heapsort; @@ -1166,6 +1171,7 @@ pub mod memchr { } #[test] +#[cfg(not(miri))] fn test_align_to_simple() { let bytes = [1u8, 2, 3, 4, 5, 6, 7]; let (prefix, aligned, suffix) = unsafe { bytes.align_to::() }; @@ -1181,6 +1187,7 @@ fn test_align_to_simple() { } #[test] +#[cfg(not(miri))] fn test_align_to_zst() { let bytes = [1, 2, 3, 4, 5, 6, 7]; let (prefix, aligned, suffix) = unsafe { bytes.align_to::<()>() }; @@ -1189,6 +1196,7 @@ fn test_align_to_zst() { } #[test] +#[cfg(not(miri))] fn test_align_to_non_trivial() { #[repr(align(8))] struct U64(u64, u64); #[repr(align(8))] struct U64U64U32(u64, u64, u32); @@ -1200,6 +1208,7 @@ fn test_align_to_non_trivial() { } #[test] +#[cfg(not(miri))] fn test_align_to_empty_mid() { use core::mem; @@ -1297,6 +1306,7 @@ fn test_copy_within() { #[test] #[should_panic(expected = "src is out of bounds")] +#[cfg(not(miri))] fn test_copy_within_panics_src_too_long() { let mut bytes = *b"Hello, World!"; // The length is only 13, so 14 is out of bounds. @@ -1305,6 +1315,7 @@ fn test_copy_within_panics_src_too_long() { #[test] #[should_panic(expected = "dest is out of bounds")] +#[cfg(not(miri))] fn test_copy_within_panics_dest_too_long() { let mut bytes = *b"Hello, World!"; // The length is only 13, so a slice of length 4 starting at index 10 is out of bounds. @@ -1312,6 +1323,7 @@ fn test_copy_within_panics_dest_too_long() { } #[test] #[should_panic(expected = "src end is before src start")] +#[cfg(not(miri))] fn test_copy_within_panics_src_inverted() { let mut bytes = *b"Hello, World!"; // 2 is greater than 1, so this range is invalid. diff --git a/src/libcore/tests/time.rs b/src/libcore/tests/time.rs index 6efd22572dc18..d39bd06930a36 100644 --- a/src/libcore/tests/time.rs +++ b/src/libcore/tests/time.rs @@ -1,3 +1,5 @@ +#![cfg(not(miri))] + use core::time::Duration; #[test] From 17998961d4d08d08be3cee5e09ca62b75b832f1a Mon Sep 17 00:00:00 2001 From: Patrick McCarter Date: Thu, 7 Feb 2019 13:12:17 -0500 Subject: [PATCH 177/278] Refactor const saturating intrinsics emulation and add unstable feature attribute #58030 --- src/libcore/num/mod.rs | 2 + src/librustc_mir/interpret/intrinsics.rs | 64 ++++++++----------- .../run-pass/const-int-saturating-arith.rs | 2 + 3 files changed, 29 insertions(+), 39 deletions(-) diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 104b124bad491..d4fade7613848 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -909,6 +909,7 @@ $EndFeature, " ```"), #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_saturating_int_methods")] #[inline] #[cfg(not(stage0))] pub const fn saturating_add(self, rhs: Self) -> Self { @@ -957,6 +958,7 @@ assert_eq!(", stringify!($SelfT), "::min_value().saturating_sub(100), ", stringi $EndFeature, " ```"), #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_saturating_int_methods")] #[inline] #[cfg(not(stage0))] pub const fn saturating_sub(self, rhs: Self) -> Self { diff --git a/src/librustc_mir/interpret/intrinsics.rs b/src/librustc_mir/interpret/intrinsics.rs index 5ec18d133c665..e8dc22b8a596f 100644 --- a/src/librustc_mir/interpret/intrinsics.rs +++ b/src/librustc_mir/interpret/intrinsics.rs @@ -122,55 +122,41 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> self.binop_with_overflow(bin_op, lhs, rhs, dest)?; } } - "saturating_add" => { + "saturating_add" | "saturating_sub" => { let l = self.read_immediate(args[0])?; let r = self.read_immediate(args[1])?; - let (val, overflowed) = self.binary_op_imm(BinOp::Add, l, r)?; - if overflowed { - let first_term: u128 = l.to_scalar()?.to_bits(l.layout.size)?; - let num_bits = l.layout.size.bits(); - let val = if l.layout.abi.is_signed() { - // For signed addition the saturated value depends on the - // sign of either term - if first_term & (1 << (num_bits-1)) == 0 { // signed term is positive - Scalar::from_uint((1u128 << (num_bits - 1)) - 1, - Size::from_bits(num_bits)) - } else { // signed term is negative - Scalar::from_uint(1u128 << (num_bits - 1), Size::from_bits(num_bits)) - } - } else { - Scalar::from_uint(u128::max_value() >> (128 - num_bits), - Size::from_bits(num_bits)) - }; - self.write_scalar(val, dest)?; + let is_add = intrinsic_name == "saturating_add"; + let (val, overflowed) = self.binary_op_imm(if is_add { + BinOp::Add } else { - self.write_scalar(val, dest)?; - } - } - "saturating_sub" => { - let l = self.read_immediate(args[0])?; - let r = self.read_immediate(args[1])?; - let (val, overflowed) = self.binary_op_imm(BinOp::Sub, l, r)?; - if overflowed { + BinOp::Sub + }, l, r)?; + let val = if overflowed { + // For signed ints the saturated value depends on the + // sign of the first term let first_term: u128 = l.to_scalar()?.to_bits(l.layout.size)?; let num_bits = l.layout.size.bits(); - let val = if l.layout.abi.is_signed() { + if l.layout.abi.is_signed() { if first_term & (1 << (num_bits-1)) == 0 { // first term is positive - // so overflow is positive - Scalar::from_uint((1u128 << (num_bits - 1)) - 1, + Scalar::from_uint((1u128 << (num_bits - 1)) - 1, // max positive Size::from_bits(num_bits)) - } else { - // if first term negative, overflow must be negative + } else { // first term is negative + // max negative Scalar::from_uint(1u128 << (num_bits - 1), Size::from_bits(num_bits)) } - } else { - // unsigned underflow saturates to 0 - Scalar::from_uint(0u128, Size::from_bits(num_bits)) - }; - self.write_scalar(val, dest)?; + } else { // unsigned + if is_add { + // max unsigned + Scalar::from_uint(u128::max_value() >> (128 - num_bits), + Size::from_bits(num_bits)) + } else { // underflow to 0 + Scalar::from_uint(0u128, Size::from_bits(num_bits)) + } + } } else { - self.write_scalar(val, dest)?; - } + val + }; + self.write_scalar(val, dest)?; } "unchecked_shl" | "unchecked_shr" => { let l = self.read_immediate(args[0])?; diff --git a/src/test/run-pass/const-int-saturating-arith.rs b/src/test/run-pass/const-int-saturating-arith.rs index 92372e073cf2e..4f586a276f0d2 100644 --- a/src/test/run-pass/const-int-saturating-arith.rs +++ b/src/test/run-pass/const-int-saturating-arith.rs @@ -1,3 +1,5 @@ +#![feature(const_saturating_int_methods)] + const INT_U32_NO: u32 = (42 as u32).saturating_add(2); const INT_U32: u32 = u32::max_value().saturating_add(1); const INT_U128: u128 = u128::max_value().saturating_add(1); From 1b41c9a42e3d5231df8621ae4b900cddecc12a75 Mon Sep 17 00:00:00 2001 From: mark Date: Mon, 14 Jan 2019 19:14:02 -0600 Subject: [PATCH 178/278] error on duplicate matcher bindings --- src/libsyntax/ext/tt/macro_rules.rs | 54 ++++++++++++++++++++++++++--- 1 file changed, 49 insertions(+), 5 deletions(-) diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index b3ecaeaedbb7a..61a5b2cb0d200 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -17,10 +17,10 @@ use crate::parse::token::Token::*; use crate::symbol::Symbol; use crate::tokenstream::{DelimSpan, TokenStream, TokenTree}; -use syntax_pos::{Span, DUMMY_SP}; +use syntax_pos::{Span, DUMMY_SP, symbol::Ident}; use log::debug; -use rustc_data_structures::fx::FxHashMap; +use rustc_data_structures::fx::{FxHashMap}; use std::borrow::Cow; use std::collections::hash_map::Entry; @@ -246,8 +246,12 @@ fn generic_extension<'cx>(cx: &'cx mut ExtCtxt<'_>, // Holy self-referential! /// Converts a `macro_rules!` invocation into a syntax extension. -pub fn compile(sess: &ParseSess, features: &Features, def: &ast::Item, edition: Edition) - -> SyntaxExtension { +pub fn compile( + sess: &ParseSess, + features: &Features, + def: &ast::Item, + edition: Edition +) -> SyntaxExtension { let lhs_nm = ast::Ident::with_empty_ctxt(Symbol::gensym("lhs")); let rhs_nm = ast::Ident::with_empty_ctxt(Symbol::gensym("rhs")); @@ -355,7 +359,9 @@ pub fn compile(sess: &ParseSess, features: &Features, def: &ast::Item, edition: // don't abort iteration early, so that errors for multiple lhses can be reported for lhs in &lhses { - valid &= check_lhs_no_empty_seq(sess, &[lhs.clone()]) + valid &= check_lhs_no_empty_seq(sess, &[lhs.clone()]); + valid &= + check_lhs_duplicate_matcher_bindings(sess, &[lhs.clone()], &mut FxHashMap::default()); } let expander: Box<_> = Box::new(MacroRulesMacroExpander { @@ -456,6 +462,44 @@ fn check_lhs_no_empty_seq(sess: &ParseSess, tts: &[quoted::TokenTree]) -> bool { true } +/// Check that the LHS contains no duplicate matcher bindings. e.g. `$a:expr, $a:expr` would be +/// illegal, since it would be ambiguous which `$a` to use if we ever needed to. +fn check_lhs_duplicate_matcher_bindings( + sess: &ParseSess, + tts: &[quoted::TokenTree], + metavar_names: &mut FxHashMap +) -> bool { + use self::quoted::TokenTree; + for tt in tts { + match *tt { + TokenTree::MetaVarDecl(span, name, _kind) => { + if let Some(&prev_span) = metavar_names.get(&name) { + sess.span_diagnostic + .struct_span_err(span, "duplicate matcher binding") + .span_note(prev_span, "previous declaration was here") + .emit(); + return false; + } else { + metavar_names.insert(name, span); + } + } + TokenTree::Delimited(_, ref del) => { + if !check_lhs_duplicate_matcher_bindings(sess, &del.tts, metavar_names) { + return false; + } + }, + TokenTree::Sequence(_, ref seq) => { + if !check_lhs_duplicate_matcher_bindings(sess, &seq.tts, metavar_names) { + return false; + } + } + _ => {} + } + } + + true +} + fn check_rhs(sess: &ParseSess, rhs: "ed::TokenTree) -> bool { match *rhs { quoted::TokenTree::Delimited(..) => return true, From 1d94cc2a2249b65f62e78e4998761193c3bfed23 Mon Sep 17 00:00:00 2001 From: mark Date: Tue, 15 Jan 2019 12:25:41 -0600 Subject: [PATCH 179/278] fix existing tests --- src/test/run-pass/macros/macro-follow.rs | 16 ++++++------ src/test/ui/macros/macro-follow.rs | 16 ++++++------ src/test/ui/macros/macro-follow.stderr | 32 ++++++++++++------------ 3 files changed, 32 insertions(+), 32 deletions(-) diff --git a/src/test/run-pass/macros/macro-follow.rs b/src/test/run-pass/macros/macro-follow.rs index f90afce90ee30..488339b025dce 100644 --- a/src/test/run-pass/macros/macro-follow.rs +++ b/src/test/run-pass/macros/macro-follow.rs @@ -73,7 +73,7 @@ macro_rules! follow_block { ($b:block $t:ty) => {}; ($b:block $s:stmt) => {}; ($b:block $p:path) => {}; - ($b:block $b:block) => {}; + ($b:block $c:block) => {}; ($b:block $i:ident) => {}; ($b:block $t:tt) => {}; ($b:block $i:item) => {}; @@ -99,9 +99,9 @@ macro_rules! follow_ident { ($i:ident $s:stmt) => {}; ($i:ident $p:path) => {}; ($i:ident $b:block) => {}; - ($i:ident $i:ident) => {}; + ($i:ident $j:ident) => {}; ($i:ident $t:tt) => {}; - ($i:ident $i:item) => {}; + ($i:ident $j:item) => {}; ($i:ident $m:meta) => {}; } // FOLLOW(tt) = any token @@ -120,12 +120,12 @@ macro_rules! follow_tt { ($t:tt ident) => {}; ($t:tt $p:pat) => {}; ($t:tt $e:expr) => {}; - ($t:tt $t:ty) => {}; + ($t:tt $v:ty) => {}; ($t:tt $s:stmt) => {}; ($t:tt $p:path) => {}; ($t:tt $b:block) => {}; ($t:tt $i:ident) => {}; - ($t:tt $t:tt) => {}; + ($t:tt $v:tt) => {}; ($t:tt $i:item) => {}; ($t:tt $m:meta) => {}; } @@ -149,9 +149,9 @@ macro_rules! follow_item { ($i:item $s:stmt) => {}; ($i:item $p:path) => {}; ($i:item $b:block) => {}; - ($i:item $i:ident) => {}; + ($i:item $j:ident) => {}; ($i:item $t:tt) => {}; - ($i:item $i:item) => {}; + ($i:item $j:item) => {}; ($i:item $m:meta) => {}; } // FOLLOW(meta) = any token @@ -177,7 +177,7 @@ macro_rules! follow_meta { ($m:meta $i:ident) => {}; ($m:meta $t:tt) => {}; ($m:meta $i:item) => {}; - ($m:meta $m:meta) => {}; + ($m:meta $n:meta) => {}; } fn main() {} diff --git a/src/test/ui/macros/macro-follow.rs b/src/test/ui/macros/macro-follow.rs index f4a1931da5aec..10b44e0017532 100644 --- a/src/test/ui/macros/macro-follow.rs +++ b/src/test/ui/macros/macro-follow.rs @@ -12,11 +12,11 @@ macro_rules! follow_pat { ($p:pat >) => {}; //~ERROR `$p:pat` is followed by `>` ($p:pat +) => {}; //~ERROR `$p:pat` is followed by `+` ($p:pat ident) => {}; //~ERROR `$p:pat` is followed by `ident` - ($p:pat $p:pat) => {}; //~ERROR `$p:pat` is followed by `$p:pat` + ($p:pat $q:pat) => {}; //~ERROR `$p:pat` is followed by `$q:pat` ($p:pat $e:expr) => {}; //~ERROR `$p:pat` is followed by `$e:expr` ($p:pat $t:ty) => {}; //~ERROR `$p:pat` is followed by `$t:ty` ($p:pat $s:stmt) => {}; //~ERROR `$p:pat` is followed by `$s:stmt` - ($p:pat $p:path) => {}; //~ERROR `$p:pat` is followed by `$p:path` + ($p:pat $q:path) => {}; //~ERROR `$p:pat` is followed by `$q:path` ($p:pat $b:block) => {}; //~ERROR `$p:pat` is followed by `$b:block` ($p:pat $i:ident) => {}; //~ERROR `$p:pat` is followed by `$i:ident` ($p:pat $t:tt) => {}; //~ERROR `$p:pat` is followed by `$t:tt` @@ -37,7 +37,7 @@ macro_rules! follow_expr { ($e:expr if) => {}; //~ERROR `$e:expr` is followed by `if` ($e:expr in) => {}; //~ERROR `$e:expr` is followed by `in` ($e:expr $p:pat) => {}; //~ERROR `$e:expr` is followed by `$p:pat` - ($e:expr $e:expr) => {}; //~ERROR `$e:expr` is followed by `$e:expr` + ($e:expr $f:expr) => {}; //~ERROR `$e:expr` is followed by `$f:expr` ($e:expr $t:ty) => {}; //~ERROR `$e:expr` is followed by `$t:ty` ($e:expr $s:stmt) => {}; //~ERROR `$e:expr` is followed by `$s:stmt` ($e:expr $p:path) => {}; //~ERROR `$e:expr` is followed by `$p:path` @@ -57,12 +57,12 @@ macro_rules! follow_ty { ($t:ty if) => {}; //~ERROR `$t:ty` is followed by `if` ($t:ty $p:pat) => {}; //~ERROR `$t:ty` is followed by `$p:pat` ($t:ty $e:expr) => {}; //~ERROR `$t:ty` is followed by `$e:expr` - ($t:ty $t:ty) => {}; //~ERROR `$t:ty` is followed by `$t:ty` + ($t:ty $r:ty) => {}; //~ERROR `$t:ty` is followed by `$r:ty` ($t:ty $s:stmt) => {}; //~ERROR `$t:ty` is followed by `$s:stmt` ($t:ty $p:path) => {}; //~ERROR `$t:ty` is followed by `$p:path` ($t:ty $b:block) => {}; // ok (RFC 1494) ($t:ty $i:ident) => {}; //~ERROR `$t:ty` is followed by `$i:ident` - ($t:ty $t:tt) => {}; //~ERROR `$t:ty` is followed by `$t:tt` + ($t:ty $r:tt) => {}; //~ERROR `$t:ty` is followed by `$r:tt` ($t:ty $i:item) => {}; //~ERROR `$t:ty` is followed by `$i:item` ($t:ty $m:meta) => {}; //~ERROR `$t:ty` is followed by `$m:meta` } @@ -82,7 +82,7 @@ macro_rules! follow_stmt { ($s:stmt $p:pat) => {}; //~ERROR `$s:stmt` is followed by `$p:pat` ($s:stmt $e:expr) => {}; //~ERROR `$s:stmt` is followed by `$e:expr` ($s:stmt $t:ty) => {}; //~ERROR `$s:stmt` is followed by `$t:ty` - ($s:stmt $s:stmt) => {}; //~ERROR `$s:stmt` is followed by `$s:stmt` + ($s:stmt $t:stmt) => {}; //~ERROR `$s:stmt` is followed by `$t:stmt` ($s:stmt $p:path) => {}; //~ERROR `$s:stmt` is followed by `$p:path` ($s:stmt $b:block) => {}; //~ERROR `$s:stmt` is followed by `$b:block` ($s:stmt $i:ident) => {}; //~ERROR `$s:stmt` is followed by `$i:ident` @@ -97,11 +97,11 @@ macro_rules! follow_path { ($p:path +) => {}; //~ERROR `$p:path` is followed by `+` ($p:path ident) => {}; //~ERROR `$p:path` is followed by `ident` ($p:path if) => {}; //~ERROR `$p:path` is followed by `if` - ($p:path $p:pat) => {}; //~ERROR `$p:path` is followed by `$p:pat` + ($p:path $q:pat) => {}; //~ERROR `$p:path` is followed by `$q:pat` ($p:path $e:expr) => {}; //~ERROR `$p:path` is followed by `$e:expr` ($p:path $t:ty) => {}; //~ERROR `$p:path` is followed by `$t:ty` ($p:path $s:stmt) => {}; //~ERROR `$p:path` is followed by `$s:stmt` - ($p:path $p:path) => {}; //~ERROR `$p:path` is followed by `$p:path` + ($p:path $q:path) => {}; //~ERROR `$p:path` is followed by `$q:path` ($p:path $b:block) => {}; // ok (RFC 1494) ($p:path $i:ident) => {}; //~ERROR `$p:path` is followed by `$i:ident` ($p:path $t:tt) => {}; //~ERROR `$p:path` is followed by `$t:tt` diff --git a/src/test/ui/macros/macro-follow.stderr b/src/test/ui/macros/macro-follow.stderr index 4aea5cc5de6bd..e3302eac4ac08 100644 --- a/src/test/ui/macros/macro-follow.stderr +++ b/src/test/ui/macros/macro-follow.stderr @@ -54,10 +54,10 @@ LL | ($p:pat ident) => {}; //~ERROR `$p:pat` is followed by `ident` | = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in` -error: `$p:pat` is followed by `$p:pat`, which is not allowed for `pat` fragments +error: `$p:pat` is followed by `$q:pat`, which is not allowed for `pat` fragments --> $DIR/macro-follow.rs:15:13 | -LL | ($p:pat $p:pat) => {}; //~ERROR `$p:pat` is followed by `$p:pat` +LL | ($p:pat $q:pat) => {}; //~ERROR `$p:pat` is followed by `$q:pat` | ^^^^^^ not allowed after `pat` fragments | = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in` @@ -86,10 +86,10 @@ LL | ($p:pat $s:stmt) => {}; //~ERROR `$p:pat` is followed by `$s:stmt` | = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in` -error: `$p:pat` is followed by `$p:path`, which is not allowed for `pat` fragments +error: `$p:pat` is followed by `$q:path`, which is not allowed for `pat` fragments --> $DIR/macro-follow.rs:19:13 | -LL | ($p:pat $p:path) => {}; //~ERROR `$p:pat` is followed by `$p:path` +LL | ($p:pat $q:path) => {}; //~ERROR `$p:pat` is followed by `$q:path` | ^^^^^^^ not allowed after `pat` fragments | = note: allowed there are: `=>`, `,`, `=`, `|`, `if` or `in` @@ -230,10 +230,10 @@ LL | ($e:expr $p:pat) => {}; //~ERROR `$e:expr` is followed by `$p:pat` | = note: allowed there are: `=>`, `,` or `;` -error: `$e:expr` is followed by `$e:expr`, which is not allowed for `expr` fragments +error: `$e:expr` is followed by `$f:expr`, which is not allowed for `expr` fragments --> $DIR/macro-follow.rs:40:14 | -LL | ($e:expr $e:expr) => {}; //~ERROR `$e:expr` is followed by `$e:expr` +LL | ($e:expr $f:expr) => {}; //~ERROR `$e:expr` is followed by `$f:expr` | ^^^^^^^ not allowed after `expr` fragments | = note: allowed there are: `=>`, `,` or `;` @@ -350,10 +350,10 @@ LL | ($t:ty $e:expr) => {}; //~ERROR `$t:ty` is followed by `$e:expr` | = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where` -error: `$t:ty` is followed by `$t:ty`, which is not allowed for `ty` fragments +error: `$t:ty` is followed by `$r:ty`, which is not allowed for `ty` fragments --> $DIR/macro-follow.rs:60:12 | -LL | ($t:ty $t:ty) => {}; //~ERROR `$t:ty` is followed by `$t:ty` +LL | ($t:ty $r:ty) => {}; //~ERROR `$t:ty` is followed by `$r:ty` | ^^^^^ not allowed after `ty` fragments | = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where` @@ -382,10 +382,10 @@ LL | ($t:ty $i:ident) => {}; //~ERROR `$t:ty` is followed by `$i:ident` | = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where` -error: `$t:ty` is followed by `$t:tt`, which is not allowed for `ty` fragments +error: `$t:ty` is followed by `$r:tt`, which is not allowed for `ty` fragments --> $DIR/macro-follow.rs:65:12 | -LL | ($t:ty $t:tt) => {}; //~ERROR `$t:ty` is followed by `$t:tt` +LL | ($t:ty $r:tt) => {}; //~ERROR `$t:ty` is followed by `$r:tt` | ^^^^^ not allowed after `ty` fragments | = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where` @@ -518,10 +518,10 @@ LL | ($s:stmt $t:ty) => {}; //~ERROR `$s:stmt` is followed by `$t:ty` | = note: allowed there are: `=>`, `,` or `;` -error: `$s:stmt` is followed by `$s:stmt`, which is not allowed for `stmt` fragments +error: `$s:stmt` is followed by `$t:stmt`, which is not allowed for `stmt` fragments --> $DIR/macro-follow.rs:85:14 | -LL | ($s:stmt $s:stmt) => {}; //~ERROR `$s:stmt` is followed by `$s:stmt` +LL | ($s:stmt $t:stmt) => {}; //~ERROR `$s:stmt` is followed by `$t:stmt` | ^^^^^^^ not allowed after `stmt` fragments | = note: allowed there are: `=>`, `,` or `;` @@ -606,10 +606,10 @@ LL | ($p:path if) => {}; //~ERROR `$p:path` is followed by `if` | = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where` -error: `$p:path` is followed by `$p:pat`, which is not allowed for `path` fragments +error: `$p:path` is followed by `$q:pat`, which is not allowed for `path` fragments --> $DIR/macro-follow.rs:100:14 | -LL | ($p:path $p:pat) => {}; //~ERROR `$p:path` is followed by `$p:pat` +LL | ($p:path $q:pat) => {}; //~ERROR `$p:path` is followed by `$q:pat` | ^^^^^^ not allowed after `path` fragments | = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where` @@ -638,10 +638,10 @@ LL | ($p:path $s:stmt) => {}; //~ERROR `$p:path` is followed by `$s:stmt` | = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where` -error: `$p:path` is followed by `$p:path`, which is not allowed for `path` fragments +error: `$p:path` is followed by `$q:path`, which is not allowed for `path` fragments --> $DIR/macro-follow.rs:104:14 | -LL | ($p:path $p:path) => {}; //~ERROR `$p:path` is followed by `$p:path` +LL | ($p:path $q:path) => {}; //~ERROR `$p:path` is followed by `$q:path` | ^^^^^^^ not allowed after `path` fragments | = note: allowed there are: `{`, `[`, `=>`, `,`, `>`, `=`, `:`, `;`, `|`, `as` or `where` From 3e790a7c304b3bcb182c4fcb745ea288d3dc56f2 Mon Sep 17 00:00:00 2001 From: mark Date: Tue, 15 Jan 2019 16:55:23 -0600 Subject: [PATCH 180/278] add a test --- .../macros/macro-multiple-matcher-bindings.rs | 19 +++++++ .../macro-multiple-matcher-bindings.stderr | 50 +++++++++++++++++++ 2 files changed, 69 insertions(+) create mode 100644 src/test/ui/macros/macro-multiple-matcher-bindings.rs create mode 100644 src/test/ui/macros/macro-multiple-matcher-bindings.stderr diff --git a/src/test/ui/macros/macro-multiple-matcher-bindings.rs b/src/test/ui/macros/macro-multiple-matcher-bindings.rs new file mode 100644 index 0000000000000..ea57d66b565d9 --- /dev/null +++ b/src/test/ui/macros/macro-multiple-matcher-bindings.rs @@ -0,0 +1,19 @@ +// Test that duplicate matcher binding names are caught at declaration time, rather than at macro +// invocation time. + +macro_rules! foo1 { + ($a:ident, $a:ident) => {}; //~ERROR duplicate matcher binding + ($a:ident, $a:path) => {}; //~ERROR duplicate matcher binding +} + +macro_rules! foo2 { + ($a:ident) => {}; // OK + ($a:path) => {}; // OK +} + +macro_rules! foo3 { + ($a:ident, $($a:ident),*) => {}; //~ERROR duplicate matcher binding + ($($a:ident)+ # $($($a:path),+);*) => {}; //~ERROR duplicate matcher binding +} + +fn main() {} diff --git a/src/test/ui/macros/macro-multiple-matcher-bindings.stderr b/src/test/ui/macros/macro-multiple-matcher-bindings.stderr new file mode 100644 index 0000000000000..3e3e10245870f --- /dev/null +++ b/src/test/ui/macros/macro-multiple-matcher-bindings.stderr @@ -0,0 +1,50 @@ +error: duplicate matcher binding + --> $DIR/macro-multiple-matcher-bindings.rs:5:16 + | +LL | ($a:ident, $a:ident) => {}; //~ERROR duplicate matcher binding + | ^^^^^^^^ + | +note: previous declaration was here + --> $DIR/macro-multiple-matcher-bindings.rs:5:6 + | +LL | ($a:ident, $a:ident) => {}; //~ERROR duplicate matcher binding + | ^^^^^^^^ + +error: duplicate matcher binding + --> $DIR/macro-multiple-matcher-bindings.rs:6:16 + | +LL | ($a:ident, $a:path) => {}; //~ERROR duplicate matcher binding + | ^^^^^^^ + | +note: previous declaration was here + --> $DIR/macro-multiple-matcher-bindings.rs:6:6 + | +LL | ($a:ident, $a:path) => {}; //~ERROR duplicate matcher binding + | ^^^^^^^^ + +error: duplicate matcher binding + --> $DIR/macro-multiple-matcher-bindings.rs:15:18 + | +LL | ($a:ident, $($a:ident),*) => {}; //~ERROR duplicate matcher binding + | ^^^^^^^^ + | +note: previous declaration was here + --> $DIR/macro-multiple-matcher-bindings.rs:15:6 + | +LL | ($a:ident, $($a:ident),*) => {}; //~ERROR duplicate matcher binding + | ^^^^^^^^ + +error: duplicate matcher binding + --> $DIR/macro-multiple-matcher-bindings.rs:16:25 + | +LL | ($($a:ident)+ # $($($a:path),+);*) => {}; //~ERROR duplicate matcher binding + | ^^^^^^^ + | +note: previous declaration was here + --> $DIR/macro-multiple-matcher-bindings.rs:16:8 + | +LL | ($($a:ident)+ # $($($a:path),+);*) => {}; //~ERROR duplicate matcher binding + | ^^^^^^^^ + +error: aborting due to 4 previous errors + From 802b256283fe7dd0f0e72499ba77d18f2838e817 Mon Sep 17 00:00:00 2001 From: Mark Mansi Date: Thu, 17 Jan 2019 21:19:56 -0600 Subject: [PATCH 181/278] Make it an incompatibility lint for now --- src/librustc/lint/builtin.rs | 6 ++ src/librustc/lint/mod.rs | 3 +- src/librustc_lint/lib.rs | 5 ++ src/libsyntax/early_buffered_lints.rs | 2 + src/libsyntax/ext/tt/macro_rules.rs | 31 +++++--- .../macros/macro-multiple-matcher-bindings.rs | 10 +-- .../macro-multiple-matcher-bindings.stderr | 71 ++++++++----------- 7 files changed, 72 insertions(+), 56 deletions(-) diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 6ae7448645a20..3ff76e98d7b89 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -352,6 +352,12 @@ declare_lint! { "outlives requirements can be inferred" } +declare_lint! { + pub DUPLICATE_MATCHER_BINDING_NAME, + Warn, + "duplicate macro matcher binding name" +} + /// Some lints that are buffered from `libsyntax`. See `syntax::early_buffered_lints`. pub mod parser { declare_lint! { diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index 4e6bf753b01aa..8952ae98e597e 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -27,7 +27,7 @@ use crate::errors::{DiagnosticBuilder, DiagnosticId}; use crate::hir::def_id::{CrateNum, LOCAL_CRATE}; use crate::hir::intravisit; use crate::hir; -use crate::lint::builtin::BuiltinLintDiagnostics; +use crate::lint::builtin::{BuiltinLintDiagnostics, DUPLICATE_MATCHER_BINDING_NAME}; use crate::lint::builtin::parser::{QUESTION_MARK_MACRO_SEP, ILL_FORMED_ATTRIBUTE_INPUT}; use crate::session::{Session, DiagnosticMessageId}; use std::{hash, ptr}; @@ -82,6 +82,7 @@ impl Lint { match lint_id { BufferedEarlyLintId::QuestionMarkMacroSep => QUESTION_MARK_MACRO_SEP, BufferedEarlyLintId::IllFormedAttributeInput => ILL_FORMED_ATTRIBUTE_INPUT, + BufferedEarlyLintId::DuplicateMacroMatcherBindingName => DUPLICATE_MATCHER_BINDING_NAME, } } diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs index fd5e68d5ae60a..460cb977346a9 100644 --- a/src/librustc_lint/lib.rs +++ b/src/librustc_lint/lib.rs @@ -354,6 +354,11 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) { reference: "issue #57644 ", edition: None, }, + FutureIncompatibleInfo { + id: LintId::of(DUPLICATE_MATCHER_BINDING_NAME), + reference: "issue #57593 ", + edition: None, + }, ]); // Register renamed and removed lints. diff --git a/src/libsyntax/early_buffered_lints.rs b/src/libsyntax/early_buffered_lints.rs index 977e6d4587709..29cb9cd7f30b5 100644 --- a/src/libsyntax/early_buffered_lints.rs +++ b/src/libsyntax/early_buffered_lints.rs @@ -12,6 +12,8 @@ pub enum BufferedEarlyLintId { /// Usage of `?` as a macro separator is deprecated. QuestionMarkMacroSep, IllFormedAttributeInput, + /// Usage of a duplicate macro matcher binding name. + DuplicateMacroMatcherBindingName, } /// Stores buffered lint info which can later be passed to `librustc`. diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 61a5b2cb0d200..33ea675f9d1bb 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -360,8 +360,12 @@ pub fn compile( // don't abort iteration early, so that errors for multiple lhses can be reported for lhs in &lhses { valid &= check_lhs_no_empty_seq(sess, &[lhs.clone()]); - valid &= - check_lhs_duplicate_matcher_bindings(sess, &[lhs.clone()], &mut FxHashMap::default()); + valid &= check_lhs_duplicate_matcher_bindings( + sess, + &[lhs.clone()], + &mut FxHashMap::default(), + def.id + ); } let expander: Box<_> = Box::new(MacroRulesMacroExpander { @@ -467,29 +471,38 @@ fn check_lhs_no_empty_seq(sess: &ParseSess, tts: &[quoted::TokenTree]) -> bool { fn check_lhs_duplicate_matcher_bindings( sess: &ParseSess, tts: &[quoted::TokenTree], - metavar_names: &mut FxHashMap + metavar_names: &mut FxHashMap, + node_id: ast::NodeId, ) -> bool { use self::quoted::TokenTree; + use crate::early_buffered_lints::BufferedEarlyLintId; for tt in tts { match *tt { TokenTree::MetaVarDecl(span, name, _kind) => { if let Some(&prev_span) = metavar_names.get(&name) { - sess.span_diagnostic - .struct_span_err(span, "duplicate matcher binding") - .span_note(prev_span, "previous declaration was here") - .emit(); + // FIXME(mark-i-m): in a few cycles, make this a hard error. + // sess.span_diagnostic + // .struct_span_err(span, "duplicate matcher binding") + // .span_note(prev_span, "previous declaration was here") + // .emit(); + sess.buffer_lint( + BufferedEarlyLintId::DuplicateMacroMatcherBindingName, + crate::source_map::MultiSpan::from(vec![prev_span, span]), + node_id, + "duplicate matcher binding" + ); return false; } else { metavar_names.insert(name, span); } } TokenTree::Delimited(_, ref del) => { - if !check_lhs_duplicate_matcher_bindings(sess, &del.tts, metavar_names) { + if !check_lhs_duplicate_matcher_bindings(sess, &del.tts, metavar_names, node_id) { return false; } }, TokenTree::Sequence(_, ref seq) => { - if !check_lhs_duplicate_matcher_bindings(sess, &seq.tts, metavar_names) { + if !check_lhs_duplicate_matcher_bindings(sess, &seq.tts, metavar_names, node_id) { return false; } } diff --git a/src/test/ui/macros/macro-multiple-matcher-bindings.rs b/src/test/ui/macros/macro-multiple-matcher-bindings.rs index ea57d66b565d9..3deae3eacecb2 100644 --- a/src/test/ui/macros/macro-multiple-matcher-bindings.rs +++ b/src/test/ui/macros/macro-multiple-matcher-bindings.rs @@ -1,9 +1,11 @@ // Test that duplicate matcher binding names are caught at declaration time, rather than at macro // invocation time. +#![allow(unused_macros)] + macro_rules! foo1 { - ($a:ident, $a:ident) => {}; //~ERROR duplicate matcher binding - ($a:ident, $a:path) => {}; //~ERROR duplicate matcher binding + ($a:ident, $a:ident) => {}; //~WARN duplicate matcher binding + ($a:ident, $a:path) => {}; //~WARN duplicate matcher binding } macro_rules! foo2 { @@ -12,8 +14,8 @@ macro_rules! foo2 { } macro_rules! foo3 { - ($a:ident, $($a:ident),*) => {}; //~ERROR duplicate matcher binding - ($($a:ident)+ # $($($a:path),+);*) => {}; //~ERROR duplicate matcher binding + ($a:ident, $($a:ident),*) => {}; //~WARN duplicate matcher binding + ($($a:ident)+ # $($($a:path),+);*) => {}; //~WARN duplicate matcher binding } fn main() {} diff --git a/src/test/ui/macros/macro-multiple-matcher-bindings.stderr b/src/test/ui/macros/macro-multiple-matcher-bindings.stderr index 3e3e10245870f..04b27e88a1f05 100644 --- a/src/test/ui/macros/macro-multiple-matcher-bindings.stderr +++ b/src/test/ui/macros/macro-multiple-matcher-bindings.stderr @@ -1,50 +1,37 @@ -error: duplicate matcher binding - --> $DIR/macro-multiple-matcher-bindings.rs:5:16 - | -LL | ($a:ident, $a:ident) => {}; //~ERROR duplicate matcher binding - | ^^^^^^^^ - | -note: previous declaration was here - --> $DIR/macro-multiple-matcher-bindings.rs:5:6 - | -LL | ($a:ident, $a:ident) => {}; //~ERROR duplicate matcher binding - | ^^^^^^^^ +warning: duplicate matcher binding + --> src/test/ui/macros/macro-multiple-matcher-bindings.rs:7:6 + | +7 | ($a:ident, $a:ident) => {}; //~WARN duplicate matcher binding + | ^^^^^^^^ ^^^^^^^^ + | + = note: #[warn(duplicate_matcher_binding_name)] on by default + = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! + = note: for more information, see issue #57593 -error: duplicate matcher binding - --> $DIR/macro-multiple-matcher-bindings.rs:6:16 - | -LL | ($a:ident, $a:path) => {}; //~ERROR duplicate matcher binding - | ^^^^^^^ - | -note: previous declaration was here - --> $DIR/macro-multiple-matcher-bindings.rs:6:6 - | -LL | ($a:ident, $a:path) => {}; //~ERROR duplicate matcher binding - | ^^^^^^^^ +warning: duplicate matcher binding + --> src/test/ui/macros/macro-multiple-matcher-bindings.rs:8:6 + | +8 | ($a:ident, $a:path) => {}; //~WARN duplicate matcher binding + | ^^^^^^^^ ^^^^^^^ + | + = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! + = note: for more information, see issue #57593 -error: duplicate matcher binding - --> $DIR/macro-multiple-matcher-bindings.rs:15:18 - | -LL | ($a:ident, $($a:ident),*) => {}; //~ERROR duplicate matcher binding - | ^^^^^^^^ +warning: duplicate matcher binding + --> src/test/ui/macros/macro-multiple-matcher-bindings.rs:17:6 | -note: previous declaration was here - --> $DIR/macro-multiple-matcher-bindings.rs:15:6 +LL | ($a:ident, $($a:ident),*) => {}; //~WARN duplicate matcher binding + | ^^^^^^^^ ^^^^^^^^ | -LL | ($a:ident, $($a:ident),*) => {}; //~ERROR duplicate matcher binding - | ^^^^^^^^ + = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! + = note: for more information, see issue #57593 -error: duplicate matcher binding - --> $DIR/macro-multiple-matcher-bindings.rs:16:25 +warning: duplicate matcher binding + --> src/test/ui/macros/macro-multiple-matcher-bindings.rs:18:8 | -LL | ($($a:ident)+ # $($($a:path),+);*) => {}; //~ERROR duplicate matcher binding - | ^^^^^^^ +LL | ($($a:ident)+ # $($($a:path),+);*) => {}; //~WARN duplicate matcher binding + | ^^^^^^^^ ^^^^^^^ | -note: previous declaration was here - --> $DIR/macro-multiple-matcher-bindings.rs:16:8 - | -LL | ($($a:ident)+ # $($($a:path),+);*) => {}; //~ERROR duplicate matcher binding - | ^^^^^^^^ - -error: aborting due to 4 previous errors + = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! + = note: for more information, see issue #57593 From c25d6b83441e0c060ee0273193ef27b29e1318cd Mon Sep 17 00:00:00 2001 From: Mark Mansi Date: Thu, 17 Jan 2019 21:30:06 -0600 Subject: [PATCH 182/278] update test --- .../macros/macro-multiple-matcher-bindings.rs | 12 ++++-- .../macro-multiple-matcher-bindings.stderr | 38 +++++++++---------- 2 files changed, 27 insertions(+), 23 deletions(-) diff --git a/src/test/ui/macros/macro-multiple-matcher-bindings.rs b/src/test/ui/macros/macro-multiple-matcher-bindings.rs index 3deae3eacecb2..9e0fa3887163d 100644 --- a/src/test/ui/macros/macro-multiple-matcher-bindings.rs +++ b/src/test/ui/macros/macro-multiple-matcher-bindings.rs @@ -1,11 +1,15 @@ // Test that duplicate matcher binding names are caught at declaration time, rather than at macro // invocation time. +// +// FIXME(mark-i-m): Update this when it becomes a hard error. + +// compile-pass #![allow(unused_macros)] macro_rules! foo1 { - ($a:ident, $a:ident) => {}; //~WARN duplicate matcher binding - ($a:ident, $a:path) => {}; //~WARN duplicate matcher binding + ($a:ident, $a:ident) => {}; //~WARNING duplicate matcher binding + ($a:ident, $a:path) => {}; //~WARNING duplicate matcher binding } macro_rules! foo2 { @@ -14,8 +18,8 @@ macro_rules! foo2 { } macro_rules! foo3 { - ($a:ident, $($a:ident),*) => {}; //~WARN duplicate matcher binding - ($($a:ident)+ # $($($a:path),+);*) => {}; //~WARN duplicate matcher binding + ($a:ident, $($a:ident),*) => {}; //~WARNING duplicate matcher binding + ($($a:ident)+ # $($($a:path),+);*) => {}; //~WARNING duplicate matcher binding } fn main() {} diff --git a/src/test/ui/macros/macro-multiple-matcher-bindings.stderr b/src/test/ui/macros/macro-multiple-matcher-bindings.stderr index 04b27e88a1f05..bc78b471a2d1e 100644 --- a/src/test/ui/macros/macro-multiple-matcher-bindings.stderr +++ b/src/test/ui/macros/macro-multiple-matcher-bindings.stderr @@ -1,35 +1,35 @@ warning: duplicate matcher binding - --> src/test/ui/macros/macro-multiple-matcher-bindings.rs:7:6 - | -7 | ($a:ident, $a:ident) => {}; //~WARN duplicate matcher binding - | ^^^^^^^^ ^^^^^^^^ - | - = note: #[warn(duplicate_matcher_binding_name)] on by default - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #57593 + --> $DIR/macro-multiple-matcher-bindings.rs:11:6 + | +LL | ($a:ident, $a:ident) => {}; //~WARNING duplicate matcher binding + | ^^^^^^^^ ^^^^^^^^ + | + = note: #[warn(duplicate_matcher_binding_name)] on by default + = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! + = note: for more information, see issue #57593 warning: duplicate matcher binding - --> src/test/ui/macros/macro-multiple-matcher-bindings.rs:8:6 - | -8 | ($a:ident, $a:path) => {}; //~WARN duplicate matcher binding - | ^^^^^^^^ ^^^^^^^ - | - = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! - = note: for more information, see issue #57593 + --> $DIR/macro-multiple-matcher-bindings.rs:12:6 + | +LL | ($a:ident, $a:path) => {}; //~WARNING duplicate matcher binding + | ^^^^^^^^ ^^^^^^^ + | + = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! + = note: for more information, see issue #57593 warning: duplicate matcher binding - --> src/test/ui/macros/macro-multiple-matcher-bindings.rs:17:6 + --> $DIR/macro-multiple-matcher-bindings.rs:21:6 | -LL | ($a:ident, $($a:ident),*) => {}; //~WARN duplicate matcher binding +LL | ($a:ident, $($a:ident),*) => {}; //~WARNING duplicate matcher binding | ^^^^^^^^ ^^^^^^^^ | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! = note: for more information, see issue #57593 warning: duplicate matcher binding - --> src/test/ui/macros/macro-multiple-matcher-bindings.rs:18:8 + --> $DIR/macro-multiple-matcher-bindings.rs:22:8 | -LL | ($($a:ident)+ # $($($a:path),+);*) => {}; //~WARN duplicate matcher binding +LL | ($($a:ident)+ # $($($a:path),+);*) => {}; //~WARNING duplicate matcher binding | ^^^^^^^^ ^^^^^^^ | = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! From da13fbda5e28482d01205d791f38a645a396ea65 Mon Sep 17 00:00:00 2001 From: Patrick McCarter Date: Thu, 7 Feb 2019 13:46:20 -0500 Subject: [PATCH 183/278] Add unstable feature attribute for unsigned const saturating add/sub intrinsics #58030 --- src/libcore/num/mod.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index d4fade7613848..d34173dafb351 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -2816,6 +2816,7 @@ assert_eq!(200u8.saturating_add(127), 255);", $EndFeature, " ```"), #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_saturating_int_methods")] #[inline] #[cfg(not(stage0))] pub const fn saturating_add(self, rhs: Self) -> Self { @@ -2859,6 +2860,7 @@ Basic usage: assert_eq!(13", stringify!($SelfT), ".saturating_sub(127), 0);", $EndFeature, " ```"), #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_saturating_int_methods")] #[inline] #[cfg(not(stage0))] pub const fn saturating_sub(self, rhs: Self) -> Self { From 725af308093818dc4386a06457eb1e452c7afee1 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 06:28:15 +0900 Subject: [PATCH 184/278] librustc_mir => 2018 --- src/librustc_mir/Cargo.toml | 3 +- src/librustc_mir/borrow_check/borrow_set.rs | 10 ++--- .../borrow_check/error_reporting.rs | 38 ++++++++++------- src/librustc_mir/borrow_check/flows.rs | 18 ++++---- src/librustc_mir/borrow_check/mod.rs | 26 ++++++------ src/librustc_mir/borrow_check/move_errors.rs | 12 +++--- .../borrow_check/mutability_errors.rs | 12 +++--- .../borrow_check/nll/constraint_generation.rs | 10 ++--- .../borrow_check/nll/constraints/graph.rs | 6 +-- .../borrow_check/nll/constraints/mod.rs | 4 +- .../nll/explain_borrow/find_use.rs | 6 +-- .../borrow_check/nll/explain_borrow/mod.rs | 20 ++++----- src/librustc_mir/borrow_check/nll/facts.rs | 4 +- .../borrow_check/nll/invalidation.rs | 24 +++++------ src/librustc_mir/borrow_check/nll/mod.rs | 38 ++++++++--------- .../nll/region_infer/error_reporting/mod.rs | 12 +++--- .../error_reporting/region_name.rs | 8 ++-- .../region_infer/error_reporting/var_name.rs | 4 +- .../borrow_check/nll/region_infer/graphviz.rs | 3 +- .../borrow_check/nll/region_infer/mod.rs | 12 +++--- .../nll/type_check/constraint_conversion.rs | 10 ++--- .../nll/type_check/free_region_relations.rs | 8 ++-- .../nll/type_check/input_output.rs | 2 +- .../nll/type_check/liveness/liveness_map.rs | 6 +-- .../nll/type_check/liveness/local_use_map.rs | 6 +-- .../nll/type_check/liveness/mod.rs | 16 +++---- .../nll/type_check/liveness/trace.rs | 20 ++++----- .../borrow_check/nll/type_check/mod.rs | 42 +++++++++---------- .../borrow_check/nll/type_check/relate_tys.rs | 4 +- src/librustc_mir/borrow_check/path_utils.rs | 10 ++--- src/librustc_mir/borrow_check/place_ext.rs | 2 +- .../borrow_check/places_conflict.rs | 6 +-- src/librustc_mir/borrow_check/used_muts.rs | 2 +- src/librustc_mir/build/block.rs | 8 ++-- src/librustc_mir/build/cfg.rs | 2 +- src/librustc_mir/build/expr/as_constant.rs | 4 +- src/librustc_mir/build/expr/as_operand.rs | 6 +-- src/librustc_mir/build/expr/as_place.rs | 8 ++-- src/librustc_mir/build/expr/as_rvalue.rs | 6 +-- src/librustc_mir/build/expr/as_temp.rs | 4 +- src/librustc_mir/build/expr/category.rs | 2 +- src/librustc_mir/build/expr/into.rs | 6 +-- src/librustc_mir/build/expr/stmt.rs | 6 +-- src/librustc_mir/build/into.rs | 6 +-- src/librustc_mir/build/matches/mod.rs | 10 ++--- src/librustc_mir/build/matches/simplify.rs | 6 +-- src/librustc_mir/build/matches/test.rs | 8 ++-- src/librustc_mir/build/matches/util.rs | 6 +-- src/librustc_mir/build/misc.rs | 2 +- src/librustc_mir/build/mod.rs | 18 ++++---- src/librustc_mir/build/scope.rs | 4 +- src/librustc_mir/const_eval.rs | 2 +- src/librustc_mir/dataflow/at_location.rs | 8 ++-- .../dataflow/drop_flag_effects.rs | 2 +- src/librustc_mir/dataflow/graphviz.rs | 22 +++++----- .../dataflow/impls/borrowed_locals.rs | 6 +-- src/librustc_mir/dataflow/impls/borrows.rs | 26 ++++++------ src/librustc_mir/dataflow/impls/mod.rs | 24 +++++------ .../dataflow/impls/storage_liveness.rs | 6 +-- src/librustc_mir/dataflow/mod.rs | 12 +++--- src/librustc_mir/dataflow/move_paths/mod.rs | 19 +++++---- src/librustc_mir/hair/cx/block.rs | 6 +-- src/librustc_mir/hair/cx/expr.rs | 10 ++--- src/librustc_mir/hair/cx/mod.rs | 8 ++-- src/librustc_mir/hair/cx/to_ref.rs | 2 +- src/librustc_mir/hair/pattern/_match.rs | 8 ++-- src/librustc_mir/hair/pattern/check_match.rs | 22 +++++----- src/librustc_mir/hair/pattern/mod.rs | 8 ++-- src/librustc_mir/interpret/eval_context.rs | 2 +- src/librustc_mir/interpret/snapshot.rs | 14 +++---- src/librustc_mir/interpret/terminator.rs | 6 +-- src/librustc_mir/interpret/traits.rs | 2 +- src/librustc_mir/interpret/visitor.rs | 2 +- src/librustc_mir/lib.rs | 20 +++------ src/librustc_mir/lints.rs | 2 +- src/librustc_mir/monomorphize/collector.rs | 4 +- src/librustc_mir/monomorphize/item.rs | 2 +- src/librustc_mir/monomorphize/partitioning.rs | 22 +++++----- src/librustc_mir/shim.rs | 14 +++---- src/librustc_mir/transform/add_call_guards.rs | 4 +- .../transform/add_moves_for_packed_drops.rs | 6 +-- src/librustc_mir/transform/add_retag.rs | 2 +- src/librustc_mir/transform/check_unsafety.rs | 10 +++-- .../transform/cleanup_post_borrowck.rs | 2 +- src/librustc_mir/transform/const_prop.rs | 8 ++-- src/librustc_mir/transform/copy_prop.rs | 6 +-- src/librustc_mir/transform/deaggregator.rs | 2 +- src/librustc_mir/transform/dump_mir.rs | 6 +-- src/librustc_mir/transform/elaborate_drops.rs | 24 +++++------ src/librustc_mir/transform/erase_regions.rs | 2 +- src/librustc_mir/transform/generator.rs | 20 ++++----- src/librustc_mir/transform/inline.rs | 6 +-- src/librustc_mir/transform/instcombine.rs | 2 +- src/librustc_mir/transform/lower_128bit.rs | 5 +-- src/librustc_mir/transform/mod.rs | 6 +-- src/librustc_mir/transform/no_landing_pads.rs | 2 +- src/librustc_mir/transform/promote_consts.rs | 3 +- src/librustc_mir/transform/qualify_consts.rs | 8 ++-- .../transform/remove_noop_landing_pads.rs | 8 ++-- src/librustc_mir/transform/rustc_peek.rs | 26 ++++++------ src/librustc_mir/transform/simplify.rs | 6 +-- .../transform/simplify_branches.rs | 2 +- .../transform/uniform_array_move_out.rs | 4 +- src/librustc_mir/util/borrowck_errors.rs | 6 +-- src/librustc_mir/util/def_use.rs | 2 +- src/librustc_mir/util/elaborate_drops.rs | 2 +- src/librustc_mir/util/graphviz.rs | 11 +++-- src/librustc_mir/util/liveness.rs | 4 +- src/librustc_mir/util/patch.rs | 4 +- src/librustc_mir/util/pretty.rs | 23 ++++++---- 110 files changed, 514 insertions(+), 505 deletions(-) diff --git a/src/librustc_mir/Cargo.toml b/src/librustc_mir/Cargo.toml index f0234c48c3eca..44a6b41cdfe45 100644 --- a/src/librustc_mir/Cargo.toml +++ b/src/librustc_mir/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_mir" version = "0.0.0" +edition = "2018" [lib] name = "rustc_mir" @@ -12,7 +13,7 @@ crate-type = ["dylib"] arena = { path = "../libarena" } bitflags = "1.0" either = "1.5.0" -graphviz = { path = "../libgraphviz" } +dot = { path = "../libgraphviz", package = "graphviz" } log = "0.4" log_settings = "0.1.1" polonius-engine = "0.6.2" diff --git a/src/librustc_mir/borrow_check/borrow_set.rs b/src/librustc_mir/borrow_check/borrow_set.rs index ecbc6118bc37c..2788f5d4325a9 100644 --- a/src/librustc_mir/borrow_check/borrow_set.rs +++ b/src/librustc_mir/borrow_check/borrow_set.rs @@ -1,7 +1,7 @@ -use borrow_check::place_ext::PlaceExt; -use borrow_check::nll::ToRegionVid; -use dataflow::indexes::BorrowIndex; -use dataflow::move_paths::MoveData; +use crate::borrow_check::place_ext::PlaceExt; +use crate::borrow_check::nll::ToRegionVid; +use crate::dataflow::indexes::BorrowIndex; +use crate::dataflow::move_paths::MoveData; use rustc::mir::traversal; use rustc::mir::visit::{ PlaceContext, Visitor, NonUseContext, MutatingUseContext, NonMutatingUseContext @@ -72,7 +72,7 @@ crate struct BorrowData<'tcx> { } impl<'tcx> fmt::Display for BorrowData<'tcx> { - fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result { let kind = match self.kind { mir::BorrowKind::Shared => "", mir::BorrowKind::Shallow => "shallow ", diff --git a/src/librustc_mir/borrow_check/error_reporting.rs b/src/librustc_mir/borrow_check/error_reporting.rs index b070031756798..afb26963217ff 100644 --- a/src/librustc_mir/borrow_check/error_reporting.rs +++ b/src/librustc_mir/borrow_check/error_reporting.rs @@ -1,7 +1,7 @@ -use borrow_check::nll::explain_borrow::BorrowExplanation; -use borrow_check::nll::region_infer::{RegionName, RegionNameSource}; -use borrow_check::prefixes::IsPrefixOf; -use borrow_check::WriteKind; +use crate::borrow_check::nll::explain_borrow::BorrowExplanation; +use crate::borrow_check::nll::region_infer::{RegionName, RegionNameSource}; +use crate::borrow_check::prefixes::IsPrefixOf; +use crate::borrow_check::WriteKind; use rustc::hir; use rustc::hir::def_id::DefId; use rustc::middle::region::ScopeTree; @@ -22,10 +22,10 @@ use syntax_pos::Span; use super::borrow_set::BorrowData; use super::{Context, MirBorrowckCtxt}; use super::{InitializationRequiringAction, PrefixSet}; -use dataflow::drop_flag_effects; -use dataflow::move_paths::indexes::MoveOutIndex; -use dataflow::move_paths::MovePathIndex; -use util::borrowck_errors::{BorrowckErrors, Origin}; +use crate::dataflow::drop_flag_effects; +use crate::dataflow::move_paths::indexes::MoveOutIndex; +use crate::dataflow::move_paths::MovePathIndex; +use crate::util::borrowck_errors::{BorrowckErrors, Origin}; #[derive(Debug)] struct MoveSite { @@ -1726,7 +1726,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { } /// End-user visible description of the `field`nth field of `base` - fn describe_field(&self, base: &Place, field: Field) -> String { + fn describe_field(&self, base: &Place<'_>, field: Field) -> String { match *base { Place::Local(local) => { let local = &self.mir.local_decls[local]; @@ -1751,7 +1751,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { } /// End-user visible description of the `field_index`nth field of `ty` - fn describe_field_from_ty(&self, ty: &ty::Ty, field: Field) -> String { + fn describe_field_from_ty(&self, ty: &ty::Ty<'_>, field: Field) -> String { if ty.is_box() { // If the type is a box, the field is described from the boxed type self.describe_field_from_ty(&ty.boxed_ty(), field) @@ -1860,7 +1860,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { fn annotate_argument_and_return_for_borrow( &self, borrow: &BorrowData<'tcx>, - ) -> Option { + ) -> Option> { // Define a fallback for when we can't match a closure. let fallback = || { let is_closure = self.infcx.tcx.is_closure(self.mir_def_id); @@ -2081,7 +2081,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { &self, did: DefId, sig: ty::PolyFnSig<'tcx>, - ) -> Option { + ) -> Option> { debug!("annotate_fn_sig: did={:?} sig={:?}", did, sig); let is_closure = self.infcx.tcx.is_closure(did); let fn_node_id = self.infcx.tcx.hir().as_local_node_id(did)?; @@ -2368,14 +2368,22 @@ impl UseSpans { } // Add a span label to the arguments of the closure, if it exists. - pub(super) fn args_span_label(self, err: &mut DiagnosticBuilder, message: impl Into) { + pub(super) fn args_span_label( + self, + err: &mut DiagnosticBuilder<'_>, + message: impl Into, + ) { if let UseSpans::ClosureUse { args_span, .. } = self { err.span_label(args_span, message); } } // Add a span label to the use of the captured variable, if it exists. - pub(super) fn var_span_label(self, err: &mut DiagnosticBuilder, message: impl Into) { + pub(super) fn var_span_label( + self, + err: &mut DiagnosticBuilder<'_>, + message: impl Into, + ) { if let UseSpans::ClosureUse { var_span, .. } = self { err.span_label(var_span, message); } @@ -2563,7 +2571,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { /// Helper to retrieve span(s) of given borrow from the current MIR /// representation - pub(super) fn retrieve_borrow_spans(&self, borrow: &BorrowData) -> UseSpans { + pub(super) fn retrieve_borrow_spans(&self, borrow: &BorrowData<'_>) -> UseSpans { let span = self.mir.source_info(borrow.reserve_location).span; self.borrow_spans(span, borrow.reserve_location) } diff --git a/src/librustc_mir/borrow_check/flows.rs b/src/librustc_mir/borrow_check/flows.rs index 4eeb19c4e7a67..8de39f0efc1a5 100644 --- a/src/librustc_mir/borrow_check/flows.rs +++ b/src/librustc_mir/borrow_check/flows.rs @@ -7,16 +7,16 @@ use rustc::mir::{BasicBlock, Location}; use rustc::ty::RegionVid; use rustc_data_structures::bit_set::BitIter; -use borrow_check::location::LocationIndex; +use crate::borrow_check::location::LocationIndex; use polonius_engine::Output; -use dataflow::move_paths::indexes::BorrowIndex; -use dataflow::move_paths::HasMoveData; -use dataflow::Borrows; -use dataflow::EverInitializedPlaces; -use dataflow::{FlowAtLocation, FlowsAtLocation}; -use dataflow::MaybeUninitializedPlaces; +use crate::dataflow::move_paths::indexes::BorrowIndex; +use crate::dataflow::move_paths::HasMoveData; +use crate::dataflow::Borrows; +use crate::dataflow::EverInitializedPlaces; +use crate::dataflow::{FlowAtLocation, FlowsAtLocation}; +use crate::dataflow::MaybeUninitializedPlaces; use either::Either; use std::fmt; use std::rc::Rc; @@ -57,7 +57,7 @@ impl<'b, 'gcx, 'tcx> Flows<'b, 'gcx, 'tcx> { } } - crate fn with_outgoing_borrows(&self, op: impl FnOnce(BitIter)) { + crate fn with_outgoing_borrows(&self, op: impl FnOnce(BitIter<'_, BorrowIndex>)) { self.borrows.with_iter_outgoing(op) } } @@ -93,7 +93,7 @@ impl<'b, 'gcx, 'tcx> FlowsAtLocation for Flows<'b, 'gcx, 'tcx> { } impl<'b, 'gcx, 'tcx> fmt::Display for Flows<'b, 'gcx, 'tcx> { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { let mut s = String::new(); s.push_str("borrows in effect: ["); diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs index 5597e4a6c597e..45a8c9e8e6909 100644 --- a/src/librustc_mir/borrow_check/mod.rs +++ b/src/librustc_mir/borrow_check/mod.rs @@ -1,6 +1,6 @@ //! This query borrow-checks the MIR to (further) ensure it is not broken. -use borrow_check::nll::region_infer::RegionInferenceContext; +use crate::borrow_check::nll::region_infer::RegionInferenceContext; use rustc::hir; use rustc::hir::Node; use rustc::hir::def_id::DefId; @@ -25,16 +25,16 @@ use std::collections::BTreeMap; use syntax_pos::Span; -use dataflow::indexes::{BorrowIndex, InitIndex, MoveOutIndex, MovePathIndex}; -use dataflow::move_paths::{HasMoveData, LookupResult, MoveData, MoveError}; -use dataflow::Borrows; -use dataflow::DataflowResultsConsumer; -use dataflow::FlowAtLocation; -use dataflow::MoveDataParamEnv; -use dataflow::{do_dataflow, DebugFormatted}; -use dataflow::EverInitializedPlaces; -use dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces}; -use util::borrowck_errors::{BorrowckErrors, Origin}; +use crate::dataflow::indexes::{BorrowIndex, InitIndex, MoveOutIndex, MovePathIndex}; +use crate::dataflow::move_paths::{HasMoveData, LookupResult, MoveData, MoveError}; +use crate::dataflow::Borrows; +use crate::dataflow::DataflowResultsConsumer; +use crate::dataflow::FlowAtLocation; +use crate::dataflow::MoveDataParamEnv; +use crate::dataflow::{do_dataflow, DebugFormatted}; +use crate::dataflow::EverInitializedPlaces; +use crate::dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces}; +use crate::util::borrowck_errors::{BorrowckErrors, Origin}; use self::borrow_set::{BorrowData, BorrowSet}; use self::flows::Flows; @@ -59,7 +59,7 @@ mod used_muts; pub(crate) mod nll; -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { *providers = Providers { mir_borrowck, ..*providers @@ -108,7 +108,7 @@ fn mir_borrowck<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> BorrowC } let opt_closure_req = tcx.infer_ctxt().enter(|infcx| { - let input_mir: &Mir = &input_mir.borrow(); + let input_mir: &Mir<'_> = &input_mir.borrow(); do_mir_borrowck(&infcx, input_mir, def_id) }); debug!("mir_borrowck done"); diff --git a/src/librustc_mir/borrow_check/move_errors.rs b/src/librustc_mir/borrow_check/move_errors.rs index 8539b5c26cee8..f7d46925e17df 100644 --- a/src/librustc_mir/borrow_check/move_errors.rs +++ b/src/librustc_mir/borrow_check/move_errors.rs @@ -6,13 +6,13 @@ use rustc::ty; use rustc_errors::{DiagnosticBuilder,Applicability}; use syntax_pos::Span; -use borrow_check::MirBorrowckCtxt; -use borrow_check::prefixes::PrefixSet; -use dataflow::move_paths::{ +use crate::borrow_check::MirBorrowckCtxt; +use crate::borrow_check::prefixes::PrefixSet; +use crate::dataflow::move_paths::{ IllegalMoveOrigin, IllegalMoveOriginKind, InitLocation, LookupResult, MoveError, MovePathIndex, }; -use util::borrowck_errors::{BorrowckErrors, Origin}; +use crate::util::borrowck_errors::{BorrowckErrors, Origin}; // Often when desugaring a pattern match we may have many individual moves in // MIR that are all part of one operation from the user's point-of-view. For @@ -63,7 +63,7 @@ enum BorrowedContentSource { } impl Display for BorrowedContentSource { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match *self { BorrowedContentSource::Arc => write!(f, "an `Arc`"), BorrowedContentSource::Rc => write!(f, "an `Rc`"), @@ -240,7 +240,7 @@ impl<'a, 'gcx, 'tcx> MirBorrowckCtxt<'a, 'gcx, 'tcx> { fn report(&mut self, error: GroupedMoveError<'tcx>) { let (mut err, err_span) = { - let (span, original_path, kind): (Span, &Place<'tcx>, &IllegalMoveOriginKind) = + let (span, original_path, kind): (Span, &Place<'tcx>, &IllegalMoveOriginKind<'_>) = match error { GroupedMoveError::MovesFromPlace { span, diff --git a/src/librustc_mir/borrow_check/mutability_errors.rs b/src/librustc_mir/borrow_check/mutability_errors.rs index 9d3ce7693ea86..dad8d903cf9fe 100644 --- a/src/librustc_mir/borrow_check/mutability_errors.rs +++ b/src/librustc_mir/borrow_check/mutability_errors.rs @@ -8,11 +8,11 @@ use rustc_data_structures::indexed_vec::Idx; use syntax_pos::Span; use syntax_pos::symbol::keywords; -use dataflow::move_paths::InitLocation; -use borrow_check::MirBorrowckCtxt; -use util::borrowck_errors::{BorrowckErrors, Origin}; -use util::collect_writes::FindAssignments; -use util::suggest_ref_mut; +use crate::dataflow::move_paths::InitLocation; +use crate::borrow_check::MirBorrowckCtxt; +use crate::util::borrowck_errors::{BorrowckErrors, Origin}; +use crate::util::collect_writes::FindAssignments; +use crate::util::suggest_ref_mut; use rustc_errors::Applicability; #[derive(Copy, Clone, Debug, Eq, PartialEq)] @@ -611,7 +611,7 @@ fn suggest_ampmut<'cx, 'gcx, 'tcx>( }) } -fn is_closure_or_generator(ty: ty::Ty) -> bool { +fn is_closure_or_generator(ty: ty::Ty<'_>) -> bool { ty.is_closure() || ty.is_generator() } diff --git a/src/librustc_mir/borrow_check/nll/constraint_generation.rs b/src/librustc_mir/borrow_check/nll/constraint_generation.rs index 588f46cb77fe2..c02c2b4934cf4 100644 --- a/src/librustc_mir/borrow_check/nll/constraint_generation.rs +++ b/src/librustc_mir/borrow_check/nll/constraint_generation.rs @@ -1,8 +1,8 @@ -use borrow_check::borrow_set::BorrowSet; -use borrow_check::location::LocationTable; -use borrow_check::nll::ToRegionVid; -use borrow_check::nll::facts::AllFacts; -use borrow_check::nll::region_infer::values::LivenessValues; +use crate::borrow_check::borrow_set::BorrowSet; +use crate::borrow_check::location::LocationTable; +use crate::borrow_check::nll::ToRegionVid; +use crate::borrow_check::nll::facts::AllFacts; +use crate::borrow_check::nll::region_infer::values::LivenessValues; use rustc::infer::InferCtxt; use rustc::mir::visit::TyContext; use rustc::mir::visit::Visitor; diff --git a/src/librustc_mir/borrow_check/nll/constraints/graph.rs b/src/librustc_mir/borrow_check/nll/constraints/graph.rs index fe9ccb489e425..2479dfd1c7093 100644 --- a/src/librustc_mir/borrow_check/nll/constraints/graph.rs +++ b/src/librustc_mir/borrow_check/nll/constraints/graph.rs @@ -1,6 +1,6 @@ -use borrow_check::nll::type_check::Locations; -use borrow_check::nll::constraints::ConstraintIndex; -use borrow_check::nll::constraints::{ConstraintSet, OutlivesConstraint}; +use crate::borrow_check::nll::type_check::Locations; +use crate::borrow_check::nll::constraints::ConstraintIndex; +use crate::borrow_check::nll::constraints::{ConstraintSet, OutlivesConstraint}; use rustc::mir::ConstraintCategory; use rustc::ty::RegionVid; use rustc_data_structures::graph; diff --git a/src/librustc_mir/borrow_check/nll/constraints/mod.rs b/src/librustc_mir/borrow_check/nll/constraints/mod.rs index 146bd65dd1143..d3f9743dfed77 100644 --- a/src/librustc_mir/borrow_check/nll/constraints/mod.rs +++ b/src/librustc_mir/borrow_check/nll/constraints/mod.rs @@ -2,7 +2,7 @@ use rustc::mir::ConstraintCategory; use rustc::ty::RegionVid; use rustc_data_structures::graph::scc::Sccs; use rustc_data_structures::indexed_vec::{Idx, IndexVec}; -use borrow_check::nll::type_check::Locations; +use crate::borrow_check::nll::type_check::Locations; use std::fmt; use std::ops::Deref; @@ -84,7 +84,7 @@ pub struct OutlivesConstraint { } impl fmt::Debug for OutlivesConstraint { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { write!( formatter, "({:?}: {:?}) due to {:?}", diff --git a/src/librustc_mir/borrow_check/nll/explain_borrow/find_use.rs b/src/librustc_mir/borrow_check/nll/explain_borrow/find_use.rs index 53035dae4f35c..c5aaf5b811ed7 100644 --- a/src/librustc_mir/borrow_check/nll/explain_borrow/find_use.rs +++ b/src/librustc_mir/borrow_check/nll/explain_borrow/find_use.rs @@ -1,13 +1,13 @@ use std::collections::VecDeque; use std::rc::Rc; -use borrow_check::nll::region_infer::{Cause, RegionInferenceContext}; -use borrow_check::nll::ToRegionVid; +use crate::borrow_check::nll::region_infer::{Cause, RegionInferenceContext}; +use crate::borrow_check::nll::ToRegionVid; +use crate::util::liveness::{self, DefUse}; use rustc::mir::visit::{MirVisitable, PlaceContext, Visitor}; use rustc::mir::{Local, Location, Mir}; use rustc::ty::{RegionVid, TyCtxt}; use rustc_data_structures::fx::FxHashSet; -use util::liveness::{self, DefUse}; crate fn find<'tcx>( mir: &Mir<'tcx>, diff --git a/src/librustc_mir/borrow_check/nll/explain_borrow/mod.rs b/src/librustc_mir/borrow_check/nll/explain_borrow/mod.rs index 968c0f53a4852..8e57d107aa61e 100644 --- a/src/librustc_mir/borrow_check/nll/explain_borrow/mod.rs +++ b/src/librustc_mir/borrow_check/nll/explain_borrow/mod.rs @@ -1,8 +1,8 @@ -use borrow_check::borrow_set::BorrowData; -use borrow_check::error_reporting::UseSpans; -use borrow_check::nll::ConstraintDescription; -use borrow_check::nll::region_infer::{Cause, RegionName}; -use borrow_check::{Context, MirBorrowckCtxt, WriteKind}; +use crate::borrow_check::borrow_set::BorrowData; +use crate::borrow_check::error_reporting::UseSpans; +use crate::borrow_check::nll::ConstraintDescription; +use crate::borrow_check::nll::region_infer::{Cause, RegionName}; +use crate::borrow_check::{Context, MirBorrowckCtxt, WriteKind}; use rustc::ty::{self, TyCtxt}; use rustc::mir::{ CastKind, ConstraintCategory, FakeReadCause, Local, Location, Mir, Operand, @@ -14,7 +14,7 @@ use syntax_pos::Span; mod find_use; -pub(in borrow_check) enum BorrowExplanation { +pub(in crate::borrow_check) enum BorrowExplanation { UsedLater(LaterUseKind, Span), UsedLaterInLoop(LaterUseKind, Span), UsedLaterWhenDropped { @@ -33,7 +33,7 @@ pub(in borrow_check) enum BorrowExplanation { } #[derive(Clone, Copy)] -pub(in borrow_check) enum LaterUseKind { +pub(in crate::borrow_check) enum LaterUseKind { TraitCapture, ClosureCapture, Call, @@ -42,13 +42,13 @@ pub(in borrow_check) enum LaterUseKind { } impl BorrowExplanation { - pub(in borrow_check) fn is_explained(&self) -> bool { + pub(in crate::borrow_check) fn is_explained(&self) -> bool { match self { BorrowExplanation::Unexplained => false, _ => true, } } - pub(in borrow_check) fn add_explanation_to_diagnostic<'cx, 'gcx, 'tcx>( + pub(in crate::borrow_check) fn add_explanation_to_diagnostic<'cx, 'gcx, 'tcx>( &self, tcx: TyCtxt<'cx, 'gcx, 'tcx>, mir: &Mir<'tcx>, @@ -187,7 +187,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { /// - second half is the place being accessed /// /// [d]: https://rust-lang.github.io/rfcs/2094-nll.html#leveraging-intuition-framing-errors-in-terms-of-points - pub(in borrow_check) fn explain_why_borrow_contains_point( + pub(in crate::borrow_check) fn explain_why_borrow_contains_point( &self, context: Context, borrow: &BorrowData<'tcx>, diff --git a/src/librustc_mir/borrow_check/nll/facts.rs b/src/librustc_mir/borrow_check/nll/facts.rs index bc33a1c9c65aa..9672d3e78cd50 100644 --- a/src/librustc_mir/borrow_check/nll/facts.rs +++ b/src/librustc_mir/borrow_check/nll/facts.rs @@ -1,5 +1,5 @@ -use borrow_check::location::{LocationIndex, LocationTable}; -use dataflow::indexes::BorrowIndex; +use crate::borrow_check::location::{LocationIndex, LocationTable}; +use crate::dataflow::indexes::BorrowIndex; use polonius_engine::AllFacts as PoloniusAllFacts; use polonius_engine::Atom; use rustc::ty::{RegionVid, TyCtxt}; diff --git a/src/librustc_mir/borrow_check/nll/invalidation.rs b/src/librustc_mir/borrow_check/nll/invalidation.rs index 112b39952559b..3df6b797a44fb 100644 --- a/src/librustc_mir/borrow_check/nll/invalidation.rs +++ b/src/librustc_mir/borrow_check/nll/invalidation.rs @@ -1,15 +1,15 @@ -use borrow_check::borrow_set::BorrowSet; -use borrow_check::location::LocationTable; -use borrow_check::{JustWrite, WriteAndRead}; -use borrow_check::{AccessDepth, Deep, Shallow}; -use borrow_check::{ReadOrWrite, Activation, Read, Reservation, Write}; -use borrow_check::{Context, ContextKind}; -use borrow_check::{LocalMutationIsAllowed, MutateMode}; -use borrow_check::ArtificialField; -use borrow_check::{ReadKind, WriteKind}; -use borrow_check::nll::facts::AllFacts; -use borrow_check::path_utils::*; -use dataflow::move_paths::indexes::BorrowIndex; +use crate::borrow_check::borrow_set::BorrowSet; +use crate::borrow_check::location::LocationTable; +use crate::borrow_check::{JustWrite, WriteAndRead}; +use crate::borrow_check::{AccessDepth, Deep, Shallow}; +use crate::borrow_check::{ReadOrWrite, Activation, Read, Reservation, Write}; +use crate::borrow_check::{Context, ContextKind}; +use crate::borrow_check::{LocalMutationIsAllowed, MutateMode}; +use crate::borrow_check::ArtificialField; +use crate::borrow_check::{ReadKind, WriteKind}; +use crate::borrow_check::nll::facts::AllFacts; +use crate::borrow_check::path_utils::*; +use crate::dataflow::move_paths::indexes::BorrowIndex; use rustc::ty::TyCtxt; use rustc::mir::visit::Visitor; use rustc::mir::{BasicBlock, Location, Mir, Place, Rvalue}; diff --git a/src/librustc_mir/borrow_check/nll/mod.rs b/src/librustc_mir/borrow_check/nll/mod.rs index a092c3b8ecde2..128d54c9f49d7 100644 --- a/src/librustc_mir/borrow_check/nll/mod.rs +++ b/src/librustc_mir/borrow_check/nll/mod.rs @@ -1,13 +1,14 @@ -use borrow_check::borrow_set::BorrowSet; -use borrow_check::location::{LocationIndex, LocationTable}; -use borrow_check::nll::facts::AllFactsExt; -use borrow_check::nll::type_check::{MirTypeckResults, MirTypeckRegionConstraints}; -use borrow_check::nll::type_check::liveness::liveness_map::NllLivenessMap; -use borrow_check::nll::region_infer::values::RegionValueElements; -use dataflow::indexes::BorrowIndex; -use dataflow::move_paths::MoveData; -use dataflow::FlowAtLocation; -use dataflow::MaybeInitializedPlaces; +use crate::borrow_check::borrow_set::BorrowSet; +use crate::borrow_check::location::{LocationIndex, LocationTable}; +use crate::borrow_check::nll::facts::AllFactsExt; +use crate::borrow_check::nll::type_check::{MirTypeckResults, MirTypeckRegionConstraints}; +use crate::borrow_check::nll::type_check::liveness::liveness_map::NllLivenessMap; +use crate::borrow_check::nll::region_infer::values::RegionValueElements; +use crate::dataflow::indexes::BorrowIndex; +use crate::dataflow::move_paths::MoveData; +use crate::dataflow::FlowAtLocation; +use crate::dataflow::MaybeInitializedPlaces; +use crate::transform::MirSource; use rustc::hir::def_id::DefId; use rustc::infer::InferCtxt; use rustc::mir::{ClosureOutlivesSubject, ClosureRegionRequirements, Mir}; @@ -19,12 +20,11 @@ use std::io; use std::path::PathBuf; use std::rc::Rc; use std::str::FromStr; -use transform::MirSource; use self::mir_util::PassWhere; use polonius_engine::{Algorithm, Output}; -use util as mir_util; -use util::pretty; +use crate::util as mir_util; +use crate::util::pretty; mod constraint_generation; pub mod explain_borrow; @@ -45,7 +45,7 @@ use self::universal_regions::UniversalRegions; /// scraping out the set of universal regions (e.g., region parameters) /// declared on the function. That set will need to be given to /// `compute_regions`. -pub(in borrow_check) fn replace_regions_in_mir<'cx, 'gcx, 'tcx>( +pub(in crate::borrow_check) fn replace_regions_in_mir<'cx, 'gcx, 'tcx>( infcx: &InferCtxt<'cx, 'gcx, 'tcx>, def_id: DefId, param_env: ty::ParamEnv<'tcx>, @@ -68,7 +68,7 @@ pub(in borrow_check) fn replace_regions_in_mir<'cx, 'gcx, 'tcx>( /// Computes the (non-lexical) regions from the input MIR. /// /// This may result in errors being reported. -pub(in borrow_check) fn compute_regions<'cx, 'gcx, 'tcx>( +pub(in crate::borrow_check) fn compute_regions<'cx, 'gcx, 'tcx>( infcx: &InferCtxt<'cx, 'gcx, 'tcx>, def_id: DefId, universal_regions: UniversalRegions<'tcx>, @@ -211,8 +211,8 @@ fn dump_mir_results<'a, 'gcx, 'tcx>( infcx: &InferCtxt<'a, 'gcx, 'tcx>, source: MirSource, mir: &Mir<'tcx>, - regioncx: &RegionInferenceContext, - closure_region_requirements: &Option, + regioncx: &RegionInferenceContext<'_>, + closure_region_requirements: &Option>, ) { if !mir_util::dump_enabled(infcx.tcx, "nll", source) { return; @@ -273,7 +273,7 @@ fn dump_annotation<'a, 'gcx, 'tcx>( mir: &Mir<'tcx>, mir_def_id: DefId, regioncx: &RegionInferenceContext<'tcx>, - closure_region_requirements: &Option, + closure_region_requirements: &Option>, errors_buffer: &mut Vec, ) { let tcx = infcx.tcx; @@ -322,7 +322,7 @@ fn dump_annotation<'a, 'gcx, 'tcx>( } fn for_each_region_constraint( - closure_region_requirements: &ClosureRegionRequirements, + closure_region_requirements: &ClosureRegionRequirements<'_>, with_msg: &mut dyn FnMut(&str) -> io::Result<()>, ) -> io::Result<()> { for req in &closure_region_requirements.outlives_requirements { diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs index 550668a7ceece..3498e3437676c 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs @@ -1,8 +1,9 @@ -use borrow_check::nll::constraints::OutlivesConstraint; -use borrow_check::nll::region_infer::RegionInferenceContext; -use borrow_check::nll::type_check::Locations; -use borrow_check::nll::universal_regions::DefiningTy; -use borrow_check::nll::ConstraintDescription; +use crate::borrow_check::nll::constraints::OutlivesConstraint; +use crate::borrow_check::nll::region_infer::RegionInferenceContext; +use crate::borrow_check::nll::type_check::Locations; +use crate::borrow_check::nll::universal_regions::DefiningTy; +use crate::borrow_check::nll::ConstraintDescription; +use crate::util::borrowck_errors::{BorrowckErrors, Origin}; use rustc::hir::def_id::DefId; use rustc::infer::error_reporting::nice_region_error::NiceRegionError; use rustc::infer::InferCtxt; @@ -15,7 +16,6 @@ use std::collections::VecDeque; use syntax::errors::Applicability; use syntax::symbol::keywords; use syntax_pos::Span; -use util::borrowck_errors::{BorrowckErrors, Origin}; mod region_name; mod var_name; diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs index bff8015511242..2c4f359f65fa5 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs @@ -1,7 +1,7 @@ use std::fmt::{self, Display}; -use borrow_check::nll::region_infer::RegionInferenceContext; -use borrow_check::nll::universal_regions::DefiningTy; -use borrow_check::nll::ToRegionVid; +use crate::borrow_check::nll::region_infer::RegionInferenceContext; +use crate::borrow_check::nll::universal_regions::DefiningTy; +use crate::borrow_check::nll::ToRegionVid; use rustc::hir; use rustc::hir::def_id::DefId; use rustc::infer::InferCtxt; @@ -109,7 +109,7 @@ impl RegionName { } impl Display for RegionName { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.name) } } diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs index c2f2e99c0a55b..bd7b8829c7b4f 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/var_name.rs @@ -1,5 +1,5 @@ -use borrow_check::nll::region_infer::RegionInferenceContext; -use borrow_check::nll::ToRegionVid; +use crate::borrow_check::nll::region_infer::RegionInferenceContext; +use crate::borrow_check::nll::ToRegionVid; use rustc::mir::{Local, Mir}; use rustc::ty::{RegionVid, TyCtxt}; use rustc_data_structures::indexed_vec::Idx; diff --git a/src/librustc_mir/borrow_check/nll/region_infer/graphviz.rs b/src/librustc_mir/borrow_check/nll/region_infer/graphviz.rs index 2da158be432be..cffc66ac7ddfd 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/graphviz.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/graphviz.rs @@ -3,8 +3,7 @@ //! data to rendered labels. use super::*; -use borrow_check::nll::constraints::OutlivesConstraint; -use dot; +use crate::borrow_check::nll::constraints::OutlivesConstraint; use std::borrow::Cow; use std::io::{self, Write}; diff --git a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs index fee5dc8646587..7fe657702d756 100644 --- a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs +++ b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs @@ -1,9 +1,11 @@ use super::universal_regions::UniversalRegions; -use borrow_check::nll::constraints::graph::NormalConstraintGraph; -use borrow_check::nll::constraints::{ConstraintSccIndex, ConstraintSet, OutlivesConstraint}; -use borrow_check::nll::region_infer::values::{PlaceholderIndices, RegionElement, ToElementIndex}; -use borrow_check::nll::type_check::free_region_relations::UniversalRegionRelations; -use borrow_check::nll::type_check::Locations; +use crate::borrow_check::nll::constraints::graph::NormalConstraintGraph; +use crate::borrow_check::nll::constraints::{ConstraintSccIndex, ConstraintSet, OutlivesConstraint}; +use crate::borrow_check::nll::region_infer::values::{ + PlaceholderIndices, RegionElement, ToElementIndex +}; +use crate::borrow_check::nll::type_check::free_region_relations::UniversalRegionRelations; +use crate::borrow_check::nll::type_check::Locations; use rustc::hir::def_id::DefId; use rustc::infer::canonical::QueryRegionConstraint; use rustc::infer::region_constraints::{GenericKind, VarInfos, VerifyBound}; diff --git a/src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs b/src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs index b7555e57a62bb..1a72205ad7ae1 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs @@ -1,8 +1,8 @@ -use borrow_check::nll::constraints::OutlivesConstraint; -use borrow_check::nll::region_infer::TypeTest; -use borrow_check::nll::type_check::{Locations, MirTypeckRegionConstraints}; -use borrow_check::nll::universal_regions::UniversalRegions; -use borrow_check::nll::ToRegionVid; +use crate::borrow_check::nll::constraints::OutlivesConstraint; +use crate::borrow_check::nll::region_infer::TypeTest; +use crate::borrow_check::nll::type_check::{Locations, MirTypeckRegionConstraints}; +use crate::borrow_check::nll::universal_regions::UniversalRegions; +use crate::borrow_check::nll::ToRegionVid; use rustc::infer::canonical::QueryRegionConstraint; use rustc::infer::outlives::env::RegionBoundPairs; use rustc::infer::outlives::obligations::{TypeOutlives, TypeOutlivesDelegate}; diff --git a/src/librustc_mir/borrow_check/nll/type_check/free_region_relations.rs b/src/librustc_mir/borrow_check/nll/type_check/free_region_relations.rs index b19dc9091cb86..f549aea81f69f 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/free_region_relations.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/free_region_relations.rs @@ -1,7 +1,7 @@ -use borrow_check::nll::type_check::constraint_conversion; -use borrow_check::nll::type_check::{Locations, MirTypeckRegionConstraints}; -use borrow_check::nll::universal_regions::UniversalRegions; -use borrow_check::nll::ToRegionVid; +use crate::borrow_check::nll::type_check::constraint_conversion; +use crate::borrow_check::nll::type_check::{Locations, MirTypeckRegionConstraints}; +use crate::borrow_check::nll::universal_regions::UniversalRegions; +use crate::borrow_check::nll::ToRegionVid; use rustc::infer::canonical::QueryRegionConstraint; use rustc::infer::outlives::free_region_map::FreeRegionRelations; use rustc::infer::region_constraints::GenericKind; diff --git a/src/librustc_mir/borrow_check/nll/type_check/input_output.rs b/src/librustc_mir/borrow_check/nll/type_check/input_output.rs index ef0f7e1b217a9..50828c294fa1b 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/input_output.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/input_output.rs @@ -7,7 +7,7 @@ //! `RETURN_PLACE` the MIR arguments) are always fully normalized (and //! contain revealed `impl Trait` values). -use borrow_check::nll::universal_regions::UniversalRegions; +use crate::borrow_check::nll::universal_regions::UniversalRegions; use rustc::infer::LateBoundRegionConversionTime; use rustc::mir::*; use rustc::ty::Ty; diff --git a/src/librustc_mir/borrow_check/nll/type_check/liveness/liveness_map.rs b/src/librustc_mir/borrow_check/nll/type_check/liveness/liveness_map.rs index dda74e6a6a688..5e2e4407cbecd 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/liveness/liveness_map.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/liveness/liveness_map.rs @@ -6,13 +6,13 @@ //! liveness code so that it only operates over variables with regions in their //! types, instead of all variables. -use borrow_check::nll::ToRegionVid; -use borrow_check::nll::facts::{AllFacts, AllFactsExt}; +use crate::borrow_check::nll::ToRegionVid; +use crate::borrow_check::nll::facts::{AllFacts, AllFactsExt}; +use crate::util::liveness::LiveVariableMap; use rustc::mir::{Local, Mir}; use rustc::ty::{RegionVid, TyCtxt}; use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::indexed_vec::{Idx, IndexVec}; -use util::liveness::LiveVariableMap; /// Map between Local and LiveVar indices: the purpose of this /// map is to define the subset of local variables for which we need diff --git a/src/librustc_mir/borrow_check/nll/type_check/liveness/local_use_map.rs b/src/librustc_mir/borrow_check/nll/type_check/liveness/local_use_map.rs index 3f13cc8b64778..e9765d2798cd7 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/liveness/local_use_map.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/liveness/local_use_map.rs @@ -1,10 +1,10 @@ -use borrow_check::nll::region_infer::values::{PointIndex, RegionValueElements}; -use borrow_check::nll::type_check::liveness::liveness_map::{LiveVar, NllLivenessMap}; +use crate::borrow_check::nll::region_infer::values::{PointIndex, RegionValueElements}; +use crate::borrow_check::nll::type_check::liveness::liveness_map::{LiveVar, NllLivenessMap}; +use crate::util::liveness::{categorize, DefUse, LiveVariableMap}; use rustc::mir::visit::{PlaceContext, Visitor}; use rustc::mir::{Local, Location, Mir}; use rustc_data_structures::indexed_vec::{Idx, IndexVec}; use rustc_data_structures::vec_linked_list as vll; -use util::liveness::{categorize, DefUse, LiveVariableMap}; /// A map that cross references each local with the locations where it /// is defined (assigned), used, or dropped. Used during liveness diff --git a/src/librustc_mir/borrow_check/nll/type_check/liveness/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/liveness/mod.rs index 633695a9b9ce5..a5510ba6936cc 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/liveness/mod.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/liveness/mod.rs @@ -1,11 +1,11 @@ -use borrow_check::location::LocationTable; -use borrow_check::nll::region_infer::values::RegionValueElements; -use borrow_check::nll::constraints::ConstraintSet; -use borrow_check::nll::NllLivenessMap; -use borrow_check::nll::universal_regions::UniversalRegions; -use dataflow::move_paths::MoveData; -use dataflow::MaybeInitializedPlaces; -use dataflow::FlowAtLocation; +use crate::borrow_check::location::LocationTable; +use crate::borrow_check::nll::region_infer::values::RegionValueElements; +use crate::borrow_check::nll::constraints::ConstraintSet; +use crate::borrow_check::nll::NllLivenessMap; +use crate::borrow_check::nll::universal_regions::UniversalRegions; +use crate::dataflow::move_paths::MoveData; +use crate::dataflow::MaybeInitializedPlaces; +use crate::dataflow::FlowAtLocation; use rustc::mir::Mir; use rustc::ty::RegionVid; use rustc_data_structures::fx::FxHashSet; diff --git a/src/librustc_mir/borrow_check/nll/type_check/liveness/trace.rs b/src/librustc_mir/borrow_check/nll/type_check/liveness/trace.rs index 77e8dd9d130e3..d058be03f55e6 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/liveness/trace.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/liveness/trace.rs @@ -1,12 +1,13 @@ -use borrow_check::location::LocationTable; -use borrow_check::nll::region_infer::values::{self, PointIndex, RegionValueElements}; -use borrow_check::nll::type_check::liveness::liveness_map::{LiveVar, NllLivenessMap}; -use borrow_check::nll::type_check::liveness::local_use_map::LocalUseMap; -use borrow_check::nll::type_check::NormalizeLocation; -use borrow_check::nll::type_check::TypeChecker; -use dataflow::move_paths::indexes::MovePathIndex; -use dataflow::move_paths::MoveData; -use dataflow::{FlowAtLocation, FlowsAtLocation, MaybeInitializedPlaces}; +use crate::borrow_check::location::LocationTable; +use crate::borrow_check::nll::region_infer::values::{self, PointIndex, RegionValueElements}; +use crate::borrow_check::nll::type_check::liveness::liveness_map::{LiveVar, NllLivenessMap}; +use crate::borrow_check::nll::type_check::liveness::local_use_map::LocalUseMap; +use crate::borrow_check::nll::type_check::NormalizeLocation; +use crate::borrow_check::nll::type_check::TypeChecker; +use crate::dataflow::move_paths::indexes::MovePathIndex; +use crate::dataflow::move_paths::MoveData; +use crate::dataflow::{FlowAtLocation, FlowsAtLocation, MaybeInitializedPlaces}; +use crate::util::liveness::LiveVariableMap; use rustc::infer::canonical::QueryRegionConstraint; use rustc::mir::{BasicBlock, ConstraintCategory, Local, Location, Mir}; use rustc::traits::query::dropck_outlives::DropckOutlivesResult; @@ -16,7 +17,6 @@ use rustc::ty::{Ty, TypeFoldable}; use rustc_data_structures::bit_set::HybridBitSet; use rustc_data_structures::fx::FxHashMap; use std::rc::Rc; -use util::liveness::LiveVariableMap; /// This is the heart of the liveness computation. For each variable X /// that requires a liveness computation, it walks over all the uses diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs index 3e6aa358ee0d1..19ff47f9c390d 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/mod.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/mod.rs @@ -2,24 +2,25 @@ #![allow(unreachable_code)] -use borrow_check::borrow_set::BorrowSet; -use borrow_check::location::LocationTable; -use borrow_check::nll::constraints::{ConstraintSet, OutlivesConstraint}; -use borrow_check::nll::facts::AllFacts; -use borrow_check::nll::region_infer::values::LivenessValues; -use borrow_check::nll::region_infer::values::PlaceholderIndex; -use borrow_check::nll::region_infer::values::PlaceholderIndices; -use borrow_check::nll::region_infer::values::RegionValueElements; -use borrow_check::nll::region_infer::{ClosureRegionRequirementsExt, TypeTest}; -use borrow_check::nll::renumber; -use borrow_check::nll::type_check::free_region_relations::{ +use crate::borrow_check::borrow_set::BorrowSet; +use crate::borrow_check::location::LocationTable; +use crate::borrow_check::nll::constraints::{ConstraintSet, OutlivesConstraint}; +use crate::borrow_check::nll::facts::AllFacts; +use crate::borrow_check::nll::region_infer::values::LivenessValues; +use crate::borrow_check::nll::region_infer::values::PlaceholderIndex; +use crate::borrow_check::nll::region_infer::values::PlaceholderIndices; +use crate::borrow_check::nll::region_infer::values::RegionValueElements; +use crate::borrow_check::nll::region_infer::{ClosureRegionRequirementsExt, TypeTest}; +use crate::borrow_check::nll::renumber; +use crate::borrow_check::nll::type_check::free_region_relations::{ CreateResult, UniversalRegionRelations, }; -use borrow_check::nll::universal_regions::{DefiningTy, UniversalRegions}; -use borrow_check::nll::ToRegionVid; -use dataflow::move_paths::MoveData; -use dataflow::FlowAtLocation; -use dataflow::MaybeInitializedPlaces; +use crate::borrow_check::nll::universal_regions::{DefiningTy, UniversalRegions}; +use crate::borrow_check::nll::ToRegionVid; +use crate::dataflow::move_paths::MoveData; +use crate::dataflow::FlowAtLocation; +use crate::dataflow::MaybeInitializedPlaces; +use crate::transform::{MirPass, MirSource}; use either::Either; use rustc::hir; use rustc::hir::def_id::DefId; @@ -46,7 +47,6 @@ use rustc::ty::layout::VariantIdx; use std::rc::Rc; use std::{fmt, iter}; use syntax_pos::{Span, DUMMY_SP}; -use transform::{MirPass, MirSource}; macro_rules! span_mirbug { ($context:expr, $elem:expr, $($message:tt)*) => ({ @@ -210,7 +210,7 @@ fn type_check_internal<'a, 'gcx, 'tcx, R>( extra(&mut checker) } -fn translate_outlives_facts(cx: &mut BorrowCheckContext) { +fn translate_outlives_facts(cx: &mut BorrowCheckContext<'_, '_>) { if let Some(facts) = cx.all_facts { let location_table = cx.location_table; facts @@ -235,7 +235,7 @@ fn translate_outlives_facts(cx: &mut BorrowCheckContext) { } } -fn mirbug(tcx: TyCtxt, span: Span, msg: &str) { +fn mirbug(tcx: TyCtxt<'_, '_, '_>, span: Span, msg: &str) { // We sometimes see MIR failures (notably predicate failures) due to // the fact that we check rvalue sized predicates here. So use `delay_span_bug` // to avoid reporting bugs in those cases. @@ -266,7 +266,7 @@ impl<'a, 'b, 'gcx, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'gcx, 'tcx> { } } - fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) { + fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext<'_>, location: Location) { self.sanitize_place(place, location, context); } @@ -447,7 +447,7 @@ impl<'a, 'b, 'gcx, 'tcx> TypeVerifier<'a, 'b, 'gcx, 'tcx> { &mut self, place: &Place<'tcx>, location: Location, - context: PlaceContext, + context: PlaceContext<'_>, ) -> PlaceTy<'tcx> { debug!("sanitize_place: {:?}", place); let place_ty = match *place { diff --git a/src/librustc_mir/borrow_check/nll/type_check/relate_tys.rs b/src/librustc_mir/borrow_check/nll/type_check/relate_tys.rs index 74ad7d988cc1a..1748e30089021 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/relate_tys.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/relate_tys.rs @@ -1,5 +1,5 @@ -use borrow_check::nll::constraints::OutlivesConstraint; -use borrow_check::nll::type_check::{BorrowCheckContext, Locations}; +use crate::borrow_check::nll::constraints::OutlivesConstraint; +use crate::borrow_check::nll::type_check::{BorrowCheckContext, Locations}; use rustc::infer::nll_relate::{TypeRelating, TypeRelatingDelegate, NormalizationStrategy}; use rustc::infer::{InferCtxt, NLLRegionVariableOrigin}; use rustc::mir::ConstraintCategory; diff --git a/src/librustc_mir/borrow_check/path_utils.rs b/src/librustc_mir/borrow_check/path_utils.rs index 6875aced8d231..1cea9f662d351 100644 --- a/src/librustc_mir/borrow_check/path_utils.rs +++ b/src/librustc_mir/borrow_check/path_utils.rs @@ -1,8 +1,8 @@ -use borrow_check::borrow_set::{BorrowSet, BorrowData, TwoPhaseActivation}; -use borrow_check::places_conflict; -use borrow_check::Context; -use borrow_check::AccessDepth; -use dataflow::indexes::BorrowIndex; +use crate::borrow_check::borrow_set::{BorrowSet, BorrowData, TwoPhaseActivation}; +use crate::borrow_check::places_conflict; +use crate::borrow_check::Context; +use crate::borrow_check::AccessDepth; +use crate::dataflow::indexes::BorrowIndex; use rustc::mir::{BasicBlock, Location, Mir, Place}; use rustc::mir::{ProjectionElem, BorrowKind}; use rustc::ty::TyCtxt; diff --git a/src/librustc_mir/borrow_check/place_ext.rs b/src/librustc_mir/borrow_check/place_ext.rs index 4d0b25b1024a3..bad236a6f5256 100644 --- a/src/librustc_mir/borrow_check/place_ext.rs +++ b/src/librustc_mir/borrow_check/place_ext.rs @@ -2,7 +2,7 @@ use rustc::hir; use rustc::mir::ProjectionElem; use rustc::mir::{Local, Mir, Place, Mutability}; use rustc::ty::{self, TyCtxt}; -use borrow_check::borrow_set::LocalsStateAtExit; +use crate::borrow_check::borrow_set::LocalsStateAtExit; /// Extension methods for the `Place` type. crate trait PlaceExt<'tcx> { diff --git a/src/librustc_mir/borrow_check/places_conflict.rs b/src/librustc_mir/borrow_check/places_conflict.rs index ac7182abb36da..cd33f22bf3cb7 100644 --- a/src/librustc_mir/borrow_check/places_conflict.rs +++ b/src/librustc_mir/borrow_check/places_conflict.rs @@ -1,6 +1,6 @@ -use borrow_check::ArtificialField; -use borrow_check::Overlap; -use borrow_check::{Deep, Shallow, AccessDepth}; +use crate::borrow_check::ArtificialField; +use crate::borrow_check::Overlap; +use crate::borrow_check::{Deep, Shallow, AccessDepth}; use rustc::hir; use rustc::mir::{BorrowKind, Mir, Place}; use rustc::mir::{Projection, ProjectionElem}; diff --git a/src/librustc_mir/borrow_check/used_muts.rs b/src/librustc_mir/borrow_check/used_muts.rs index 0ff7ff4de10de..8c7359bdee768 100644 --- a/src/librustc_mir/borrow_check/used_muts.rs +++ b/src/librustc_mir/borrow_check/used_muts.rs @@ -3,7 +3,7 @@ use rustc::mir::{BasicBlock, Local, Location, Place, Statement, StatementKind, T use rustc_data_structures::fx::FxHashSet; -use borrow_check::MirBorrowckCtxt; +use crate::borrow_check::MirBorrowckCtxt; impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> { /// Walks the MIR adding to the set of `used_mut` locals that will be ignored for the purposes diff --git a/src/librustc_mir/build/block.rs b/src/librustc_mir/build/block.rs index f3d89a7a02515..7d93e131a6ca9 100644 --- a/src/librustc_mir/build/block.rs +++ b/src/librustc_mir/build/block.rs @@ -1,7 +1,7 @@ -use build::{BlockAnd, BlockAndExtension, BlockFrame, Builder}; -use build::ForGuard::OutsideGuard; -use build::matches::ArmHasGuard; -use hair::*; +use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder}; +use crate::build::ForGuard::OutsideGuard; +use crate::build::matches::ArmHasGuard; +use crate::hair::*; use rustc::mir::*; use rustc::hir; use syntax_pos::Span; diff --git a/src/librustc_mir/build/cfg.rs b/src/librustc_mir/build/cfg.rs index a9e468db1d1b7..778d1e71cedfc 100644 --- a/src/librustc_mir/build/cfg.rs +++ b/src/librustc_mir/build/cfg.rs @@ -1,6 +1,6 @@ //! Routines for manipulating the control-flow graph. -use build::CFG; +use crate::build::CFG; use rustc::mir::*; impl<'tcx> CFG<'tcx> { diff --git a/src/librustc_mir/build/expr/as_constant.rs b/src/librustc_mir/build/expr/as_constant.rs index 31e0c0daa3fa6..614668170d5be 100644 --- a/src/librustc_mir/build/expr/as_constant.rs +++ b/src/librustc_mir/build/expr/as_constant.rs @@ -1,7 +1,7 @@ //! See docs in build/expr/mod.rs -use build::Builder; -use hair::*; +use crate::build::Builder; +use crate::hair::*; use rustc::mir::*; use rustc::ty::CanonicalUserTypeAnnotation; diff --git a/src/librustc_mir/build/expr/as_operand.rs b/src/librustc_mir/build/expr/as_operand.rs index 1f653575a7fbf..38fae8539c8d7 100644 --- a/src/librustc_mir/build/expr/as_operand.rs +++ b/src/librustc_mir/build/expr/as_operand.rs @@ -1,8 +1,8 @@ //! See docs in build/expr/mod.rs -use build::expr::category::Category; -use build::{BlockAnd, BlockAndExtension, Builder}; -use hair::*; +use crate::build::expr::category::Category; +use crate::build::{BlockAnd, BlockAndExtension, Builder}; +use crate::hair::*; use rustc::middle::region; use rustc::mir::*; diff --git a/src/librustc_mir/build/expr/as_place.rs b/src/librustc_mir/build/expr/as_place.rs index 6bd61ab53fd21..ed444191226a1 100644 --- a/src/librustc_mir/build/expr/as_place.rs +++ b/src/librustc_mir/build/expr/as_place.rs @@ -1,9 +1,9 @@ //! See docs in build/expr/mod.rs -use build::expr::category::Category; -use build::ForGuard::{OutsideGuard, RefWithinGuard}; -use build::{BlockAnd, BlockAndExtension, Builder}; -use hair::*; +use crate::build::expr::category::Category; +use crate::build::ForGuard::{OutsideGuard, RefWithinGuard}; +use crate::build::{BlockAnd, BlockAndExtension, Builder}; +use crate::hair::*; use rustc::mir::interpret::EvalErrorKind::BoundsCheck; use rustc::mir::*; use rustc::ty::{CanonicalUserTypeAnnotation, Variance}; diff --git a/src/librustc_mir/build/expr/as_rvalue.rs b/src/librustc_mir/build/expr/as_rvalue.rs index 3de2f47578650..06658675f70f4 100644 --- a/src/librustc_mir/build/expr/as_rvalue.rs +++ b/src/librustc_mir/build/expr/as_rvalue.rs @@ -3,9 +3,9 @@ use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::indexed_vec::Idx; -use build::expr::category::{Category, RvalueFunc}; -use build::{BlockAnd, BlockAndExtension, Builder}; -use hair::*; +use crate::build::expr::category::{Category, RvalueFunc}; +use crate::build::{BlockAnd, BlockAndExtension, Builder}; +use crate::hair::*; use rustc::middle::region; use rustc::mir::interpret::EvalErrorKind; use rustc::mir::*; diff --git a/src/librustc_mir/build/expr/as_temp.rs b/src/librustc_mir/build/expr/as_temp.rs index df271ff6e4016..efa1a4895e0c0 100644 --- a/src/librustc_mir/build/expr/as_temp.rs +++ b/src/librustc_mir/build/expr/as_temp.rs @@ -1,7 +1,7 @@ //! See docs in build/expr/mod.rs -use build::{BlockAnd, BlockAndExtension, Builder}; -use hair::*; +use crate::build::{BlockAnd, BlockAndExtension, Builder}; +use crate::hair::*; use rustc::middle::region; use rustc::mir::*; diff --git a/src/librustc_mir/build/expr/category.rs b/src/librustc_mir/build/expr/category.rs index 53f84a495696c..ca7d435e62229 100644 --- a/src/librustc_mir/build/expr/category.rs +++ b/src/librustc_mir/build/expr/category.rs @@ -1,4 +1,4 @@ -use hair::*; +use crate::hair::*; #[derive(Debug, PartialEq)] pub enum Category { diff --git a/src/librustc_mir/build/expr/into.rs b/src/librustc_mir/build/expr/into.rs index 2ffff68137dd2..05231bc7b3f16 100644 --- a/src/librustc_mir/build/expr/into.rs +++ b/src/librustc_mir/build/expr/into.rs @@ -1,8 +1,8 @@ //! See docs in build/expr/mod.rs -use build::expr::category::{Category, RvalueFunc}; -use build::{BlockAnd, BlockAndExtension, BlockFrame, Builder}; -use hair::*; +use crate::build::expr::category::{Category, RvalueFunc}; +use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder}; +use crate::hair::*; use rustc::mir::*; use rustc::ty; diff --git a/src/librustc_mir/build/expr/stmt.rs b/src/librustc_mir/build/expr/stmt.rs index 1cbc60586c356..aadc2368f5aec 100644 --- a/src/librustc_mir/build/expr/stmt.rs +++ b/src/librustc_mir/build/expr/stmt.rs @@ -1,6 +1,6 @@ -use build::scope::BreakableScope; -use build::{BlockAnd, BlockAndExtension, BlockFrame, Builder}; -use hair::*; +use crate::build::scope::BreakableScope; +use crate::build::{BlockAnd, BlockAndExtension, BlockFrame, Builder}; +use crate::hair::*; use rustc::mir::*; impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> { diff --git a/src/librustc_mir/build/into.rs b/src/librustc_mir/build/into.rs index 1b29126082067..67b6540febea8 100644 --- a/src/librustc_mir/build/into.rs +++ b/src/librustc_mir/build/into.rs @@ -4,11 +4,11 @@ //! wrapped up as expressions (e.g., blocks). To make this ergonomic, we use this //! latter `EvalInto` trait. -use build::{BlockAnd, Builder}; -use hair::*; +use crate::build::{BlockAnd, Builder}; +use crate::hair::*; use rustc::mir::*; -pub(in build) trait EvalInto<'tcx> { +pub(in crate::build) trait EvalInto<'tcx> { fn eval_into<'a, 'gcx>(self, builder: &mut Builder<'a, 'gcx, 'tcx>, destination: &Place<'tcx>, diff --git a/src/librustc_mir/build/matches/mod.rs b/src/librustc_mir/build/matches/mod.rs index 2f1e8c03f2f7e..cf051ba2e0fa6 100644 --- a/src/librustc_mir/build/matches/mod.rs +++ b/src/librustc_mir/build/matches/mod.rs @@ -3,11 +3,11 @@ //! includes the high-level algorithm, the submodules contain the //! details. -use build::scope::{CachedBlock, DropKind}; -use build::ForGuard::{self, OutsideGuard, RefWithinGuard, ValWithinGuard}; -use build::{BlockAnd, BlockAndExtension, Builder}; -use build::{GuardFrame, GuardFrameLocal, LocalsForNode}; -use hair::*; +use crate::build::scope::{CachedBlock, DropKind}; +use crate::build::ForGuard::{self, OutsideGuard, RefWithinGuard, ValWithinGuard}; +use crate::build::{BlockAnd, BlockAndExtension, Builder}; +use crate::build::{GuardFrame, GuardFrameLocal, LocalsForNode}; +use crate::hair::*; use rustc::mir::*; use rustc::ty::{self, CanonicalUserTypeAnnotation, Ty}; use rustc::ty::layout::VariantIdx; diff --git a/src/librustc_mir/build/matches/simplify.rs b/src/librustc_mir/build/matches/simplify.rs index c219fd2218223..6be9ccb27036e 100644 --- a/src/librustc_mir/build/matches/simplify.rs +++ b/src/librustc_mir/build/matches/simplify.rs @@ -12,9 +12,9 @@ //! sort of test: for example, testing which variant an enum is, or //! testing a value against a constant. -use build::Builder; -use build::matches::{Ascription, Binding, MatchPair, Candidate}; -use hair::*; +use crate::build::Builder; +use crate::build::matches::{Ascription, Binding, MatchPair, Candidate}; +use crate::hair::*; use rustc::ty; use rustc::ty::layout::{Integer, IntegerExt, Size}; use syntax::attr::{SignedInt, UnsignedInt}; diff --git a/src/librustc_mir/build/matches/test.rs b/src/librustc_mir/build/matches/test.rs index 696c173b048ad..395858c07b606 100644 --- a/src/librustc_mir/build/matches/test.rs +++ b/src/librustc_mir/build/matches/test.rs @@ -5,10 +5,10 @@ // identify what tests are needed, perform the tests, and then filter // the candidates based on the result. -use build::Builder; -use build::matches::{Candidate, MatchPair, Test, TestKind}; -use hair::*; -use hair::pattern::compare_const_vals; +use crate::build::Builder; +use crate::build::matches::{Candidate, MatchPair, Test, TestKind}; +use crate::hair::*; +use crate::hair::pattern::compare_const_vals; use rustc_data_structures::bit_set::BitSet; use rustc_data_structures::fx::FxHashMap; use rustc::ty::{self, Ty}; diff --git a/src/librustc_mir/build/matches/util.rs b/src/librustc_mir/build/matches/util.rs index b5a1a388e9cbc..ed12c1b3bc9c1 100644 --- a/src/librustc_mir/build/matches/util.rs +++ b/src/librustc_mir/build/matches/util.rs @@ -1,6 +1,6 @@ -use build::Builder; -use build::matches::MatchPair; -use hair::*; +use crate::build::Builder; +use crate::build::matches::MatchPair; +use crate::hair::*; use rustc::mir::*; use std::u32; use std::convert::TryInto; diff --git a/src/librustc_mir/build/misc.rs b/src/librustc_mir/build/misc.rs index c849c02242840..1634c36d34acf 100644 --- a/src/librustc_mir/build/misc.rs +++ b/src/librustc_mir/build/misc.rs @@ -1,7 +1,7 @@ //! Miscellaneous builder routines that are not specific to building any particular //! kind of thing. -use build::Builder; +use crate::build::Builder; use rustc::ty::{self, Ty}; diff --git a/src/librustc_mir/build/mod.rs b/src/librustc_mir/build/mod.rs index f38648fda0e36..a52b032aeb508 100644 --- a/src/librustc_mir/build/mod.rs +++ b/src/librustc_mir/build/mod.rs @@ -1,7 +1,10 @@ -use build; -use build::scope::{CachedBlock, DropKind}; -use hair::cx::Cx; -use hair::{LintLevel, BindingMode, PatternKind}; +use crate::build; +use crate::build::scope::{CachedBlock, DropKind}; +use crate::hair::cx::Cx; +use crate::hair::{LintLevel, BindingMode, PatternKind}; +use crate::shim; +use crate::transform::MirSource; +use crate::util as mir_util; use rustc::hir; use rustc::hir::Node; use rustc::hir::def_id::DefId; @@ -13,7 +16,6 @@ use rustc::ty::subst::Substs; use rustc::util::nodemap::NodeMap; use rustc_target::spec::PanicStrategy; use rustc_data_structures::indexed_vec::{IndexVec, Idx}; -use shim; use std::mem; use std::u32; use rustc_target::spec::abi::Abi; @@ -21,8 +23,6 @@ use syntax::ast; use syntax::attr::{self, UnwindAttr}; use syntax::symbol::keywords; use syntax_pos::Span; -use transform::MirSource; -use util as mir_util; use super::lints; @@ -161,7 +161,7 @@ pub fn mir_build<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Mir<'t }; globalizer.visit_mir(&mut mir); let mir = unsafe { - mem::transmute::>(mir) + mem::transmute::, Mir<'tcx>>(mir) }; mir_util::dump_mir(tcx, None, "mir_map", &0, @@ -241,7 +241,7 @@ fn create_constructor_shim<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, }; globalizer.visit_mir(&mut mir); let mir = unsafe { - mem::transmute::>(mir) + mem::transmute::, Mir<'tcx>>(mir) }; mir_util::dump_mir(tcx, None, "mir_map", &0, diff --git a/src/librustc_mir/build/scope.rs b/src/librustc_mir/build/scope.rs index 78abba5f885b2..3872f5db26278 100644 --- a/src/librustc_mir/build/scope.rs +++ b/src/librustc_mir/build/scope.rs @@ -77,8 +77,8 @@ should go to. */ -use build::{BlockAnd, BlockAndExtension, Builder, CFG}; -use hair::LintLevel; +use crate::build::{BlockAnd, BlockAndExtension, Builder, CFG}; +use crate::hair::LintLevel; use rustc::middle::region; use rustc::ty::Ty; use rustc::hir; diff --git a/src/librustc_mir/const_eval.rs b/src/librustc_mir/const_eval.rs index f83a930353b73..d1b4486dd9345 100644 --- a/src/librustc_mir/const_eval.rs +++ b/src/librustc_mir/const_eval.rs @@ -190,7 +190,7 @@ enum ConstEvalError { } impl fmt::Display for ConstEvalError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { use self::ConstEvalError::*; match *self { NeedsRfc(ref msg) => { diff --git a/src/librustc_mir/dataflow/at_location.rs b/src/librustc_mir/dataflow/at_location.rs index 375bc4fead443..d0b9fbc99f03f 100644 --- a/src/librustc_mir/dataflow/at_location.rs +++ b/src/librustc_mir/dataflow/at_location.rs @@ -4,8 +4,8 @@ use rustc::mir::{BasicBlock, Location}; use rustc_data_structures::bit_set::{BitIter, BitSet, HybridBitSet}; -use dataflow::{BitDenotation, BlockSets, DataflowResults}; -use dataflow::move_paths::{HasMoveData, MovePathIndex}; +use crate::dataflow::{BitDenotation, BlockSets, DataflowResults}; +use crate::dataflow::move_paths::{HasMoveData, MovePathIndex}; use std::iter; @@ -115,7 +115,7 @@ where } /// Returns an iterator over the elements present in the current state. - pub fn iter_incoming(&self) -> iter::Peekable> { + pub fn iter_incoming(&self) -> iter::Peekable> { self.curr_state.iter().peekable() } @@ -124,7 +124,7 @@ where /// Invokes `f` with an iterator over the resulting state. pub fn with_iter_outgoing(&self, f: F) where - F: FnOnce(BitIter), + F: FnOnce(BitIter<'_, BD::Idx>), { let mut curr_state = self.curr_state.clone(); curr_state.union(&self.stmt_gen); diff --git a/src/librustc_mir/dataflow/drop_flag_effects.rs b/src/librustc_mir/dataflow/drop_flag_effects.rs index 22fb7a3bc470e..49499cf928d74 100644 --- a/src/librustc_mir/dataflow/drop_flag_effects.rs +++ b/src/librustc_mir/dataflow/drop_flag_effects.rs @@ -1,6 +1,6 @@ use rustc::mir::{self, Mir, Location}; use rustc::ty::{self, TyCtxt}; -use util::elaborate_drops::DropFlagState; +use crate::util::elaborate_drops::DropFlagState; use super::{MoveDataParamEnv}; use super::indexes::MovePathIndex; diff --git a/src/librustc_mir/dataflow/graphviz.rs b/src/librustc_mir/dataflow/graphviz.rs index 34752baa020e2..9d9f18d4b0dcf 100644 --- a/src/librustc_mir/dataflow/graphviz.rs +++ b/src/librustc_mir/dataflow/graphviz.rs @@ -3,8 +3,6 @@ use syntax::ast::NodeId; use rustc::mir::{BasicBlock, Mir}; -use dot; - use std::fs; use std::io; use std::marker::PhantomData; @@ -59,7 +57,7 @@ pub type Node = BasicBlock; #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub struct Edge { source: BasicBlock, index: usize } -fn outgoing(mir: &Mir, bb: BasicBlock) -> Vec { +fn outgoing(mir: &Mir<'_>, bb: BasicBlock) -> Vec { (0..mir[bb].terminator().successors().count()) .map(|index| Edge { source: bb, index: index}).collect() } @@ -70,18 +68,18 @@ impl<'a, 'tcx, MWF, P> dot::Labeller<'a> for Graph<'a, 'tcx, MWF, P> { type Node = Node; type Edge = Edge; - fn graph_id(&self) -> dot::Id { + fn graph_id(&self) -> dot::Id<'_> { dot::Id::new(format!("graph_for_node_{}", self.mbcx.node_id())) .unwrap() } - fn node_id(&self, n: &Node) -> dot::Id { + fn node_id(&self, n: &Node) -> dot::Id<'_> { dot::Id::new(format!("bb_{}", n.index())) .unwrap() } - fn node_label(&self, n: &Node) -> dot::LabelText { + fn node_label(&self, n: &Node) -> dot::LabelText<'_> { // Node label is something like this: // +---------+----------------------------------+------------------+------------------+ // | ENTRY | MIR | GEN | KILL | @@ -105,7 +103,7 @@ impl<'a, 'tcx, MWF, P> dot::Labeller<'a> for Graph<'a, 'tcx, MWF, P> } - fn node_shape(&self, _n: &Node) -> Option { + fn node_shape(&self, _n: &Node) -> Option> { Some(dot::LabelText::label("none")) } @@ -125,7 +123,7 @@ where MWF: MirWithFlowState<'tcx>, n: &Node, w: &mut W, block: BasicBlock, - mir: &Mir) -> io::Result<()> { + mir: &Mir<'_>) -> io::Result<()> { // Header rows const HDRS: [&str; 4] = ["ENTRY", "MIR", "BLOCK GENS", "BLOCK KILLS"]; const HDR_FMT: &str = "bgcolor=\"grey\""; @@ -150,7 +148,7 @@ where MWF: MirWithFlowState<'tcx>, n: &Node, w: &mut W, block: BasicBlock, - mir: &Mir) + mir: &Mir<'_>) -> io::Result<()> { let i = n.index(); @@ -200,7 +198,7 @@ where MWF: MirWithFlowState<'tcx>, n: &Node, w: &mut W, block: BasicBlock, - mir: &Mir) + mir: &Mir<'_>) -> io::Result<()> { let i = n.index(); @@ -241,7 +239,7 @@ impl<'a, 'tcx, MWF, P> dot::GraphWalk<'a> for Graph<'a, 'tcx, MWF, P> { type Node = Node; type Edge = Edge; - fn nodes(&self) -> dot::Nodes { + fn nodes(&self) -> dot::Nodes<'_, Node> { self.mbcx.mir() .basic_blocks() .indices() @@ -249,7 +247,7 @@ impl<'a, 'tcx, MWF, P> dot::GraphWalk<'a> for Graph<'a, 'tcx, MWF, P> .into() } - fn edges(&self) -> dot::Edges { + fn edges(&self) -> dot::Edges<'_, Edge> { let mir = self.mbcx.mir(); mir.basic_blocks() diff --git a/src/librustc_mir/dataflow/impls/borrowed_locals.rs b/src/librustc_mir/dataflow/impls/borrowed_locals.rs index 9d03e35a35069..51d628ce6c5c2 100644 --- a/src/librustc_mir/dataflow/impls/borrowed_locals.rs +++ b/src/librustc_mir/dataflow/impls/borrowed_locals.rs @@ -2,7 +2,7 @@ pub use super::*; use rustc::mir::*; use rustc::mir::visit::Visitor; -use dataflow::BitDenotation; +use crate::dataflow::BitDenotation; /// This calculates if any part of a MIR local could have previously been borrowed. /// This means that once a local has been borrowed, its bit will be set @@ -38,7 +38,7 @@ impl<'a, 'tcx> BitDenotation<'tcx> for HaveBeenBorrowedLocals<'a, 'tcx> { } fn statement_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, Local>, loc: Location) { let stmt = &self.mir[loc.block].statements[loc.statement_index]; @@ -54,7 +54,7 @@ impl<'a, 'tcx> BitDenotation<'tcx> for HaveBeenBorrowedLocals<'a, 'tcx> { } fn terminator_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, Local>, loc: Location) { BorrowedLocalsVisitor { sets, diff --git a/src/librustc_mir/dataflow/impls/borrows.rs b/src/librustc_mir/dataflow/impls/borrows.rs index 72218e29cfd20..beb0b3187082b 100644 --- a/src/librustc_mir/dataflow/impls/borrows.rs +++ b/src/librustc_mir/dataflow/impls/borrows.rs @@ -1,5 +1,5 @@ -use borrow_check::borrow_set::{BorrowSet, BorrowData}; -use borrow_check::place_ext::PlaceExt; +use crate::borrow_check::borrow_set::{BorrowSet, BorrowData}; +use crate::borrow_check::place_ext::PlaceExt; use rustc::mir::{self, Location, Place, Mir}; use rustc::ty::TyCtxt; @@ -9,11 +9,11 @@ use rustc_data_structures::bit_set::{BitSet, BitSetOperator}; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::indexed_vec::{Idx, IndexVec}; -use dataflow::{BitDenotation, BlockSets, InitialFlow}; -pub use dataflow::indexes::BorrowIndex; -use borrow_check::nll::region_infer::RegionInferenceContext; -use borrow_check::nll::ToRegionVid; -use borrow_check::places_conflict; +use crate::dataflow::{BitDenotation, BlockSets, InitialFlow}; +pub use crate::dataflow::indexes::BorrowIndex; +use crate::borrow_check::nll::region_infer::RegionInferenceContext; +use crate::borrow_check::nll::ToRegionVid; +use crate::borrow_check::places_conflict; use std::rc::Rc; @@ -163,7 +163,7 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> { /// Add all borrows to the kill set, if those borrows are out of scope at `location`. /// That means they went out of a nonlexical scope fn kill_loans_out_of_scope_at_location(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, BorrowIndex>, location: Location) { // NOTE: The state associated with a given `location` // reflects the dataflow on entry to the statement. @@ -184,7 +184,7 @@ impl<'a, 'gcx, 'tcx> Borrows<'a, 'gcx, 'tcx> { /// Kill any borrows that conflict with `place`. fn kill_borrows_on_place( &self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, BorrowIndex>, place: &Place<'tcx> ) { debug!("kill_borrows_on_place: place={:?}", place); @@ -243,13 +243,13 @@ impl<'a, 'gcx, 'tcx> BitDenotation<'tcx> for Borrows<'a, 'gcx, 'tcx> { } fn before_statement_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, BorrowIndex>, location: Location) { debug!("Borrows::before_statement_effect sets: {:?} location: {:?}", sets, location); self.kill_loans_out_of_scope_at_location(sets, location); } - fn statement_effect(&self, sets: &mut BlockSets, location: Location) { + fn statement_effect(&self, sets: &mut BlockSets<'_, BorrowIndex>, location: Location) { debug!("Borrows::statement_effect: sets={:?} location={:?}", sets, location); let block = &self.mir.basic_blocks().get(location.block).unwrap_or_else(|| { @@ -307,13 +307,13 @@ impl<'a, 'gcx, 'tcx> BitDenotation<'tcx> for Borrows<'a, 'gcx, 'tcx> { } fn before_terminator_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, BorrowIndex>, location: Location) { debug!("Borrows::before_terminator_effect sets: {:?} location: {:?}", sets, location); self.kill_loans_out_of_scope_at_location(sets, location); } - fn terminator_effect(&self, _: &mut BlockSets, _: Location) {} + fn terminator_effect(&self, _: &mut BlockSets<'_, BorrowIndex>, _: Location) {} fn propagate_call_return( &self, diff --git a/src/librustc_mir/dataflow/impls/mod.rs b/src/librustc_mir/dataflow/impls/mod.rs index 1ccda3a12e433..c8965b9f7f4c7 100644 --- a/src/librustc_mir/dataflow/impls/mod.rs +++ b/src/librustc_mir/dataflow/impls/mod.rs @@ -9,7 +9,7 @@ use rustc_data_structures::indexed_vec::Idx; use super::MoveDataParamEnv; -use util::elaborate_drops::DropFlagState; +use crate::util::elaborate_drops::DropFlagState; use super::move_paths::{HasMoveData, MoveData, MovePathIndex, InitIndex}; use super::move_paths::{LookupResult, InitKind}; @@ -251,7 +251,7 @@ impl<'a, 'gcx, 'tcx> HasMoveData<'tcx> for EverInitializedPlaces<'a, 'gcx, 'tcx> impl<'a, 'gcx, 'tcx> MaybeInitializedPlaces<'a, 'gcx, 'tcx> { - fn update_bits(sets: &mut BlockSets, path: MovePathIndex, + fn update_bits(sets: &mut BlockSets<'_, MovePathIndex>, path: MovePathIndex, state: DropFlagState) { match state { @@ -262,7 +262,7 @@ impl<'a, 'gcx, 'tcx> MaybeInitializedPlaces<'a, 'gcx, 'tcx> { } impl<'a, 'gcx, 'tcx> MaybeUninitializedPlaces<'a, 'gcx, 'tcx> { - fn update_bits(sets: &mut BlockSets, path: MovePathIndex, + fn update_bits(sets: &mut BlockSets<'_, MovePathIndex>, path: MovePathIndex, state: DropFlagState) { match state { @@ -273,7 +273,7 @@ impl<'a, 'gcx, 'tcx> MaybeUninitializedPlaces<'a, 'gcx, 'tcx> { } impl<'a, 'gcx, 'tcx> DefinitelyInitializedPlaces<'a, 'gcx, 'tcx> { - fn update_bits(sets: &mut BlockSets, path: MovePathIndex, + fn update_bits(sets: &mut BlockSets<'_, MovePathIndex>, path: MovePathIndex, state: DropFlagState) { match state { @@ -300,7 +300,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation<'tcx> for MaybeInitializedPlaces<'a, 'gcx, 't } fn statement_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, MovePathIndex>, location: Location) { drop_flag_effects_for_location( @@ -311,7 +311,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation<'tcx> for MaybeInitializedPlaces<'a, 'gcx, 't } fn terminator_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, MovePathIndex>, location: Location) { drop_flag_effects_for_location( @@ -358,7 +358,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation<'tcx> for MaybeUninitializedPlaces<'a, 'gcx, } fn statement_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, MovePathIndex>, location: Location) { drop_flag_effects_for_location( @@ -369,7 +369,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation<'tcx> for MaybeUninitializedPlaces<'a, 'gcx, } fn terminator_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, MovePathIndex>, location: Location) { drop_flag_effects_for_location( @@ -414,7 +414,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation<'tcx> for DefinitelyInitializedPlaces<'a, 'gc } fn statement_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, MovePathIndex>, location: Location) { drop_flag_effects_for_location( @@ -425,7 +425,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation<'tcx> for DefinitelyInitializedPlaces<'a, 'gc } fn terminator_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, MovePathIndex>, location: Location) { drop_flag_effects_for_location( @@ -464,7 +464,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation<'tcx> for EverInitializedPlaces<'a, 'gcx, 'tc } fn statement_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, InitIndex>, location: Location) { let (_, mir, move_data) = (self.tcx, self.mir, self.move_data()); let stmt = &mir[location.block].statements[location.statement_index]; @@ -511,7 +511,7 @@ impl<'a, 'gcx, 'tcx> BitDenotation<'tcx> for EverInitializedPlaces<'a, 'gcx, 'tc } fn terminator_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, InitIndex>, location: Location) { let (mir, move_data) = (self.mir, self.move_data()); diff --git a/src/librustc_mir/dataflow/impls/storage_liveness.rs b/src/librustc_mir/dataflow/impls/storage_liveness.rs index 9c17076e6fde0..6b8eb6f17f6c1 100644 --- a/src/librustc_mir/dataflow/impls/storage_liveness.rs +++ b/src/librustc_mir/dataflow/impls/storage_liveness.rs @@ -1,7 +1,7 @@ pub use super::*; use rustc::mir::*; -use dataflow::BitDenotation; +use crate::dataflow::BitDenotation; #[derive(Copy, Clone)] pub struct MaybeStorageLive<'a, 'tcx: 'a> { @@ -31,7 +31,7 @@ impl<'a, 'tcx> BitDenotation<'tcx> for MaybeStorageLive<'a, 'tcx> { } fn statement_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, Local>, loc: Location) { let stmt = &self.mir[loc.block].statements[loc.statement_index]; @@ -43,7 +43,7 @@ impl<'a, 'tcx> BitDenotation<'tcx> for MaybeStorageLive<'a, 'tcx> { } fn terminator_effect(&self, - _sets: &mut BlockSets, + _sets: &mut BlockSets<'_, Local>, _loc: Location) { // Terminators have no effect } diff --git a/src/librustc_mir/dataflow/mod.rs b/src/librustc_mir/dataflow/mod.rs index f09db970b7353..1853b60efd7e6 100644 --- a/src/librustc_mir/dataflow/mod.rs +++ b/src/librustc_mir/dataflow/mod.rs @@ -58,7 +58,7 @@ impl DebugFormatted { } impl fmt::Debug for DebugFormatted { - fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result { write!(w, "{}", self.0) } } @@ -525,7 +525,7 @@ impl<'a, E:Idx> BlockSets<'a, E> { impl AllSets { pub fn bits_per_block(&self) -> usize { self.bits_per_block } - pub fn for_block(&mut self, block_idx: usize) -> BlockSets { + pub fn for_block(&mut self, block_idx: usize) -> BlockSets<'_, E> { BlockSets { on_entry: &mut self.on_entry_sets[block_idx], gen_set: &mut self.gen_sets[block_idx], @@ -616,7 +616,7 @@ pub trait BitDenotation<'tcx>: BitSetOperator { /// applied, in that order, before moving for the next /// statement. fn before_statement_effect(&self, - _sets: &mut BlockSets, + _sets: &mut BlockSets<'_, Self::Idx>, _location: Location) {} /// Mutates the block-sets (the flow sets for the given @@ -630,7 +630,7 @@ pub trait BitDenotation<'tcx>: BitSetOperator { /// `bb_data` is the sequence of statements identified by `bb` in /// the MIR. fn statement_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, Self::Idx>, location: Location); /// Similar to `terminator_effect`, except it applies @@ -645,7 +645,7 @@ pub trait BitDenotation<'tcx>: BitSetOperator { /// applied, in that order, before moving for the next /// terminator. fn before_terminator_effect(&self, - _sets: &mut BlockSets, + _sets: &mut BlockSets<'_, Self::Idx>, _location: Location) {} /// Mutates the block-sets (the flow sets for the given @@ -659,7 +659,7 @@ pub trait BitDenotation<'tcx>: BitSetOperator { /// The effects applied here cannot depend on which branch the /// terminator took. fn terminator_effect(&self, - sets: &mut BlockSets, + sets: &mut BlockSets<'_, Self::Idx>, location: Location); /// Mutates the block-sets according to the (flow-dependent) diff --git a/src/librustc_mir/dataflow/move_paths/mod.rs b/src/librustc_mir/dataflow/move_paths/mod.rs index d77216220ac2b..efd979a7da4fb 100644 --- a/src/librustc_mir/dataflow/move_paths/mod.rs +++ b/src/librustc_mir/dataflow/move_paths/mod.rs @@ -37,7 +37,7 @@ pub(crate) mod indexes { } impl fmt::Debug for $Index { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { write!(fmt, "{}{}", $debug_name, self.index()) } } @@ -62,7 +62,7 @@ pub use self::indexes::MoveOutIndex; pub use self::indexes::InitIndex; impl MoveOutIndex { - pub fn move_path_index(&self, move_data: &MoveData) -> MovePathIndex { + pub fn move_path_index(&self, move_data: &MoveData<'_>) -> MovePathIndex { move_data.moves[*self].path } } @@ -88,7 +88,10 @@ pub struct MovePath<'tcx> { } impl<'tcx> MovePath<'tcx> { - pub fn parents(&self, move_paths: &IndexVec) -> Vec { + pub fn parents( + &self, + move_paths: &IndexVec>, + ) -> Vec { let mut parents = Vec::new(); let mut curr_parent = self.parent; @@ -102,7 +105,7 @@ impl<'tcx> MovePath<'tcx> { } impl<'tcx> fmt::Debug for MovePath<'tcx> { - fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result { write!(w, "MovePath {{")?; if let Some(parent) = self.parent { write!(w, " parent: {:?},", parent)?; @@ -118,7 +121,7 @@ impl<'tcx> fmt::Debug for MovePath<'tcx> { } impl<'tcx> fmt::Display for MovePath<'tcx> { - fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result { write!(w, "{:?}", self.place) } } @@ -166,7 +169,7 @@ impl IndexMut for LocationMap { } impl LocationMap where T: Default + Clone { - fn new(mir: &Mir) -> Self { + fn new(mir: &Mir<'_>) -> Self { LocationMap { map: mir.basic_blocks().iter().map(|block| { vec![T::default(); block.statements.len()+1] @@ -190,7 +193,7 @@ pub struct MoveOut { } impl fmt::Debug for MoveOut { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { write!(fmt, "{:?}@{:?}", self.path, self.source) } } @@ -227,7 +230,7 @@ pub enum InitKind { } impl fmt::Debug for Init { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { write!(fmt, "{:?}@{:?} ({:?})", self.path, self.location, self.kind) } } diff --git a/src/librustc_mir/hair/cx/block.rs b/src/librustc_mir/hair/cx/block.rs index 518ae978ae17a..c24cf956504da 100644 --- a/src/librustc_mir/hair/cx/block.rs +++ b/src/librustc_mir/hair/cx/block.rs @@ -1,6 +1,6 @@ -use hair::*; -use hair::cx::Cx; -use hair::cx::to_ref::ToRef; +use crate::hair::*; +use crate::hair::cx::Cx; +use crate::hair::cx::to_ref::ToRef; use rustc::middle::region; use rustc::hir; use rustc::ty; diff --git a/src/librustc_mir/hair/cx/expr.rs b/src/librustc_mir/hair/cx/expr.rs index 8d64c9e9ada89..0759b95a78ff4 100644 --- a/src/librustc_mir/hair/cx/expr.rs +++ b/src/librustc_mir/hair/cx/expr.rs @@ -1,9 +1,9 @@ -use hair::*; +use crate::hair::*; +use crate::hair::cx::Cx; +use crate::hair::cx::block; +use crate::hair::cx::to_ref::ToRef; +use crate::hair::util::UserAnnotatedTyHelpers; use rustc_data_structures::indexed_vec::Idx; -use hair::cx::Cx; -use hair::cx::block; -use hair::cx::to_ref::ToRef; -use hair::util::UserAnnotatedTyHelpers; use rustc::hir::def::{Def, CtorKind}; use rustc::mir::interpret::{GlobalId, ErrorHandled}; use rustc::ty::{self, AdtKind, Ty}; diff --git a/src/librustc_mir/hair/cx/mod.rs b/src/librustc_mir/hair/cx/mod.rs index f514cac6326be..6d61801fc7162 100644 --- a/src/librustc_mir/hair/cx/mod.rs +++ b/src/librustc_mir/hair/cx/mod.rs @@ -4,8 +4,8 @@ //! work. //! -use hair::*; -use hair::util::UserAnnotatedTyHelpers; +use crate::hair::*; +use crate::hair::util::UserAnnotatedTyHelpers; use rustc_data_structures::indexed_vec::Idx; use rustc::hir::def_id::{DefId, LOCAL_CRATE}; @@ -21,7 +21,7 @@ use syntax::attr; use syntax::symbol::Symbol; use rustc::hir; use rustc_data_structures::sync::Lrc; -use hair::constant::{lit_to_const, LitToConstError}; +use crate::hair::constant::{lit_to_const, LitToConstError}; #[derive(Clone)] pub struct Cx<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> { @@ -239,7 +239,7 @@ impl UserAnnotatedTyHelpers<'gcx, 'tcx> for Cx<'_, 'gcx, 'tcx> { } } -fn lint_level_for_hir_id(tcx: TyCtxt, mut id: ast::NodeId) -> ast::NodeId { +fn lint_level_for_hir_id(tcx: TyCtxt<'_, '_, '_>, mut id: ast::NodeId) -> ast::NodeId { // Right now we insert a `with_ignore` node in the dep graph here to // ignore the fact that `lint_levels` below depends on the entire crate. // For now this'll prevent false positives of recompiling too much when diff --git a/src/librustc_mir/hair/cx/to_ref.rs b/src/librustc_mir/hair/cx/to_ref.rs index 1b87e4450c56e..a462c61c2acba 100644 --- a/src/librustc_mir/hair/cx/to_ref.rs +++ b/src/librustc_mir/hair/cx/to_ref.rs @@ -1,4 +1,4 @@ -use hair::*; +use crate::hair::*; use rustc::hir; use syntax::ptr::P; diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs index 7f5b1a761d261..5779a032acc4d 100644 --- a/src/librustc_mir/hair/pattern/_match.rs +++ b/src/librustc_mir/hair/pattern/_match.rs @@ -307,7 +307,7 @@ impl<'p, 'tcx> Matrix<'p, 'tcx> { /// + _ + [_, _, ..tail] + /// ++++++++++++++++++++++++++ impl<'p, 'tcx> fmt::Debug for Matrix<'p, 'tcx> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "\n")?; let &Matrix(ref m) = self; @@ -442,7 +442,7 @@ impl<'tcx> Constructor<'tcx> { VariantIdx::new(0) } &ConstantValue(c) => { - ::const_eval::const_variant_index( + crate::const_eval::const_variant_index( cx.tcx, cx.param_env, c, @@ -1115,7 +1115,7 @@ pub fn is_useful<'p, 'a: 'p, 'tcx: 'a>(cx: &mut MatchCheckCtxt<'a, 'tcx>, } else { debug!("is_useful - expanding wildcard"); - let used_ctors: Vec = rows.iter().flat_map(|row| { + let used_ctors: Vec> = rows.iter().flat_map(|row| { pat_constructors(cx, row[0], pcx).unwrap_or(vec![]) }).collect(); debug!("used_ctors = {:#?}", used_ctors); @@ -1302,7 +1302,7 @@ fn is_useful_specialized<'p, 'a: 'p, 'tcx: 'a>( /// Returns None in case of a catch-all, which can't be specialized. fn pat_constructors<'tcx>(cx: &mut MatchCheckCtxt<'_, 'tcx>, pat: &Pattern<'tcx>, - pcx: PatternContext) + pcx: PatternContext<'_>) -> Option>> { match *pat.kind { diff --git a/src/librustc_mir/hair/pattern/check_match.rs b/src/librustc_mir/hair/pattern/check_match.rs index a47d64319bdc5..978051aab591b 100644 --- a/src/librustc_mir/hair/pattern/check_match.rs +++ b/src/librustc_mir/hair/pattern/check_match.rs @@ -229,7 +229,7 @@ impl<'a, 'tcx> MatchVisitor<'a, 'tcx> { return; } - let matrix: Matrix = inlined_arms + let matrix: Matrix<'_, '_> = inlined_arms .iter() .filter(|&&(_, guard)| guard.is_none()) .flat_map(|arm| &arm.0) @@ -248,7 +248,7 @@ impl<'a, 'tcx> MatchVisitor<'a, 'tcx> { self.tables); let pattern = patcx.lower_pattern(pat); let pattern_ty = pattern.ty; - let pats: Matrix = vec![smallvec![ + let pats: Matrix<'_, '_> = vec![smallvec![ expand_pattern(cx, pattern) ]].into_iter().collect(); @@ -283,7 +283,7 @@ impl<'a, 'tcx> MatchVisitor<'a, 'tcx> { } } -fn check_for_bindings_named_same_as_variants(cx: &MatchVisitor, pat: &Pat) { +fn check_for_bindings_named_same_as_variants(cx: &MatchVisitor<'_, '_>, pat: &Pat) { pat.walk(|p| { if let PatKind::Binding(_, _, _, ident, None) = p.node { if let Some(&bm) = cx.tables.pat_binding_modes().get(p.hir_id) { @@ -462,7 +462,7 @@ fn check_exhaustive<'p, 'a: 'p, 'tcx: 'a>(cx: &mut MatchCheckCtxt<'a, 'tcx>, } // Legality of move bindings checking -fn check_legality_of_move_bindings(cx: &MatchVisitor, +fn check_legality_of_move_bindings(cx: &MatchVisitor<'_, '_>, has_guard: bool, pats: &[P]) { let mut by_ref_span = None; @@ -541,7 +541,7 @@ fn check_legality_of_move_bindings(cx: &MatchVisitor, /// assign. /// /// FIXME: this should be done by borrowck. -fn check_for_mutation_in_guard(cx: &MatchVisitor, guard: &hir::Guard) { +fn check_for_mutation_in_guard(cx: &MatchVisitor<'_, '_>, guard: &hir::Guard) { let mut checker = MutationChecker { cx, }; @@ -561,13 +561,13 @@ struct MutationChecker<'a, 'tcx: 'a> { } impl<'a, 'tcx> Delegate<'tcx> for MutationChecker<'a, 'tcx> { - fn matched_pat(&mut self, _: &Pat, _: &cmt_, _: euv::MatchMode) {} - fn consume(&mut self, _: ast::NodeId, _: Span, _: &cmt_, _: ConsumeMode) {} - fn consume_pat(&mut self, _: &Pat, _: &cmt_, _: ConsumeMode) {} + fn matched_pat(&mut self, _: &Pat, _: &cmt_<'_>, _: euv::MatchMode) {} + fn consume(&mut self, _: ast::NodeId, _: Span, _: &cmt_<'_>, _: ConsumeMode) {} + fn consume_pat(&mut self, _: &Pat, _: &cmt_<'_>, _: ConsumeMode) {} fn borrow(&mut self, _: ast::NodeId, span: Span, - _: &cmt_, + _: &cmt_<'_>, _: ty::Region<'tcx>, kind:ty:: BorrowKind, _: LoanCause) { @@ -588,7 +588,7 @@ impl<'a, 'tcx> Delegate<'tcx> for MutationChecker<'a, 'tcx> { } } fn decl_without_init(&mut self, _: ast::NodeId, _: Span) {} - fn mutate(&mut self, _: ast::NodeId, span: Span, _: &cmt_, mode: MutateMode) { + fn mutate(&mut self, _: ast::NodeId, span: Span, _: &cmt_<'_>, mode: MutateMode) { match mode { MutateMode::JustWrite | MutateMode::WriteAndRead => { struct_span_err!(self.cx.tcx.sess, span, E0302, "cannot assign in a pattern guard") @@ -603,7 +603,7 @@ impl<'a, 'tcx> Delegate<'tcx> for MutationChecker<'a, 'tcx> { /// Forbids bindings in `@` patterns. This is necessary for memory safety, /// because of the way rvalues are handled in the borrow check. (See issue /// #14587.) -fn check_legality_of_bindings_in_at_patterns(cx: &MatchVisitor, pat: &Pat) { +fn check_legality_of_bindings_in_at_patterns(cx: &MatchVisitor<'_, '_>, pat: &Pat) { AtBindingPatternVisitor { cx: cx, bindings_allowed: true }.visit_pat(pat); } diff --git a/src/librustc_mir/hair/pattern/mod.rs b/src/librustc_mir/hair/pattern/mod.rs index 6b7e14161186d..8d32becd439e0 100644 --- a/src/librustc_mir/hair/pattern/mod.rs +++ b/src/librustc_mir/hair/pattern/mod.rs @@ -6,10 +6,10 @@ mod check_match; pub use self::check_match::check_crate; pub(crate) use self::check_match::check_match; -use const_eval::{const_field, const_variant_index}; +use crate::const_eval::{const_field, const_variant_index}; -use hair::util::UserAnnotatedTyHelpers; -use hair::constant::*; +use crate::hair::util::UserAnnotatedTyHelpers; +use crate::hair::constant::*; use rustc::mir::{fmt_const_val, Field, BorrowKind, Mutability}; use rustc::mir::{UserTypeProjection}; @@ -176,7 +176,7 @@ pub struct PatternRange<'tcx> { } impl<'tcx> fmt::Display for Pattern<'tcx> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match *self.kind { PatternKind::Wild => write!(f, "_"), PatternKind::AscribeUserType { ref subpattern, .. } => diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs index 1b976d822ebff..c87338fb0ce94 100644 --- a/src/librustc_mir/interpret/eval_context.rs +++ b/src/librustc_mir/interpret/eval_context.rs @@ -322,7 +322,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tc ) -> EvalResult<'tcx, TyLayout<'tcx>> { match frame.locals[local].layout.get() { None => { - let layout = ::interpret::operand::from_known_layout(layout, || { + let layout = crate::interpret::operand::from_known_layout(layout, || { let local_ty = frame.mir.local_decls[local].ty; let local_ty = self.monomorphize_with_substs(local_ty, frame.instance.substs); self.layout_of(local_ty) diff --git a/src/librustc_mir/interpret/snapshot.rs b/src/librustc_mir/interpret/snapshot.rs index 5fae461bdc203..ee295116ba962 100644 --- a/src/librustc_mir/interpret/snapshot.rs +++ b/src/librustc_mir/interpret/snapshot.rs @@ -25,7 +25,7 @@ use syntax::source_map::Span; use super::eval_context::{LocalState, StackPopCleanup}; use super::{Frame, Memory, Operand, MemPlace, Place, Immediate, ScalarMaybeUndef, LocalValue}; -use const_eval::CompileTimeInterpreter; +use crate::const_eval::CompileTimeInterpreter; #[derive(Default)] pub(crate) struct InfiniteLoopDetector<'a, 'mir, 'tcx: 'a + 'mir> { @@ -200,7 +200,7 @@ impl_snapshot_for!(enum ScalarMaybeUndef { Undef, }); -impl_stable_hash_for!(struct ::interpret::MemPlace { +impl_stable_hash_for!(struct crate::interpret::MemPlace { ptr, align, meta, @@ -211,7 +211,7 @@ impl_snapshot_for!(struct MemPlace { align -> *align, // just copy alignment verbatim }); -impl_stable_hash_for!(enum ::interpret::Place { +impl_stable_hash_for!(enum crate::interpret::Place { Ptr(mem_place), Local { frame, local }, }); @@ -232,7 +232,7 @@ impl<'a, Ctx> Snapshot<'a, Ctx> for Place } } -impl_stable_hash_for!(enum ::interpret::Immediate { +impl_stable_hash_for!(enum crate::interpret::Immediate { Scalar(x), ScalarPair(x, y), }); @@ -241,7 +241,7 @@ impl_snapshot_for!(enum Immediate { ScalarPair(s, t), }); -impl_stable_hash_for!(enum ::interpret::Operand { +impl_stable_hash_for!(enum crate::interpret::Operand { Immediate(x), Indirect(x), }); @@ -250,7 +250,7 @@ impl_snapshot_for!(enum Operand { Indirect(m), }); -impl_stable_hash_for!(enum ::interpret::LocalValue { +impl_stable_hash_for!(enum crate::interpret::LocalValue { Dead, Live(x), }); @@ -298,7 +298,7 @@ impl<'a, Ctx> Snapshot<'a, Ctx> for &'a Allocation } } -impl_stable_hash_for!(enum ::interpret::eval_context::StackPopCleanup { +impl_stable_hash_for!(enum crate::interpret::eval_context::StackPopCleanup { Goto(block), None { cleanup }, }); diff --git a/src/librustc_mir/interpret/terminator.rs b/src/librustc_mir/interpret/terminator.rs index 7e823524c180c..be50daa17092f 100644 --- a/src/librustc_mir/interpret/terminator.rs +++ b/src/librustc_mir/interpret/terminator.rs @@ -112,7 +112,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> let ty = place.layout.ty; trace!("TerminatorKind::drop: {:?}, type {}", location, ty); - let instance = ::monomorphize::resolve_drop_in_place(*self.tcx, ty); + let instance = crate::monomorphize::resolve_drop_in_place(*self.tcx, ty); self.drop_in_place( place, instance, @@ -326,7 +326,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> // last incoming argument. These two iterators do not have the same type, // so to keep the code paths uniform we accept an allocation // (for RustCall ABI only). - let caller_args : Cow<[OpTy<'tcx, M::PointerTag>]> = + let caller_args : Cow<'_, [OpTy<'tcx, M::PointerTag>]> = if caller_abi == Abi::RustCall && !args.is_empty() { // Untuple let (&untuple_arg, args) = args.split_last().unwrap(); @@ -335,7 +335,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> .chain((0..untuple_arg.layout.fields.count()).into_iter() .map(|i| self.operand_field(untuple_arg, i as u64)) ) - .collect::>>>()?) + .collect::>>>()?) } else { // Plain arg passing Cow::from(args) diff --git a/src/librustc_mir/interpret/traits.rs b/src/librustc_mir/interpret/traits.rs index 642bbc114f562..63253bae9078b 100644 --- a/src/librustc_mir/interpret/traits.rs +++ b/src/librustc_mir/interpret/traits.rs @@ -52,7 +52,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> ).with_default_tag(); let tcx = &*self.tcx; - let drop = ::monomorphize::resolve_drop_in_place(*tcx, ty); + let drop = crate::monomorphize::resolve_drop_in_place(*tcx, ty); let drop = self.memory.create_fn_alloc(drop).with_default_tag(); // no need to do any alignment checks on the memory accesses below, because we know the // allocation is correctly aligned as we created it above. Also we're only offsetting by diff --git a/src/librustc_mir/interpret/visitor.rs b/src/librustc_mir/interpret/visitor.rs index 4773f5627d716..930bcb44374aa 100644 --- a/src/librustc_mir/interpret/visitor.rs +++ b/src/librustc_mir/interpret/visitor.rs @@ -26,7 +26,7 @@ pub trait Value<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>>: Copy ) -> EvalResult<'tcx, OpTy<'tcx, M::PointerTag>>; /// Create this from an `MPlaceTy`. - fn from_mem_place(MPlaceTy<'tcx, M::PointerTag>) -> Self; + fn from_mem_place(mplace: MPlaceTy<'tcx, M::PointerTag>) -> Self; /// Project to the given enum variant. fn project_downcast( diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs index ccfc15bac042c..72a13c791cec0 100644 --- a/src/librustc_mir/lib.rs +++ b/src/librustc_mir/lib.rs @@ -4,7 +4,6 @@ Rust MIR: a lowered representation of Rust. Also: an experiment! */ -#![feature(nll)] #![feature(in_band_lifetimes)] #![feature(slice_patterns)] #![feature(slice_sort_by_cached_key)] @@ -29,28 +28,19 @@ Rust MIR: a lowered representation of Rust. Also: an experiment! #![recursion_limit="256"] -extern crate arena; +#![deny(rust_2018_idioms)] +#![allow(explicit_outlives_requirements)] #[macro_use] extern crate bitflags; #[macro_use] extern crate log; -extern crate either; -extern crate graphviz as dot; -extern crate polonius_engine; #[macro_use] extern crate rustc; #[macro_use] extern crate rustc_data_structures; -extern crate serialize as rustc_serialize; -extern crate rustc_errors; +#[allow(unused_extern_crates)] +extern crate serialize as rustc_serialize; // used by deriving #[macro_use] extern crate syntax; -extern crate syntax_pos; -extern crate rustc_target; -extern crate log_settings; -extern crate rustc_apfloat; -extern crate byteorder; -extern crate core; -extern crate smallvec; // Once we can use edition 2018 in the compiler, // replace this with real try blocks. @@ -77,7 +67,7 @@ pub mod const_eval; pub use hair::pattern::check_crate as matchck_crate; use rustc::ty::query::Providers; -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { borrow_check::provide(providers); shim::provide(providers); transform::provide(providers); diff --git a/src/librustc_mir/lints.rs b/src/librustc_mir/lints.rs index 8ded31d89daea..6b6e8fcdc82cf 100644 --- a/src/librustc_mir/lints.rs +++ b/src/librustc_mir/lints.rs @@ -18,7 +18,7 @@ pub fn check(tcx: TyCtxt<'a, 'tcx, 'tcx>, } fn check_fn_for_unconditional_recursion(tcx: TyCtxt<'a, 'tcx, 'tcx>, - fn_kind: FnKind, + fn_kind: FnKind<'_>, mir: &Mir<'tcx>, def_id: DefId) { if let FnKind::Closure(_) = fn_kind { diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs index e713ab17c3af5..7f3c24daf606d 100644 --- a/src/librustc_mir/monomorphize/collector.rs +++ b/src/librustc_mir/monomorphize/collector.rs @@ -189,11 +189,11 @@ use rustc::mir::visit::Visitor as MirVisitor; use rustc::mir::mono::MonoItem; use rustc::mir::interpret::{Scalar, GlobalId, AllocKind, ErrorHandled}; -use monomorphize::{self, Instance}; +use crate::monomorphize::{self, Instance}; use rustc::util::nodemap::{FxHashSet, FxHashMap, DefIdMap}; use rustc::util::common::time; -use monomorphize::item::{MonoItemExt, DefPathBasedNames, InstantiationMode}; +use crate::monomorphize::item::{MonoItemExt, DefPathBasedNames, InstantiationMode}; use rustc_data_structures::bit_set::GrowableBitSet; use rustc_data_structures::sync::{MTRef, MTLock, ParallelIterator, par_iter}; diff --git a/src/librustc_mir/monomorphize/item.rs b/src/librustc_mir/monomorphize/item.rs index 431cc0d52b4c8..d3381f463f49e 100644 --- a/src/librustc_mir/monomorphize/item.rs +++ b/src/librustc_mir/monomorphize/item.rs @@ -1,4 +1,4 @@ -use monomorphize::Instance; +use crate::monomorphize::Instance; use rustc::hir; use rustc::hir::def_id::{DefId, LOCAL_CRATE}; use rustc::session::config::OptLevel; diff --git a/src/librustc_mir/monomorphize/partitioning.rs b/src/librustc_mir/monomorphize/partitioning.rs index 569e4c828f601..d4c7ebefe1753 100644 --- a/src/librustc_mir/monomorphize/partitioning.rs +++ b/src/librustc_mir/monomorphize/partitioning.rs @@ -111,9 +111,9 @@ use rustc::util::common::time; use rustc::util::nodemap::{DefIdSet, FxHashMap, FxHashSet}; use rustc::mir::mono::MonoItem; -use monomorphize::collector::InliningMap; -use monomorphize::collector::{self, MonoItemCollectionMode}; -use monomorphize::item::{MonoItemExt, InstantiationMode}; +use crate::monomorphize::collector::InliningMap; +use crate::monomorphize::collector::{self, MonoItemCollectionMode}; +use crate::monomorphize::item::{MonoItemExt, InstantiationMode}; pub use rustc::mir::mono::CodegenUnit; @@ -146,7 +146,7 @@ pub trait CodegenUnitExt<'tcx> { WorkProductId::from_cgu_name(&self.name().as_str()) } - fn work_product(&self, tcx: TyCtxt) -> WorkProduct { + fn work_product(&self, tcx: TyCtxt<'_, '_, '_>) -> WorkProduct { let work_product_id = self.work_product_id(); tcx.dep_graph .previous_work_product(&work_product_id) @@ -213,7 +213,7 @@ impl<'tcx> CodegenUnitExt<'tcx> for CodegenUnit<'tcx> { } // Anything we can't find a proper codegen unit for goes into this. -fn fallback_cgu_name(name_builder: &mut CodegenUnitNameBuilder) -> InternedString { +fn fallback_cgu_name(name_builder: &mut CodegenUnitNameBuilder<'_, '_, '_>) -> InternedString { name_builder.build_cgu_name(LOCAL_CRATE, &["fallback"], Some("cgu")) } @@ -536,7 +536,7 @@ fn mono_item_visibility( } } -fn default_visibility(tcx: TyCtxt, id: DefId, is_generic: bool) -> Visibility { +fn default_visibility(tcx: TyCtxt<'_, '_, '_>, id: DefId, is_generic: bool) -> Visibility { if !tcx.sess.target.target.options.default_hidden_visibility { return Visibility::Default } @@ -795,8 +795,8 @@ fn characteristic_def_id_of_mono_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, type CguNameCache = FxHashMap<(DefId, bool), InternedString>; -fn compute_codegen_unit_name(tcx: TyCtxt, - name_builder: &mut CodegenUnitNameBuilder, +fn compute_codegen_unit_name(tcx: TyCtxt<'_, '_, '_>, + name_builder: &mut CodegenUnitNameBuilder<'_, '_, '_>, def_id: DefId, volatile: bool, cache: &mut CguNameCache) @@ -855,7 +855,7 @@ fn compute_codegen_unit_name(tcx: TyCtxt, }).clone() } -fn numbered_codegen_unit_name(name_builder: &mut CodegenUnitNameBuilder, +fn numbered_codegen_unit_name(name_builder: &mut CodegenUnitNameBuilder<'_, '_, '_>, index: usize) -> InternedString { name_builder.build_cgu_name_no_mangle(LOCAL_CRATE, &["cgu"], Some(index)) @@ -929,7 +929,7 @@ fn collect_and_partition_mono_items<'a, 'tcx>( tcx.sess.abort_if_errors(); - ::monomorphize::assert_symbols_are_distinct(tcx, items.iter()); + crate::monomorphize::assert_symbols_are_distinct(tcx, items.iter()); let strategy = if tcx.sess.opts.incremental.is_some() { PartitioningStrategy::PerModule @@ -1013,7 +1013,7 @@ fn collect_and_partition_mono_items<'a, 'tcx>( (Arc::new(mono_items), Arc::new(codegen_units)) } -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { providers.collect_and_partition_mono_items = collect_and_partition_mono_items; diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs index 751815eab287b..942e7a1f1bbbd 100644 --- a/src/librustc_mir/shim.rs +++ b/src/librustc_mir/shim.rs @@ -16,12 +16,12 @@ use syntax_pos::Span; use std::fmt; use std::iter; -use transform::{add_moves_for_packed_drops, add_call_guards}; -use transform::{remove_noop_landing_pads, no_landing_pads, simplify}; -use util::elaborate_drops::{self, DropElaborator, DropStyle, DropFlagMode}; -use util::patch::MirPatch; +use crate::transform::{add_moves_for_packed_drops, add_call_guards}; +use crate::transform::{remove_noop_landing_pads, no_landing_pads, simplify}; +use crate::util::elaborate_drops::{self, DropElaborator, DropStyle, DropFlagMode}; +use crate::util::patch::MirPatch; -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { providers.mir_shims = make_shim; } @@ -138,7 +138,7 @@ enum CallKind { Direct(DefId), } -fn temp_decl(mutability: Mutability, ty: Ty, span: Span) -> LocalDecl { +fn temp_decl(mutability: Mutability, ty: Ty<'_>, span: Span) -> LocalDecl<'_> { let source_info = SourceInfo { scope: OUTERMOST_SOURCE_SCOPE, span }; LocalDecl { mutability, @@ -259,7 +259,7 @@ pub struct DropShimElaborator<'a, 'tcx: 'a> { } impl<'a, 'tcx> fmt::Debug for DropShimElaborator<'a, 'tcx> { - fn fmt(&self, _f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { Ok(()) } } diff --git a/src/librustc_mir/transform/add_call_guards.rs b/src/librustc_mir/transform/add_call_guards.rs index 3ea1c8e82ff2b..dab96faaa2a5e 100644 --- a/src/librustc_mir/transform/add_call_guards.rs +++ b/src/librustc_mir/transform/add_call_guards.rs @@ -1,7 +1,7 @@ use rustc::ty::TyCtxt; use rustc::mir::*; use rustc_data_structures::indexed_vec::{Idx, IndexVec}; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; #[derive(PartialEq)] pub enum AddCallGuards { @@ -40,7 +40,7 @@ impl MirPass for AddCallGuards { } impl AddCallGuards { - pub fn add_call_guards(&self, mir: &mut Mir) { + pub fn add_call_guards(&self, mir: &mut Mir<'_>) { let pred_count: IndexVec<_, _> = mir.predecessors().iter().map(|ps| ps.len()).collect(); diff --git a/src/librustc_mir/transform/add_moves_for_packed_drops.rs b/src/librustc_mir/transform/add_moves_for_packed_drops.rs index 8ec6902cf15fd..1492f0c50a31a 100644 --- a/src/librustc_mir/transform/add_moves_for_packed_drops.rs +++ b/src/librustc_mir/transform/add_moves_for_packed_drops.rs @@ -2,9 +2,9 @@ use rustc::hir::def_id::DefId; use rustc::mir::*; use rustc::ty::TyCtxt; -use transform::{MirPass, MirSource}; -use util::patch::MirPatch; -use util; +use crate::transform::{MirPass, MirSource}; +use crate::util::patch::MirPatch; +use crate::util; // This pass moves values being dropped that are within a packed // struct to a separate local before dropping them, to ensure that diff --git a/src/librustc_mir/transform/add_retag.rs b/src/librustc_mir/transform/add_retag.rs index 3d5897bca9f52..7bfcd318afe2d 100644 --- a/src/librustc_mir/transform/add_retag.rs +++ b/src/librustc_mir/transform/add_retag.rs @@ -6,7 +6,7 @@ use rustc::ty::{self, Ty, TyCtxt}; use rustc::mir::*; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; pub struct AddRetag; diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs index ab8da2f352c1c..b2e1afc519ec5 100644 --- a/src/librustc_mir/transform/check_unsafety.rs +++ b/src/librustc_mir/transform/check_unsafety.rs @@ -17,7 +17,7 @@ use syntax::symbol::Symbol; use std::ops::Bound; -use util; +use crate::util; pub struct UnsafetyChecker<'a, 'tcx: 'a> { mir: &'a Mir<'tcx>, @@ -458,7 +458,7 @@ impl<'a, 'tcx> UnsafetyChecker<'a, 'tcx> { } } -pub(crate) fn provide(providers: &mut Providers) { +pub(crate) fn provide(providers: &mut Providers<'_>) { *providers = Providers { unsafety_check_result, unsafe_derive_on_repr_packed, @@ -575,7 +575,7 @@ fn unsafe_derive_on_repr_packed<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: D } /// Return the NodeId for an enclosing scope that is also `unsafe` -fn is_enclosed(tcx: TyCtxt, +fn is_enclosed(tcx: TyCtxt<'_, '_, '_>, used_unsafe: &FxHashSet, id: ast::NodeId) -> Option<(String, ast::NodeId)> { let parent_id = tcx.hir().get_parent_node(id); @@ -598,7 +598,9 @@ fn is_enclosed(tcx: TyCtxt, } } -fn report_unused_unsafe(tcx: TyCtxt, used_unsafe: &FxHashSet, id: ast::NodeId) { +fn report_unused_unsafe(tcx: TyCtxt<'_, '_, '_>, + used_unsafe: &FxHashSet, + id: ast::NodeId) { let span = tcx.sess.source_map().def_span(tcx.hir().span(id)); let msg = "unnecessary `unsafe` block"; let mut db = tcx.struct_span_lint_node(UNUSED_UNSAFE, id, span, msg); diff --git a/src/librustc_mir/transform/cleanup_post_borrowck.rs b/src/librustc_mir/transform/cleanup_post_borrowck.rs index e6df6b7fd2724..240ef7c8ba42a 100644 --- a/src/librustc_mir/transform/cleanup_post_borrowck.rs +++ b/src/librustc_mir/transform/cleanup_post_borrowck.rs @@ -26,7 +26,7 @@ use rustc::mir::{BasicBlock, FakeReadCause, Local, Location, Mir, Place}; use rustc::mir::{Statement, StatementKind}; use rustc::mir::visit::MutVisitor; use rustc::ty::TyCtxt; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; pub struct CleanAscribeUserType; diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs index dc556a15cd855..dd1f37a591888 100644 --- a/src/librustc_mir/transform/const_prop.rs +++ b/src/librustc_mir/transform/const_prop.rs @@ -18,12 +18,12 @@ use rustc::ty::layout::{ HasTyCtxt, TargetDataLayout, HasDataLayout, }; -use interpret::{self, EvalContext, ScalarMaybeUndef, Immediate, OpTy, MemoryKind}; -use const_eval::{ +use crate::interpret::{self, EvalContext, ScalarMaybeUndef, Immediate, OpTy, MemoryKind}; +use crate::const_eval::{ CompileTimeInterpreter, error_to_const_error, eval_promoted, mk_eval_cx, lazy_const_to_op, }; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; pub struct ConstProp; @@ -486,7 +486,7 @@ struct CanConstProp { impl CanConstProp { /// returns true if `local` can be propagated - fn check(mir: &Mir) -> IndexVec { + fn check(mir: &Mir<'_>) -> IndexVec { let mut cpv = CanConstProp { can_const_prop: IndexVec::from_elem(true, &mir.local_decls), found_assignment: IndexVec::from_elem(false, &mir.local_decls), diff --git a/src/librustc_mir/transform/copy_prop.rs b/src/librustc_mir/transform/copy_prop.rs index 55e14077c3ed0..4789c35740eb3 100644 --- a/src/librustc_mir/transform/copy_prop.rs +++ b/src/librustc_mir/transform/copy_prop.rs @@ -22,8 +22,8 @@ use rustc::mir::{Constant, Local, LocalKind, Location, Place, Mir, Operand, Rvalue, StatementKind}; use rustc::mir::visit::MutVisitor; use rustc::ty::TyCtxt; -use transform::{MirPass, MirSource}; -use util::def_use::DefUseAnalysis; +use crate::transform::{MirPass, MirSource}; +use crate::util::def_use::DefUseAnalysis; pub struct CopyPropagation; @@ -173,7 +173,7 @@ enum Action<'tcx> { } impl<'tcx> Action<'tcx> { - fn local_copy(mir: &Mir<'tcx>, def_use_analysis: &DefUseAnalysis, src_place: &Place<'tcx>) + fn local_copy(mir: &Mir<'tcx>, def_use_analysis: &DefUseAnalysis<'_>, src_place: &Place<'tcx>) -> Option> { // The source must be a local. let src_local = if let Place::Local(local) = *src_place { diff --git a/src/librustc_mir/transform/deaggregator.rs b/src/librustc_mir/transform/deaggregator.rs index a2fe9def8eeba..669384e31dac3 100644 --- a/src/librustc_mir/transform/deaggregator.rs +++ b/src/librustc_mir/transform/deaggregator.rs @@ -1,7 +1,7 @@ use rustc::ty::TyCtxt; use rustc::mir::*; use rustc_data_structures::indexed_vec::Idx; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; pub struct Deaggregator; diff --git a/src/librustc_mir/transform/dump_mir.rs b/src/librustc_mir/transform/dump_mir.rs index 8fabb2d11fc46..d7f697a320049 100644 --- a/src/librustc_mir/transform/dump_mir.rs +++ b/src/librustc_mir/transform/dump_mir.rs @@ -8,8 +8,8 @@ use std::io; use rustc::mir::Mir; use rustc::session::config::{OutputFilenames, OutputType}; use rustc::ty::TyCtxt; -use transform::{MirPass, MirSource}; -use util as mir_util; +use crate::transform::{MirPass, MirSource}; +use crate::util as mir_util; pub struct Marker(pub &'static str); @@ -31,7 +31,7 @@ pub struct Disambiguator { } impl fmt::Display for Disambiguator { - fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { let title = if self.is_after { "after" } else { "before" }; write!(formatter, "{}", title) } diff --git a/src/librustc_mir/transform/elaborate_drops.rs b/src/librustc_mir/transform/elaborate_drops.rs index 06e16de8b43bc..4aaa0be7964a4 100644 --- a/src/librustc_mir/transform/elaborate_drops.rs +++ b/src/librustc_mir/transform/elaborate_drops.rs @@ -1,10 +1,14 @@ -use dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex, LookupResult}; -use dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces}; -use dataflow::{DataflowResults}; -use dataflow::{on_all_children_bits, on_all_drop_children_bits}; -use dataflow::{drop_flag_effects_for_location, on_lookup_result_bits}; -use dataflow::MoveDataParamEnv; -use dataflow::{self, do_dataflow, DebugFormatted}; +use crate::dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex, LookupResult}; +use crate::dataflow::{MaybeInitializedPlaces, MaybeUninitializedPlaces}; +use crate::dataflow::{DataflowResults}; +use crate::dataflow::{on_all_children_bits, on_all_drop_children_bits}; +use crate::dataflow::{drop_flag_effects_for_location, on_lookup_result_bits}; +use crate::dataflow::MoveDataParamEnv; +use crate::dataflow::{self, do_dataflow, DebugFormatted}; +use crate::transform::{MirPass, MirSource}; +use crate::util::patch::MirPatch; +use crate::util::elaborate_drops::{DropFlagState, Unwind, elaborate_drop}; +use crate::util::elaborate_drops::{DropElaborator, DropStyle, DropFlagMode}; use rustc::ty::{self, TyCtxt}; use rustc::ty::layout::VariantIdx; use rustc::mir::*; @@ -13,10 +17,6 @@ use rustc_data_structures::bit_set::BitSet; use std::fmt; use syntax::ast; use syntax_pos::Span; -use transform::{MirPass, MirSource}; -use util::patch::MirPatch; -use util::elaborate_drops::{DropFlagState, Unwind, elaborate_drop}; -use util::elaborate_drops::{DropElaborator, DropStyle, DropFlagMode}; pub struct ElaborateDrops; @@ -174,7 +174,7 @@ struct Elaborator<'a, 'b: 'a, 'tcx: 'b> { } impl<'a, 'b, 'tcx> fmt::Debug for Elaborator<'a, 'b, 'tcx> { - fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result { Ok(()) } } diff --git a/src/librustc_mir/transform/erase_regions.rs b/src/librustc_mir/transform/erase_regions.rs index b464b7d65e466..b555a2aa83ee3 100644 --- a/src/librustc_mir/transform/erase_regions.rs +++ b/src/librustc_mir/transform/erase_regions.rs @@ -8,7 +8,7 @@ use rustc::ty::subst::Substs; use rustc::ty::{self, Ty, TyCtxt}; use rustc::mir::*; use rustc::mir::visit::{MutVisitor, TyContext}; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; struct EraseRegionsVisitor<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx>, diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs index f5cc6a43e28b9..9897f9833ca62 100644 --- a/src/librustc_mir/transform/generator.rs +++ b/src/librustc_mir/transform/generator.rs @@ -56,19 +56,19 @@ use rustc::mir::visit::{PlaceContext, Visitor, MutVisitor}; use rustc::ty::{self, TyCtxt, AdtDef, Ty}; use rustc::ty::layout::VariantIdx; use rustc::ty::subst::Substs; -use util::dump_mir; -use util::liveness::{self, IdentityMap}; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::bit_set::BitSet; use std::borrow::Cow; use std::iter::once; use std::mem; -use transform::{MirPass, MirSource}; -use transform::simplify; -use transform::no_landing_pads::no_landing_pads; -use dataflow::{do_dataflow, DebugFormatted, state_for_location}; -use dataflow::{MaybeStorageLive, HaveBeenBorrowedLocals}; +use crate::transform::{MirPass, MirSource}; +use crate::transform::simplify; +use crate::transform::no_landing_pads::no_landing_pads; +use crate::dataflow::{do_dataflow, DebugFormatted, state_for_location}; +use crate::dataflow::{MaybeStorageLive, HaveBeenBorrowedLocals}; +use crate::util::dump_mir; +use crate::util::liveness::{self, IdentityMap}; pub struct StateTransform; @@ -581,9 +581,9 @@ fn insert_switch<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, fn elaborate_generator_drops<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId, mir: &mut Mir<'tcx>) { - use util::elaborate_drops::{elaborate_drop, Unwind}; - use util::patch::MirPatch; - use shim::DropShimElaborator; + use crate::util::elaborate_drops::{elaborate_drop, Unwind}; + use crate::util::patch::MirPatch; + use crate::shim::DropShimElaborator; // Note that `elaborate_drops` only drops the upvars of a generator, and // this is ok because `open_drop` can only be reached within that own diff --git a/src/librustc_mir/transform/inline.rs b/src/librustc_mir/transform/inline.rs index 9f0907adc9892..4fddf6f8e09c2 100644 --- a/src/librustc_mir/transform/inline.rs +++ b/src/librustc_mir/transform/inline.rs @@ -13,10 +13,10 @@ use rustc::ty::subst::{Subst,Substs}; use std::collections::VecDeque; use std::iter; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; use super::simplify::{remove_dead_blocks, CfgSimplifier}; -use syntax::{attr}; +use syntax::attr; use rustc_target::spec::abi::Abi; const DEFAULT_THRESHOLD: usize = 50; @@ -426,7 +426,7 @@ impl<'a, 'tcx> Inliner<'a, 'tcx> { // Place could result in two different locations if `f` // writes to `i`. To prevent this we need to create a temporary // borrow of the place and pass the destination as `*temp` instead. - fn dest_needs_borrow(place: &Place) -> bool { + fn dest_needs_borrow(place: &Place<'_>) -> bool { match *place { Place::Projection(ref p) => { match p.elem { diff --git a/src/librustc_mir/transform/instcombine.rs b/src/librustc_mir/transform/instcombine.rs index 2b5e761d1d055..21772e1f1cd5b 100644 --- a/src/librustc_mir/transform/instcombine.rs +++ b/src/librustc_mir/transform/instcombine.rs @@ -6,7 +6,7 @@ use rustc::ty::{TyCtxt, TyKind}; use rustc::util::nodemap::{FxHashMap, FxHashSet}; use rustc_data_structures::indexed_vec::Idx; use std::mem; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; pub struct InstCombine; diff --git a/src/librustc_mir/transform/lower_128bit.rs b/src/librustc_mir/transform/lower_128bit.rs index d14e0f078e6c6..aa248ba7c53df 100644 --- a/src/librustc_mir/transform/lower_128bit.rs +++ b/src/librustc_mir/transform/lower_128bit.rs @@ -5,8 +5,7 @@ use rustc::middle::lang_items::LangItem; use rustc::mir::*; use rustc::ty::{List, Ty, TyCtxt, TyKind}; use rustc_data_structures::indexed_vec::{Idx}; -use transform::{MirPass, MirSource}; -use syntax; +use crate::transform::{MirPass, MirSource}; pub struct Lower128Bit; @@ -182,7 +181,7 @@ impl RhsKind { } } -fn sign_of_128bit(ty: Ty) -> Option { +fn sign_of_128bit(ty: Ty<'_>) -> Option { match ty.sty { TyKind::Int(syntax::ast::IntTy::I128) => Some(true), TyKind::Uint(syntax::ast::UintTy::U128) => Some(false), diff --git a/src/librustc_mir/transform/mod.rs b/src/librustc_mir/transform/mod.rs index a4f011b2e2ec9..cc37a8381f234 100644 --- a/src/librustc_mir/transform/mod.rs +++ b/src/librustc_mir/transform/mod.rs @@ -1,5 +1,5 @@ -use borrow_check::nll::type_check; -use build; +use crate::borrow_check::nll::type_check; +use crate::build; use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; use rustc::mir::{Mir, MirPhase, Promoted}; use rustc::ty::TyCtxt; @@ -38,7 +38,7 @@ pub mod inline; pub mod lower_128bit; pub mod uniform_array_move_out; -pub(crate) fn provide(providers: &mut Providers) { +pub(crate) fn provide(providers: &mut Providers<'_>) { self::qualify_consts::provide(providers); self::check_unsafety::provide(providers); *providers = Providers { diff --git a/src/librustc_mir/transform/no_landing_pads.rs b/src/librustc_mir/transform/no_landing_pads.rs index 2d13b066270a2..15b59d36d363c 100644 --- a/src/librustc_mir/transform/no_landing_pads.rs +++ b/src/librustc_mir/transform/no_landing_pads.rs @@ -4,7 +4,7 @@ use rustc::ty::TyCtxt; use rustc::mir::*; use rustc::mir::visit::MutVisitor; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; pub struct NoLandingPads; diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs index 1602fc35a2c95..d1dc5cfec994d 100644 --- a/src/librustc_mir/transform/promote_consts.rs +++ b/src/librustc_mir/transform/promote_consts.rs @@ -130,7 +130,8 @@ impl<'tcx> Visitor<'tcx> for TempCollector<'tcx> { } } -pub fn collect_temps(mir: &Mir, rpo: &mut ReversePostorder) -> IndexVec { +pub fn collect_temps(mir: &Mir<'_>, + rpo: &mut ReversePostorder<'_, '_>) -> IndexVec { let mut collector = TempCollector { temps: IndexVec::from_elem(TempState::Undefined, &mir.local_decls), span: mir.span, diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs index 7d1943e21b90d..c786e9438af12 100644 --- a/src/librustc_mir/transform/qualify_consts.rs +++ b/src/librustc_mir/transform/qualify_consts.rs @@ -27,7 +27,7 @@ use syntax_pos::{Span, DUMMY_SP}; use std::fmt; use std::usize; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; use super::promote_consts::{self, Candidate, TempState}; bitflags! { @@ -84,7 +84,7 @@ enum Mode { } impl fmt::Display for Mode { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match *self { Mode::Const => write!(f, "constant"), Mode::Static | Mode::StaticMut => write!(f, "static"), @@ -1128,7 +1128,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> { } } -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { *providers = Providers { mir_const_qualif, ..*providers @@ -1317,7 +1317,7 @@ impl MirPass for QualifyAndPromoteConstants { } } -fn args_required_const(tcx: TyCtxt, def_id: DefId) -> Option> { +fn args_required_const(tcx: TyCtxt<'_, '_, '_>, def_id: DefId) -> Option> { let attrs = tcx.get_attrs(def_id); let attr = attrs.iter().find(|a| a.check_name("rustc_args_required_const"))?; let mut ret = FxHashSet::default(); diff --git a/src/librustc_mir/transform/remove_noop_landing_pads.rs b/src/librustc_mir/transform/remove_noop_landing_pads.rs index c8ef2decf2606..4fcb4c10f9e6d 100644 --- a/src/librustc_mir/transform/remove_noop_landing_pads.rs +++ b/src/librustc_mir/transform/remove_noop_landing_pads.rs @@ -1,8 +1,8 @@ use rustc::ty::TyCtxt; use rustc::mir::*; use rustc_data_structures::bit_set::BitSet; -use transform::{MirPass, MirSource}; -use util::patch::MirPatch; +use crate::transform::{MirPass, MirSource}; +use crate::util::patch::MirPatch; /// A pass that removes no-op landing pads and replaces jumps to them with /// `None`. This is important because otherwise LLVM generates terrible @@ -34,7 +34,7 @@ impl RemoveNoopLandingPads { fn is_nop_landing_pad( &self, bb: BasicBlock, - mir: &Mir, + mir: &Mir<'_>, nop_landing_pads: &BitSet, ) -> bool { for stmt in &mir[bb].statements { @@ -86,7 +86,7 @@ impl RemoveNoopLandingPads { } } - fn remove_nop_landing_pads(&self, mir: &mut Mir) { + fn remove_nop_landing_pads(&self, mir: &mut Mir<'_>) { // make sure there's a single resume block let resume_block = { let patch = MirPatch::new(mir); diff --git a/src/librustc_mir/transform/rustc_peek.rs b/src/librustc_mir/transform/rustc_peek.rs index 36a6279e50320..806c1c1cca457 100644 --- a/src/librustc_mir/transform/rustc_peek.rs +++ b/src/librustc_mir/transform/rustc_peek.rs @@ -5,18 +5,20 @@ use syntax_pos::Span; use rustc::ty::{self, TyCtxt}; use rustc::mir::{self, Mir, Location}; use rustc_data_structures::bit_set::BitSet; -use transform::{MirPass, MirSource}; - -use dataflow::{do_dataflow, DebugFormatted}; -use dataflow::MoveDataParamEnv; -use dataflow::BitDenotation; -use dataflow::DataflowResults; -use dataflow::{DefinitelyInitializedPlaces, MaybeInitializedPlaces, MaybeUninitializedPlaces}; -use dataflow::move_paths::{MovePathIndex, LookupResult}; -use dataflow::move_paths::{HasMoveData, MoveData}; -use dataflow; - -use dataflow::has_rustc_mir_with; +use crate::transform::{MirPass, MirSource}; + +use crate::dataflow::{do_dataflow, DebugFormatted}; +use crate::dataflow::MoveDataParamEnv; +use crate::dataflow::BitDenotation; +use crate::dataflow::DataflowResults; +use crate::dataflow::{ + DefinitelyInitializedPlaces, MaybeInitializedPlaces, MaybeUninitializedPlaces +}; +use crate::dataflow::move_paths::{MovePathIndex, LookupResult}; +use crate::dataflow::move_paths::{HasMoveData, MoveData}; +use crate::dataflow; + +use crate::dataflow::has_rustc_mir_with; pub struct SanityCheck; diff --git a/src/librustc_mir/transform/simplify.rs b/src/librustc_mir/transform/simplify.rs index ed2da98dd5311..90486d1566413 100644 --- a/src/librustc_mir/transform/simplify.rs +++ b/src/librustc_mir/transform/simplify.rs @@ -34,7 +34,7 @@ use rustc::mir::*; use rustc::mir::visit::{MutVisitor, Visitor, PlaceContext}; use rustc::session::config::DebugInfo; use std::borrow::Cow; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; pub struct SimplifyCfg { label: String } @@ -44,7 +44,7 @@ impl SimplifyCfg { } } -pub fn simplify_cfg(mir: &mut Mir) { +pub fn simplify_cfg(mir: &mut Mir<'_>) { CfgSimplifier::new(mir).simplify(); remove_dead_blocks(mir); @@ -263,7 +263,7 @@ impl<'a, 'tcx: 'a> CfgSimplifier<'a, 'tcx> { } } -pub fn remove_dead_blocks(mir: &mut Mir) { +pub fn remove_dead_blocks(mir: &mut Mir<'_>) { let mut seen = BitSet::new_empty(mir.basic_blocks().len()); for (bb, _) in traversal::preorder(mir) { seen.insert(bb.index()); diff --git a/src/librustc_mir/transform/simplify_branches.rs b/src/librustc_mir/transform/simplify_branches.rs index abaea70946383..0dc89bfe14709 100644 --- a/src/librustc_mir/transform/simplify_branches.rs +++ b/src/librustc_mir/transform/simplify_branches.rs @@ -2,7 +2,7 @@ use rustc::ty::{TyCtxt, ParamEnv}; use rustc::mir::*; -use transform::{MirPass, MirSource}; +use crate::transform::{MirPass, MirSource}; use std::borrow::Cow; diff --git a/src/librustc_mir/transform/uniform_array_move_out.rs b/src/librustc_mir/transform/uniform_array_move_out.rs index 5ab9669baaca0..09918436817f3 100644 --- a/src/librustc_mir/transform/uniform_array_move_out.rs +++ b/src/librustc_mir/transform/uniform_array_move_out.rs @@ -30,9 +30,9 @@ use rustc::ty; use rustc::ty::TyCtxt; use rustc::mir::*; use rustc::mir::visit::{Visitor, PlaceContext, NonUseContext}; -use transform::{MirPass, MirSource}; -use util::patch::MirPatch; use rustc_data_structures::indexed_vec::{IndexVec}; +use crate::transform::{MirPass, MirSource}; +use crate::util::patch::MirPatch; pub struct UniformArrayMoveOut; diff --git a/src/librustc_mir/util/borrowck_errors.rs b/src/librustc_mir/util/borrowck_errors.rs index 7ad73aaa3f9a9..fd694ddbbd19f 100644 --- a/src/librustc_mir/util/borrowck_errors.rs +++ b/src/librustc_mir/util/borrowck_errors.rs @@ -12,7 +12,7 @@ pub enum Origin { } impl fmt::Display for Origin { - fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result { // If the user passed `-Z borrowck=compare`, then include // origin info as part of the error report, // otherwise @@ -437,7 +437,7 @@ pub trait BorrowckErrors<'cx>: Sized + Copy { fn cannot_move_out_of_interior_noncopy( self, move_from_span: Span, - ty: ty::Ty, + ty: ty::Ty<'_>, is_index: Option, o: Origin, ) -> DiagnosticBuilder<'cx> { @@ -464,7 +464,7 @@ pub trait BorrowckErrors<'cx>: Sized + Copy { fn cannot_move_out_of_interior_of_drop( self, move_from_span: Span, - container_ty: ty::Ty, + container_ty: ty::Ty<'_>, o: Origin, ) -> DiagnosticBuilder<'cx> { let mut err = struct_span_err!( diff --git a/src/librustc_mir/util/def_use.rs b/src/librustc_mir/util/def_use.rs index 057a7c8be88c9..3b9d7c3612a57 100644 --- a/src/librustc_mir/util/def_use.rs +++ b/src/librustc_mir/util/def_use.rs @@ -107,7 +107,7 @@ impl<'tcx> Info<'tcx> { pub fn defs_not_including_drop( &self, - ) -> iter::Filter>, fn(&&Use<'tcx>) -> bool> { + ) -> iter::Filter>, fn(&&Use<'tcx>) -> bool> { self.defs_and_uses.iter().filter(|place_use| { place_use.context.is_mutating_use() && !place_use.context.is_drop() }) diff --git a/src/librustc_mir/util/elaborate_drops.rs b/src/librustc_mir/util/elaborate_drops.rs index 8b55a4424ae29..23e92b3e933d3 100644 --- a/src/librustc_mir/util/elaborate_drops.rs +++ b/src/librustc_mir/util/elaborate_drops.rs @@ -8,7 +8,7 @@ use rustc::ty::layout::VariantIdx; use rustc::ty::subst::Substs; use rustc::ty::util::IntTypeExt; use rustc_data_structures::indexed_vec::Idx; -use util::patch::MirPatch; +use crate::util::patch::MirPatch; use std::u32; diff --git a/src/librustc_mir/util/graphviz.rs b/src/librustc_mir/util/graphviz.rs index b68898f713021..e93b96c12161c 100644 --- a/src/librustc_mir/util/graphviz.rs +++ b/src/librustc_mir/util/graphviz.rs @@ -1,4 +1,3 @@ -use dot; use rustc::hir::def_id::DefId; use rustc::mir::*; use rustc::ty::TyCtxt; @@ -24,7 +23,7 @@ pub fn write_mir_graphviz<'tcx, W>(tcx: TyCtxt<'_, '_, 'tcx>, /// Write a graphviz DOT graph of the MIR. pub fn write_mir_fn_graphviz<'tcx, W>(tcx: TyCtxt<'_, '_, 'tcx>, def_id: DefId, - mir: &Mir, + mir: &Mir<'_>, w: &mut W) -> io::Result<()> where W: Write { @@ -58,7 +57,7 @@ pub fn write_mir_fn_graphviz<'tcx, W>(tcx: TyCtxt<'_, '_, 'tcx>, /// `init` and `fini` are callbacks for emitting additional rows of /// data (using HTML enclosed with `` in the emitted text). pub fn write_node_label(block: BasicBlock, - mir: &Mir, + mir: &Mir<'_>, w: &mut W, num_cols: u32, init: INIT, @@ -100,7 +99,7 @@ pub fn write_node_label(block: BasicBlock, } /// Write a graphviz DOT node for the given basic block. -fn write_node(block: BasicBlock, mir: &Mir, w: &mut W) -> io::Result<()> { +fn write_node(block: BasicBlock, mir: &Mir<'_>, w: &mut W) -> io::Result<()> { // Start a new node with the label to follow, in one of DOT's pseudo-HTML tables. write!(w, r#" {} [shape="none", label=<"#, node(block))?; write_node_label(block, mir, w, 1, |_| Ok(()), |_| Ok(()))?; @@ -109,7 +108,7 @@ fn write_node(block: BasicBlock, mir: &Mir, w: &mut W) -> io::Result<( } /// Write graphviz DOT edges with labels between the given basic block and all of its successors. -fn write_edges(source: BasicBlock, mir: &Mir, w: &mut W) -> io::Result<()> { +fn write_edges(source: BasicBlock, mir: &Mir<'_>, w: &mut W) -> io::Result<()> { let terminator = mir[source].terminator(); let labels = terminator.kind.fmt_successor_labels(); @@ -125,7 +124,7 @@ fn write_edges(source: BasicBlock, mir: &Mir, w: &mut W) -> io::Result /// all the variables and temporaries. fn write_graph_label<'a, 'gcx, 'tcx, W: Write>(tcx: TyCtxt<'a, 'gcx, 'tcx>, def_id: DefId, - mir: &Mir, + mir: &Mir<'_>, w: &mut W) -> io::Result<()> { write!(w, " label= = BitSet; diff --git a/src/librustc_mir/util/patch.rs b/src/librustc_mir/util/patch.rs index 5a1f94677a1d4..366cd71f6d4e9 100644 --- a/src/librustc_mir/util/patch.rs +++ b/src/librustc_mir/util/patch.rs @@ -170,14 +170,14 @@ impl<'tcx> MirPatch<'tcx> { } } - pub fn source_info_for_index(data: &BasicBlockData, loc: Location) -> SourceInfo { + pub fn source_info_for_index(data: &BasicBlockData<'_>, loc: Location) -> SourceInfo { match data.statements.get(loc.statement_index) { Some(stmt) => stmt.source_info, None => data.terminator().source_info } } - pub fn source_info_for_location(&self, mir: &Mir, loc: Location) -> SourceInfo { + pub fn source_info_for_location(&self, mir: &Mir<'_>, loc: Location) -> SourceInfo { let data = match loc.block.index().checked_sub(mir.basic_blocks().len()) { Some(new) => &self.new_blocks[new], None => &mir[loc.block] diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs index 3a15356806a97..6e1ec31c9372f 100644 --- a/src/librustc_mir/util/pretty.rs +++ b/src/librustc_mir/util/pretty.rs @@ -12,7 +12,7 @@ use std::fs; use std::io::{self, Write}; use std::path::{Path, PathBuf}; use super::graphviz::write_mir_fn_graphviz; -use transform::MirSource; +use crate::transform::MirSource; const INDENT: &str = " "; /// Alignment for lining up comments following MIR statements @@ -446,7 +446,7 @@ impl<'cx, 'gcx, 'tcx> Visitor<'tcx> for ExtraComments<'cx, 'gcx, 'tcx> { } } -fn comment(tcx: TyCtxt, SourceInfo { span, scope }: SourceInfo) -> String { +fn comment(tcx: TyCtxt<'_, '_, '_>, SourceInfo { span, scope }: SourceInfo) -> String { format!( "scope {} at {}", scope.index(), @@ -458,8 +458,8 @@ fn comment(tcx: TyCtxt, SourceInfo { span, scope }: SourceInfo) -> String { /// /// Returns the total number of variables printed. fn write_scope_tree( - tcx: TyCtxt, - mir: &Mir, + tcx: TyCtxt<'_, '_, '_>, + mir: &Mir<'_>, scope_tree: &FxHashMap>, w: &mut dyn Write, parent: SourceScope, @@ -529,7 +529,7 @@ fn write_scope_tree( pub fn write_mir_intro<'a, 'gcx, 'tcx>( tcx: TyCtxt<'a, 'gcx, 'tcx>, src: MirSource, - mir: &Mir, + mir: &Mir<'_>, w: &mut dyn Write, ) -> io::Result<()> { write_mir_sig(tcx, src, mir, w)?; @@ -568,7 +568,12 @@ pub fn write_mir_intro<'a, 'gcx, 'tcx>( Ok(()) } -fn write_mir_sig(tcx: TyCtxt, src: MirSource, mir: &Mir, w: &mut dyn Write) -> io::Result<()> { +fn write_mir_sig( + tcx: TyCtxt<'_, '_, '_>, + src: MirSource, + mir: &Mir<'_>, + w: &mut dyn Write, +) -> io::Result<()> { let id = tcx.hir().as_local_node_id(src.def_id).unwrap(); let body_owner_kind = tcx.hir().body_owner_kind(id); match (body_owner_kind, src.promoted) { @@ -614,7 +619,7 @@ fn write_mir_sig(tcx: TyCtxt, src: MirSource, mir: &Mir, w: &mut dyn Write) -> i Ok(()) } -fn write_temp_decls(mir: &Mir, w: &mut dyn Write) -> io::Result<()> { +fn write_temp_decls(mir: &Mir<'_>, w: &mut dyn Write) -> io::Result<()> { // Compiler-introduced temporary types. for temp in mir.temps_iter() { writeln!( @@ -630,7 +635,7 @@ fn write_temp_decls(mir: &Mir, w: &mut dyn Write) -> io::Result<()> { Ok(()) } -fn write_user_type_annotations(mir: &Mir, w: &mut dyn Write) -> io::Result<()> { +fn write_user_type_annotations(mir: &Mir<'_>, w: &mut dyn Write) -> io::Result<()> { if !mir.user_type_annotations.is_empty() { writeln!(w, "| User Type Annotations")?; } @@ -643,7 +648,7 @@ fn write_user_type_annotations(mir: &Mir, w: &mut dyn Write) -> io::Result<()> { Ok(()) } -pub fn dump_mir_def_ids(tcx: TyCtxt, single: Option) -> Vec { +pub fn dump_mir_def_ids(tcx: TyCtxt<'_, '_, '_>, single: Option) -> Vec { if let Some(i) = single { vec![i] } else { From 0e2d96e88c660c574723dfc6cf8aab084917cb8c Mon Sep 17 00:00:00 2001 From: Alexander Regueiro Date: Sat, 2 Feb 2019 01:08:15 +0000 Subject: [PATCH 185/278] Factored out error reporting from `smart_resolve_path_fragment` fn. --- src/librustc_resolve/lib.rs | 679 ++++++++++++++++++------------------ 1 file changed, 347 insertions(+), 332 deletions(-) diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 270f242419714..30772cd0d45a2 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -3124,391 +3124,405 @@ impl<'a> Resolver<'a> { ) } - fn smart_resolve_path_fragment(&mut self, - id: NodeId, - qself: Option<&QSelf>, - path: &[Segment], - span: Span, - source: PathSource<'_>, - crate_lint: CrateLint) - -> PathResolution { + /// Handles error reporting for `smart_resolve_path_fragment` function. + /// Creates base error and amends it with one short label and possibly some longer helps/notes. + fn smart_resolve_report_errors( + &mut self, + path: &[Segment], + span: Span, + source: PathSource<'_>, + def: Option, + ) -> (DiagnosticBuilder<'a>, Vec) { let ident_span = path.last().map_or(span, |ident| ident.ident.span); let ns = source.namespace(); let is_expected = &|def| source.is_expected(def); let is_enum_variant = &|def| if let Def::Variant(..) = def { true } else { false }; - - // Base error is amended with one short label and possibly some longer helps/notes. - let report_errors = |this: &mut Self, def: Option| { - // Make the base error. - let expected = source.descr_expected(); - let path_str = Segment::names_to_string(path); - let item_str = path.last().unwrap().ident; - let code = source.error_code(def.is_some()); - let (base_msg, fallback_label, base_span) = if let Some(def) = def { - (format!("expected {}, found {} `{}`", expected, def.kind_name(), path_str), - format!("not a {}", expected), - span) + + // Make the base error. + let expected = source.descr_expected(); + let path_str = Segment::names_to_string(path); + let item_str = path.last().unwrap().ident; + let code = source.error_code(def.is_some()); + let (base_msg, fallback_label, base_span) = if let Some(def) = def { + (format!("expected {}, found {} `{}`", expected, def.kind_name(), path_str), + format!("not a {}", expected), + span) + } else { + let item_span = path.last().unwrap().ident.span; + let (mod_prefix, mod_str) = if path.len() == 1 { + (String::new(), "this scope".to_string()) + } else if path.len() == 2 && path[0].ident.name == keywords::PathRoot.name() { + (String::new(), "the crate root".to_string()) } else { - let item_span = path.last().unwrap().ident.span; - let (mod_prefix, mod_str) = if path.len() == 1 { - (String::new(), "this scope".to_string()) - } else if path.len() == 2 && path[0].ident.name == keywords::PathRoot.name() { - (String::new(), "the crate root".to_string()) - } else { - let mod_path = &path[..path.len() - 1]; - let mod_prefix = match this.resolve_path_without_parent_scope( - mod_path, Some(TypeNS), false, span, CrateLint::No - ) { - PathResult::Module(ModuleOrUniformRoot::Module(module)) => - module.def(), - _ => None, - }.map_or(String::new(), |def| format!("{} ", def.kind_name())); - (mod_prefix, format!("`{}`", Segment::names_to_string(mod_path))) - }; - (format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str), - format!("not found in {}", mod_str), - item_span) + let mod_path = &path[..path.len() - 1]; + let mod_prefix = match self.resolve_path_without_parent_scope( + mod_path, Some(TypeNS), false, span, CrateLint::No + ) { + PathResult::Module(ModuleOrUniformRoot::Module(module)) => + module.def(), + _ => None, + }.map_or(String::new(), |def| format!("{} ", def.kind_name())); + (mod_prefix, format!("`{}`", Segment::names_to_string(mod_path))) }; + (format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str), + format!("not found in {}", mod_str), + item_span) + }; - let code = DiagnosticId::Error(code.into()); - let mut err = this.session.struct_span_err_with_code(base_span, &base_msg, code); + let code = DiagnosticId::Error(code.into()); + let mut err = self.session.struct_span_err_with_code(base_span, &base_msg, code); - // Emit help message for fake-self from other languages like `this`(javascript) - if ["this", "my"].contains(&&*item_str.as_str()) - && this.self_value_is_available(path[0].ident.span, span) { - err.span_suggestion( + // Emit help message for fake-self from other languages (e.g., `this` in Javascript). + if ["this", "my"].contains(&&*item_str.as_str()) + && self.self_value_is_available(path[0].ident.span, span) { + err.span_suggestion( + span, + "did you mean", + "self".to_string(), + Applicability::MaybeIncorrect, + ); + } + + // Emit special messages for unresolved `Self` and `self`. + if is_self_type(path, ns) { + __diagnostic_used!(E0411); + err.code(DiagnosticId::Error("E0411".into())); + err.span_label(span, format!("`Self` is only available in impls, traits, \ + and type definitions")); + return (err, Vec::new()); + } + if is_self_value(path, ns) { + debug!("smart_resolve_path_fragment: E0424, source={:?}", source); + + __diagnostic_used!(E0424); + err.code(DiagnosticId::Error("E0424".into())); + err.span_label(span, match source { + PathSource::Pat => { + format!("`self` value is a keyword \ + and may not be bound to \ + variables or shadowed") + } + _ => { + format!("`self` value is a keyword \ + only available in methods \ + with `self` parameter") + } + }); + return (err, Vec::new()); + } + + // Try to lookup name in more relaxed fashion for better error reporting. + let ident = path.last().unwrap().ident; + let candidates = self.lookup_import_candidates(ident, ns, is_expected); + if candidates.is_empty() && is_expected(Def::Enum(DefId::local(CRATE_DEF_INDEX))) { + let enum_candidates = + self.lookup_import_candidates(ident, ns, is_enum_variant); + let mut enum_candidates = enum_candidates.iter() + .map(|suggestion| { + import_candidate_to_enum_paths(&suggestion) + }).collect::>(); + enum_candidates.sort(); + + if !enum_candidates.is_empty() { + // Contextualize for E0412 "cannot find type", but don't belabor the point + // (that it's a variant) for E0573 "expected type, found variant". + let preamble = if def.is_none() { + let others = match enum_candidates.len() { + 1 => String::new(), + 2 => " and 1 other".to_owned(), + n => format!(" and {} others", n) + }; + format!("there is an enum variant `{}`{}; ", + enum_candidates[0].0, others) + } else { + String::new() + }; + let msg = format!("{}try using the variant's enum", preamble); + + err.span_suggestions( span, - "did you mean", - "self".to_string(), - Applicability::MaybeIncorrect, + &msg, + enum_candidates.into_iter() + .map(|(_variant_path, enum_ty_path)| enum_ty_path) + // Variants re-exported in prelude doesn't mean `prelude::v1` is the + // type name! + // FIXME: is there a more principled way to do this that + // would work for other re-exports? + .filter(|enum_ty_path| enum_ty_path != "std::prelude::v1") + // Also write `Option` rather than `std::prelude::v1::Option`. + .map(|enum_ty_path| { + // FIXME #56861: DRYer prelude filtering. + enum_ty_path.trim_start_matches("std::prelude::v1::").to_owned() + }), + Applicability::MachineApplicable, ); } - - // Emit special messages for unresolved `Self` and `self`. - if is_self_type(path, ns) { - __diagnostic_used!(E0411); - err.code(DiagnosticId::Error("E0411".into())); - err.span_label(span, format!("`Self` is only available in impls, traits, \ - and type definitions")); - return (err, Vec::new()); - } - if is_self_value(path, ns) { - debug!("smart_resolve_path_fragment E0424 source:{:?}", source); - - __diagnostic_used!(E0424); - err.code(DiagnosticId::Error("E0424".into())); - err.span_label(span, match source { - PathSource::Pat => { - format!("`self` value is a keyword \ - and may not be bound to \ - variables or shadowed") + } + if path.len() == 1 && self.self_type_is_available(span) { + if let Some(candidate) = self.lookup_assoc_candidate(ident, ns, is_expected) { + let self_is_available = self.self_value_is_available(path[0].ident.span, span); + match candidate { + AssocSuggestion::Field => { + err.span_suggestion( + span, + "try", + format!("self.{}", path_str), + Applicability::MachineApplicable, + ); + if !self_is_available { + err.span_label(span, format!("`self` value is a keyword \ + only available in \ + methods with `self` parameter")); + } } - _ => { - format!("`self` value is a keyword \ - only available in methods \ - with `self` parameter") + AssocSuggestion::MethodWithSelf if self_is_available => { + err.span_suggestion( + span, + "try", + format!("self.{}", path_str), + Applicability::MachineApplicable, + ); } - }); - return (err, Vec::new()); + AssocSuggestion::MethodWithSelf | AssocSuggestion::AssocItem => { + err.span_suggestion( + span, + "try", + format!("Self::{}", path_str), + Applicability::MachineApplicable, + ); + } + } + return (err, candidates); } + } - // Try to lookup the name in more relaxed fashion for better error reporting. - let ident = path.last().unwrap().ident; - let candidates = this.lookup_import_candidates(ident, ns, is_expected); - if candidates.is_empty() && is_expected(Def::Enum(DefId::local(CRATE_DEF_INDEX))) { - let enum_candidates = - this.lookup_import_candidates(ident, ns, is_enum_variant); - let mut enum_candidates = enum_candidates.iter() - .map(|suggestion| { - import_candidate_to_enum_paths(&suggestion) - }).collect::>(); - enum_candidates.sort(); - - if !enum_candidates.is_empty() { - // contextualize for E0412 "cannot find type", but don't belabor the point - // (that it's a variant) for E0573 "expected type, found variant" - let preamble = if def.is_none() { - let others = match enum_candidates.len() { - 1 => String::new(), - 2 => " and 1 other".to_owned(), - n => format!(" and {} others", n) - }; - format!("there is an enum variant `{}`{}; ", - enum_candidates[0].0, others) - } else { - String::new() - }; - let msg = format!("{}try using the variant's enum", preamble); + let mut levenshtein_worked = false; - err.span_suggestions( + // Try Levenshtein algorithm. + let suggestion = self.lookup_typo_candidate(path, ns, is_expected, span); + if let Some(suggestion) = suggestion { + let msg = format!( + "{} {} with a similar name exists", + suggestion.article, suggestion.kind + ); + err.span_suggestion( + ident_span, + &msg, + suggestion.candidate.to_string(), + Applicability::MaybeIncorrect, + ); + + levenshtein_worked = true; + } + + // Try context-dependent help if relaxed lookup didn't work. + if let Some(def) = def { + match (def, source) { + (Def::Macro(..), _) => { + err.span_suggestion( span, - &msg, - enum_candidates.into_iter() - .map(|(_variant_path, enum_ty_path)| enum_ty_path) - // variants reëxported in prelude doesn't mean `prelude::v1` is the - // type name! FIXME: is there a more principled way to do this that - // would work for other reëxports? - .filter(|enum_ty_path| enum_ty_path != "std::prelude::v1") - // also say `Option` rather than `std::prelude::v1::Option` - .map(|enum_ty_path| { - // FIXME #56861: DRYer prelude filtering - enum_ty_path.trim_start_matches("std::prelude::v1::").to_owned() - }), - Applicability::MachineApplicable, + "use `!` to invoke the macro", + format!("{}!", path_str), + Applicability::MaybeIncorrect, ); + return (err, candidates); } - } - if path.len() == 1 && this.self_type_is_available(span) { - if let Some(candidate) = this.lookup_assoc_candidate(ident, ns, is_expected) { - let self_is_available = this.self_value_is_available(path[0].ident.span, span); - match candidate { - AssocSuggestion::Field => { - err.span_suggestion( - span, - "try", - format!("self.{}", path_str), - Applicability::MachineApplicable, - ); - if !self_is_available { - err.span_label(span, format!("`self` value is a keyword \ - only available in \ - methods with `self` parameter")); - } - } - AssocSuggestion::MethodWithSelf if self_is_available => { - err.span_suggestion( - span, - "try", - format!("self.{}", path_str), - Applicability::MachineApplicable, - ); - } - AssocSuggestion::MethodWithSelf | AssocSuggestion::AssocItem => { - err.span_suggestion( - span, - "try", - format!("Self::{}", path_str), - Applicability::MachineApplicable, - ); - } + (Def::TyAlias(..), PathSource::Trait(_)) => { + err.span_label(span, "type aliases cannot be used as traits"); + if nightly_options::is_nightly_build() { + err.note("did you mean to use a trait alias?"); } return (err, candidates); } - } - - let mut levenshtein_worked = false; - - // Try Levenshtein algorithm. - let suggestion = this.lookup_typo_candidate(path, ns, is_expected, span); - if let Some(suggestion) = suggestion { - let msg = format!( - "{} {} with a similar name exists", - suggestion.article, suggestion.kind - ); - err.span_suggestion( - ident_span, - &msg, - suggestion.candidate.to_string(), - Applicability::MaybeIncorrect, - ); - - levenshtein_worked = true; - } - - // Try context dependent help if relaxed lookup didn't work. - if let Some(def) = def { - match (def, source) { - (Def::Macro(..), _) => { + (Def::Mod(..), PathSource::Expr(Some(parent))) => match parent.node { + ExprKind::Field(_, ident) => { err.span_suggestion( - span, - "use `!` to invoke the macro", - format!("{}!", path_str), + parent.span, + "use the path separator to refer to an item", + format!("{}::{}", path_str, ident), Applicability::MaybeIncorrect, ); return (err, candidates); } - (Def::TyAlias(..), PathSource::Trait(_)) => { - err.span_label(span, "type aliases cannot be used as traits"); - if nightly_options::is_nightly_build() { - err.note("did you mean to use a trait alias?"); - } + ExprKind::MethodCall(ref segment, ..) => { + let span = parent.span.with_hi(segment.ident.span.hi()); + err.span_suggestion( + span, + "use the path separator to refer to an item", + format!("{}::{}", path_str, segment.ident), + Applicability::MaybeIncorrect, + ); return (err, candidates); } - (Def::Mod(..), PathSource::Expr(Some(parent))) => match parent.node { - ExprKind::Field(_, ident) => { - err.span_suggestion( - parent.span, - "use the path separator to refer to an item", - format!("{}::{}", path_str, ident), - Applicability::MaybeIncorrect, - ); - return (err, candidates); - } - ExprKind::MethodCall(ref segment, ..) => { - let span = parent.span.with_hi(segment.ident.span.hi()); - err.span_suggestion( - span, - "use the path separator to refer to an item", - format!("{}::{}", path_str, segment.ident), - Applicability::MaybeIncorrect, - ); - return (err, candidates); - } - _ => {} - }, - (Def::Enum(..), PathSource::TupleStruct) - | (Def::Enum(..), PathSource::Expr(..)) => { - if let Some(variants) = this.collect_enum_variants(def) { - err.note(&format!("did you mean to use one \ - of the following variants?\n{}", - variants.iter() - .map(|suggestion| path_names_to_string(suggestion)) - .map(|suggestion| format!("- `{}`", suggestion)) - .collect::>() - .join("\n"))); + _ => {} + }, + (Def::Enum(..), PathSource::TupleStruct) + | (Def::Enum(..), PathSource::Expr(..)) => { + if let Some(variants) = self.collect_enum_variants(def) { + err.note(&format!("did you mean to use one \ + of the following variants?\n{}", + variants.iter() + .map(|suggestion| path_names_to_string(suggestion)) + .map(|suggestion| format!("- `{}`", suggestion)) + .collect::>() + .join("\n"))); - } else { - err.note("did you mean to use one of the enum's variants?"); + } else { + err.note("did you mean to use one of the enum's variants?"); + } + return (err, candidates); + }, + (Def::Struct(def_id), _) if ns == ValueNS => { + if let Some((ctor_def, ctor_vis)) + = self.struct_constructors.get(&def_id).cloned() { + let accessible_ctor = self.is_accessible(ctor_vis); + if is_expected(ctor_def) && !accessible_ctor { + err.span_label(span, format!("constructor is not visible \ + here due to private fields")); } - return (err, candidates); - }, - (Def::Struct(def_id), _) if ns == ValueNS => { - if let Some((ctor_def, ctor_vis)) - = this.struct_constructors.get(&def_id).cloned() { - let accessible_ctor = this.is_accessible(ctor_vis); - if is_expected(ctor_def) && !accessible_ctor { - err.span_label(span, format!("constructor is not visible \ - here due to private fields")); - } - } else { - // HACK(estebank): find a better way to figure out that this was a - // parser issue where a struct literal is being used on an expression - // where a brace being opened means a block is being started. Look - // ahead for the next text to see if `span` is followed by a `{`. - let sm = this.session.source_map(); - let mut sp = span; - loop { - sp = sm.next_point(sp); - match sm.span_to_snippet(sp) { - Ok(ref snippet) => { - if snippet.chars().any(|c| { !c.is_whitespace() }) { - break; - } + } else { + // HACK(estebank): find a better way to figure out that this was a + // parser issue where a struct literal is being used on an expression + // where a brace being opened means a block is being started. Look + // ahead for the next text to see if `span` is followed by a `{`. + let sm = self.session.source_map(); + let mut sp = span; + loop { + sp = sm.next_point(sp); + match sm.span_to_snippet(sp) { + Ok(ref snippet) => { + if snippet.chars().any(|c| { !c.is_whitespace() }) { + break; } - _ => break, } + _ => break, } - let followed_by_brace = match sm.span_to_snippet(sp) { - Ok(ref snippet) if snippet == "{" => true, - _ => false, - }; - // In case this could be a struct literal that needs to be surrounded - // by parenthesis, find the appropriate span. - let mut i = 0; - let mut closing_brace = None; - loop { - sp = sm.next_point(sp); - match sm.span_to_snippet(sp) { - Ok(ref snippet) => { - if snippet == "}" { - let sp = span.to(sp); - if let Ok(snippet) = sm.span_to_snippet(sp) { - closing_brace = Some((sp, snippet)); - } - break; + } + let followed_by_brace = match sm.span_to_snippet(sp) { + Ok(ref snippet) if snippet == "{" => true, + _ => false, + }; + // In case this could be a struct literal that needs to be surrounded + // by parenthesis, find the appropriate span. + let mut i = 0; + let mut closing_brace = None; + loop { + sp = sm.next_point(sp); + match sm.span_to_snippet(sp) { + Ok(ref snippet) => { + if snippet == "}" { + let sp = span.to(sp); + if let Ok(snippet) = sm.span_to_snippet(sp) { + closing_brace = Some((sp, snippet)); } + break; } - _ => break, - } - i += 1; - if i > 100 { // The bigger the span the more likely we're - break; // incorrect. Bound it to 100 chars long. } + _ => break, } - match source { - PathSource::Expr(Some(parent)) => { - match parent.node { - ExprKind::MethodCall(ref path_assignment, _) => { - err.span_suggestion( - sm.start_point(parent.span) - .to(path_assignment.ident.span), - "use `::` to access an associated function", - format!("{}::{}", - path_str, - path_assignment.ident), - Applicability::MaybeIncorrect - ); - return (err, candidates); - }, - _ => { - err.span_label( - span, - format!("did you mean `{} {{ /* fields */ }}`?", - path_str), - ); - return (err, candidates); - }, - } - }, - PathSource::Expr(None) if followed_by_brace == true => { - if let Some((sp, snippet)) = closing_brace { + i += 1; + // The bigger the span, the more likely we're + // incorrect. Bound it to 100 chars long. + if i > 100 { + break; + } + } + match source { + PathSource::Expr(Some(parent)) => { + match parent.node { + ExprKind::MethodCall(ref path_assignment, _) => { err.span_suggestion( - sp, - "surround the struct literal with parenthesis", - format!("({})", snippet), - Applicability::MaybeIncorrect, + sm.start_point(parent.span) + .to(path_assignment.ident.span), + "use `::` to access an associated function", + format!("{}::{}", + path_str, + path_assignment.ident), + Applicability::MaybeIncorrect ); - } else { + return (err, candidates); + }, + _ => { err.span_label( span, - format!("did you mean `({} {{ /* fields */ }})`?", + format!("did you mean `{} {{ /* fields */ }}`?", path_str), ); - } - return (err, candidates); - }, - _ => { + return (err, candidates); + }, + } + }, + PathSource::Expr(None) if followed_by_brace == true => { + if let Some((sp, snippet)) = closing_brace { + err.span_suggestion( + sp, + "surround the struct literal with parenthesis", + format!("({})", snippet), + Applicability::MaybeIncorrect, + ); + } else { err.span_label( span, - format!("did you mean `{} {{ /* fields */ }}`?", + format!("did you mean `({} {{ /* fields */ }})`?", path_str), ); - return (err, candidates); - }, - } + } + return (err, candidates); + }, + _ => { + err.span_label( + span, + format!("did you mean `{} {{ /* fields */ }}`?", + path_str), + ); + return (err, candidates); + }, } - return (err, candidates); } - (Def::Union(..), _) | - (Def::Variant(..), _) | - (Def::VariantCtor(_, CtorKind::Fictive), _) if ns == ValueNS => { - err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?", - path_str)); - return (err, candidates); - } - (Def::SelfTy(..), _) if ns == ValueNS => { - err.span_label(span, fallback_label); - err.note("can't use `Self` as a constructor, you must use the \ - implemented struct"); - return (err, candidates); - } - (Def::TyAlias(_), _) | (Def::AssociatedTy(..), _) if ns == ValueNS => { - err.note("can't use a type alias as a constructor"); - return (err, candidates); - } - _ => {} + return (err, candidates); } + (Def::Union(..), _) | + (Def::Variant(..), _) | + (Def::VariantCtor(_, CtorKind::Fictive), _) if ns == ValueNS => { + err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?", + path_str)); + return (err, candidates); + } + (Def::SelfTy(..), _) if ns == ValueNS => { + err.span_label(span, fallback_label); + err.note("can't use `Self` as a constructor, you must use the \ + implemented struct"); + return (err, candidates); + } + (Def::TyAlias(_), _) | (Def::AssociatedTy(..), _) if ns == ValueNS => { + err.note("can't use a type alias as a constructor"); + return (err, candidates); + } + _ => {} } + } + + // Fallback label. + if !levenshtein_worked { + err.span_label(base_span, fallback_label); + self.type_ascription_suggestion(&mut err, base_span); + } + (err, candidates) + } + + fn smart_resolve_path_fragment(&mut self, + id: NodeId, + qself: Option<&QSelf>, + path: &[Segment], + span: Span, + source: PathSource, + crate_lint: CrateLint) + -> PathResolution { + let ns = source.namespace(); + let is_expected = &|def| source.is_expected(def); - // Fallback label. - if !levenshtein_worked { - err.span_label(base_span, fallback_label); - this.type_ascription_suggestion(&mut err, base_span); - } - (err, candidates) - }; let report_errors = |this: &mut Self, def: Option| { - let (err, candidates) = report_errors(this, def); + let (err, candidates) = this.smart_resolve_report_errors(path, span, source, def); let def_id = this.current_module.normal_ancestor_id; let node_id = this.definitions.as_local_node_id(def_id).unwrap(); let better = def.is_some(); @@ -3579,7 +3593,8 @@ impl<'a> Resolver<'a> { debug!("self.current_type_ascription {:?}", self.current_type_ascription); if let Some(sp) = self.current_type_ascription.last() { let mut sp = *sp; - loop { // try to find the `:`, bail on first non-':'/non-whitespace + loop { + // Try to find the `:`; bail on first non-':' / non-whitespace. sp = cm.next_point(sp); if let Ok(snippet) = cm.span_to_snippet(sp.to(cm.next_point(sp))) { debug!("snippet {:?}", snippet); From 14b674ab9d1f0b71763a168bd764eb7d53154008 Mon Sep 17 00:00:00 2001 From: Alexander Regueiro Date: Sat, 2 Feb 2019 02:18:32 +0000 Subject: [PATCH 186/278] Factored out context-dependent help for error reporting. --- src/librustc_resolve/lib.rs | 378 +++++++++++++++++++----------------- 1 file changed, 195 insertions(+), 183 deletions(-) diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 30772cd0d45a2..1a5fce14fa8fd 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -3124,6 +3124,193 @@ impl<'a> Resolver<'a> { ) } + /// Provides context-dependent help for errors reported by the `smart_resolve_path_fragment` + /// function. + /// Returns `true` if able to provide context-dependent help. + fn smart_resolve_context_dep_help( + &mut self, + err: &mut DiagnosticBuilder<'a>, + span: Span, + source: PathSource, + def: Def, + path_str: &str, + fallback_label: &str, + ) -> bool { + let ns = source.namespace(); + let is_expected = &|def| source.is_expected(def); + + match (def, source) { + (Def::Macro(..), _) => { + err.span_suggestion( + span, + "use `!` to invoke the macro", + format!("{}!", path_str), + Applicability::MaybeIncorrect, + ); + } + (Def::TyAlias(..), PathSource::Trait(_)) => { + err.span_label(span, "type aliases cannot be used as traits"); + if nightly_options::is_nightly_build() { + err.note("did you mean to use a trait alias?"); + } + } + (Def::Mod(..), PathSource::Expr(Some(parent))) => match parent.node { + ExprKind::Field(_, ident) => { + err.span_suggestion( + parent.span, + "use the path separator to refer to an item", + format!("{}::{}", path_str, ident), + Applicability::MaybeIncorrect, + ); + } + ExprKind::MethodCall(ref segment, ..) => { + let span = parent.span.with_hi(segment.ident.span.hi()); + err.span_suggestion( + span, + "use the path separator to refer to an item", + format!("{}::{}", path_str, segment.ident), + Applicability::MaybeIncorrect, + ); + } + _ => return false, + }, + (Def::Enum(..), PathSource::TupleStruct) + | (Def::Enum(..), PathSource::Expr(..)) => { + if let Some(variants) = self.collect_enum_variants(def) { + err.note(&format!("did you mean to use one \ + of the following variants?\n{}", + variants.iter() + .map(|suggestion| path_names_to_string(suggestion)) + .map(|suggestion| format!("- `{}`", suggestion)) + .collect::>() + .join("\n"))); + } else { + err.note("did you mean to use one of the enum's variants?"); + } + }, + (Def::Struct(def_id), _) if ns == ValueNS => { + if let Some((ctor_def, ctor_vis)) + = self.struct_constructors.get(&def_id).cloned() { + let accessible_ctor = self.is_accessible(ctor_vis); + if is_expected(ctor_def) && !accessible_ctor { + err.span_label(span, format!("constructor is not visible \ + here due to private fields")); + } + } else { + // HACK(estebank): find a better way to figure out that this was a + // parser issue where a struct literal is being used on an expression + // where a brace being opened means a block is being started. Look + // ahead for the next text to see if `span` is followed by a `{`. + let sm = self.session.source_map(); + let mut sp = span; + loop { + sp = sm.next_point(sp); + match sm.span_to_snippet(sp) { + Ok(ref snippet) => { + if snippet.chars().any(|c| { !c.is_whitespace() }) { + break; + } + } + _ => break, + } + } + let followed_by_brace = match sm.span_to_snippet(sp) { + Ok(ref snippet) if snippet == "{" => true, + _ => false, + }; + // In case this could be a struct literal that needs to be surrounded + // by parenthesis, find the appropriate span. + let mut i = 0; + let mut closing_brace = None; + loop { + sp = sm.next_point(sp); + match sm.span_to_snippet(sp) { + Ok(ref snippet) => { + if snippet == "}" { + let sp = span.to(sp); + if let Ok(snippet) = sm.span_to_snippet(sp) { + closing_brace = Some((sp, snippet)); + } + break; + } + } + _ => break, + } + i += 1; + // The bigger the span, the more likely we're incorrect -- + // bound it to 100 chars long. + if i > 100 { + break; + } + } + match source { + PathSource::Expr(Some(parent)) => { + match parent.node { + ExprKind::MethodCall(ref path_assignment, _) => { + err.span_suggestion( + sm.start_point(parent.span) + .to(path_assignment.ident.span), + "use `::` to access an associated function", + format!("{}::{}", + path_str, + path_assignment.ident), + Applicability::MaybeIncorrect + ); + }, + _ => { + err.span_label( + span, + format!("did you mean `{} {{ /* fields */ }}`?", + path_str), + ); + }, + } + }, + PathSource::Expr(None) if followed_by_brace == true => { + if let Some((sp, snippet)) = closing_brace { + err.span_suggestion( + sp, + "surround the struct literal with parenthesis", + format!("({})", snippet), + Applicability::MaybeIncorrect, + ); + } else { + err.span_label( + span, + format!("did you mean `({} {{ /* fields */ }})`?", + path_str), + ); + } + }, + _ => { + err.span_label( + span, + format!("did you mean `{} {{ /* fields */ }}`?", + path_str), + ); + }, + } + } + } + (Def::Union(..), _) | + (Def::Variant(..), _) | + (Def::VariantCtor(_, CtorKind::Fictive), _) if ns == ValueNS => { + err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?", + path_str)); + } + (Def::SelfTy(..), _) if ns == ValueNS => { + err.span_label(span, fallback_label); + err.note("can't use `Self` as a constructor, you must use the \ + implemented struct"); + } + (Def::TyAlias(_), _) | (Def::AssociatedTy(..), _) if ns == ValueNS => { + err.note("can't use a type alias as a constructor"); + } + _ => return false, + } + true + } + /// Handles error reporting for `smart_resolve_path_fragment` function. /// Creates base error and amends it with one short label and possibly some longer helps/notes. fn smart_resolve_report_errors( @@ -3137,7 +3324,7 @@ impl<'a> Resolver<'a> { let ns = source.namespace(); let is_expected = &|def| source.is_expected(def); let is_enum_variant = &|def| if let Def::Variant(..) = def { true } else { false }; - + // Make the base error. let expected = source.descr_expected(); let path_str = Segment::names_to_string(path); @@ -3317,188 +3504,13 @@ impl<'a> Resolver<'a> { // Try context-dependent help if relaxed lookup didn't work. if let Some(def) = def { - match (def, source) { - (Def::Macro(..), _) => { - err.span_suggestion( - span, - "use `!` to invoke the macro", - format!("{}!", path_str), - Applicability::MaybeIncorrect, - ); - return (err, candidates); - } - (Def::TyAlias(..), PathSource::Trait(_)) => { - err.span_label(span, "type aliases cannot be used as traits"); - if nightly_options::is_nightly_build() { - err.note("did you mean to use a trait alias?"); - } - return (err, candidates); - } - (Def::Mod(..), PathSource::Expr(Some(parent))) => match parent.node { - ExprKind::Field(_, ident) => { - err.span_suggestion( - parent.span, - "use the path separator to refer to an item", - format!("{}::{}", path_str, ident), - Applicability::MaybeIncorrect, - ); - return (err, candidates); - } - ExprKind::MethodCall(ref segment, ..) => { - let span = parent.span.with_hi(segment.ident.span.hi()); - err.span_suggestion( - span, - "use the path separator to refer to an item", - format!("{}::{}", path_str, segment.ident), - Applicability::MaybeIncorrect, - ); - return (err, candidates); - } - _ => {} - }, - (Def::Enum(..), PathSource::TupleStruct) - | (Def::Enum(..), PathSource::Expr(..)) => { - if let Some(variants) = self.collect_enum_variants(def) { - err.note(&format!("did you mean to use one \ - of the following variants?\n{}", - variants.iter() - .map(|suggestion| path_names_to_string(suggestion)) - .map(|suggestion| format!("- `{}`", suggestion)) - .collect::>() - .join("\n"))); - - } else { - err.note("did you mean to use one of the enum's variants?"); - } - return (err, candidates); - }, - (Def::Struct(def_id), _) if ns == ValueNS => { - if let Some((ctor_def, ctor_vis)) - = self.struct_constructors.get(&def_id).cloned() { - let accessible_ctor = self.is_accessible(ctor_vis); - if is_expected(ctor_def) && !accessible_ctor { - err.span_label(span, format!("constructor is not visible \ - here due to private fields")); - } - } else { - // HACK(estebank): find a better way to figure out that this was a - // parser issue where a struct literal is being used on an expression - // where a brace being opened means a block is being started. Look - // ahead for the next text to see if `span` is followed by a `{`. - let sm = self.session.source_map(); - let mut sp = span; - loop { - sp = sm.next_point(sp); - match sm.span_to_snippet(sp) { - Ok(ref snippet) => { - if snippet.chars().any(|c| { !c.is_whitespace() }) { - break; - } - } - _ => break, - } - } - let followed_by_brace = match sm.span_to_snippet(sp) { - Ok(ref snippet) if snippet == "{" => true, - _ => false, - }; - // In case this could be a struct literal that needs to be surrounded - // by parenthesis, find the appropriate span. - let mut i = 0; - let mut closing_brace = None; - loop { - sp = sm.next_point(sp); - match sm.span_to_snippet(sp) { - Ok(ref snippet) => { - if snippet == "}" { - let sp = span.to(sp); - if let Ok(snippet) = sm.span_to_snippet(sp) { - closing_brace = Some((sp, snippet)); - } - break; - } - } - _ => break, - } - i += 1; - // The bigger the span, the more likely we're - // incorrect. Bound it to 100 chars long. - if i > 100 { - break; - } - } - match source { - PathSource::Expr(Some(parent)) => { - match parent.node { - ExprKind::MethodCall(ref path_assignment, _) => { - err.span_suggestion( - sm.start_point(parent.span) - .to(path_assignment.ident.span), - "use `::` to access an associated function", - format!("{}::{}", - path_str, - path_assignment.ident), - Applicability::MaybeIncorrect - ); - return (err, candidates); - }, - _ => { - err.span_label( - span, - format!("did you mean `{} {{ /* fields */ }}`?", - path_str), - ); - return (err, candidates); - }, - } - }, - PathSource::Expr(None) if followed_by_brace == true => { - if let Some((sp, snippet)) = closing_brace { - err.span_suggestion( - sp, - "surround the struct literal with parenthesis", - format!("({})", snippet), - Applicability::MaybeIncorrect, - ); - } else { - err.span_label( - span, - format!("did you mean `({} {{ /* fields */ }})`?", - path_str), - ); - } - return (err, candidates); - }, - _ => { - err.span_label( - span, - format!("did you mean `{} {{ /* fields */ }}`?", - path_str), - ); - return (err, candidates); - }, - } - } - return (err, candidates); - } - (Def::Union(..), _) | - (Def::Variant(..), _) | - (Def::VariantCtor(_, CtorKind::Fictive), _) if ns == ValueNS => { - err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?", - path_str)); - return (err, candidates); - } - (Def::SelfTy(..), _) if ns == ValueNS => { - err.span_label(span, fallback_label); - err.note("can't use `Self` as a constructor, you must use the \ - implemented struct"); - return (err, candidates); - } - (Def::TyAlias(_), _) | (Def::AssociatedTy(..), _) if ns == ValueNS => { - err.note("can't use a type alias as a constructor"); - return (err, candidates); - } - _ => {} + if self.smart_resolve_context_dep_help(&mut err, + span, + source, + def, + &path_str, + &fallback_label) { + return (err, candidates); } } From 497a772d04731d9e93abb71ae99696684e514bb3 Mon Sep 17 00:00:00 2001 From: Alexander Regueiro Date: Mon, 4 Feb 2019 11:25:29 +0100 Subject: [PATCH 187/278] Addressed review points. --- src/librustc_resolve/error_reporting.rs | 417 +++++++++++++++++++++++- src/librustc_resolve/lib.rs | 399 ----------------------- 2 files changed, 412 insertions(+), 404 deletions(-) diff --git a/src/librustc_resolve/error_reporting.rs b/src/librustc_resolve/error_reporting.rs index b131a6b62f9bf..88892ae2cd3d8 100644 --- a/src/librustc_resolve/error_reporting.rs +++ b/src/librustc_resolve/error_reporting.rs @@ -1,13 +1,420 @@ -use crate::{CrateLint, PathResult, Segment}; -use crate::macros::ParentScope; -use crate::resolve_imports::ImportResolver; +use std::cmp::Reverse; +use log::debug; +use rustc::hir::def::*; +use rustc::hir::def::Namespace::*; +use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId}; +use rustc::session::config::nightly_options; +use syntax::ast::{ExprKind}; use syntax::symbol::keywords; use syntax_pos::Span; -use log::debug; +use crate::errors::{Applicability, DiagnosticBuilder, DiagnosticId}; +use crate::macros::ParentScope; +use crate::resolve_imports::ImportResolver; +use crate::{import_candidate_to_enum_paths, is_self_type, is_self_value, path_names_to_string}; +use crate::{AssocSuggestion, CrateLint, ImportSuggestion, ModuleOrUniformRoot, PathResult, + PathSource, Resolver, Segment}; -use std::cmp::Reverse; +impl<'a> Resolver<'a> { + /// Handles error reporting for `smart_resolve_path_fragment` function. + /// Creates base error and amends it with one short label and possibly some longer helps/notes. + pub(crate) fn smart_resolve_report_errors( + &mut self, + path: &[Segment], + span: Span, + source: PathSource, + def: Option, + ) -> (DiagnosticBuilder<'a>, Vec) { + let ident_span = path.last().map_or(span, |ident| ident.ident.span); + let ns = source.namespace(); + let is_expected = &|def| source.is_expected(def); + let is_enum_variant = &|def| if let Def::Variant(..) = def { true } else { false }; + + // Make the base error. + let expected = source.descr_expected(); + let path_str = Segment::names_to_string(path); + let item_str = path.last().unwrap().ident; + let code = source.error_code(def.is_some()); + let (base_msg, fallback_label, base_span) = if let Some(def) = def { + (format!("expected {}, found {} `{}`", expected, def.kind_name(), path_str), + format!("not a {}", expected), + span) + } else { + let item_span = path.last().unwrap().ident.span; + let (mod_prefix, mod_str) = if path.len() == 1 { + (String::new(), "this scope".to_string()) + } else if path.len() == 2 && path[0].ident.name == keywords::PathRoot.name() { + (String::new(), "the crate root".to_string()) + } else { + let mod_path = &path[..path.len() - 1]; + let mod_prefix = match self.resolve_path_without_parent_scope( + mod_path, Some(TypeNS), false, span, CrateLint::No + ) { + PathResult::Module(ModuleOrUniformRoot::Module(module)) => + module.def(), + _ => None, + }.map_or(String::new(), |def| format!("{} ", def.kind_name())); + (mod_prefix, format!("`{}`", Segment::names_to_string(mod_path))) + }; + (format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str), + format!("not found in {}", mod_str), + item_span) + }; + + let code = DiagnosticId::Error(code.into()); + let mut err = self.session.struct_span_err_with_code(base_span, &base_msg, code); + + // Emit help message for fake-self from other languages (e.g., `this` in Javascript). + if ["this", "my"].contains(&&*item_str.as_str()) + && self.self_value_is_available(path[0].ident.span, span) { + err.span_suggestion( + span, + "did you mean", + "self".to_string(), + Applicability::MaybeIncorrect, + ); + } + + // Emit special messages for unresolved `Self` and `self`. + if is_self_type(path, ns) { + __diagnostic_used!(E0411); + err.code(DiagnosticId::Error("E0411".into())); + err.span_label(span, format!("`Self` is only available in impls, traits, \ + and type definitions")); + return (err, Vec::new()); + } + if is_self_value(path, ns) { + debug!("smart_resolve_path_fragment: E0424, source={:?}", source); + + __diagnostic_used!(E0424); + err.code(DiagnosticId::Error("E0424".into())); + err.span_label(span, match source { + PathSource::Pat => { + format!("`self` value is a keyword \ + and may not be bound to \ + variables or shadowed") + } + _ => { + format!("`self` value is a keyword \ + only available in methods \ + with `self` parameter") + } + }); + return (err, Vec::new()); + } + + // Try to lookup name in more relaxed fashion for better error reporting. + let ident = path.last().unwrap().ident; + let candidates = self.lookup_import_candidates(ident, ns, is_expected); + if candidates.is_empty() && is_expected(Def::Enum(DefId::local(CRATE_DEF_INDEX))) { + let enum_candidates = + self.lookup_import_candidates(ident, ns, is_enum_variant); + let mut enum_candidates = enum_candidates.iter() + .map(|suggestion| { + import_candidate_to_enum_paths(&suggestion) + }).collect::>(); + enum_candidates.sort(); + + if !enum_candidates.is_empty() { + // Contextualize for E0412 "cannot find type", but don't belabor the point + // (that it's a variant) for E0573 "expected type, found variant". + let preamble = if def.is_none() { + let others = match enum_candidates.len() { + 1 => String::new(), + 2 => " and 1 other".to_owned(), + n => format!(" and {} others", n) + }; + format!("there is an enum variant `{}`{}; ", + enum_candidates[0].0, others) + } else { + String::new() + }; + let msg = format!("{}try using the variant's enum", preamble); + + err.span_suggestions( + span, + &msg, + enum_candidates.into_iter() + .map(|(_variant_path, enum_ty_path)| enum_ty_path) + // Variants re-exported in prelude doesn't mean `prelude::v1` is the + // type name! + // FIXME: is there a more principled way to do this that + // would work for other re-exports? + .filter(|enum_ty_path| enum_ty_path != "std::prelude::v1") + // Also write `Option` rather than `std::prelude::v1::Option`. + .map(|enum_ty_path| { + // FIXME #56861: DRY-er prelude filtering. + enum_ty_path.trim_start_matches("std::prelude::v1::").to_owned() + }), + Applicability::MachineApplicable, + ); + } + } + if path.len() == 1 && self.self_type_is_available(span) { + if let Some(candidate) = self.lookup_assoc_candidate(ident, ns, is_expected) { + let self_is_available = self.self_value_is_available(path[0].ident.span, span); + match candidate { + AssocSuggestion::Field => { + err.span_suggestion( + span, + "try", + format!("self.{}", path_str), + Applicability::MachineApplicable, + ); + if !self_is_available { + err.span_label(span, format!("`self` value is a keyword \ + only available in \ + methods with `self` parameter")); + } + } + AssocSuggestion::MethodWithSelf if self_is_available => { + err.span_suggestion( + span, + "try", + format!("self.{}", path_str), + Applicability::MachineApplicable, + ); + } + AssocSuggestion::MethodWithSelf | AssocSuggestion::AssocItem => { + err.span_suggestion( + span, + "try", + format!("Self::{}", path_str), + Applicability::MachineApplicable, + ); + } + } + return (err, candidates); + } + } + + let mut levenshtein_worked = false; + + // Try Levenshtein algorithm. + let suggestion = self.lookup_typo_candidate(path, ns, is_expected, span); + if let Some(suggestion) = suggestion { + let msg = format!( + "{} {} with a similar name exists", + suggestion.article, suggestion.kind + ); + err.span_suggestion( + ident_span, + &msg, + suggestion.candidate.to_string(), + Applicability::MaybeIncorrect, + ); + + levenshtein_worked = true; + } + + // Try context-dependent help if relaxed lookup didn't work. + if let Some(def) = def { + if self.smart_resolve_context_dependent_help(&mut err, + span, + source, + def, + &path_str, + &fallback_label) { + return (err, candidates); + } + } + + // Fallback label. + if !levenshtein_worked { + err.span_label(base_span, fallback_label); + self.type_ascription_suggestion(&mut err, base_span); + } + (err, candidates) + } + + /// Provides context-dependent help for errors reported by the `smart_resolve_path_fragment` + /// function. + /// Returns `true` if able to provide context-dependent help. + fn smart_resolve_context_dependent_help( + &mut self, + err: &mut DiagnosticBuilder<'a>, + span: Span, + source: PathSource, + def: Def, + path_str: &str, + fallback_label: &str, + ) -> bool { + let ns = source.namespace(); + let is_expected = &|def| source.is_expected(def); + + match (def, source) { + (Def::Macro(..), _) => { + err.span_suggestion( + span, + "use `!` to invoke the macro", + format!("{}!", path_str), + Applicability::MaybeIncorrect, + ); + } + (Def::TyAlias(..), PathSource::Trait(_)) => { + err.span_label(span, "type aliases cannot be used as traits"); + if nightly_options::is_nightly_build() { + err.note("did you mean to use a trait alias?"); + } + } + (Def::Mod(..), PathSource::Expr(Some(parent))) => match parent.node { + ExprKind::Field(_, ident) => { + err.span_suggestion( + parent.span, + "use the path separator to refer to an item", + format!("{}::{}", path_str, ident), + Applicability::MaybeIncorrect, + ); + } + ExprKind::MethodCall(ref segment, ..) => { + let span = parent.span.with_hi(segment.ident.span.hi()); + err.span_suggestion( + span, + "use the path separator to refer to an item", + format!("{}::{}", path_str, segment.ident), + Applicability::MaybeIncorrect, + ); + } + _ => return false, + }, + (Def::Enum(..), PathSource::TupleStruct) + | (Def::Enum(..), PathSource::Expr(..)) => { + if let Some(variants) = self.collect_enum_variants(def) { + err.note(&format!("did you mean to use one \ + of the following variants?\n{}", + variants.iter() + .map(|suggestion| path_names_to_string(suggestion)) + .map(|suggestion| format!("- `{}`", suggestion)) + .collect::>() + .join("\n"))); + } else { + err.note("did you mean to use one of the enum's variants?"); + } + }, + (Def::Struct(def_id), _) if ns == ValueNS => { + if let Some((ctor_def, ctor_vis)) + = self.struct_constructors.get(&def_id).cloned() { + let accessible_ctor = self.is_accessible(ctor_vis); + if is_expected(ctor_def) && !accessible_ctor { + err.span_label(span, format!("constructor is not visible \ + here due to private fields")); + } + } else { + // HACK(estebank): find a better way to figure out that this was a + // parser issue where a struct literal is being used on an expression + // where a brace being opened means a block is being started. Look + // ahead for the next text to see if `span` is followed by a `{`. + let sm = self.session.source_map(); + let mut sp = span; + loop { + sp = sm.next_point(sp); + match sm.span_to_snippet(sp) { + Ok(ref snippet) => { + if snippet.chars().any(|c| { !c.is_whitespace() }) { + break; + } + } + _ => break, + } + } + let followed_by_brace = match sm.span_to_snippet(sp) { + Ok(ref snippet) if snippet == "{" => true, + _ => false, + }; + // In case this could be a struct literal that needs to be surrounded + // by parenthesis, find the appropriate span. + let mut i = 0; + let mut closing_brace = None; + loop { + sp = sm.next_point(sp); + match sm.span_to_snippet(sp) { + Ok(ref snippet) => { + if snippet == "}" { + let sp = span.to(sp); + if let Ok(snippet) = sm.span_to_snippet(sp) { + closing_brace = Some((sp, snippet)); + } + break; + } + } + _ => break, + } + i += 1; + // The bigger the span, the more likely we're incorrect -- + // bound it to 100 chars long. + if i > 100 { + break; + } + } + match source { + PathSource::Expr(Some(parent)) => { + match parent.node { + ExprKind::MethodCall(ref path_assignment, _) => { + err.span_suggestion( + sm.start_point(parent.span) + .to(path_assignment.ident.span), + "use `::` to access an associated function", + format!("{}::{}", + path_str, + path_assignment.ident), + Applicability::MaybeIncorrect + ); + }, + _ => { + err.span_label( + span, + format!("did you mean `{} {{ /* fields */ }}`?", + path_str), + ); + }, + } + }, + PathSource::Expr(None) if followed_by_brace == true => { + if let Some((sp, snippet)) = closing_brace { + err.span_suggestion( + sp, + "surround the struct literal with parenthesis", + format!("({})", snippet), + Applicability::MaybeIncorrect, + ); + } else { + err.span_label( + span, + format!("did you mean `({} {{ /* fields */ }})`?", + path_str), + ); + } + }, + _ => { + err.span_label( + span, + format!("did you mean `{} {{ /* fields */ }}`?", + path_str), + ); + }, + } + } + } + (Def::Union(..), _) | + (Def::Variant(..), _) | + (Def::VariantCtor(_, CtorKind::Fictive), _) if ns == ValueNS => { + err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?", + path_str)); + } + (Def::SelfTy(..), _) if ns == ValueNS => { + err.span_label(span, fallback_label); + err.note("can't use `Self` as a constructor, you must use the \ + implemented struct"); + } + (Def::TyAlias(_), _) | (Def::AssociatedTy(..), _) if ns == ValueNS => { + err.note("can't use a type alias as a constructor"); + } + _ => return false, + } + true + } +} impl<'a, 'b:'a> ImportResolver<'a, 'b> { /// Add suggestions for a path that cannot be resolved. diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 1a5fce14fa8fd..590dcb8947db4 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -25,7 +25,6 @@ use rustc::hir::def::*; use rustc::hir::def::Namespace::*; use rustc::hir::def_id::{CRATE_DEF_INDEX, LOCAL_CRATE, DefId}; use rustc::hir::{Freevar, FreevarMap, TraitCandidate, TraitMap, GlobMap}; -use rustc::session::config::nightly_options; use rustc::ty; use rustc::util::nodemap::{NodeMap, NodeSet, FxHashMap, FxHashSet, DefIdMap}; use rustc::{bug, span_bug}; @@ -3124,404 +3123,6 @@ impl<'a> Resolver<'a> { ) } - /// Provides context-dependent help for errors reported by the `smart_resolve_path_fragment` - /// function. - /// Returns `true` if able to provide context-dependent help. - fn smart_resolve_context_dep_help( - &mut self, - err: &mut DiagnosticBuilder<'a>, - span: Span, - source: PathSource, - def: Def, - path_str: &str, - fallback_label: &str, - ) -> bool { - let ns = source.namespace(); - let is_expected = &|def| source.is_expected(def); - - match (def, source) { - (Def::Macro(..), _) => { - err.span_suggestion( - span, - "use `!` to invoke the macro", - format!("{}!", path_str), - Applicability::MaybeIncorrect, - ); - } - (Def::TyAlias(..), PathSource::Trait(_)) => { - err.span_label(span, "type aliases cannot be used as traits"); - if nightly_options::is_nightly_build() { - err.note("did you mean to use a trait alias?"); - } - } - (Def::Mod(..), PathSource::Expr(Some(parent))) => match parent.node { - ExprKind::Field(_, ident) => { - err.span_suggestion( - parent.span, - "use the path separator to refer to an item", - format!("{}::{}", path_str, ident), - Applicability::MaybeIncorrect, - ); - } - ExprKind::MethodCall(ref segment, ..) => { - let span = parent.span.with_hi(segment.ident.span.hi()); - err.span_suggestion( - span, - "use the path separator to refer to an item", - format!("{}::{}", path_str, segment.ident), - Applicability::MaybeIncorrect, - ); - } - _ => return false, - }, - (Def::Enum(..), PathSource::TupleStruct) - | (Def::Enum(..), PathSource::Expr(..)) => { - if let Some(variants) = self.collect_enum_variants(def) { - err.note(&format!("did you mean to use one \ - of the following variants?\n{}", - variants.iter() - .map(|suggestion| path_names_to_string(suggestion)) - .map(|suggestion| format!("- `{}`", suggestion)) - .collect::>() - .join("\n"))); - } else { - err.note("did you mean to use one of the enum's variants?"); - } - }, - (Def::Struct(def_id), _) if ns == ValueNS => { - if let Some((ctor_def, ctor_vis)) - = self.struct_constructors.get(&def_id).cloned() { - let accessible_ctor = self.is_accessible(ctor_vis); - if is_expected(ctor_def) && !accessible_ctor { - err.span_label(span, format!("constructor is not visible \ - here due to private fields")); - } - } else { - // HACK(estebank): find a better way to figure out that this was a - // parser issue where a struct literal is being used on an expression - // where a brace being opened means a block is being started. Look - // ahead for the next text to see if `span` is followed by a `{`. - let sm = self.session.source_map(); - let mut sp = span; - loop { - sp = sm.next_point(sp); - match sm.span_to_snippet(sp) { - Ok(ref snippet) => { - if snippet.chars().any(|c| { !c.is_whitespace() }) { - break; - } - } - _ => break, - } - } - let followed_by_brace = match sm.span_to_snippet(sp) { - Ok(ref snippet) if snippet == "{" => true, - _ => false, - }; - // In case this could be a struct literal that needs to be surrounded - // by parenthesis, find the appropriate span. - let mut i = 0; - let mut closing_brace = None; - loop { - sp = sm.next_point(sp); - match sm.span_to_snippet(sp) { - Ok(ref snippet) => { - if snippet == "}" { - let sp = span.to(sp); - if let Ok(snippet) = sm.span_to_snippet(sp) { - closing_brace = Some((sp, snippet)); - } - break; - } - } - _ => break, - } - i += 1; - // The bigger the span, the more likely we're incorrect -- - // bound it to 100 chars long. - if i > 100 { - break; - } - } - match source { - PathSource::Expr(Some(parent)) => { - match parent.node { - ExprKind::MethodCall(ref path_assignment, _) => { - err.span_suggestion( - sm.start_point(parent.span) - .to(path_assignment.ident.span), - "use `::` to access an associated function", - format!("{}::{}", - path_str, - path_assignment.ident), - Applicability::MaybeIncorrect - ); - }, - _ => { - err.span_label( - span, - format!("did you mean `{} {{ /* fields */ }}`?", - path_str), - ); - }, - } - }, - PathSource::Expr(None) if followed_by_brace == true => { - if let Some((sp, snippet)) = closing_brace { - err.span_suggestion( - sp, - "surround the struct literal with parenthesis", - format!("({})", snippet), - Applicability::MaybeIncorrect, - ); - } else { - err.span_label( - span, - format!("did you mean `({} {{ /* fields */ }})`?", - path_str), - ); - } - }, - _ => { - err.span_label( - span, - format!("did you mean `{} {{ /* fields */ }}`?", - path_str), - ); - }, - } - } - } - (Def::Union(..), _) | - (Def::Variant(..), _) | - (Def::VariantCtor(_, CtorKind::Fictive), _) if ns == ValueNS => { - err.span_label(span, format!("did you mean `{} {{ /* fields */ }}`?", - path_str)); - } - (Def::SelfTy(..), _) if ns == ValueNS => { - err.span_label(span, fallback_label); - err.note("can't use `Self` as a constructor, you must use the \ - implemented struct"); - } - (Def::TyAlias(_), _) | (Def::AssociatedTy(..), _) if ns == ValueNS => { - err.note("can't use a type alias as a constructor"); - } - _ => return false, - } - true - } - - /// Handles error reporting for `smart_resolve_path_fragment` function. - /// Creates base error and amends it with one short label and possibly some longer helps/notes. - fn smart_resolve_report_errors( - &mut self, - path: &[Segment], - span: Span, - source: PathSource<'_>, - def: Option, - ) -> (DiagnosticBuilder<'a>, Vec) { - let ident_span = path.last().map_or(span, |ident| ident.ident.span); - let ns = source.namespace(); - let is_expected = &|def| source.is_expected(def); - let is_enum_variant = &|def| if let Def::Variant(..) = def { true } else { false }; - - // Make the base error. - let expected = source.descr_expected(); - let path_str = Segment::names_to_string(path); - let item_str = path.last().unwrap().ident; - let code = source.error_code(def.is_some()); - let (base_msg, fallback_label, base_span) = if let Some(def) = def { - (format!("expected {}, found {} `{}`", expected, def.kind_name(), path_str), - format!("not a {}", expected), - span) - } else { - let item_span = path.last().unwrap().ident.span; - let (mod_prefix, mod_str) = if path.len() == 1 { - (String::new(), "this scope".to_string()) - } else if path.len() == 2 && path[0].ident.name == keywords::PathRoot.name() { - (String::new(), "the crate root".to_string()) - } else { - let mod_path = &path[..path.len() - 1]; - let mod_prefix = match self.resolve_path_without_parent_scope( - mod_path, Some(TypeNS), false, span, CrateLint::No - ) { - PathResult::Module(ModuleOrUniformRoot::Module(module)) => - module.def(), - _ => None, - }.map_or(String::new(), |def| format!("{} ", def.kind_name())); - (mod_prefix, format!("`{}`", Segment::names_to_string(mod_path))) - }; - (format!("cannot find {} `{}` in {}{}", expected, item_str, mod_prefix, mod_str), - format!("not found in {}", mod_str), - item_span) - }; - - let code = DiagnosticId::Error(code.into()); - let mut err = self.session.struct_span_err_with_code(base_span, &base_msg, code); - - // Emit help message for fake-self from other languages (e.g., `this` in Javascript). - if ["this", "my"].contains(&&*item_str.as_str()) - && self.self_value_is_available(path[0].ident.span, span) { - err.span_suggestion( - span, - "did you mean", - "self".to_string(), - Applicability::MaybeIncorrect, - ); - } - - // Emit special messages for unresolved `Self` and `self`. - if is_self_type(path, ns) { - __diagnostic_used!(E0411); - err.code(DiagnosticId::Error("E0411".into())); - err.span_label(span, format!("`Self` is only available in impls, traits, \ - and type definitions")); - return (err, Vec::new()); - } - if is_self_value(path, ns) { - debug!("smart_resolve_path_fragment: E0424, source={:?}", source); - - __diagnostic_used!(E0424); - err.code(DiagnosticId::Error("E0424".into())); - err.span_label(span, match source { - PathSource::Pat => { - format!("`self` value is a keyword \ - and may not be bound to \ - variables or shadowed") - } - _ => { - format!("`self` value is a keyword \ - only available in methods \ - with `self` parameter") - } - }); - return (err, Vec::new()); - } - - // Try to lookup name in more relaxed fashion for better error reporting. - let ident = path.last().unwrap().ident; - let candidates = self.lookup_import_candidates(ident, ns, is_expected); - if candidates.is_empty() && is_expected(Def::Enum(DefId::local(CRATE_DEF_INDEX))) { - let enum_candidates = - self.lookup_import_candidates(ident, ns, is_enum_variant); - let mut enum_candidates = enum_candidates.iter() - .map(|suggestion| { - import_candidate_to_enum_paths(&suggestion) - }).collect::>(); - enum_candidates.sort(); - - if !enum_candidates.is_empty() { - // Contextualize for E0412 "cannot find type", but don't belabor the point - // (that it's a variant) for E0573 "expected type, found variant". - let preamble = if def.is_none() { - let others = match enum_candidates.len() { - 1 => String::new(), - 2 => " and 1 other".to_owned(), - n => format!(" and {} others", n) - }; - format!("there is an enum variant `{}`{}; ", - enum_candidates[0].0, others) - } else { - String::new() - }; - let msg = format!("{}try using the variant's enum", preamble); - - err.span_suggestions( - span, - &msg, - enum_candidates.into_iter() - .map(|(_variant_path, enum_ty_path)| enum_ty_path) - // Variants re-exported in prelude doesn't mean `prelude::v1` is the - // type name! - // FIXME: is there a more principled way to do this that - // would work for other re-exports? - .filter(|enum_ty_path| enum_ty_path != "std::prelude::v1") - // Also write `Option` rather than `std::prelude::v1::Option`. - .map(|enum_ty_path| { - // FIXME #56861: DRYer prelude filtering. - enum_ty_path.trim_start_matches("std::prelude::v1::").to_owned() - }), - Applicability::MachineApplicable, - ); - } - } - if path.len() == 1 && self.self_type_is_available(span) { - if let Some(candidate) = self.lookup_assoc_candidate(ident, ns, is_expected) { - let self_is_available = self.self_value_is_available(path[0].ident.span, span); - match candidate { - AssocSuggestion::Field => { - err.span_suggestion( - span, - "try", - format!("self.{}", path_str), - Applicability::MachineApplicable, - ); - if !self_is_available { - err.span_label(span, format!("`self` value is a keyword \ - only available in \ - methods with `self` parameter")); - } - } - AssocSuggestion::MethodWithSelf if self_is_available => { - err.span_suggestion( - span, - "try", - format!("self.{}", path_str), - Applicability::MachineApplicable, - ); - } - AssocSuggestion::MethodWithSelf | AssocSuggestion::AssocItem => { - err.span_suggestion( - span, - "try", - format!("Self::{}", path_str), - Applicability::MachineApplicable, - ); - } - } - return (err, candidates); - } - } - - let mut levenshtein_worked = false; - - // Try Levenshtein algorithm. - let suggestion = self.lookup_typo_candidate(path, ns, is_expected, span); - if let Some(suggestion) = suggestion { - let msg = format!( - "{} {} with a similar name exists", - suggestion.article, suggestion.kind - ); - err.span_suggestion( - ident_span, - &msg, - suggestion.candidate.to_string(), - Applicability::MaybeIncorrect, - ); - - levenshtein_worked = true; - } - - // Try context-dependent help if relaxed lookup didn't work. - if let Some(def) = def { - if self.smart_resolve_context_dep_help(&mut err, - span, - source, - def, - &path_str, - &fallback_label) { - return (err, candidates); - } - } - - // Fallback label. - if !levenshtein_worked { - err.span_label(base_span, fallback_label); - self.type_ascription_suggestion(&mut err, base_span); - } - (err, candidates) - } - fn smart_resolve_path_fragment(&mut self, id: NodeId, qself: Option<&QSelf>, From 5c87bc85e2d7395d671311a5b8b97013b2e73d87 Mon Sep 17 00:00:00 2001 From: Alexander Regueiro Date: Mon, 4 Feb 2019 11:24:09 +0100 Subject: [PATCH 188/278] Minor cosmetic changes. --- src/librustc_resolve/error_reporting.rs | 12 ++++++------ src/librustc_resolve/lib.rs | 5 ++--- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/src/librustc_resolve/error_reporting.rs b/src/librustc_resolve/error_reporting.rs index 88892ae2cd3d8..1f7ae7c3034f3 100644 --- a/src/librustc_resolve/error_reporting.rs +++ b/src/librustc_resolve/error_reporting.rs @@ -417,7 +417,7 @@ impl<'a> Resolver<'a> { } impl<'a, 'b:'a> ImportResolver<'a, 'b> { - /// Add suggestions for a path that cannot be resolved. + /// Adds suggestions for a path that cannot be resolved. pub(crate) fn make_path_suggestion( &mut self, span: Span, @@ -431,7 +431,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { // On 2015 `{{root}}` is usually added implicitly. (Some(fst), Some(snd)) if fst.ident.name == keywords::PathRoot.name() && !snd.ident.is_path_segment_keyword() => {} - // `ident::...` on 2018 + // `ident::...` on 2018. (Some(fst), _) if fst.ident.span.rust_2018() && !fst.ident.is_path_segment_keyword() => { // Insert a placeholder that's later replaced by `self`/`super`/etc. @@ -470,7 +470,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { } } - /// Suggest a missing `crate::` if that resolves to an correct module. + /// Suggests a missing `crate::` if that resolves to an correct module. /// /// ``` /// | @@ -501,7 +501,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { } } - /// Suggest a missing `super::` if that resolves to an correct module. + /// Suggests a missing `super::` if that resolves to an correct module. /// /// ``` /// | @@ -525,7 +525,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { } } - /// Suggest a missing external crate name if that resolves to an correct module. + /// Suggests a missing external crate name if that resolves to an correct module. /// /// ``` /// | @@ -546,7 +546,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { } // Sort extern crate names in reverse order to get - // 1) some consistent ordering for emitted dignostics and + // 1) some consistent ordering for emitted dignostics, and // 2) `std` suggestions before `core` suggestions. let mut extern_crate_names = self.resolver.extern_prelude.iter().map(|(ident, _)| ident.name).collect::>(); diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 590dcb8947db4..69f8722a82b9b 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1737,7 +1737,7 @@ impl<'a> Resolver<'a> { } } - /// resolve_hir_path, but takes a callback in case there was an error + /// Like `resolve_hir_path`, but takes a callback in case there was an error. fn resolve_hir_path_cb( &mut self, path: &ast::Path, @@ -1750,7 +1750,7 @@ impl<'a> Resolver<'a> { let span = path.span; let segments = &path.segments; let path = Segment::from_path(&path); - // FIXME (Manishearth): Intra doc links won't get warned of epoch changes + // FIXME(Manishearth): intra-doc links won't get warned of epoch changes. let def = match self.resolve_path_without_parent_scope(&path, Some(namespace), true, span, CrateLint::No) { PathResult::Module(ModuleOrUniformRoot::Module(module)) => @@ -5066,7 +5066,6 @@ fn import_candidate_to_enum_paths(suggestion: &ImportSuggestion) -> (String, Str (variant_path_string, enum_path_string) } - /// When an entity with a given name is not available in scope, we search for /// entities with that name in all crates. This method allows outputting the /// results of this search in a programmer-friendly way From fd70e8e8db6f0a43f9f5bc669e03ab9bbdce7fbc Mon Sep 17 00:00:00 2001 From: Alexander Regueiro Date: Thu, 7 Feb 2019 22:25:15 +0100 Subject: [PATCH 189/278] WIP --- src/librustc_resolve/error_reporting.rs | 4 ++-- src/librustc_resolve/lib.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/librustc_resolve/error_reporting.rs b/src/librustc_resolve/error_reporting.rs index 1f7ae7c3034f3..8300e691bbea4 100644 --- a/src/librustc_resolve/error_reporting.rs +++ b/src/librustc_resolve/error_reporting.rs @@ -23,7 +23,7 @@ impl<'a> Resolver<'a> { &mut self, path: &[Segment], span: Span, - source: PathSource, + source: PathSource<'_>, def: Option, ) -> (DiagnosticBuilder<'a>, Vec) { let ident_span = path.last().map_or(span, |ident| ident.ident.span); @@ -235,7 +235,7 @@ impl<'a> Resolver<'a> { &mut self, err: &mut DiagnosticBuilder<'a>, span: Span, - source: PathSource, + source: PathSource<'_>, def: Def, path_str: &str, fallback_label: &str, diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 69f8722a82b9b..611b956035ba7 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -3128,7 +3128,7 @@ impl<'a> Resolver<'a> { qself: Option<&QSelf>, path: &[Segment], span: Span, - source: PathSource, + source: PathSource<'_>, crate_lint: CrateLint) -> PathResolution { let ns = source.namespace(); From 34ec9a59423a299a6cd1bedfd4e0a660748f6540 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Sun, 20 Jan 2019 05:44:02 +0100 Subject: [PATCH 190/278] Add a query type which is always marked as red if it runs --- src/librustc/dep_graph/graph.rs | 89 +++++++++++++++++++------------ src/librustc/dep_graph/mod.rs | 2 +- src/librustc/hir/map/collector.rs | 14 ++--- src/librustc/ty/context.rs | 5 +- src/librustc/ty/query/config.rs | 9 +++- src/librustc/ty/query/mod.rs | 13 ++--- src/librustc/ty/query/plumbing.rs | 31 ++++++++--- src/librustc_codegen_llvm/base.rs | 4 +- 8 files changed, 106 insertions(+), 61 deletions(-) diff --git a/src/librustc/dep_graph/graph.rs b/src/librustc/dep_graph/graph.rs index 663c408ac22fd..e8c1cd36064e1 100644 --- a/src/librustc/dep_graph/graph.rs +++ b/src/librustc/dep_graph/graph.rs @@ -79,6 +79,16 @@ struct DepGraphData { loaded_from_cache: Lock>, } +pub fn hash_result(hcx: &mut StableHashingContext<'_>, result: &R) -> Option +where + R: for<'a> HashStable>, +{ + let mut stable_hasher = StableHasher::new(); + result.hash_stable(hcx, &mut stable_hasher); + + Some(stable_hasher.finish()) +} + impl DepGraph { pub fn new(prev_graph: PreviousDepGraph, @@ -178,14 +188,16 @@ impl DepGraph { /// `arg` parameter. /// /// [rustc guide]: https://rust-lang.github.io/rustc-guide/incremental-compilation.html - pub fn with_task<'gcx, C, A, R>(&self, - key: DepNode, - cx: C, - arg: A, - task: fn(C, A) -> R) - -> (R, DepNodeIndex) - where C: DepGraphSafe + StableHashingContextProvider<'gcx>, - R: HashStable>, + pub fn with_task<'a, C, A, R>( + &self, + key: DepNode, + cx: C, + arg: A, + task: fn(C, A) -> R, + hash_result: impl FnOnce(&mut StableHashingContext<'_>, &R) -> Option, + ) -> (R, DepNodeIndex) + where + C: DepGraphSafe + StableHashingContextProvider<'a>, { self.with_task_impl(key, cx, arg, false, task, |_key| Some(TaskDeps { @@ -196,17 +208,18 @@ impl DepGraph { }), |data, key, fingerprint, task| { data.borrow_mut().complete_task(key, task.unwrap(), fingerprint) - }) + }, + hash_result) } /// Creates a new dep-graph input with value `input` - pub fn input_task<'gcx, C, R>(&self, + pub fn input_task<'a, C, R>(&self, key: DepNode, cx: C, input: R) -> (R, DepNodeIndex) - where C: DepGraphSafe + StableHashingContextProvider<'gcx>, - R: HashStable>, + where C: DepGraphSafe + StableHashingContextProvider<'a>, + R: for<'b> HashStable>, { fn identity_fn(_: C, arg: A) -> A { arg @@ -216,10 +229,11 @@ impl DepGraph { |_| None, |data, key, fingerprint, _| { data.borrow_mut().alloc_node(key, SmallVec::new(), fingerprint) - }) + }, + hash_result::) } - fn with_task_impl<'gcx, C, A, R>( + fn with_task_impl<'a, C, A, R>( &self, key: DepNode, cx: C, @@ -230,11 +244,11 @@ impl DepGraph { finish_task_and_alloc_depnode: fn(&Lock, DepNode, Fingerprint, - Option) -> DepNodeIndex + Option) -> DepNodeIndex, + hash_result: impl FnOnce(&mut StableHashingContext<'_>, &R) -> Option, ) -> (R, DepNodeIndex) where - C: DepGraphSafe + StableHashingContextProvider<'gcx>, - R: HashStable>, + C: DepGraphSafe + StableHashingContextProvider<'a>, { if let Some(ref data) = self.data { let task_deps = create_task(key).map(|deps| Lock::new(deps)); @@ -269,15 +283,12 @@ impl DepGraph { profq_msg(hcx.sess(), ProfileQueriesMsg::TaskEnd) }; - let mut stable_hasher = StableHasher::new(); - result.hash_stable(&mut hcx, &mut stable_hasher); - - let current_fingerprint = stable_hasher.finish(); + let current_fingerprint = hash_result(&mut hcx, &result); let dep_node_index = finish_task_and_alloc_depnode( &data.current, key, - current_fingerprint, + current_fingerprint.unwrap_or(Fingerprint::ZERO), task_deps.map(|lock| lock.into_inner()), ); @@ -285,15 +296,20 @@ impl DepGraph { if let Some(prev_index) = data.previous.node_to_index_opt(&key) { let prev_fingerprint = data.previous.fingerprint_by_index(prev_index); - let color = if current_fingerprint == prev_fingerprint { - DepNodeColor::Green(dep_node_index) + let color = if let Some(current_fingerprint) = current_fingerprint { + if current_fingerprint == prev_fingerprint { + DepNodeColor::Green(dep_node_index) + } else { + DepNodeColor::Red + } } else { + // Mark the node as Red if we can't hash the result DepNodeColor::Red }; debug_assert!(data.colors.get(prev_index).is_none(), - "DepGraph::with_task() - Duplicate DepNodeColor \ - insertion for {:?}", key); + "DepGraph::with_task() - Duplicate DepNodeColor \ + insertion for {:?}", key); data.colors.insert(prev_index, color); } @@ -342,14 +358,16 @@ impl DepGraph { /// Execute something within an "eval-always" task which is a task // that runs whenever anything changes. - pub fn with_eval_always_task<'gcx, C, A, R>(&self, - key: DepNode, - cx: C, - arg: A, - task: fn(C, A) -> R) - -> (R, DepNodeIndex) - where C: DepGraphSafe + StableHashingContextProvider<'gcx>, - R: HashStable>, + pub fn with_eval_always_task<'a, C, A, R>( + &self, + key: DepNode, + cx: C, + arg: A, + task: fn(C, A) -> R, + hash_result: impl FnOnce(&mut StableHashingContext<'_>, &R) -> Option, + ) -> (R, DepNodeIndex) + where + C: DepGraphSafe + StableHashingContextProvider<'a>, { self.with_task_impl(key, cx, arg, false, task, |_| None, @@ -359,7 +377,8 @@ impl DepGraph { &DepNode::new_no_params(DepKind::Krate) ]; current.alloc_node(key, smallvec![krate_idx], fingerprint) - }) + }, + hash_result) } #[inline] diff --git a/src/librustc/dep_graph/mod.rs b/src/librustc/dep_graph/mod.rs index 022caabcbf3a1..b84d2ad145889 100644 --- a/src/librustc/dep_graph/mod.rs +++ b/src/librustc/dep_graph/mod.rs @@ -10,7 +10,7 @@ pub mod cgu_reuse_tracker; pub use self::dep_tracking_map::{DepTrackingMap, DepTrackingMapConfig}; pub use self::dep_node::{DepNode, DepKind, DepConstructor, WorkProductId, label_strs}; -pub use self::graph::{DepGraph, WorkProduct, DepNodeIndex, DepNodeColor, TaskDeps}; +pub use self::graph::{DepGraph, WorkProduct, DepNodeIndex, DepNodeColor, TaskDeps, hash_result}; pub use self::graph::WorkProductFileKind; pub use self::prev::PreviousDepGraph; pub use self::query::DepGraphQuery; diff --git a/src/librustc/hir/map/collector.rs b/src/librustc/hir/map/collector.rs index f84bb77e29b27..37552f18f4a08 100644 --- a/src/librustc/hir/map/collector.rs +++ b/src/librustc/hir/map/collector.rs @@ -48,14 +48,14 @@ pub(super) struct NodeCollector<'a, 'hir> { hir_body_nodes: Vec<(DefPathHash, Fingerprint)>, } -fn input_dep_node_and_hash<'a, I>( +fn input_dep_node_and_hash( dep_graph: &DepGraph, - hcx: &mut StableHashingContext<'a>, + hcx: &mut StableHashingContext<'_>, dep_node: DepNode, input: I, ) -> (DepNodeIndex, Fingerprint) where - I: HashStable>, + I: for<'a> HashStable>, { let dep_node_index = dep_graph.input_task(dep_node, &mut *hcx, &input).1; @@ -70,15 +70,15 @@ where (dep_node_index, hash) } -fn alloc_hir_dep_nodes<'a, I>( +fn alloc_hir_dep_nodes( dep_graph: &DepGraph, - hcx: &mut StableHashingContext<'a>, + hcx: &mut StableHashingContext<'_>, def_path_hash: DefPathHash, item_like: I, hir_body_nodes: &mut Vec<(DefPathHash, Fingerprint)>, ) -> (DepNodeIndex, DepNodeIndex) where - I: HashStable>, + I: for<'a> HashStable>, { let sig = dep_graph.input_task( def_path_hash.to_dep_node(DepKind::Hir), @@ -286,7 +286,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> { self.parent_node = parent_node; } - fn with_dep_node_owner>, + fn with_dep_node_owner HashStable>, F: FnOnce(&mut Self)>(&mut self, dep_node_owner: DefIndex, item_like: &T, diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 140c772256d3f..795853a37c758 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -1,7 +1,7 @@ //! type context book-keeping use crate::dep_graph::DepGraph; -use crate::dep_graph::{DepNode, DepConstructor}; +use crate::dep_graph::{self, DepNode, DepConstructor}; use crate::errors::DiagnosticBuilder; use crate::session::Session; use crate::session::config::{BorrowckMode, OutputFilenames}; @@ -1435,7 +1435,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { self.dep_graph.with_task(dep_node, self, crate_hash, - |_, x| x // No transformation needed + |_, x| x, // No transformation needed + dep_graph::hash_result, ); } } diff --git a/src/librustc/ty/query/config.rs b/src/librustc/ty/query/config.rs index 255e39eaccd6d..a3ee92f8e1263 100644 --- a/src/librustc/ty/query/config.rs +++ b/src/librustc/ty/query/config.rs @@ -20,7 +20,7 @@ use std::hash::Hash; use std::fmt::Debug; use syntax_pos::symbol::InternedString; use rustc_data_structures::sync::Lock; -use rustc_data_structures::stable_hasher::HashStable; +use rustc_data_structures::fingerprint::Fingerprint; use crate::ich::StableHashingContext; // Query configuration and description traits. @@ -30,7 +30,7 @@ pub trait QueryConfig<'tcx> { const CATEGORY: ProfileCategory; type Key: Eq + Hash + Clone + Debug; - type Value: Clone + for<'a> HashStable>; + type Value: Clone; } pub(super) trait QueryAccessors<'tcx>: QueryConfig<'tcx> { @@ -44,6 +44,11 @@ pub(super) trait QueryAccessors<'tcx>: QueryConfig<'tcx> { // Don't use this method to compute query results, instead use the methods on TyCtxt fn compute(tcx: TyCtxt<'_, 'tcx, '_>, key: Self::Key) -> Self::Value; + fn hash_result( + hcx: &mut StableHashingContext<'_>, + result: &Self::Value + ) -> Option; + fn handle_cycle_error(tcx: TyCtxt<'_, 'tcx, '_>) -> Self::Value; } diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs index 20a700bb58dd1..8211dc50fc6e0 100644 --- a/src/librustc/ty/query/mod.rs +++ b/src/librustc/ty/query/mod.rs @@ -1,4 +1,4 @@ -use crate::dep_graph::{DepConstructor, DepNode}; +use crate::dep_graph::{self, DepConstructor, DepNode}; use crate::errors::DiagnosticBuilder; use crate::hir::def_id::{CrateNum, DefId, DefIndex}; use crate::hir::def::{Def, Export}; @@ -49,6 +49,7 @@ use rustc_data_structures::indexed_vec::IndexVec; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::stable_hasher::StableVec; use rustc_data_structures::sync::Lrc; +use rustc_data_structures::fingerprint::Fingerprint; use rustc_target::spec::PanicStrategy; use std::borrow::Cow; @@ -227,19 +228,19 @@ define_queries! { <'tcx> /// Fetch the MIR for a given def-id right after it's built - this includes /// unreachable code. - [] fn mir_built: MirBuilt(DefId) -> &'tcx Steal>, + [no_hash] fn mir_built: MirBuilt(DefId) -> &'tcx Steal>, /// Fetch the MIR for a given def-id up till the point where it is /// ready for const evaluation. /// /// See the README for the `mir` module for details. - [] fn mir_const: MirConst(DefId) -> &'tcx Steal>, + [no_hash] fn mir_const: MirConst(DefId) -> &'tcx Steal>, - [] fn mir_validated: MirValidated(DefId) -> &'tcx Steal>, + [no_hash] fn mir_validated: MirValidated(DefId) -> &'tcx Steal>, /// MIR after our optimization passes have run. This is MIR that is ready /// for codegen. This is also the only query that can fetch non-local MIR, at present. - [] fn optimized_mir: MirOptimized(DefId) -> &'tcx mir::Mir<'tcx>, + [no_hash] fn optimized_mir: MirOptimized(DefId) -> &'tcx mir::Mir<'tcx>, }, TypeChecking { @@ -282,7 +283,7 @@ define_queries! { <'tcx> TypeChecking { [] fn typeck_item_bodies: typeck_item_bodies_dep_node(CrateNum) -> CompileResult, - [] fn typeck_tables_of: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx>, + [no_hash] fn typeck_tables_of: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx>, }, Other { diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs index a26b21a1059fe..3dcb939d63606 100644 --- a/src/librustc/ty/query/plumbing.rs +++ b/src/librustc/ty/query/plumbing.rs @@ -499,7 +499,6 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { dep_node: &DepNode, dep_node_index: DepNodeIndex, ) { - use rustc_data_structures::stable_hasher::{StableHasher, HashStable}; use crate::ich::Fingerprint; assert!(Some(self.dep_graph.fingerprint_of(dep_node_index)) == @@ -509,11 +508,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { debug!("BEGIN verify_ich({:?})", dep_node); let mut hcx = self.create_stable_hashing_context(); - let mut hasher = StableHasher::new(); - result.hash_stable(&mut hcx, &mut hasher); - - let new_hash: Fingerprint = hasher.finish(); + let new_hash = Q::hash_result(&mut hcx, result).unwrap_or(Fingerprint::ZERO); debug!("END verify_ich({:?})", dep_node); let old_hash = self.dep_graph.fingerprint_of(dep_node_index); @@ -549,12 +545,14 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { tcx.dep_graph.with_eval_always_task(dep_node, tcx, key, - Q::compute) + Q::compute, + Q::hash_result) } else { tcx.dep_graph.with_task(dep_node, tcx, key, - Q::compute) + Q::compute, + Q::hash_result) } }) }); @@ -679,6 +677,18 @@ macro_rules! handle_cycle_error { }; } +macro_rules! hash_result { + ([][$hcx:expr, $result:expr]) => {{ + dep_graph::hash_result($hcx, &$result) + }}; + ([no_hash$(, $modifiers:ident)*][$hcx:expr, $result:expr]) => {{ + None + }}; + ([$other:ident$(, $modifiers:ident)*][$($args:tt)*]) => { + hash_result!([$($modifiers),*][$($args)*]) + }; +} + macro_rules! define_queries { (<$tcx:tt> $($category:tt { $($(#[$attr:meta])* [$($modifiers:tt)*] fn $name:ident: $node:ident($K:ty) -> $V:ty,)* @@ -966,6 +976,13 @@ macro_rules! define_queries_inner { }) } + fn hash_result( + _hcx: &mut StableHashingContext<'_>, + _result: &Self::Value + ) -> Option { + hash_result!([$($modifiers)*][_hcx, _result]) + } + fn handle_cycle_error(tcx: TyCtxt<'_, 'tcx, '_>) -> Self::Value { handle_cycle_error!([$($modifiers)*][tcx]) } diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs index 6e1ef440a3f3f..d9f44ca6e45a3 100644 --- a/src/librustc_codegen_llvm/base.rs +++ b/src/librustc_codegen_llvm/base.rs @@ -20,6 +20,7 @@ use super::LlvmCodegenBackend; use llvm; use metadata; +use rustc::dep_graph; use rustc::mir::mono::{Linkage, Visibility, Stats}; use rustc::middle::cstore::{EncodedMetadata}; use rustc::ty::TyCtxt; @@ -145,7 +146,8 @@ pub fn compile_codegen_unit<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let ((stats, module), _) = tcx.dep_graph.with_task(dep_node, tcx, cgu_name, - module_codegen); + module_codegen, + dep_graph::hash_result); let time_to_codegen = start_time.elapsed(); // We assume that the cost to run LLVM on a CGU is proportional to From 8c59b6d1309dbcef7bae87b40d7658d8be60bb5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Sun, 20 Jan 2019 16:43:57 +0100 Subject: [PATCH 191/278] Remove no_hash from optimized_mir --- src/librustc/ty/query/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs index 8211dc50fc6e0..6ac2d933c0e7d 100644 --- a/src/librustc/ty/query/mod.rs +++ b/src/librustc/ty/query/mod.rs @@ -240,7 +240,7 @@ define_queries! { <'tcx> /// MIR after our optimization passes have run. This is MIR that is ready /// for codegen. This is also the only query that can fetch non-local MIR, at present. - [no_hash] fn optimized_mir: MirOptimized(DefId) -> &'tcx mir::Mir<'tcx>, + [] fn optimized_mir: MirOptimized(DefId) -> &'tcx mir::Mir<'tcx>, }, TypeChecking { From 084704535097b08690b17fe8249271ff92d111c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Mon, 21 Jan 2019 03:39:25 +0100 Subject: [PATCH 192/278] Remove no_hash from typeck_tables_of --- src/librustc/ty/query/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs index 6ac2d933c0e7d..5082bc9266473 100644 --- a/src/librustc/ty/query/mod.rs +++ b/src/librustc/ty/query/mod.rs @@ -283,7 +283,7 @@ define_queries! { <'tcx> TypeChecking { [] fn typeck_item_bodies: typeck_item_bodies_dep_node(CrateNum) -> CompileResult, - [no_hash] fn typeck_tables_of: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx>, + [] fn typeck_tables_of: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx>, }, Other { From 33a9be0650cf5085283c2b4d509dcdd6125c25de Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Tue, 22 Jan 2019 08:59:17 +0100 Subject: [PATCH 193/278] Move no_hash from mir_built to optimized_mir --- src/librustc/ty/query/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs index 5082bc9266473..66c1695087fa5 100644 --- a/src/librustc/ty/query/mod.rs +++ b/src/librustc/ty/query/mod.rs @@ -228,7 +228,7 @@ define_queries! { <'tcx> /// Fetch the MIR for a given def-id right after it's built - this includes /// unreachable code. - [no_hash] fn mir_built: MirBuilt(DefId) -> &'tcx Steal>, + [] fn mir_built: MirBuilt(DefId) -> &'tcx Steal>, /// Fetch the MIR for a given def-id up till the point where it is /// ready for const evaluation. @@ -240,7 +240,7 @@ define_queries! { <'tcx> /// MIR after our optimization passes have run. This is MIR that is ready /// for codegen. This is also the only query that can fetch non-local MIR, at present. - [] fn optimized_mir: MirOptimized(DefId) -> &'tcx mir::Mir<'tcx>, + [no_hash] fn optimized_mir: MirOptimized(DefId) -> &'tcx mir::Mir<'tcx>, }, TypeChecking { From 6ec66df7737a5378a3db72223e93c4567e229829 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Tue, 22 Jan 2019 15:24:00 +0100 Subject: [PATCH 194/278] Remove no_hash from optimized_mir --- src/librustc/ty/query/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs index 66c1695087fa5..d002b99f385a3 100644 --- a/src/librustc/ty/query/mod.rs +++ b/src/librustc/ty/query/mod.rs @@ -240,7 +240,7 @@ define_queries! { <'tcx> /// MIR after our optimization passes have run. This is MIR that is ready /// for codegen. This is also the only query that can fetch non-local MIR, at present. - [no_hash] fn optimized_mir: MirOptimized(DefId) -> &'tcx mir::Mir<'tcx>, + [] fn optimized_mir: MirOptimized(DefId) -> &'tcx mir::Mir<'tcx>, }, TypeChecking { From a0f02cdba0050bba5a963dc14643d6ca7b7cd396 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Sat, 26 Jan 2019 16:52:34 +0100 Subject: [PATCH 195/278] Update tests --- .../persist/dirty_clean.rs | 4 +- .../incremental/hashes/call_expressions.rs | 16 +++--- .../incremental/hashes/closure_expressions.rs | 8 +-- .../incremental/hashes/enum_constructors.rs | 28 +++++----- .../incremental/hashes/exported_vs_not.rs | 6 +- src/test/incremental/hashes/for_loops.rs | 16 +++--- .../incremental/hashes/function_interfaces.rs | 14 ++--- src/test/incremental/hashes/if_expressions.rs | 12 ++-- src/test/incremental/hashes/inherent_impls.rs | 20 +++---- src/test/incremental/hashes/inline_asm.rs | 12 ++-- .../incremental/hashes/let_expressions.rs | 24 ++++---- .../incremental/hashes/loop_expressions.rs | 10 ++-- .../incremental/hashes/match_expressions.rs | 26 ++++----- src/test/incremental/hashes/panic_exprs.rs | 18 +++--- .../incremental/hashes/struct_constructors.rs | 16 +++--- .../hashes/unary_and_binary_exprs.rs | 56 +++++++++---------- .../incremental/hashes/while_let_loops.rs | 12 ++-- src/test/incremental/hashes/while_loops.rs | 12 ++-- 18 files changed, 155 insertions(+), 155 deletions(-) diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index 3ff4d2ec38dff..105623e5e4e3c 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -67,11 +67,11 @@ const BASE_IMPL: &[&str] = &[ label_strs::ImplTraitRef, ]; -/// DepNodes for MirValidated/Optimized, which is relevant in "executable" +/// DepNodes for MirBuilt/Optimized, which is relevant in "executable" /// code, i.e., functions+methods const BASE_MIR: &[&str] = &[ label_strs::MirOptimized, - label_strs::MirValidated, + label_strs::MirBuilt, ]; /// Struct, Enum and Union DepNodes diff --git a/src/test/incremental/hashes/call_expressions.rs b/src/test/incremental/hashes/call_expressions.rs index 52de065598965..f0f1f09a8388b 100644 --- a/src/test/incremental/hashes/call_expressions.rs +++ b/src/test/incremental/hashes/call_expressions.rs @@ -25,7 +25,7 @@ pub fn change_callee_function() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_callee_function() { callee2(1, 2) @@ -40,7 +40,7 @@ pub fn change_argument_function() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_argument_function() { callee1(1, 3) @@ -81,7 +81,7 @@ pub fn change_callee_method() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_callee_method() { let s = Struct; @@ -98,7 +98,7 @@ pub fn change_argument_method() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_argument_method() { let s = Struct; @@ -115,7 +115,7 @@ pub fn change_ufcs_callee_method() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_ufcs_callee_method() { let s = Struct; @@ -132,7 +132,7 @@ pub fn change_argument_method_ufcs() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_argument_method_ufcs() { let s = Struct; @@ -149,7 +149,7 @@ pub fn change_to_ufcs() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] // One might think this would be expanded in the HirBody/Mir, but it actually // results in slightly different Hir/Mir. @@ -171,7 +171,7 @@ pub mod change_ufcs_callee_indirectly { #[cfg(not(cfail1))] use super::Struct2 as Struct; - #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] + #[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] diff --git a/src/test/incremental/hashes/closure_expressions.rs b/src/test/incremental/hashes/closure_expressions.rs index 0e8cf80b88981..4e82729aa3be1 100644 --- a/src/test/incremental/hashes/closure_expressions.rs +++ b/src/test/incremental/hashes/closure_expressions.rs @@ -37,7 +37,7 @@ pub fn add_parameter() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_parameter() { let x = 0u32; @@ -53,7 +53,7 @@ pub fn change_parameter_pattern() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_parameter_pattern() { let _ = |&x: &u32| x; @@ -84,7 +84,7 @@ pub fn add_type_ascription_to_parameter() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_type_ascription_to_parameter() { let closure = |x: u32| x + 1u32; @@ -101,7 +101,7 @@ pub fn change_parameter_type() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_parameter_type() { let closure = |x: u16| (x as u64) + 1; diff --git a/src/test/incremental/hashes/enum_constructors.rs b/src/test/incremental/hashes/enum_constructors.rs index e9b557bde20f7..a74c3ab04e2af 100644 --- a/src/test/incremental/hashes/enum_constructors.rs +++ b/src/test/incremental/hashes/enum_constructors.rs @@ -34,7 +34,7 @@ pub fn change_field_value_struct_like() -> Enum { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn change_field_value_struct_like() -> Enum { Enum::Struct { @@ -96,7 +96,7 @@ pub fn change_constructor_path_struct_like() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_constructor_path_struct_like() { let _ = Enum2::Struct { @@ -119,7 +119,7 @@ pub fn change_constructor_variant_struct_like() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn change_constructor_variant_struct_like() { let _ = Enum2::Struct2 { @@ -139,7 +139,7 @@ pub mod change_constructor_path_indirectly_struct_like { #[rustc_clean( cfg="cfail2", - except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,\ + except="FnSignature,Hir,HirBody,MirOptimized,MirBuilt,\ TypeckTables" )] #[rustc_clean(cfg="cfail3")] @@ -161,7 +161,7 @@ pub mod change_constructor_variant_indirectly_struct_like { #[cfg(not(cfail1))] use super::Enum2::Struct2 as Variant; - #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] + #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn function() -> Enum2 { Variant { @@ -180,7 +180,7 @@ pub fn change_field_value_tuple_like() -> Enum { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn change_field_value_tuple_like() -> Enum { Enum::Tuple(0, 1, 3) @@ -197,7 +197,7 @@ pub fn change_constructor_path_tuple_like() { #[cfg(not(cfail1))] #[rustc_clean( cfg="cfail2", - except="HirBody,MirOptimized,MirValidated,TypeckTables" + except="HirBody,MirOptimized,MirBuilt,TypeckTables" )] #[rustc_clean(cfg="cfail3")] pub fn change_constructor_path_tuple_like() { @@ -215,7 +215,7 @@ pub fn change_constructor_variant_tuple_like() { #[cfg(not(cfail1))] #[rustc_clean( cfg="cfail2", - except="HirBody,MirOptimized,MirValidated,TypeckTables" + except="HirBody,MirOptimized,MirBuilt,TypeckTables" )] #[rustc_clean(cfg="cfail3")] pub fn change_constructor_variant_tuple_like() { @@ -232,7 +232,7 @@ pub mod change_constructor_path_indirectly_tuple_like { #[rustc_clean( cfg="cfail2", - except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,\ + except="FnSignature,Hir,HirBody,MirOptimized,MirBuilt,\ TypeckTables" )] #[rustc_clean(cfg="cfail3")] @@ -251,7 +251,7 @@ pub mod change_constructor_variant_indirectly_tuple_like { #[cfg(not(cfail1))] use super::Enum2::Tuple2 as Variant; - #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] + #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn function() -> Enum2 { Variant(0, 1, 2) @@ -278,7 +278,7 @@ pub fn change_constructor_path_c_like() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_constructor_path_c_like() { let _ = Clike2::B; @@ -293,7 +293,7 @@ pub fn change_constructor_variant_c_like() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn change_constructor_variant_c_like() { let _ = Clike::C; @@ -309,7 +309,7 @@ pub mod change_constructor_path_indirectly_c_like { #[rustc_clean( cfg="cfail2", - except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,\ + except="FnSignature,Hir,HirBody,MirOptimized,MirBuilt,\ TypeckTables" )] #[rustc_clean(cfg="cfail3")] @@ -328,7 +328,7 @@ pub mod change_constructor_variant_indirectly_c_like { #[cfg(not(cfail1))] use super::Clike::B as Variant; - #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] + #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn function() -> Clike { Variant diff --git a/src/test/incremental/hashes/exported_vs_not.rs b/src/test/incremental/hashes/exported_vs_not.rs index 1880dd2fb0d7c..c9f844f96ebd7 100644 --- a/src/test/incremental/hashes/exported_vs_not.rs +++ b/src/test/incremental/hashes/exported_vs_not.rs @@ -16,7 +16,7 @@ pub fn body_not_exported_to_metadata() -> u32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn body_not_exported_to_metadata() -> u32 { 2 @@ -35,7 +35,7 @@ pub fn body_exported_to_metadata_because_of_inline() -> u32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] #[inline] pub fn body_exported_to_metadata_because_of_inline() -> u32 { @@ -55,7 +55,7 @@ pub fn body_exported_to_metadata_because_of_generic() -> u32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] #[inline] pub fn body_exported_to_metadata_because_of_generic() -> u32 { diff --git a/src/test/incremental/hashes/for_loops.rs b/src/test/incremental/hashes/for_loops.rs index 90c1ecf10c707..da093ded63566 100644 --- a/src/test/incremental/hashes/for_loops.rs +++ b/src/test/incremental/hashes/for_loops.rs @@ -25,7 +25,7 @@ pub fn change_loop_body() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_loop_body() { let mut _x = 0; @@ -48,7 +48,7 @@ pub fn change_iteration_variable_name() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_iteration_variable_name() { let mut _x = 0; @@ -71,7 +71,7 @@ pub fn change_iteration_variable_pattern() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_iteration_variable_pattern() { let mut _x = 0; @@ -94,7 +94,7 @@ pub fn change_iterable() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_iterable() { let mut _x = 0; @@ -116,7 +116,7 @@ pub fn add_break() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_break() { let mut _x = 0; @@ -187,7 +187,7 @@ pub fn change_break_label() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_break_label() { let mut _x = 0; @@ -237,7 +237,7 @@ pub fn change_continue_label() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_continue_label() { let mut _x = 0; @@ -262,7 +262,7 @@ pub fn change_continue_to_break() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_continue_to_break() { let mut _x = 0; diff --git a/src/test/incremental/hashes/function_interfaces.rs b/src/test/incremental/hashes/function_interfaces.rs index 21263c8b6c614..8a0af2b0044a4 100644 --- a/src/test/incremental/hashes/function_interfaces.rs +++ b/src/test/incremental/hashes/function_interfaces.rs @@ -24,7 +24,7 @@ pub fn add_parameter() {} #[cfg(not(cfail1))] #[rustc_clean(cfg = "cfail2", - except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")] + except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")] #[rustc_clean(cfg = "cfail3")] pub fn add_parameter(p: i32) {} @@ -47,7 +47,7 @@ pub fn type_of_parameter(p: i32) {} #[cfg(not(cfail1))] #[rustc_clean(cfg = "cfail2", - except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")] + except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")] #[rustc_clean(cfg = "cfail3")] pub fn type_of_parameter(p: i64) {} @@ -59,7 +59,7 @@ pub fn type_of_parameter_ref(p: &i32) {} #[cfg(not(cfail1))] #[rustc_clean(cfg = "cfail2", - except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")] + except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")] #[rustc_clean(cfg = "cfail3")] pub fn type_of_parameter_ref(p: &mut i32) {} @@ -71,7 +71,7 @@ pub fn order_of_parameters(p1: i32, p2: i64) {} #[cfg(not(cfail1))] #[rustc_clean(cfg = "cfail2", - except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")] + except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")] #[rustc_clean(cfg = "cfail3")] pub fn order_of_parameters(p2: i64, p1: i32) {} @@ -83,7 +83,7 @@ pub fn make_unsafe() {} #[cfg(not(cfail1))] #[rustc_clean(cfg = "cfail2", - except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")] + except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")] #[rustc_clean(cfg = "cfail3")] pub unsafe fn make_unsafe() {} @@ -292,7 +292,7 @@ pub mod change_return_type_indirectly { use super::ReferencedType2 as ReturnType; #[rustc_clean(cfg = "cfail2", - except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")] + except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")] #[rustc_clean(cfg = "cfail3")] pub fn indirect_return_type() -> ReturnType { ReturnType {} @@ -309,7 +309,7 @@ pub mod change_parameter_type_indirectly { use super::ReferencedType2 as ParameterType; #[rustc_clean(cfg = "cfail2", - except = "Hir, HirBody, MirValidated, MirOptimized, TypeckTables, FnSignature")] + except = "Hir, HirBody, MirBuilt, MirOptimized, TypeckTables, FnSignature")] #[rustc_clean(cfg = "cfail3")] pub fn indirect_parameter_type(p: ParameterType) {} } diff --git a/src/test/incremental/hashes/if_expressions.rs b/src/test/incremental/hashes/if_expressions.rs index 18dba63072bad..a01247ff4243c 100644 --- a/src/test/incremental/hashes/if_expressions.rs +++ b/src/test/incremental/hashes/if_expressions.rs @@ -25,7 +25,7 @@ pub fn change_condition(x: bool) -> u32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_condition(x: bool) -> u32 { if !x { @@ -46,7 +46,7 @@ pub fn change_then_branch(x: bool) -> u32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_then_branch(x: bool) -> u32 { if x { @@ -69,7 +69,7 @@ pub fn change_else_branch(x: bool) -> u32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_else_branch(x: bool) -> u32 { if x { @@ -120,7 +120,7 @@ pub fn change_condition_if_let(x: Option) -> u32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_condition_if_let(x: Option) -> u32 { if let Some(_) = x { @@ -143,7 +143,7 @@ pub fn change_then_branch_if_let(x: Option) -> u32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_then_branch_if_let(x: Option) -> u32 { if let Some(x) = x { @@ -166,7 +166,7 @@ pub fn change_else_branch_if_let(x: Option) -> u32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_else_branch_if_let(x: Option) -> u32 { if let Some(x) = x { diff --git a/src/test/incremental/hashes/inherent_impls.rs b/src/test/incremental/hashes/inherent_impls.rs index 92ce5a606bf90..3abc6c4d2e23e 100644 --- a/src/test/incremental/hashes/inherent_impls.rs +++ b/src/test/incremental/hashes/inherent_impls.rs @@ -42,7 +42,7 @@ impl Foo { #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] impl Foo { - #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] + #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn method_body() { println!("Hello, world!"); @@ -63,7 +63,7 @@ impl Foo { #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] impl Foo { - #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] + #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] #[inline] pub fn method_body_inlined() { @@ -114,7 +114,7 @@ impl Foo { impl Foo { #[rustc_clean( cfg="cfail2", - except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirValidated" + except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirBuilt" )] #[rustc_clean(cfg="cfail3")] pub fn method_selfmutness(&mut self) { } @@ -154,7 +154,7 @@ impl Foo { impl Foo { #[rustc_clean( cfg="cfail2", - except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirValidated" + except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirBuilt" )] #[rustc_clean(cfg="cfail3")] pub fn add_method_parameter(&self, _: i32) { } @@ -172,7 +172,7 @@ impl Foo { #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] impl Foo { - #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] + #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn change_method_parameter_name(&self, b: i64) { } } @@ -191,7 +191,7 @@ impl Foo { impl Foo { #[rustc_clean( cfg="cfail2", - except="Hir,HirBody,FnSignature,MirOptimized,MirValidated,TypeckTables")] + except="Hir,HirBody,FnSignature,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_method_return_type(&self) -> u8 { 0 } } @@ -226,7 +226,7 @@ impl Foo { #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] impl Foo { - #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] + #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn change_method_parameter_order(&self, b: i64, a: i64) { } } @@ -245,7 +245,7 @@ impl Foo { impl Foo { #[rustc_clean( cfg="cfail2", - except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirValidated" + except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirBuilt" )] #[rustc_clean(cfg="cfail3")] pub unsafe fn make_method_unsafe(&self) { } @@ -447,7 +447,7 @@ impl Bar { impl Bar { #[rustc_clean( cfg="cfail2", - except="GenericsOfItem,FnSignature,TypeckTables,TypeOfItem,MirOptimized,MirValidated" + except="GenericsOfItem,FnSignature,TypeckTables,TypeOfItem,MirOptimized,MirBuilt" )] #[rustc_clean(cfg="cfail3")] pub fn add_type_parameter_to_impl(&self) { } @@ -465,7 +465,7 @@ impl Bar { #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] impl Bar { - #[rustc_clean(cfg="cfail2", except="FnSignature,MirOptimized,MirValidated,TypeckTables")] + #[rustc_clean(cfg="cfail2", except="FnSignature,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_impl_self_type(&self) { } } diff --git a/src/test/incremental/hashes/inline_asm.rs b/src/test/incremental/hashes/inline_asm.rs index e73aa89a8374d..c5e7f525fd0fb 100644 --- a/src/test/incremental/hashes/inline_asm.rs +++ b/src/test/incremental/hashes/inline_asm.rs @@ -33,7 +33,7 @@ pub fn change_template(a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] pub fn change_template(a: i32) -> i32 { @@ -69,7 +69,7 @@ pub fn change_output(a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] pub fn change_output(a: i32) -> i32 { @@ -105,7 +105,7 @@ pub fn change_input(_a: i32, _b: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] pub fn change_input(_a: i32, _b: i32) -> i32 { @@ -140,7 +140,7 @@ pub fn change_input_constraint(_a: i32, _b: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] pub fn change_input_constraint(_a: i32, _b: i32) -> i32 { @@ -175,7 +175,7 @@ pub fn change_clobber(_a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] pub fn change_clobber(_a: i32) -> i32 { @@ -210,7 +210,7 @@ pub fn change_options(_a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] pub fn change_options(_a: i32) -> i32 { diff --git a/src/test/incremental/hashes/let_expressions.rs b/src/test/incremental/hashes/let_expressions.rs index b6050f059c27b..a2b33fecea865 100644 --- a/src/test/incremental/hashes/let_expressions.rs +++ b/src/test/incremental/hashes/let_expressions.rs @@ -22,7 +22,7 @@ pub fn change_name() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized")] + except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_name() { let _y = 2u64; @@ -38,7 +38,7 @@ pub fn add_type() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,TypeckTables,MirValidated,MirOptimized")] + except="HirBody,TypeckTables,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn add_type() { let _x: u32 = 2u32; @@ -54,7 +54,7 @@ pub fn change_type() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,TypeckTables,MirValidated,MirOptimized")] + except="HirBody,TypeckTables,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_type() { let _x: u8 = 2; @@ -70,7 +70,7 @@ pub fn change_mutability_of_reference_type() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,TypeckTables,MirValidated,MirOptimized")] + except="HirBody,TypeckTables,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_mutability_of_reference_type() { let _x: &mut u64; @@ -86,7 +86,7 @@ pub fn change_mutability_of_slot() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,TypeckTables,MirValidated,MirOptimized")] + except="HirBody,TypeckTables,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_mutability_of_slot() { let _x: u64 = 0; @@ -102,7 +102,7 @@ pub fn change_simple_binding_to_pattern() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,TypeckTables,MirValidated,MirOptimized")] + except="HirBody,TypeckTables,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_simple_binding_to_pattern() { let (_a, _b) = (0u8, 'x'); @@ -118,7 +118,7 @@ pub fn change_name_in_pattern() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized")] + except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_name_in_pattern() { let (_a, _c) = (1u8, 'y'); @@ -134,7 +134,7 @@ pub fn add_ref_in_pattern() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,TypeckTables,MirValidated,MirOptimized")] + except="HirBody,TypeckTables,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn add_ref_in_pattern() { let (ref _a, _b) = (1u8, 'y'); @@ -150,7 +150,7 @@ pub fn add_amp_in_pattern() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,TypeckTables,MirValidated,MirOptimized")] + except="HirBody,TypeckTables,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn add_amp_in_pattern() { let (&_a, _b) = (&1u8, 'y'); @@ -166,7 +166,7 @@ pub fn change_mutability_of_binding_in_pattern() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,TypeckTables,MirValidated,MirOptimized")] + except="HirBody,TypeckTables,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_mutability_of_binding_in_pattern() { let (mut _a, _b) = (99u8, 'q'); @@ -182,7 +182,7 @@ pub fn add_initializer() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,TypeckTables,MirValidated,MirOptimized")] + except="HirBody,TypeckTables,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn add_initializer() { let _x: i16 = 3i16; @@ -198,7 +198,7 @@ pub fn change_initializer() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized")] + except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_initializer() { let _x = 5u16; diff --git a/src/test/incremental/hashes/loop_expressions.rs b/src/test/incremental/hashes/loop_expressions.rs index a218b01fc8512..a48d150b8b0f2 100644 --- a/src/test/incremental/hashes/loop_expressions.rs +++ b/src/test/incremental/hashes/loop_expressions.rs @@ -25,7 +25,7 @@ pub fn change_loop_body() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_loop_body() { let mut _x = 0; @@ -47,7 +47,7 @@ pub fn add_break() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_break() { let mut _x = 0; @@ -118,7 +118,7 @@ pub fn change_break_label() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_break_label() { let mut _x = 0; @@ -168,7 +168,7 @@ pub fn change_continue_label() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_continue_label() { let mut _x = 0; @@ -193,7 +193,7 @@ pub fn change_continue_to_break() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_continue_to_break() { let mut _x = 0; diff --git a/src/test/incremental/hashes/match_expressions.rs b/src/test/incremental/hashes/match_expressions.rs index b6b934eb7d508..11fe84d88e9b3 100644 --- a/src/test/incremental/hashes/match_expressions.rs +++ b/src/test/incremental/hashes/match_expressions.rs @@ -26,7 +26,7 @@ pub fn add_arm(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized,TypeckTables")] + except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_arm(x: u32) -> u32 { match x { @@ -51,7 +51,7 @@ pub fn change_order_of_arms(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized")] + except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_order_of_arms(x: u32) -> u32 { match x { @@ -75,7 +75,7 @@ pub fn add_guard_clause(x: u32, y: bool) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized,TypeckTables")] + except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_guard_clause(x: u32, y: bool) -> u32 { match x { @@ -99,7 +99,7 @@ pub fn change_guard_clause(x: u32, y: bool) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized,TypeckTables")] + except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_guard_clause(x: u32, y: bool) -> u32 { match x { @@ -123,7 +123,7 @@ pub fn add_at_binding(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized,TypeckTables")] + except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_at_binding(x: u32) -> u32 { match x { @@ -147,7 +147,7 @@ pub fn change_name_of_at_binding(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized")] + except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_name_of_at_binding(x: u32) -> u32 { match x { @@ -170,7 +170,7 @@ pub fn change_simple_name_to_pattern(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized,TypeckTables")] + except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_simple_name_to_pattern(x: u32) -> u32 { match (x, x & 1) { @@ -193,7 +193,7 @@ pub fn change_name_in_pattern(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized")] + except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_name_in_pattern(x: u32) -> u32 { match (x, x & 1) { @@ -216,7 +216,7 @@ pub fn change_mutability_of_binding_in_pattern(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized,TypeckTables")] + except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_mutability_of_binding_in_pattern(x: u32) -> u32 { match (x, x & 1) { @@ -238,7 +238,7 @@ pub fn add_ref_to_binding_in_pattern(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized,TypeckTables")] + except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_ref_to_binding_in_pattern(x: u32) -> u32 { match (x, x & 1) { @@ -260,7 +260,7 @@ pub fn add_amp_to_binding_in_pattern(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", -except="HirBody,MirValidated,MirOptimized,TypeckTables")] +except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_amp_to_binding_in_pattern(x: u32) -> u32 { match (&x, x & 1) { @@ -283,7 +283,7 @@ pub fn change_rhs_of_arm(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized")] + except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_rhs_of_arm(x: u32) -> u32 { match x { @@ -307,7 +307,7 @@ pub fn add_alternative_to_arm(x: u32) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", - except="HirBody,MirValidated,MirOptimized,TypeckTables")] + except="HirBody,MirBuilt,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_alternative_to_arm(x: u32) -> u32 { match x { diff --git a/src/test/incremental/hashes/panic_exprs.rs b/src/test/incremental/hashes/panic_exprs.rs index 3ae2c396d829c..9a3c93147a098 100644 --- a/src/test/incremental/hashes/panic_exprs.rs +++ b/src/test/incremental/hashes/panic_exprs.rs @@ -18,7 +18,7 @@ // Indexing expression --------------------------------------------------------- -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn indexing(slice: &[u8]) -> u8 { #[cfg(cfail1)] @@ -33,7 +33,7 @@ pub fn indexing(slice: &[u8]) -> u8 { // Arithmetic overflow plus ---------------------------------------------------- -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn arithmetic_overflow_plus(val: i32) -> i32 { #[cfg(cfail1)] @@ -48,7 +48,7 @@ pub fn arithmetic_overflow_plus(val: i32) -> i32 { // Arithmetic overflow minus ---------------------------------------------------- -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn arithmetic_overflow_minus(val: i32) -> i32 { #[cfg(cfail1)] @@ -63,7 +63,7 @@ pub fn arithmetic_overflow_minus(val: i32) -> i32 { // Arithmetic overflow mult ---------------------------------------------------- -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn arithmetic_overflow_mult(val: i32) -> i32 { #[cfg(cfail1)] @@ -78,7 +78,7 @@ pub fn arithmetic_overflow_mult(val: i32) -> i32 { // Arithmetic overflow negation ------------------------------------------------ -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn arithmetic_overflow_negation(val: i32) -> i32 { #[cfg(cfail1)] @@ -93,7 +93,7 @@ pub fn arithmetic_overflow_negation(val: i32) -> i32 { // Division by zero ------------------------------------------------------------ -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn division_by_zero(val: i32) -> i32 { #[cfg(cfail1)] @@ -107,7 +107,7 @@ pub fn division_by_zero(val: i32) -> i32 { } // Division by zero ------------------------------------------------------------ -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn mod_by_zero(val: i32) -> i32 { #[cfg(cfail1)] @@ -122,7 +122,7 @@ pub fn mod_by_zero(val: i32) -> i32 { // shift left ------------------------------------------------------------------ -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn shift_left(val: i32, shift: usize) -> i32 { #[cfg(cfail1)] @@ -137,7 +137,7 @@ pub fn shift_left(val: i32, shift: usize) -> i32 { // shift right ------------------------------------------------------------------ -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirBuilt,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn shift_right(val: i32, shift: usize) -> i32 { #[cfg(cfail1)] diff --git a/src/test/incremental/hashes/struct_constructors.rs b/src/test/incremental/hashes/struct_constructors.rs index 5444fe78f0a47..a42fda3188520 100644 --- a/src/test/incremental/hashes/struct_constructors.rs +++ b/src/test/incremental/hashes/struct_constructors.rs @@ -31,7 +31,7 @@ pub fn change_field_value_regular_struct() -> RegularStruct { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn change_field_value_regular_struct() -> RegularStruct { RegularStruct { @@ -82,7 +82,7 @@ pub fn add_field_regular_struct() -> RegularStruct { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_field_regular_struct() -> RegularStruct { let struct1 = RegularStruct { @@ -117,7 +117,7 @@ pub fn change_field_label_regular_struct() -> RegularStruct { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_field_label_regular_struct() -> RegularStruct { let struct1 = RegularStruct { @@ -152,7 +152,7 @@ pub fn change_constructor_path_regular_struct() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_constructor_path_regular_struct() { let _ = RegularStruct2 { @@ -173,7 +173,7 @@ pub mod change_constructor_path_indirectly_regular_struct { #[rustc_clean( cfg="cfail2", - except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,TypeckTables" + except="FnSignature,Hir,HirBody,MirOptimized,MirBuilt,TypeckTables" )] #[rustc_clean(cfg="cfail3")] pub fn function() -> Struct { @@ -196,7 +196,7 @@ pub fn change_field_value_tuple_struct() -> TupleStruct { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn change_field_value_tuple_struct() -> TupleStruct { TupleStruct(0, 1, 3) @@ -213,7 +213,7 @@ pub fn change_constructor_path_tuple_struct() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirBuilt,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_constructor_path_tuple_struct() { let _ = TupleStruct2(0, 1, 2); @@ -230,7 +230,7 @@ pub mod change_constructor_path_indirectly_tuple_struct { #[rustc_clean( cfg="cfail2", - except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,TypeckTables" + except="FnSignature,Hir,HirBody,MirOptimized,MirBuilt,TypeckTables" )] #[rustc_clean(cfg="cfail3")] pub fn function() -> Struct { diff --git a/src/test/incremental/hashes/unary_and_binary_exprs.rs b/src/test/incremental/hashes/unary_and_binary_exprs.rs index 26cc41fd8186c..ef8035a300a43 100644 --- a/src/test/incremental/hashes/unary_and_binary_exprs.rs +++ b/src/test/incremental/hashes/unary_and_binary_exprs.rs @@ -21,7 +21,7 @@ pub fn const_negation() -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn const_negation() -> i32 { -1 @@ -36,7 +36,7 @@ pub fn const_bitwise_not() -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn const_bitwise_not() -> i32 { !99 @@ -51,7 +51,7 @@ pub fn var_negation(x: i32, y: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn var_negation(x: i32, y: i32) -> i32 { -y @@ -66,7 +66,7 @@ pub fn var_bitwise_not(x: i32, y: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn var_bitwise_not(x: i32, y: i32) -> i32 { !y @@ -81,7 +81,7 @@ pub fn var_deref(x: &i32, y: &i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated,TypeckTables", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt,TypeckTables", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn var_deref(x: &i32, y: &i32) -> i32 { *y @@ -96,7 +96,7 @@ pub fn first_const_add() -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn first_const_add() -> i32 { 2 + 3 @@ -111,7 +111,7 @@ pub fn second_const_add() -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn second_const_add() -> i32 { 1 + 3 @@ -126,7 +126,7 @@ pub fn first_var_add(a: i32, b: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn first_var_add(a: i32, b: i32) -> i32 { b + 2 @@ -141,7 +141,7 @@ pub fn second_var_add(a: i32, b: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn second_var_add(a: i32, b: i32) -> i32 { 1 + b @@ -156,7 +156,7 @@ pub fn plus_to_minus(a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn plus_to_minus(a: i32) -> i32 { 1 - a @@ -171,7 +171,7 @@ pub fn plus_to_mult(a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn plus_to_mult(a: i32) -> i32 { 1 * a @@ -186,7 +186,7 @@ pub fn plus_to_div(a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn plus_to_div(a: i32) -> i32 { 1 / a @@ -201,7 +201,7 @@ pub fn plus_to_mod(a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn plus_to_mod(a: i32) -> i32 { 1 % a @@ -216,7 +216,7 @@ pub fn and_to_or(a: bool, b: bool) -> bool { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn and_to_or(a: bool, b: bool) -> bool { a || b @@ -231,7 +231,7 @@ pub fn bitwise_and_to_bitwise_or(a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn bitwise_and_to_bitwise_or(a: i32) -> i32 { 1 | a @@ -246,7 +246,7 @@ pub fn bitwise_and_to_bitwise_xor(a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn bitwise_and_to_bitwise_xor(a: i32) -> i32 { 1 ^ a @@ -261,7 +261,7 @@ pub fn bitwise_and_to_lshift(a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn bitwise_and_to_lshift(a: i32) -> i32 { a << 1 @@ -276,7 +276,7 @@ pub fn bitwise_and_to_rshift(a: i32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn bitwise_and_to_rshift(a: i32) -> i32 { a >> 1 @@ -291,7 +291,7 @@ pub fn eq_to_uneq(a: i32) -> bool { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn eq_to_uneq(a: i32) -> bool { a != 1 @@ -306,7 +306,7 @@ pub fn eq_to_lt(a: i32) -> bool { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn eq_to_lt(a: i32) -> bool { a < 1 @@ -321,7 +321,7 @@ pub fn eq_to_gt(a: i32) -> bool { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn eq_to_gt(a: i32) -> bool { a > 1 @@ -336,7 +336,7 @@ pub fn eq_to_le(a: i32) -> bool { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn eq_to_le(a: i32) -> bool { a <= 1 @@ -351,7 +351,7 @@ pub fn eq_to_ge(a: i32) -> bool { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn eq_to_ge(a: i32) -> bool { a >= 1 @@ -368,7 +368,7 @@ pub fn type_cast(a: u8) -> u64 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated,TypeckTables", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt,TypeckTables", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn type_cast(a: u8) -> u64 { let b = a as u32; @@ -385,7 +385,7 @@ pub fn value_cast(a: u32) -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn value_cast(a: u32) -> i32 { 2 as i32 @@ -403,7 +403,7 @@ pub fn place() -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn place() -> i32 { let mut x = 10; @@ -423,7 +423,7 @@ pub fn rvalue() -> i32 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn rvalue() -> i32 { let mut x = 10; @@ -440,7 +440,7 @@ pub fn index_to_slice(s: &[u8], i: usize, j: usize) -> u8 { } #[cfg(not(cfail1))] -#[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] +#[rustc_clean(except="HirBody,MirOptimized,MirBuilt", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] pub fn index_to_slice(s: &[u8], i: usize, j: usize) -> u8 { s[j] diff --git a/src/test/incremental/hashes/while_let_loops.rs b/src/test/incremental/hashes/while_let_loops.rs index edfea05ae9835..c708d5b969df5 100644 --- a/src/test/incremental/hashes/while_let_loops.rs +++ b/src/test/incremental/hashes/while_let_loops.rs @@ -25,7 +25,7 @@ pub fn change_loop_body() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_loop_body() { let mut _x = 0; @@ -48,7 +48,7 @@ pub fn change_loop_condition() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_loop_condition() { let mut _x = 0; @@ -70,7 +70,7 @@ pub fn add_break() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_break() { let mut _x = 0; @@ -141,7 +141,7 @@ pub fn change_break_label() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_break_label() { let mut _x = 0; @@ -191,7 +191,7 @@ pub fn change_continue_label() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn change_continue_label() { let mut _x = 0; @@ -216,7 +216,7 @@ pub fn change_continue_to_break() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_continue_to_break() { let mut _x = 0; diff --git a/src/test/incremental/hashes/while_loops.rs b/src/test/incremental/hashes/while_loops.rs index 85c2c9fa25064..c7b84a120c8df 100644 --- a/src/test/incremental/hashes/while_loops.rs +++ b/src/test/incremental/hashes/while_loops.rs @@ -25,7 +25,7 @@ pub fn change_loop_body() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_loop_body() { let mut _x = 0; @@ -48,7 +48,7 @@ pub fn change_loop_condition() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_loop_condition() { let mut _x = 0; @@ -70,7 +70,7 @@ pub fn add_break() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized, TypeckTables")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized, TypeckTables")] #[rustc_clean(cfg="cfail3")] pub fn add_break() { let mut _x = 0; @@ -141,7 +141,7 @@ pub fn change_break_label() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_break_label() { let mut _x = 0; @@ -191,7 +191,7 @@ pub fn change_continue_label() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt")] #[rustc_clean(cfg="cfail3")] pub fn change_continue_label() { let mut _x = 0; @@ -216,7 +216,7 @@ pub fn change_continue_to_break() { } #[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody, MirValidated, MirOptimized")] +#[rustc_clean(cfg="cfail2", except="HirBody, MirBuilt, MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn change_continue_to_break() { let mut _x = 0; From aa775a5debb7bb2988467e59defcc54286a9f74d Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 15:05:04 +0900 Subject: [PATCH 196/278] rustc-std-workspace-core => 2018 --- src/tools/rustc-std-workspace-core/Cargo.toml | 1 + src/tools/rustc-std-workspace-core/lib.rs | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tools/rustc-std-workspace-core/Cargo.toml b/src/tools/rustc-std-workspace-core/Cargo.toml index f000d634e1943..d527ce12bc3a1 100644 --- a/src/tools/rustc-std-workspace-core/Cargo.toml +++ b/src/tools/rustc-std-workspace-core/Cargo.toml @@ -6,6 +6,7 @@ license = 'MIT/Apache-2.0' description = """ Hack for the compiler's own build system """ +edition = "2018" [lib] path = "lib.rs" diff --git a/src/tools/rustc-std-workspace-core/lib.rs b/src/tools/rustc-std-workspace-core/lib.rs index e2946fe2a97f1..99d51bc2d56ac 100644 --- a/src/tools/rustc-std-workspace-core/lib.rs +++ b/src/tools/rustc-std-workspace-core/lib.rs @@ -1,6 +1,5 @@ #![feature(no_core)] #![no_core] - -extern crate core; +#![deny(rust_2018_idioms)] pub use core::*; From 36806b542e8129e76eb191a46babf5b9d4a037c7 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 15:17:51 +0900 Subject: [PATCH 197/278] rustc-workspace-hack => 2018 --- src/tools/rustc-workspace-hack/Cargo.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tools/rustc-workspace-hack/Cargo.toml b/src/tools/rustc-workspace-hack/Cargo.toml index f5eeddda036fd..f943ac9815ac6 100644 --- a/src/tools/rustc-workspace-hack/Cargo.toml +++ b/src/tools/rustc-workspace-hack/Cargo.toml @@ -6,6 +6,7 @@ license = 'MIT/Apache-2.0' description = """ Hack for the compiler's own build system """ +edition = "2018" [lib] path = "lib.rs" From b4a6f597934f16f89e27058a32a514c9572f148f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= Date: Fri, 8 Feb 2019 04:30:27 +0100 Subject: [PATCH 198/278] Allow a dirty MirBuilt for make_extern and make_method_extern --- src/test/incremental/hashes/function_interfaces.rs | 2 +- src/test/incremental/hashes/inherent_impls.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/incremental/hashes/function_interfaces.rs b/src/test/incremental/hashes/function_interfaces.rs index 8a0af2b0044a4..4330b0025a251 100644 --- a/src/test/incremental/hashes/function_interfaces.rs +++ b/src/test/incremental/hashes/function_interfaces.rs @@ -94,7 +94,7 @@ pub unsafe fn make_unsafe() {} pub fn make_extern() {} #[cfg(not(cfail1))] -#[rustc_clean(cfg = "cfail2", except = "Hir, HirBody, TypeckTables, FnSignature")] +#[rustc_clean(cfg = "cfail2", except = "Hir, HirBody, MirBuilt, TypeckTables, FnSignature")] #[rustc_clean(cfg = "cfail3")] pub extern "C" fn make_extern() {} diff --git a/src/test/incremental/hashes/inherent_impls.rs b/src/test/incremental/hashes/inherent_impls.rs index 3abc6c4d2e23e..d1574aee9a9c0 100644 --- a/src/test/incremental/hashes/inherent_impls.rs +++ b/src/test/incremental/hashes/inherent_impls.rs @@ -263,7 +263,7 @@ impl Foo { #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] impl Foo { - #[rustc_clean(cfg="cfail2", except="Hir,HirBody,FnSignature,TypeckTables")] + #[rustc_clean(cfg="cfail2", except="Hir,HirBody,MirBuilt,FnSignature,TypeckTables")] #[rustc_clean(cfg="cfail3")] pub extern fn make_method_extern(&self) { } } From efa8fb006e6e7d0d70f1e65810b69993df44006c Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 16:44:15 +0900 Subject: [PATCH 199/278] error_index_generator => 2018 --- src/tools/error_index_generator/Cargo.toml | 1 + src/tools/error_index_generator/main.rs | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/tools/error_index_generator/Cargo.toml b/src/tools/error_index_generator/Cargo.toml index 7f8783c9d89be..116be234f3ceb 100644 --- a/src/tools/error_index_generator/Cargo.toml +++ b/src/tools/error_index_generator/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "error_index_generator" version = "0.0.0" +edition = "2018" [dependencies] rustdoc = { path = "../../librustdoc" } diff --git a/src/tools/error_index_generator/main.rs b/src/tools/error_index_generator/main.rs index 72cfd7d5e58e9..ef045495a0864 100644 --- a/src/tools/error_index_generator/main.rs +++ b/src/tools/error_index_generator/main.rs @@ -1,8 +1,9 @@ #![feature(rustc_private)] +#![deny(rust_2018_idioms)] + extern crate env_logger; extern crate syntax; -extern crate rustdoc; extern crate serialize as rustc_serialize; use std::collections::BTreeMap; From 5ef71508fec1e2f89b257f6b6b65e5ca3295d658 Mon Sep 17 00:00:00 2001 From: Pietro Albini Date: Sun, 9 Dec 2018 17:40:49 +0100 Subject: [PATCH 200/278] unused_imports: update tests --- src/test/ui/bad/bad-lint-cap2.stderr | 2 +- src/test/ui/bad/bad-lint-cap3.stderr | 2 +- src/test/ui/imports/unused.stderr | 2 +- src/test/ui/issues/issue-30730.stderr | 2 +- ...directives-on-use-items-issue-10534.stderr | 4 ++-- src/test/ui/lint/lint-unused-imports.rs | 2 +- src/test/ui/lint/lint-unused-imports.stderr | 20 ++++++++++--------- .../ui/lint/lints-in-foreign-macros.stderr | 6 +++--- .../rfc-2166-underscore-imports/basic.stderr | 4 ++-- .../unused-2018.stderr | 4 ++-- src/test/ui/span/multispan-import-lint.stderr | 4 ++++ .../use/use-nested-groups-unused-imports.rs | 2 +- .../use-nested-groups-unused-imports.stderr | 12 ++++++----- 13 files changed, 37 insertions(+), 29 deletions(-) diff --git a/src/test/ui/bad/bad-lint-cap2.stderr b/src/test/ui/bad/bad-lint-cap2.stderr index d7ec41489d156..b9638722778ee 100644 --- a/src/test/ui/bad/bad-lint-cap2.stderr +++ b/src/test/ui/bad/bad-lint-cap2.stderr @@ -2,7 +2,7 @@ error: unused import: `std::option` --> $DIR/bad-lint-cap2.rs:6:5 | LL | use std::option; //~ ERROR - | ^^^^^^^^^^^ + | ----^^^^^^^^^^^- help: remove the whole `use` item | note: lint level defined here --> $DIR/bad-lint-cap2.rs:4:9 diff --git a/src/test/ui/bad/bad-lint-cap3.stderr b/src/test/ui/bad/bad-lint-cap3.stderr index 5bf0b089afa20..21ed50b550afc 100644 --- a/src/test/ui/bad/bad-lint-cap3.stderr +++ b/src/test/ui/bad/bad-lint-cap3.stderr @@ -2,7 +2,7 @@ warning: unused import: `std::option` --> $DIR/bad-lint-cap3.rs:7:5 | LL | use std::option; //~ WARN - | ^^^^^^^^^^^ + | ----^^^^^^^^^^^- help: remove the whole `use` item | note: lint level defined here --> $DIR/bad-lint-cap3.rs:4:9 diff --git a/src/test/ui/imports/unused.stderr b/src/test/ui/imports/unused.stderr index b56e930158cc1..fa82e974e1e29 100644 --- a/src/test/ui/imports/unused.stderr +++ b/src/test/ui/imports/unused.stderr @@ -2,7 +2,7 @@ error: unused import: `super::f` --> $DIR/unused.rs:7:24 | LL | pub(super) use super::f; //~ ERROR unused - | ^^^^^^^^ + | ---------------^^^^^^^^- help: remove the whole `use` item | note: lint level defined here --> $DIR/unused.rs:1:9 diff --git a/src/test/ui/issues/issue-30730.stderr b/src/test/ui/issues/issue-30730.stderr index 0a901076f467a..3cfadd33b8fec 100644 --- a/src/test/ui/issues/issue-30730.stderr +++ b/src/test/ui/issues/issue-30730.stderr @@ -2,7 +2,7 @@ error: unused import: `std::thread` --> $DIR/issue-30730.rs:3:5 | LL | use std::thread; - | ^^^^^^^^^^^ + | ----^^^^^^^^^^^- help: remove the whole `use` item | note: lint level defined here --> $DIR/issue-30730.rs:2:9 diff --git a/src/test/ui/lint/lint-directives-on-use-items-issue-10534.stderr b/src/test/ui/lint/lint-directives-on-use-items-issue-10534.stderr index 170b98a12a848..e588d24517c8c 100644 --- a/src/test/ui/lint/lint-directives-on-use-items-issue-10534.stderr +++ b/src/test/ui/lint/lint-directives-on-use-items-issue-10534.stderr @@ -2,7 +2,7 @@ error: unused import: `a::x` --> $DIR/lint-directives-on-use-items-issue-10534.rs:12:9 | LL | use a::x; //~ ERROR: unused import - | ^^^^ + | ----^^^^- help: remove the whole `use` item | note: lint level defined here --> $DIR/lint-directives-on-use-items-issue-10534.rs:1:9 @@ -14,7 +14,7 @@ error: unused import: `a::y` --> $DIR/lint-directives-on-use-items-issue-10534.rs:21:9 | LL | use a::y; //~ ERROR: unused import - | ^^^^ + | ----^^^^- help: remove the whole `use` item | note: lint level defined here --> $DIR/lint-directives-on-use-items-issue-10534.rs:20:12 diff --git a/src/test/ui/lint/lint-unused-imports.rs b/src/test/ui/lint/lint-unused-imports.rs index 489252479fef3..9c5b206203c1d 100644 --- a/src/test/ui/lint/lint-unused-imports.rs +++ b/src/test/ui/lint/lint-unused-imports.rs @@ -6,7 +6,7 @@ use bar::c::cc as cal; use std::mem::*; // shouldn't get errors for not using // everything imported use std::fmt::{}; -//~^ ERROR unused import: `use std::fmt::{};` +//~^ ERROR unused import: `std::fmt::{}` // Should get errors for both 'Some' and 'None' use std::option::Option::{Some, None}; diff --git a/src/test/ui/lint/lint-unused-imports.stderr b/src/test/ui/lint/lint-unused-imports.stderr index 214f4a472dc7e..7970b0201db70 100644 --- a/src/test/ui/lint/lint-unused-imports.stderr +++ b/src/test/ui/lint/lint-unused-imports.stderr @@ -1,8 +1,8 @@ -error: unused import: `use std::fmt::{};` - --> $DIR/lint-unused-imports.rs:8:1 +error: unused import: `std::fmt::{}` + --> $DIR/lint-unused-imports.rs:8:5 | LL | use std::fmt::{}; - | ^^^^^^^^^^^^^^^^^ + | ----^^^^^^^^^^^^- help: remove the whole `use` item | note: lint level defined here --> $DIR/lint-unused-imports.rs:1:9 @@ -14,37 +14,39 @@ error: unused imports: `None`, `Some` --> $DIR/lint-unused-imports.rs:12:27 | LL | use std::option::Option::{Some, None}; - | ^^^^ ^^^^ + | --------------------------^^^^--^^^^-- help: remove the whole `use` item error: unused import: `test::A` --> $DIR/lint-unused-imports.rs:15:5 | LL | use test::A; //~ ERROR unused import: `test::A` - | ^^^^^^^ + | ----^^^^^^^- help: remove the whole `use` item error: unused import: `bar` --> $DIR/lint-unused-imports.rs:24:18 | LL | use test2::{foo, bar}; //~ ERROR unused import: `bar` - | ^^^ + | --^^^ + | | + | help: remove the unused import error: unused import: `foo::Square` --> $DIR/lint-unused-imports.rs:52:13 | LL | use foo::Square; //~ ERROR unused import: `foo::Square` - | ^^^^^^^^^^^ + | ----^^^^^^^^^^^- help: remove the whole `use` item error: unused import: `self::g` --> $DIR/lint-unused-imports.rs:68:9 | LL | use self::g; //~ ERROR unused import: `self::g` - | ^^^^^^^ + | ----^^^^^^^- help: remove the whole `use` item error: unused import: `test2::foo` --> $DIR/lint-unused-imports.rs:77:9 | LL | use test2::foo; //~ ERROR unused import: `test2::foo` - | ^^^^^^^^^^ + | ----^^^^^^^^^^- help: remove the whole `use` item error: unused import: `test::B2` --> $DIR/lint-unused-imports.rs:20:5 diff --git a/src/test/ui/lint/lints-in-foreign-macros.stderr b/src/test/ui/lint/lints-in-foreign-macros.stderr index 8287ca5692bd9..b808ca708a311 100644 --- a/src/test/ui/lint/lints-in-foreign-macros.stderr +++ b/src/test/ui/lint/lints-in-foreign-macros.stderr @@ -2,7 +2,7 @@ warning: unused import: `std::string::ToString` --> $DIR/lints-in-foreign-macros.rs:11:16 | LL | () => {use std::string::ToString;} //~ WARN: unused import - | ^^^^^^^^^^^^^^^^^^^^^ + | ----^^^^^^^^^^^^^^^^^^^^^- help: remove the whole `use` item ... LL | mod a { foo!(); } | ------- in this macro invocation @@ -17,13 +17,13 @@ warning: unused import: `std::string::ToString` --> $DIR/lints-in-foreign-macros.rs:16:18 | LL | mod c { baz!(use std::string::ToString;); } //~ WARN: unused import - | ^^^^^^^^^^^^^^^^^^^^^ + | ----^^^^^^^^^^^^^^^^^^^^^- help: remove the whole `use` item warning: unused import: `std::string::ToString` --> $DIR/lints-in-foreign-macros.rs:17:19 | LL | mod d { baz2!(use std::string::ToString;); } //~ WARN: unused import - | ^^^^^^^^^^^^^^^^^^^^^ + | ----^^^^^^^^^^^^^^^^^^^^^- help: remove the whole `use` item warning: missing documentation for crate --> $DIR/lints-in-foreign-macros.rs:4:1 diff --git a/src/test/ui/rfc-2166-underscore-imports/basic.stderr b/src/test/ui/rfc-2166-underscore-imports/basic.stderr index 3080359192603..c7b36eaf2e76b 100644 --- a/src/test/ui/rfc-2166-underscore-imports/basic.stderr +++ b/src/test/ui/rfc-2166-underscore-imports/basic.stderr @@ -2,7 +2,7 @@ warning: unused import: `m::Tr1 as _` --> $DIR/basic.rs:26:9 | LL | use m::Tr1 as _; //~ WARN unused import - | ^^^^^^^^^^^ + | ----^^^^^^^^^^^- help: remove the whole `use` item | note: lint level defined here --> $DIR/basic.rs:4:9 @@ -14,5 +14,5 @@ warning: unused import: `S as _` --> $DIR/basic.rs:27:9 | LL | use S as _; //~ WARN unused import - | ^^^^^^ + | ----^^^^^^- help: remove the whole `use` item diff --git a/src/test/ui/rfc-2166-underscore-imports/unused-2018.stderr b/src/test/ui/rfc-2166-underscore-imports/unused-2018.stderr index 4163c2876074b..0bbc17276d98b 100644 --- a/src/test/ui/rfc-2166-underscore-imports/unused-2018.stderr +++ b/src/test/ui/rfc-2166-underscore-imports/unused-2018.stderr @@ -2,7 +2,7 @@ error: unused import: `core::any` --> $DIR/unused-2018.rs:6:9 | LL | use core::any; //~ ERROR unused import: `core::any` - | ^^^^^^^^^ + | ----^^^^^^^^^- help: remove the whole `use` item | note: lint level defined here --> $DIR/unused-2018.rs:3:9 @@ -14,7 +14,7 @@ error: unused import: `core` --> $DIR/unused-2018.rs:10:9 | LL | use core; //~ ERROR unused import: `core` - | ^^^^ + | ----^^^^- help: remove the whole `use` item error: aborting due to 2 previous errors diff --git a/src/test/ui/span/multispan-import-lint.stderr b/src/test/ui/span/multispan-import-lint.stderr index a730d081b7c03..6bd0e9be81f5e 100644 --- a/src/test/ui/span/multispan-import-lint.stderr +++ b/src/test/ui/span/multispan-import-lint.stderr @@ -10,4 +10,8 @@ note: lint level defined here LL | #![warn(unused)] | ^^^^^^ = note: #[warn(unused_imports)] implied by #[warn(unused)] +help: remove the unused imports + | +LL | use std::cmp::{min}; + | -- -- diff --git a/src/test/ui/use/use-nested-groups-unused-imports.rs b/src/test/ui/use/use-nested-groups-unused-imports.rs index 5bdc7b2c03f0f..5fe85954dc8e9 100644 --- a/src/test/ui/use/use-nested-groups-unused-imports.rs +++ b/src/test/ui/use/use-nested-groups-unused-imports.rs @@ -18,7 +18,7 @@ use foo::{Foo, bar::{baz::{}, foobar::*}, *}; use foo::bar::baz::{*, *}; //~^ ERROR unused import: `*` use foo::{}; - //~^ ERROR unused import: `use foo::{};` + //~^ ERROR unused import: `foo::{}` fn main() { let _: Bar; diff --git a/src/test/ui/use/use-nested-groups-unused-imports.stderr b/src/test/ui/use/use-nested-groups-unused-imports.stderr index f60c7f5023798..6af6f449de5e6 100644 --- a/src/test/ui/use/use-nested-groups-unused-imports.stderr +++ b/src/test/ui/use/use-nested-groups-unused-imports.stderr @@ -2,7 +2,7 @@ error: unused imports: `*`, `Foo`, `baz::{}`, `foobar::*` --> $DIR/use-nested-groups-unused-imports.rs:16:11 | LL | use foo::{Foo, bar::{baz::{}, foobar::*}, *}; - | ^^^ ^^^^^^^ ^^^^^^^^^ ^ + | ----------^^^--------^^^^^^^--^^^^^^^^^---^-- help: remove the whole `use` item | note: lint level defined here --> $DIR/use-nested-groups-unused-imports.rs:3:9 @@ -14,13 +14,15 @@ error: unused import: `*` --> $DIR/use-nested-groups-unused-imports.rs:18:24 | LL | use foo::bar::baz::{*, *}; - | ^ + | --^ + | | + | help: remove the unused import -error: unused import: `use foo::{};` - --> $DIR/use-nested-groups-unused-imports.rs:20:1 +error: unused import: `foo::{}` + --> $DIR/use-nested-groups-unused-imports.rs:20:5 | LL | use foo::{}; - | ^^^^^^^^^^^^ + | ----^^^^^^^- help: remove the whole `use` item error: aborting due to 3 previous errors From fb3c4fbfc33b77b7beeeaf4a749a2081a8bfbc2f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Fri, 8 Feb 2019 01:16:56 -0800 Subject: [PATCH 201/278] Fix nll test output --- src/test/ui/augmented-assignments.nll.stderr | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/ui/augmented-assignments.nll.stderr b/src/test/ui/augmented-assignments.nll.stderr index 840b377263db9..33c94d6e3a59e 100644 --- a/src/test/ui/augmented-assignments.nll.stderr +++ b/src/test/ui/augmented-assignments.nll.stderr @@ -9,7 +9,7 @@ LL | x //~ error: use of moved value: `x` LL | | //~^ value used here after move LL | | += LL | | x; //~ value moved here - | | - + | | ^ | | | | |_____move out of `x` occurs here | borrow later used here From 5288f3f9674f876ba7b28c4594301c00cab14984 Mon Sep 17 00:00:00 2001 From: hrls Date: Fri, 8 Feb 2019 12:47:20 +0300 Subject: [PATCH 202/278] fix rustdoc JS --- src/librustdoc/html/static/main.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js index d6c05de0df6f2..877ac9a62bbec 100644 --- a/src/librustdoc/html/static/main.js +++ b/src/librustdoc/html/static/main.js @@ -2026,7 +2026,7 @@ if (!DOMTokenList.prototype.remove) { } else if (action === "hide") { addClass(relatedDoc, "fns-now-collapsed"); addClass(docblock, "hidden-by-usual-hider"); - onEachLazy(toggle.childNodes, adjustToggle(true, dontApplyBlockRule); + onEachLazy(toggle.childNodes, adjustToggle(true, dontApplyBlockRule)); onEachLazy(relatedDoc.childNodes, implHider(true, dontApplyBlockRule)); } } From 541503afa13a4ea8596755e0e88e6dd13a95faa5 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Fri, 8 Feb 2019 11:41:01 +0100 Subject: [PATCH 203/278] std::sys::unix::stdio: explain why we do into_raw --- src/libstd/sys/unix/stdio.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/libstd/sys/unix/stdio.rs b/src/libstd/sys/unix/stdio.rs index 8a6b7b5f876ff..715f2eafb2d9b 100644 --- a/src/libstd/sys/unix/stdio.rs +++ b/src/libstd/sys/unix/stdio.rs @@ -12,7 +12,7 @@ impl Stdin { pub fn read(&self, data: &mut [u8]) -> io::Result { let fd = FileDesc::new(libc::STDIN_FILENO); let ret = fd.read(data); - fd.into_raw(); + fd.into_raw(); // do not close this FD ret } } @@ -23,7 +23,7 @@ impl Stdout { pub fn write(&self, data: &[u8]) -> io::Result { let fd = FileDesc::new(libc::STDOUT_FILENO); let ret = fd.write(data); - fd.into_raw(); + fd.into_raw(); // do not close this FD ret } @@ -38,7 +38,7 @@ impl Stderr { pub fn write(&self, data: &[u8]) -> io::Result { let fd = FileDesc::new(libc::STDERR_FILENO); let ret = fd.write(data); - fd.into_raw(); + fd.into_raw(); // do not close this FD ret } From 7815c9b1c80c96d80b2054a5bc182bc628473cfd Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 19:56:52 +0900 Subject: [PATCH 204/278] Revert removed #![feature(nll)] --- src/librustc_mir/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs index 72a13c791cec0..afd33a51a6a3b 100644 --- a/src/librustc_mir/lib.rs +++ b/src/librustc_mir/lib.rs @@ -4,6 +4,7 @@ Rust MIR: a lowered representation of Rust. Also: an experiment! */ +#![feature(nll)] #![feature(in_band_lifetimes)] #![feature(slice_patterns)] #![feature(slice_sort_by_cached_key)] From d2514523db8d02fedc6f5d88545b96c55dd26a43 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 20:08:08 +0900 Subject: [PATCH 205/278] Use real try blocks --- src/librustc_mir/borrow_check/nll/mod.rs | 4 ++-- src/librustc_mir/lib.rs | 9 +-------- src/librustc_mir/util/pretty.rs | 4 ++-- 3 files changed, 5 insertions(+), 12 deletions(-) diff --git a/src/librustc_mir/borrow_check/nll/mod.rs b/src/librustc_mir/borrow_check/nll/mod.rs index 128d54c9f49d7..1fca104cd3825 100644 --- a/src/librustc_mir/borrow_check/nll/mod.rs +++ b/src/librustc_mir/borrow_check/nll/mod.rs @@ -254,14 +254,14 @@ fn dump_mir_results<'a, 'gcx, 'tcx>( ); // Also dump the inference graph constraints as a graphviz file. - let _: io::Result<()> = try_block! { + let _: io::Result<()> = try { let mut file = pretty::create_dump_file(infcx.tcx, "regioncx.all.dot", None, "nll", &0, source)?; regioncx.dump_graphviz_raw_constraints(&mut file)?; }; // Also dump the inference graph constraints as a graphviz file. - let _: io::Result<()> = try_block! { + let _: io::Result<()> = try { let mut file = pretty::create_dump_file(infcx.tcx, "regioncx.scc.dot", None, "nll", &0, source)?; regioncx.dump_graphviz_scc_constraints(&mut file)?; diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs index afd33a51a6a3b..143104a0feec1 100644 --- a/src/librustc_mir/lib.rs +++ b/src/librustc_mir/lib.rs @@ -26,6 +26,7 @@ Rust MIR: a lowered representation of Rust. Also: an experiment! #![feature(slice_concat_ext)] #![feature(try_from)] #![feature(reverse_bits)] +#![feature(try_blocks)] #![recursion_limit="256"] @@ -43,14 +44,6 @@ extern crate serialize as rustc_serialize; // used by deriving #[macro_use] extern crate syntax; -// Once we can use edition 2018 in the compiler, -// replace this with real try blocks. -macro_rules! try_block { - ($($inside:tt)*) => ( - (||{ ::std::ops::Try::from_ok({ $($inside)* }) })() - ) -} - mod diagnostics; mod borrow_check; diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs index 6e1ec31c9372f..2e1fc756833b8 100644 --- a/src/librustc_mir/util/pretty.rs +++ b/src/librustc_mir/util/pretty.rs @@ -131,7 +131,7 @@ fn dump_matched_mir_node<'a, 'gcx, 'tcx, F>( ) where F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>, { - let _: io::Result<()> = try_block! { + let _: io::Result<()> = try { let mut file = create_dump_file(tcx, "mir", pass_num, pass_name, disambiguator, source)?; writeln!(file, "// MIR for `{}`", node_path)?; writeln!(file, "// source = {:?}", source)?; @@ -148,7 +148,7 @@ fn dump_matched_mir_node<'a, 'gcx, 'tcx, F>( }; if tcx.sess.opts.debugging_opts.dump_mir_graphviz { - let _: io::Result<()> = try_block! { + let _: io::Result<()> = try { let mut file = create_dump_file(tcx, "dot", pass_num, pass_name, disambiguator, source)?; write_mir_fn_graphviz(tcx, source.def_id, mir, &mut file)?; From c9bc85ecf100da1358ff2c2545fe5fa6caa506c2 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 20:13:12 +0900 Subject: [PATCH 206/278] Remove #[macro_use] extern crate bitflags --- src/librustc_mir/lib.rs | 2 -- src/librustc_mir/transform/qualify_consts.rs | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs index 143104a0feec1..909f96956695d 100644 --- a/src/librustc_mir/lib.rs +++ b/src/librustc_mir/lib.rs @@ -33,8 +33,6 @@ Rust MIR: a lowered representation of Rust. Also: an experiment! #![deny(rust_2018_idioms)] #![allow(explicit_outlives_requirements)] -#[macro_use] -extern crate bitflags; #[macro_use] extern crate log; #[macro_use] extern crate rustc; diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs index c786e9438af12..ab4e3ad23f69a 100644 --- a/src/librustc_mir/transform/qualify_consts.rs +++ b/src/librustc_mir/transform/qualify_consts.rs @@ -30,7 +30,7 @@ use std::usize; use crate::transform::{MirPass, MirSource}; use super::promote_consts::{self, Candidate, TempState}; -bitflags! { +bitflags::bitflags! { // Borrows of temporaries can be promoted only if // they have none of these qualifications, with // the exception of `STATIC_REF` (in statics only). From 6140134b6f2004a4d331821278c8b17f47a51f25 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 20:35:41 +0900 Subject: [PATCH 207/278] librustc_lint => 2018 --- src/librustc_lint/Cargo.toml | 1 + src/librustc_lint/builtin.rs | 108 +++++++++++++------------ src/librustc_lint/diagnostics.rs | 2 + src/librustc_lint/lib.rs | 10 +-- src/librustc_lint/nonstandard_style.rs | 39 ++++----- src/librustc_lint/types.rs | 19 +++-- src/librustc_lint/unused.rs | 29 ++++--- 7 files changed, 108 insertions(+), 100 deletions(-) diff --git a/src/librustc_lint/Cargo.toml b/src/librustc_lint/Cargo.toml index 7fb7a06ea1ad5..82f7118df2d0b 100644 --- a/src/librustc_lint/Cargo.toml +++ b/src/librustc_lint/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_lint" version = "0.0.0" +edition = "2018" [lib] name = "rustc_lint" diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 7c25d8d8b793f..cbcc7f3574d03 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -21,6 +21,7 @@ use rustc::hir::def::Def; use rustc::hir::def_id::{DefId, LOCAL_CRATE}; use rustc::ty::{self, Ty}; +use rustc::{lint, util}; use hir::Node; use util::nodemap::NodeSet; use lint::{LateContext, LintContext, LintArray}; @@ -42,10 +43,13 @@ use syntax::symbol::keywords; use syntax::errors::{Applicability, DiagnosticBuilder}; use syntax::print::pprust::expr_to_string; use syntax::visit::FnKind; +use syntax::struct_span_err; use rustc::hir::{self, GenericParamKind, PatKind}; -use nonstandard_style::{MethodLateContext, method_context}; +use crate::nonstandard_style::{MethodLateContext, method_context}; + +use log::debug; // hardwired lints from librustc pub use lint::builtin::*; @@ -70,7 +74,7 @@ impl LintPass for WhileTrue { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for WhileTrue { - fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) { + fn check_expr(&mut self, cx: &LateContext<'_, '_>, e: &hir::Expr) { if let hir::ExprKind::While(ref cond, ..) = e.node { if let hir::ExprKind::Lit(ref lit) = cond.node { if let ast::LitKind::Bool(true) = lit.node { @@ -102,7 +106,7 @@ declare_lint! { pub struct BoxPointers; impl BoxPointers { - fn check_heap_type<'a, 'tcx>(&self, cx: &LateContext, span: Span, ty: Ty) { + fn check_heap_type<'a, 'tcx>(&self, cx: &LateContext<'_, '_>, span: Span, ty: Ty<'_>) { for leaf_ty in ty.walk() { if leaf_ty.is_box() { let m = format!("type uses owned (Box type) pointers: {}", ty); @@ -123,7 +127,7 @@ impl LintPass for BoxPointers { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxPointers { - fn check_item(&mut self, cx: &LateContext, it: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { match it.node { hir::ItemKind::Fn(..) | hir::ItemKind::Ty(..) | @@ -150,7 +154,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BoxPointers { } } - fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) { + fn check_expr(&mut self, cx: &LateContext<'_, '_>, e: &hir::Expr) { let ty = cx.tables.node_id_to_type(e.hir_id); self.check_heap_type(cx, e.span, ty); } @@ -176,7 +180,7 @@ impl LintPass for NonShorthandFieldPatterns { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonShorthandFieldPatterns { - fn check_pat(&mut self, cx: &LateContext, pat: &hir::Pat) { + fn check_pat(&mut self, cx: &LateContext<'_, '_>, pat: &hir::Pat) { if let PatKind::Struct(ref qpath, ref field_pats, _) = pat.node { let variant = cx.tables.pat_ty(pat).ty_adt_def() .expect("struct pattern type is not an ADT") @@ -233,7 +237,7 @@ impl LintPass for UnsafeCode { } impl UnsafeCode { - fn report_unsafe(&self, cx: &EarlyContext, span: Span, desc: &'static str) { + fn report_unsafe(&self, cx: &EarlyContext<'_>, span: Span, desc: &'static str) { // This comes from a macro that has #[allow_internal_unsafe]. if span.allows_unsafe() { return; @@ -244,7 +248,7 @@ impl UnsafeCode { } impl EarlyLintPass for UnsafeCode { - fn check_attribute(&mut self, cx: &EarlyContext, attr: &ast::Attribute) { + fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &ast::Attribute) { if attr.check_name("allow_internal_unsafe") { self.report_unsafe(cx, attr.span, "`allow_internal_unsafe` allows defining \ macros using unsafe without triggering \ @@ -252,7 +256,7 @@ impl EarlyLintPass for UnsafeCode { } } - fn check_expr(&mut self, cx: &EarlyContext, e: &ast::Expr) { + fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) { if let ast::ExprKind::Block(ref blk, _) = e.node { // Don't warn about generated blocks, that'll just pollute the output. if blk.rules == ast::BlockCheckMode::Unsafe(ast::UserProvided) { @@ -261,7 +265,7 @@ impl EarlyLintPass for UnsafeCode { } } - fn check_item(&mut self, cx: &EarlyContext, it: &ast::Item) { + fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) { match it.node { ast::ItemKind::Trait(_, ast::Unsafety::Unsafe, ..) => { self.report_unsafe(cx, it.span, "declaration of an `unsafe` trait") @@ -276,8 +280,8 @@ impl EarlyLintPass for UnsafeCode { } fn check_fn(&mut self, - cx: &EarlyContext, - fk: FnKind, + cx: &EarlyContext<'_>, + fk: FnKind<'_>, _: &ast::FnDecl, span: Span, _: ast::NodeId) { @@ -296,7 +300,7 @@ impl EarlyLintPass for UnsafeCode { } } - fn check_trait_item(&mut self, cx: &EarlyContext, item: &ast::TraitItem) { + fn check_trait_item(&mut self, cx: &EarlyContext<'_>, item: &ast::TraitItem) { if let ast::TraitItemKind::Method(ref sig, None) = item.node { if sig.header.unsafety == ast::Unsafety::Unsafe { self.report_unsafe(cx, item.span, "declaration of an `unsafe` method") @@ -354,7 +358,7 @@ impl MissingDoc { } fn check_missing_docs_attrs(&self, - cx: &LateContext, + cx: &LateContext<'_, '_>, id: Option, attrs: &[ast::Attribute], sp: Span, @@ -399,7 +403,7 @@ impl LintPass for MissingDoc { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { - fn enter_lint_attrs(&mut self, _: &LateContext, attrs: &[ast::Attribute]) { + fn enter_lint_attrs(&mut self, _: &LateContext<'_, '_>, attrs: &[ast::Attribute]) { let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| { attr.check_name("doc") && @@ -411,11 +415,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { self.doc_hidden_stack.push(doc_hidden); } - fn exit_lint_attrs(&mut self, _: &LateContext, _attrs: &[ast::Attribute]) { + fn exit_lint_attrs(&mut self, _: &LateContext<'_, '_>, _attrs: &[ast::Attribute]) { self.doc_hidden_stack.pop().expect("empty doc_hidden_stack"); } - fn check_crate(&mut self, cx: &LateContext, krate: &hir::Crate) { + fn check_crate(&mut self, cx: &LateContext<'_, '_>, krate: &hir::Crate) { self.check_missing_docs_attrs(cx, None, &krate.attrs, krate.span, "crate"); for macro_def in &krate.exported_macros { @@ -428,7 +432,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { } } - fn check_item(&mut self, cx: &LateContext, it: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { let desc = match it.node { hir::ItemKind::Fn(..) => "a function", hir::ItemKind::Mod(..) => "a module", @@ -473,7 +477,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { self.check_missing_docs_attrs(cx, Some(it.id), &it.attrs, it.span, desc); } - fn check_trait_item(&mut self, cx: &LateContext, trait_item: &hir::TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'_, '_>, trait_item: &hir::TraitItem) { if self.private_traits.contains(&trait_item.id) { return; } @@ -491,7 +495,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { desc); } - fn check_impl_item(&mut self, cx: &LateContext, impl_item: &hir::ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'_, '_>, impl_item: &hir::ImplItem) { // If the method is an impl for a trait, don't doc. if method_context(cx, impl_item.id) == MethodLateContext::TraitImpl { return; @@ -510,7 +514,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { desc); } - fn check_struct_field(&mut self, cx: &LateContext, sf: &hir::StructField) { + fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, sf: &hir::StructField) { if !sf.is_positional() { self.check_missing_docs_attrs(cx, Some(sf.id), @@ -520,7 +524,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc { } } - fn check_variant(&mut self, cx: &LateContext, v: &hir::Variant, _: &hir::Generics) { + fn check_variant(&mut self, cx: &LateContext<'_, '_>, v: &hir::Variant, _: &hir::Generics) { self.check_missing_docs_attrs(cx, Some(v.node.data.id()), &v.node.attrs, @@ -549,7 +553,7 @@ impl LintPass for MissingCopyImplementations { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingCopyImplementations { - fn check_item(&mut self, cx: &LateContext, item: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item) { if !cx.access_levels.is_reachable(item.id) { return; } @@ -620,7 +624,7 @@ impl LintPass for MissingDebugImplementations { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDebugImplementations { - fn check_item(&mut self, cx: &LateContext, item: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item) { if !cx.access_levels.is_reachable(item.id) { return; } @@ -681,7 +685,7 @@ impl LintPass for AnonymousParameters { } impl EarlyLintPass for AnonymousParameters { - fn check_trait_item(&mut self, cx: &EarlyContext, it: &ast::TraitItem) { + fn check_trait_item(&mut self, cx: &EarlyContext<'_>, it: &ast::TraitItem) { match it.node { ast::TraitItemKind::Method(ref sig, _) => { for arg in sig.decl.inputs.iter() { @@ -749,7 +753,7 @@ impl LintPass for DeprecatedAttr { } impl EarlyLintPass for DeprecatedAttr { - fn check_attribute(&mut self, cx: &EarlyContext, attr: &ast::Attribute) { + fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &ast::Attribute) { for &&(n, _, _, ref g) in &self.depr_attrs { if attr.name() == n { if let &AttributeGate::Gated(Stability::Deprecated(link, suggestion), @@ -804,15 +808,15 @@ impl UnusedDocComment { } impl EarlyLintPass for UnusedDocComment { - fn check_local(&mut self, cx: &EarlyContext, decl: &ast::Local) { + fn check_local(&mut self, cx: &EarlyContext<'_>, decl: &ast::Local) { self.warn_if_doc(decl.attrs.iter(), cx); } - fn check_arm(&mut self, cx: &EarlyContext, arm: &ast::Arm) { + fn check_arm(&mut self, cx: &EarlyContext<'_>, arm: &ast::Arm) { self.warn_if_doc(arm.attrs.iter(), cx); } - fn check_expr(&mut self, cx: &EarlyContext, expr: &ast::Expr) { + fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &ast::Expr) { self.warn_if_doc(expr.attrs.iter(), cx); } } @@ -837,7 +841,7 @@ impl LintPass for PluginAsLibrary { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PluginAsLibrary { - fn check_item(&mut self, cx: &LateContext, it: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { if cx.tcx.plugin_registrar_fn(LOCAL_CRATE).is_some() { // We're compiling a plugin; it's fine to link other plugins. return; @@ -894,7 +898,7 @@ impl LintPass for InvalidNoMangleItems { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidNoMangleItems { - fn check_item(&mut self, cx: &LateContext, it: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { match it.node { hir::ItemKind::Fn(.., ref generics, _) => { if let Some(no_mangle_attr) = attr::find_by_name(&it.attrs, "no_mangle") { @@ -968,7 +972,7 @@ impl LintPass for MutableTransmutes { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MutableTransmutes { - fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) { + fn check_expr(&mut self, cx: &LateContext<'_, '_>, expr: &hir::Expr) { use rustc_target::spec::abi::Abi::RustIntrinsic; let msg = "mutating transmuted &mut T from &T may cause undefined behavior, \ @@ -1004,7 +1008,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MutableTransmutes { None } - fn def_id_is_transmute(cx: &LateContext, def_id: DefId) -> bool { + fn def_id_is_transmute(cx: &LateContext<'_, '_>, def_id: DefId) -> bool { cx.tcx.fn_sig(def_id).abi() == RustIntrinsic && cx.tcx.item_name(def_id) == "transmute" } @@ -1032,7 +1036,7 @@ impl LintPass for UnstableFeatures { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnstableFeatures { - fn check_attribute(&mut self, ctx: &LateContext, attr: &ast::Attribute) { + fn check_attribute(&mut self, ctx: &LateContext<'_, '_>, attr: &ast::Attribute) { if attr.check_name("feature") { if let Some(items) = attr.meta_item_list() { for item in items { @@ -1063,7 +1067,7 @@ impl LintPass for UnionsWithDropFields { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnionsWithDropFields { - fn check_item(&mut self, ctx: &LateContext, item: &hir::Item) { + fn check_item(&mut self, ctx: &LateContext<'_, '_>, item: &hir::Item) { if let hir::ItemKind::Union(ref vdata, _) = item.node { for field in vdata.fields() { let field_ty = ctx.tcx.type_of(ctx.tcx.hir().local_def_id(field.id)); @@ -1099,7 +1103,7 @@ impl LintPass for UnreachablePub { } impl UnreachablePub { - fn perform_lint(&self, cx: &LateContext, what: &str, id: ast::NodeId, + fn perform_lint(&self, cx: &LateContext<'_, '_>, what: &str, id: ast::NodeId, vis: &hir::Visibility, span: Span, exportable: bool) { let mut applicability = Applicability::MachineApplicable; match vis.node { @@ -1134,20 +1138,20 @@ impl UnreachablePub { impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnreachablePub { - fn check_item(&mut self, cx: &LateContext, item: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item) { self.perform_lint(cx, "item", item.id, &item.vis, item.span, true); } - fn check_foreign_item(&mut self, cx: &LateContext, foreign_item: &hir::ForeignItem) { + fn check_foreign_item(&mut self, cx: &LateContext<'_, '_>, foreign_item: &hir::ForeignItem) { self.perform_lint(cx, "item", foreign_item.id, &foreign_item.vis, foreign_item.span, true); } - fn check_struct_field(&mut self, cx: &LateContext, field: &hir::StructField) { + fn check_struct_field(&mut self, cx: &LateContext<'_, '_>, field: &hir::StructField) { self.perform_lint(cx, "field", field.id, &field.vis, field.span, false); } - fn check_impl_item(&mut self, cx: &LateContext, impl_item: &hir::ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'_, '_>, impl_item: &hir::ImplItem) { self.perform_lint(cx, "item", impl_item.id, &impl_item.vis, impl_item.span, false); } } @@ -1193,7 +1197,7 @@ impl TypeAliasBounds { } } - fn suggest_changing_assoc_types(ty: &hir::Ty, err: &mut DiagnosticBuilder) { + fn suggest_changing_assoc_types(ty: &hir::Ty, err: &mut DiagnosticBuilder<'_>) { // Access to associates types should use `::Assoc`, which does not need a // bound. Let's see if this type does that. @@ -1225,7 +1229,7 @@ impl TypeAliasBounds { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeAliasBounds { - fn check_item(&mut self, cx: &LateContext, item: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::Item) { let (ty, type_alias_generics) = match item.node { hir::ItemKind::Ty(ref ty, ref generics) => (&*ty, generics), _ => return, @@ -1281,7 +1285,7 @@ impl LintPass for UnusedBrokenConst { lint_array!() } } -fn check_const(cx: &LateContext, body_id: hir::BodyId) { +fn check_const(cx: &LateContext<'_, '_>, body_id: hir::BodyId) { let def_id = cx.tcx.hir().body_owner_def_id(body_id); let is_static = cx.tcx.is_static(def_id).is_some(); let param_env = if is_static { @@ -1299,7 +1303,7 @@ fn check_const(cx: &LateContext, body_id: hir::BodyId) { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedBrokenConst { - fn check_item(&mut self, cx: &LateContext, it: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { match it.node { hir::ItemKind::Const(_, body_id) => { check_const(cx, body_id); @@ -1429,7 +1433,7 @@ impl LintPass for EllipsisInclusiveRangePatterns { } impl EarlyLintPass for EllipsisInclusiveRangePatterns { - fn check_pat(&mut self, cx: &EarlyContext, pat: &ast::Pat, visit_subpats: &mut bool) { + fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &ast::Pat, visit_subpats: &mut bool) { use self::ast::{PatKind, RangeEnd, RangeSyntax::DotDotDot}; /// If `pat` is a `...` pattern, return the start and end of the range, as well as the span @@ -1507,7 +1511,7 @@ impl LintPass for UnnameableTestItems { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnameableTestItems { - fn check_item(&mut self, cx: &LateContext, it: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { if self.items_nameable { if let hir::ItemKind::Mod(..) = it.node {} else { @@ -1526,7 +1530,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnnameableTestItems { } } - fn check_item_post(&mut self, _cx: &LateContext, it: &hir::Item) { + fn check_item_post(&mut self, _cx: &LateContext<'_, '_>, it: &hir::Item) { if !self.items_nameable && self.boundary == it.id { self.items_nameable = true; } @@ -1554,7 +1558,7 @@ impl LintPass for KeywordIdents { } impl KeywordIdents { - fn check_tokens(&mut self, cx: &EarlyContext, tokens: TokenStream) { + fn check_tokens(&mut self, cx: &EarlyContext<'_>, tokens: TokenStream) { for tt in tokens.into_trees() { match tt { TokenTree::Token(span, tok) => match tok.ident() { @@ -1576,13 +1580,13 @@ impl KeywordIdents { } impl EarlyLintPass for KeywordIdents { - fn check_mac_def(&mut self, cx: &EarlyContext, mac_def: &ast::MacroDef, _id: ast::NodeId) { + fn check_mac_def(&mut self, cx: &EarlyContext<'_>, mac_def: &ast::MacroDef, _id: ast::NodeId) { self.check_tokens(cx, mac_def.stream()); } - fn check_mac(&mut self, cx: &EarlyContext, mac: &ast::Mac) { + fn check_mac(&mut self, cx: &EarlyContext<'_>, mac: &ast::Mac) { self.check_tokens(cx, mac.node.tts.clone().into()); } - fn check_ident(&mut self, cx: &EarlyContext, ident: ast::Ident) { + fn check_ident(&mut self, cx: &EarlyContext<'_>, ident: ast::Ident) { let ident_str = &ident.as_str()[..]; let cur_edition = cx.sess.edition(); let is_raw_ident = |ident: ast::Ident| { @@ -1665,7 +1669,7 @@ impl LintPass for ExplicitOutlivesRequirements { impl ExplicitOutlivesRequirements { fn collect_outlives_bound_spans( &self, - cx: &LateContext, + cx: &LateContext<'_, '_>, item_def_id: DefId, param_name: &str, bounds: &hir::GenericBounds, diff --git a/src/librustc_lint/diagnostics.rs b/src/librustc_lint/diagnostics.rs index 9a608e4fef08b..3165673111cca 100644 --- a/src/librustc_lint/diagnostics.rs +++ b/src/librustc_lint/diagnostics.rs @@ -1,3 +1,5 @@ +use syntax::{register_diagnostic, register_diagnostics}; + register_diagnostics! { E0721, // `await` keyword } diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs index 6607951d2cd14..fa9d8ce6cb7c4 100644 --- a/src/librustc_lint/lib.rs +++ b/src/librustc_lint/lib.rs @@ -21,15 +21,10 @@ #![recursion_limit="256"] -#[macro_use] -extern crate syntax; +#![deny(rust_2018_idioms)] + #[macro_use] extern crate rustc; -#[macro_use] -extern crate log; -extern crate rustc_target; -extern crate syntax_pos; -extern crate rustc_data_structures; mod diagnostics; mod nonstandard_style; @@ -51,7 +46,6 @@ use rustc::lint::builtin::{ parser::ILL_FORMED_ATTRIBUTE_INPUT, }; use rustc::session; -use rustc::util; use rustc::hir; use syntax::ast; diff --git a/src/librustc_lint/nonstandard_style.rs b/src/librustc_lint/nonstandard_style.rs index ae2ed28104e5b..2dbafc7ede2a2 100644 --- a/src/librustc_lint/nonstandard_style.rs +++ b/src/librustc_lint/nonstandard_style.rs @@ -1,6 +1,7 @@ use rustc::hir::{self, GenericParamKind, PatKind}; use rustc::hir::def::Def; use rustc::hir::intravisit::FnKind; +use rustc::lint; use rustc::ty; use rustc_target::spec::abi::Abi; use lint::{EarlyContext, LateContext, LintContext, LintArray}; @@ -17,7 +18,7 @@ pub enum MethodLateContext { PlainImpl, } -pub fn method_context(cx: &LateContext, id: ast::NodeId) -> MethodLateContext { +pub fn method_context(cx: &LateContext<'_, '_>, id: ast::NodeId) -> MethodLateContext { let def_id = cx.tcx.hir().local_def_id(id); let item = cx.tcx.associated_item(def_id); match item.container { @@ -41,7 +42,7 @@ declare_lint! { pub struct NonCamelCaseTypes; impl NonCamelCaseTypes { - fn check_case(&self, cx: &EarlyContext, sort: &str, ident: &Ident) { + fn check_case(&self, cx: &EarlyContext<'_>, sort: &str, ident: &Ident) { fn char_has_case(c: char) -> bool { c.is_lowercase() || c.is_uppercase() } @@ -115,7 +116,7 @@ impl LintPass for NonCamelCaseTypes { } impl EarlyLintPass for NonCamelCaseTypes { - fn check_item(&mut self, cx: &EarlyContext, it: &ast::Item) { + fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) { let has_repr_c = it.attrs .iter() .any(|attr| { @@ -138,11 +139,11 @@ impl EarlyLintPass for NonCamelCaseTypes { } } - fn check_variant(&mut self, cx: &EarlyContext, v: &ast::Variant, _: &ast::Generics) { + fn check_variant(&mut self, cx: &EarlyContext<'_>, v: &ast::Variant, _: &ast::Generics) { self.check_case(cx, "variant", &v.node.ident); } - fn check_generic_param(&mut self, cx: &EarlyContext, param: &ast::GenericParam) { + fn check_generic_param(&mut self, cx: &EarlyContext<'_>, param: &ast::GenericParam) { if let ast::GenericParamKind::Type { .. } = param.kind { self.check_case(cx, "type parameter", ¶m.ident); } @@ -190,7 +191,7 @@ impl NonSnakeCase { } /// Checks if a given identifier is snake case, and reports a diagnostic if not. - fn check_snake_case(&self, cx: &LateContext, sort: &str, ident: &Ident) { + fn check_snake_case(&self, cx: &LateContext<'_, '_>, sort: &str, ident: &Ident) { fn is_snake_case(ident: &str) -> bool { if ident.is_empty() { return true; @@ -249,7 +250,7 @@ impl LintPass for NonSnakeCase { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase { - fn check_crate(&mut self, cx: &LateContext, cr: &hir::Crate) { + fn check_crate(&mut self, cx: &LateContext<'_, '_>, cr: &hir::Crate) { let crate_ident = if let Some(name) = &cx.tcx.sess.opts.crate_name { Some(Ident::from_str(name)) } else { @@ -286,7 +287,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase { } } - fn check_generic_param(&mut self, cx: &LateContext, param: &hir::GenericParam) { + fn check_generic_param(&mut self, cx: &LateContext<'_, '_>, param: &hir::GenericParam) { if let GenericParamKind::Lifetime { .. } = param.kind { self.check_snake_case(cx, "lifetime", ¶m.name.ident()); } @@ -294,8 +295,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase { fn check_fn( &mut self, - cx: &LateContext, - fk: FnKind, + cx: &LateContext<'_, '_>, + fk: FnKind<'_>, _: &hir::FnDecl, _: &hir::Body, _: Span, @@ -324,13 +325,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase { } } - fn check_item(&mut self, cx: &LateContext, it: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { if let hir::ItemKind::Mod(_) = it.node { self.check_snake_case(cx, "module", &it.ident); } } - fn check_trait_item(&mut self, cx: &LateContext, item: &hir::TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'_, '_>, item: &hir::TraitItem) { if let hir::TraitItemKind::Method(_, hir::TraitMethod::Required(pnames)) = &item.node { self.check_snake_case(cx, "trait method", &item.ident); for param_name in pnames { @@ -339,7 +340,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase { } } - fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) { + fn check_pat(&mut self, cx: &LateContext<'_, '_>, p: &hir::Pat) { if let &PatKind::Binding(_, _, _, ident, _) = &p.node { self.check_snake_case(cx, "variable", &ident); } @@ -347,7 +348,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonSnakeCase { fn check_struct_def( &mut self, - cx: &LateContext, + cx: &LateContext<'_, '_>, s: &hir::VariantData, _: ast::Name, _: &hir::Generics, @@ -369,7 +370,7 @@ declare_lint! { pub struct NonUpperCaseGlobals; impl NonUpperCaseGlobals { - fn check_upper_case(cx: &LateContext, sort: &str, ident: &Ident) { + fn check_upper_case(cx: &LateContext<'_, '_>, sort: &str, ident: &Ident) { let name = &ident.name.as_str(); if name.chars().any(|c| c.is_lowercase()) { @@ -399,7 +400,7 @@ impl LintPass for NonUpperCaseGlobals { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals { - fn check_item(&mut self, cx: &LateContext, it: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { match it.node { hir::ItemKind::Static(..) if !attr::contains_name(&it.attrs, "no_mangle") => { NonUpperCaseGlobals::check_upper_case(cx, "static variable", &it.ident); @@ -411,19 +412,19 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals { } } - fn check_trait_item(&mut self, cx: &LateContext, ti: &hir::TraitItem) { + fn check_trait_item(&mut self, cx: &LateContext<'_, '_>, ti: &hir::TraitItem) { if let hir::TraitItemKind::Const(..) = ti.node { NonUpperCaseGlobals::check_upper_case(cx, "associated constant", &ti.ident); } } - fn check_impl_item(&mut self, cx: &LateContext, ii: &hir::ImplItem) { + fn check_impl_item(&mut self, cx: &LateContext<'_, '_>, ii: &hir::ImplItem) { if let hir::ImplItemKind::Const(..) = ii.node { NonUpperCaseGlobals::check_upper_case(cx, "associated constant", &ii.ident); } } - fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) { + fn check_pat(&mut self, cx: &LateContext<'_, '_>, p: &hir::Pat) { // Lint for constants that look like binding identifiers (#7526) if let PatKind::Path(hir::QPath::Resolved(None, ref path)) = p.node { if let Def::Const(..) = path.def { diff --git a/src/librustc_lint/types.rs b/src/librustc_lint/types.rs index 4abd55b7e31f7..f6b7ccfe2ecd8 100644 --- a/src/librustc_lint/types.rs +++ b/src/librustc_lint/types.rs @@ -4,6 +4,7 @@ use rustc::hir::Node; use rustc::ty::subst::Substs; use rustc::ty::{self, AdtKind, ParamEnv, Ty, TyCtxt}; use rustc::ty::layout::{self, IntegerExt, LayoutOf, VariantIdx}; +use rustc::{lint, util}; use rustc_data_structures::indexed_vec::Idx; use util::nodemap::FxHashSet; use lint::{LateContext, LintContext, LintArray}; @@ -23,6 +24,8 @@ use rustc::hir; use rustc::mir::interpret::{sign_extend, truncate}; +use log::debug; + declare_lint! { UNUSED_COMPARISONS, Warn, @@ -241,7 +244,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits { } } - fn check_limits(cx: &LateContext, + fn check_limits(cx: &LateContext<'_, '_>, binop: hir::BinOp, l: &hir::Expr, r: &hir::Expr) @@ -298,7 +301,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits { } } - fn get_bin_hex_repr(cx: &LateContext, lit: &ast::Lit) -> Option { + fn get_bin_hex_repr(cx: &LateContext<'_, '_>, lit: &ast::Lit) -> Option { let src = cx.sess().source_map().span_to_snippet(lit.span).ok()?; let firstch = src.chars().next()?; @@ -320,7 +323,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits { // // No suggestion for: `isize`, `usize`. fn get_type_suggestion<'a>( - t: &ty::TyKind, + t: &ty::TyKind<'_>, val: u128, negative: bool, ) -> Option { @@ -364,9 +367,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TypeLimits { } fn report_bin_hex_error( - cx: &LateContext, + cx: &LateContext<'_, '_>, expr: &hir::Expr, - ty: ty::TyKind, + ty: ty::TyKind<'_>, repr_str: String, val: u128, negative: bool, @@ -481,7 +484,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> { fn check_type_for_ffi(&self, cache: &mut FxHashSet>, ty: Ty<'tcx>) -> FfiResult<'tcx> { - use self::FfiResult::*; + use FfiResult::*; let cx = self.cx.tcx; @@ -799,7 +802,7 @@ impl LintPass for ImproperCTypes { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ImproperCTypes { - fn check_foreign_item(&mut self, cx: &LateContext, it: &hir::ForeignItem) { + fn check_foreign_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::ForeignItem) { let mut vis = ImproperCTypesVisitor { cx }; let abi = cx.tcx.hir().get_foreign_abi(it.id); if abi != Abi::RustIntrinsic && abi != Abi::PlatformIntrinsic { @@ -829,7 +832,7 @@ impl LintPass for VariantSizeDifferences { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for VariantSizeDifferences { - fn check_item(&mut self, cx: &LateContext, it: &hir::Item) { + fn check_item(&mut self, cx: &LateContext<'_, '_>, it: &hir::Item) { if let hir::ItemKind::Enum(ref enum_definition, _) = it.node { let item_def_id = cx.tcx.hir().local_def_id(it.id); let t = cx.tcx.type_of(item_def_id); diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs index acf5da1e1886a..407e684293515 100644 --- a/src/librustc_lint/unused.rs +++ b/src/librustc_lint/unused.rs @@ -1,5 +1,6 @@ use rustc::hir::def::Def; use rustc::hir::def_id::DefId; +use rustc::lint; use rustc::ty; use rustc::ty::adjustment; use lint::{LateContext, EarlyContext, LintContext, LintArray}; @@ -16,6 +17,8 @@ use syntax_pos::Span; use rustc::hir; +use log::debug; + declare_lint! { pub UNUSED_MUST_USE, Warn, @@ -43,7 +46,7 @@ impl LintPass for UnusedResults { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedResults { - fn check_stmt(&mut self, cx: &LateContext, s: &hir::Stmt) { + fn check_stmt(&mut self, cx: &LateContext<'_, '_>, s: &hir::Stmt) { let expr = match s.node { hir::StmtKind::Semi(ref expr) => &**expr, _ => return, @@ -168,7 +171,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedResults { } fn check_must_use( - cx: &LateContext, + cx: &LateContext<'_, '_>, def_id: DefId, sp: Span, descr_pre_path: &str, @@ -212,7 +215,7 @@ impl LintPass for PathStatements { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PathStatements { - fn check_stmt(&mut self, cx: &LateContext, s: &hir::Stmt) { + fn check_stmt(&mut self, cx: &LateContext<'_, '_>, s: &hir::Stmt) { if let hir::StmtKind::Semi(ref expr) = s.node { if let hir::ExprKind::Path(_) = expr.node { cx.span_lint(PATH_STATEMENTS, s.span, "path statement with no effect"); @@ -241,7 +244,7 @@ impl LintPass for UnusedAttributes { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAttributes { - fn check_attribute(&mut self, cx: &LateContext, attr: &ast::Attribute) { + fn check_attribute(&mut self, cx: &LateContext<'_, '_>, attr: &ast::Attribute) { debug!("checking attribute: {:?}", attr); // Note that check_name() marks the attribute as used if it matches. for &(name, ty, ..) in BUILTIN_ATTRIBUTES { @@ -303,7 +306,7 @@ pub struct UnusedParens; impl UnusedParens { fn check_unused_parens_expr(&self, - cx: &EarlyContext, + cx: &EarlyContext<'_>, value: &ast::Expr, msg: &str, followed_by_block: bool) { @@ -325,7 +328,7 @@ impl UnusedParens { } fn check_unused_parens_pat(&self, - cx: &EarlyContext, + cx: &EarlyContext<'_>, value: &ast::Pat, msg: &str) { if let ast::PatKind::Paren(_) = value.node { @@ -339,7 +342,7 @@ impl UnusedParens { } } - fn remove_outer_parens(cx: &EarlyContext, span: Span, pattern: &str, msg: &str) { + fn remove_outer_parens(cx: &EarlyContext<'_>, span: Span, pattern: &str, msg: &str) { let span_msg = format!("unnecessary parentheses around {}", msg); let mut err = cx.struct_span_lint(UNUSED_PARENS, span, &span_msg); let mut ate_left_paren = false; @@ -387,7 +390,7 @@ impl LintPass for UnusedParens { } impl EarlyLintPass for UnusedParens { - fn check_expr(&mut self, cx: &EarlyContext, e: &ast::Expr) { + fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &ast::Expr) { use syntax::ast::ExprKind::*; let (value, msg, followed_by_block) = match e.node { If(ref cond, ..) => (cond, "`if` condition", true), @@ -429,7 +432,7 @@ impl EarlyLintPass for UnusedParens { self.check_unused_parens_expr(cx, &value, msg, followed_by_block); } - fn check_pat(&mut self, cx: &EarlyContext, p: &ast::Pat, _: &mut bool) { + fn check_pat(&mut self, cx: &EarlyContext<'_>, p: &ast::Pat, _: &mut bool) { use ast::PatKind::{Paren, Range}; // The lint visitor will visit each subpattern of `p`. We do not want to lint any range // pattern no matter where it occurs in the pattern. For something like `&(a..=b)`, there @@ -443,7 +446,7 @@ impl EarlyLintPass for UnusedParens { } } - fn check_stmt(&mut self, cx: &EarlyContext, s: &ast::Stmt) { + fn check_stmt(&mut self, cx: &EarlyContext<'_>, s: &ast::Stmt) { if let ast::StmtKind::Local(ref local) = s.node { if let Some(ref value) = local.init { self.check_unused_parens_expr(cx, &value, "assigned value", false); @@ -462,7 +465,7 @@ declare_lint! { pub struct UnusedImportBraces; impl UnusedImportBraces { - fn check_use_tree(&self, cx: &EarlyContext, use_tree: &ast::UseTree, item: &ast::Item) { + fn check_use_tree(&self, cx: &EarlyContext<'_>, use_tree: &ast::UseTree, item: &ast::Item) { if let ast::UseTreeKind::Nested(ref items) = use_tree.kind { // Recursively check nested UseTrees for &(ref tree, _) in items { @@ -509,7 +512,7 @@ impl LintPass for UnusedImportBraces { } impl EarlyLintPass for UnusedImportBraces { - fn check_item(&mut self, cx: &EarlyContext, item: &ast::Item) { + fn check_item(&mut self, cx: &EarlyContext<'_>, item: &ast::Item) { if let ast::ItemKind::Use(ref use_tree) = item.node { self.check_use_tree(cx, use_tree, item); } @@ -536,7 +539,7 @@ impl LintPass for UnusedAllocation { } impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnusedAllocation { - fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) { + fn check_expr(&mut self, cx: &LateContext<'_, '_>, e: &hir::Expr) { match e.node { hir::ExprKind::Box(_) => {} _ => return, From b962ecc6f97cbd6258d1a77041a865aecd6fa3fb Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Fri, 8 Feb 2019 12:38:47 +0100 Subject: [PATCH 208/278] Cleanup JS a bit --- src/librustdoc/html/static/main.js | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js index d6c05de0df6f2..3a59d1f259654 100644 --- a/src/librustdoc/html/static/main.js +++ b/src/librustdoc/html/static/main.js @@ -79,8 +79,6 @@ if (!DOMTokenList.prototype.remove) { // 2 for "In Return Types" var currentTab = 0; - var themesWidth = null; - var titleBeforeSearch = document.title; function getPageId() { @@ -240,7 +238,7 @@ if (!DOMTokenList.prototype.remove) { return String.fromCharCode(c); } - function displayHelp(display, ev) { + function displayHelp(display, ev, help) { if (display === true) { if (hasClass(help, "hidden")) { ev.preventDefault(); @@ -258,7 +256,7 @@ if (!DOMTokenList.prototype.remove) { hideModal(); var search = document.getElementById("search"); if (hasClass(help, "hidden") === false) { - displayHelp(false, ev); + displayHelp(false, ev, help); } else if (hasClass(search, "hidden") === false) { ev.preventDefault(); addClass(search, "hidden"); @@ -289,7 +287,7 @@ if (!DOMTokenList.prototype.remove) { case "s": case "S": - displayHelp(false, ev); + displayHelp(false, ev, help); hideModal(); ev.preventDefault(); focusSearchBar(); @@ -304,7 +302,7 @@ if (!DOMTokenList.prototype.remove) { case "?": if (ev.shiftKey) { hideModal(); - displayHelp(true, ev); + displayHelp(true, ev, help); } break; } @@ -654,7 +652,7 @@ if (!DOMTokenList.prototype.remove) { return MAX_LEV_DISTANCE + 1; } } - return lev_distance;//Math.ceil(total / done); + return Math.ceil(total / done); } } return MAX_LEV_DISTANCE + 1; @@ -2432,7 +2430,7 @@ if (!DOMTokenList.prototype.remove) { // for vertical layout (column-oriented flex layout for divs caused // errors in mobile browsers). if (e.tagName === "H2" || e.tagName === "H3") { - let nextTagName = e.nextElementSibling.tagName; + var nextTagName = e.nextElementSibling.tagName; if (nextTagName == "H2" || nextTagName == "H3") { e.nextElementSibling.style.display = "flex"; } else { From bf531bd4594ad78fe3443554e2b80d7a496faf4a Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 20:40:49 +0900 Subject: [PATCH 209/278] librustc_passes => 2018 --- src/librustc_passes/Cargo.toml | 3 ++- src/librustc_passes/ast_validation.rs | 3 ++- src/librustc_passes/diagnostics.rs | 2 ++ src/librustc_passes/hir_stats.rs | 2 +- src/librustc_passes/lib.rs | 14 +++----------- src/librustc_passes/loops.rs | 5 +++-- src/librustc_passes/rvalue_promotion.rs | 16 ++++++++++------ 7 files changed, 23 insertions(+), 22 deletions(-) diff --git a/src/librustc_passes/Cargo.toml b/src/librustc_passes/Cargo.toml index f5154a033af8d..00bdcdc0cc021 100644 --- a/src/librustc_passes/Cargo.toml +++ b/src/librustc_passes/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_passes" version = "0.0.0" +edition = "2018" [lib] name = "rustc_passes" @@ -16,4 +17,4 @@ rustc_data_structures = { path = "../librustc_data_structures" } syntax = { path = "../libsyntax" } syntax_ext = { path = "../libsyntax_ext" } syntax_pos = { path = "../libsyntax_pos" } -rustc_errors = { path = "../librustc_errors" } +errors = { path = "../librustc_errors", package = "rustc_errors" } diff --git a/src/librustc_passes/ast_validation.rs b/src/librustc_passes/ast_validation.rs index 3deb2ff8d8a0b..4b1cf6a035ef7 100644 --- a/src/librustc_passes/ast_validation.rs +++ b/src/librustc_passes/ast_validation.rs @@ -15,10 +15,11 @@ use syntax::source_map::Spanned; use syntax::symbol::keywords; use syntax::ptr::P; use syntax::visit::{self, Visitor}; +use syntax::{span_err, struct_span_err, walk_list}; use syntax_ext::proc_macro_decls::is_proc_macro_attr; use syntax_pos::Span; -use errors; use errors::Applicability; +use log::debug; struct AstValidator<'a> { session: &'a Session, diff --git a/src/librustc_passes/diagnostics.rs b/src/librustc_passes/diagnostics.rs index 037227aeb715d..19d4d3aeb0f65 100644 --- a/src/librustc_passes/diagnostics.rs +++ b/src/librustc_passes/diagnostics.rs @@ -1,5 +1,7 @@ #![allow(non_snake_case)] +use syntax::{register_diagnostic, register_diagnostics, register_long_diagnostics}; + register_long_diagnostics! { /* E0014: r##" diff --git a/src/librustc_passes/hir_stats.rs b/src/librustc_passes/hir_stats.rs index 74d6d75a7f528..2427abad07c95 100644 --- a/src/librustc_passes/hir_stats.rs +++ b/src/librustc_passes/hir_stats.rs @@ -61,7 +61,7 @@ impl<'k> StatCollector<'k> { }); entry.count += 1; - entry.size = ::std::mem::size_of_val(node); + entry.size = std::mem::size_of_val(node); } fn print(&self, title: &str) { diff --git a/src/librustc_passes/lib.rs b/src/librustc_passes/lib.rs index 76605c58a7889..7b0e57846f360 100644 --- a/src/librustc_passes/lib.rs +++ b/src/librustc_passes/lib.rs @@ -13,18 +13,10 @@ #![recursion_limit="256"] -#[macro_use] -extern crate rustc; -extern crate rustc_mir; -extern crate rustc_data_structures; +#![deny(rust_2018_idioms)] #[macro_use] -extern crate log; -#[macro_use] -extern crate syntax; -extern crate syntax_ext; -extern crate syntax_pos; -extern crate rustc_errors as errors; +extern crate rustc; use rustc::ty::query::Providers; @@ -38,7 +30,7 @@ pub mod loops; __build_diagnostic_array! { librustc_passes, DIAGNOSTICS } -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { rvalue_promotion::provide(providers); loops::provide(providers); } diff --git a/src/librustc_passes/loops.rs b/src/librustc_passes/loops.rs index f05a7be7d7513..533e043efa9d2 100644 --- a/src/librustc_passes/loops.rs +++ b/src/librustc_passes/loops.rs @@ -1,4 +1,4 @@ -use self::Context::*; +use Context::*; use rustc::session::Session; @@ -9,6 +9,7 @@ use rustc::hir::map::Map; use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap}; use rustc::hir::{self, Node, Destination}; use syntax::ast; +use syntax::struct_span_err; use syntax_pos::Span; use errors::Applicability; @@ -59,7 +60,7 @@ fn check_mod_loops<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId) { }.as_deep_visitor()); } -pub(crate) fn provide(providers: &mut Providers) { +pub(crate) fn provide(providers: &mut Providers<'_>) { *providers = Providers { check_mod_loops, ..*providers diff --git a/src/librustc_passes/rvalue_promotion.rs b/src/librustc_passes/rvalue_promotion.rs index c11b1af97766d..748500ac46b57 100644 --- a/src/librustc_passes/rvalue_promotion.rs +++ b/src/librustc_passes/rvalue_promotion.rs @@ -28,10 +28,11 @@ use rustc::hir; use rustc_data_structures::sync::Lrc; use syntax::ast; use syntax_pos::{Span, DUMMY_SP}; -use self::Promotability::*; +use log::debug; +use Promotability::*; use std::ops::{BitAnd, BitAndAssign, BitOr}; -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { *providers = Providers { rvalue_promotable_map, const_is_rvalue_promotable_to_static, @@ -622,7 +623,7 @@ impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'gcx> { fn consume(&mut self, _consume_id: ast::NodeId, _consume_span: Span, - _cmt: &mc::cmt_, + _cmt: &mc::cmt_<'_>, _mode: euv::ConsumeMode) {} fn borrow(&mut self, @@ -681,11 +682,14 @@ impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'gcx> { fn mutate(&mut self, _assignment_id: ast::NodeId, _assignment_span: Span, - _assignee_cmt: &mc::cmt_, + _assignee_cmt: &mc::cmt_<'_>, _mode: euv::MutateMode) { } - fn matched_pat(&mut self, _: &hir::Pat, _: &mc::cmt_, _: euv::MatchMode) {} + fn matched_pat(&mut self, _: &hir::Pat, _: &mc::cmt_<'_>, _: euv::MatchMode) {} - fn consume_pat(&mut self, _consume_pat: &hir::Pat, _cmt: &mc::cmt_, _mode: euv::ConsumeMode) {} + fn consume_pat(&mut self, + _consume_pat: &hir::Pat, + _cmt: &mc::cmt_<'_>, + _mode: euv::ConsumeMode) {} } From 7267bc2d4a0ba006d63b58eb927362d620930c68 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 20:50:17 +0900 Subject: [PATCH 210/278] librustc_metadata => 2018 --- src/librustc_metadata/Cargo.toml | 3 ++- src/librustc_metadata/creader.rs | 19 +++++++++-------- src/librustc_metadata/cstore.rs | 4 ++-- src/librustc_metadata/cstore_impl.rs | 16 +++++++------- src/librustc_metadata/decoder.rs | 7 +++--- src/librustc_metadata/diagnostics.rs | 2 ++ src/librustc_metadata/dynamic_lib.rs | 2 -- src/librustc_metadata/encoder.rs | 11 +++++----- src/librustc_metadata/index.rs | 7 +++--- src/librustc_metadata/index_builder.rs | 26 +++++++++++------------ src/librustc_metadata/isolated_encoder.rs | 4 ++-- src/librustc_metadata/lib.rs | 14 +++--------- src/librustc_metadata/locator.rs | 13 +++++++----- src/librustc_metadata/native_libs.rs | 1 + src/librustc_metadata/schema.rs | 4 ++-- 15 files changed, 67 insertions(+), 66 deletions(-) diff --git a/src/librustc_metadata/Cargo.toml b/src/librustc_metadata/Cargo.toml index 337c87c24ba2b..e234f4f880703 100644 --- a/src/librustc_metadata/Cargo.toml +++ b/src/librustc_metadata/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_metadata" version = "0.0.0" +edition = "2018" [lib] name = "rustc_metadata" @@ -14,7 +15,7 @@ log = "0.4" memmap = "0.6" rustc = { path = "../librustc" } rustc_data_structures = { path = "../librustc_data_structures" } -rustc_errors = { path = "../librustc_errors" } +errors = { path = "../librustc_errors", package = "rustc_errors" } rustc_target = { path = "../librustc_target" } serialize = { path = "../libserialize" } stable_deref_trait = "1.0.0" diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs index e9785e7c88d0d..0b4c8a5367c15 100644 --- a/src/librustc_metadata/creader.rs +++ b/src/librustc_metadata/creader.rs @@ -1,9 +1,9 @@ //! Validates all used crates and extern libraries and loads their metadata -use cstore::{self, CStore, CrateSource, MetadataBlob}; -use locator::{self, CratePaths}; -use decoder::proc_macro_def_path_table; -use schema::CrateRoot; +use crate::cstore::{self, CStore, CrateSource, MetadataBlob}; +use crate::locator::{self, CratePaths}; +use crate::decoder::proc_macro_def_path_table; +use crate::schema::CrateRoot; use rustc_data_structures::sync::{Lrc, RwLock, Lock}; use rustc::hir::def_id::CrateNum; @@ -29,8 +29,9 @@ use syntax::attr; use syntax::ext::base::SyntaxExtension; use syntax::symbol::Symbol; use syntax::visit; +use syntax::{span_err, span_fatal}; use syntax_pos::{Span, DUMMY_SP}; -use log; +use log::{debug, info, log_enabled}; pub struct Library { pub dylib: Option<(PathBuf, PathKind)>, @@ -342,7 +343,7 @@ impl<'a> CrateLoader<'a> { } } - fn load(&mut self, locate_ctxt: &mut locator::Context) -> Option { + fn load(&mut self, locate_ctxt: &mut locator::Context<'_>) -> Option { let library = locate_ctxt.maybe_load_library_crate()?; // In the case that we're loading a crate, but not matching @@ -427,7 +428,7 @@ impl<'a> CrateLoader<'a> { // The map from crate numbers in the crate we're resolving to local crate numbers. // We map 0 and all other holes in the map to our parent crate. The "additional" // self-dependencies should be harmless. - ::std::iter::once(krate).chain(crate_root.crate_deps + std::iter::once(krate).chain(crate_root.crate_deps .decode(metadata) .map(|dep| { info!("resolving dep crate {} hash: `{}` extra filename: `{}`", dep.name, dep.hash, @@ -522,7 +523,7 @@ impl<'a> CrateLoader<'a> { fn load_derive_macros(&mut self, root: &CrateRoot, dylib: Option, span: Span) -> Vec<(ast::Name, Lrc)> { use std::{env, mem}; - use dynamic_lib::DynamicLibrary; + use crate::dynamic_lib::DynamicLibrary; use proc_macro::bridge::client::ProcMacro; use syntax_ext::deriving::custom::ProcMacroDerive; use syntax_ext::proc_macro_impl::{AttrProcMacro, BangProcMacro}; @@ -996,7 +997,7 @@ impl<'a> CrateLoader<'a> { item.ident, orig_name); let orig_name = match orig_name { Some(orig_name) => { - ::validate_crate_name(Some(self.sess), &orig_name.as_str(), + crate::validate_crate_name(Some(self.sess), &orig_name.as_str(), Some(item.span)); orig_name } diff --git a/src/librustc_metadata/cstore.rs b/src/librustc_metadata/cstore.rs index 543fb5d5df5be..a2f69bc45634d 100644 --- a/src/librustc_metadata/cstore.rs +++ b/src/librustc_metadata/cstore.rs @@ -1,7 +1,7 @@ // The crate store - a central repo for information collected about external // crates and libraries -use schema; +use crate::schema; use rustc::hir::def_id::{CrateNum, DefIndex}; use rustc::hir::map::definitions::DefPathTable; use rustc::middle::cstore::{DepKind, ExternCrate, MetadataLoader}; @@ -19,7 +19,7 @@ pub use rustc::middle::cstore::{NativeLibrary, NativeLibraryKind, LinkagePrefere pub use rustc::middle::cstore::NativeLibraryKind::*; pub use rustc::middle::cstore::{CrateSource, LibSource, ForeignModule}; -pub use cstore_impl::{provide, provide_extern}; +pub use crate::cstore_impl::{provide, provide_extern}; // A map from external crate numbers (as decoded from some crate file) to // local crate numbers (as generated during this session). Each external diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index e61229db86ddb..49a3e335e3417 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -1,9 +1,9 @@ -use cstore::{self, LoadedMacro}; -use encoder; -use link_args; -use native_libs; -use foreign_modules; -use schema; +use crate::cstore::{self, LoadedMacro}; +use crate::encoder; +use crate::link_args; +use crate::native_libs; +use crate::foreign_modules; +use crate::schema; use rustc::ty::query::QueryConfig; use rustc::middle::cstore::{CrateStore, DepKind, @@ -51,7 +51,7 @@ macro_rules! provide { index: CRATE_DEF_INDEX }); let dep_node = def_path_hash - .to_dep_node(::rustc::dep_graph::DepKind::CrateMetadata); + .to_dep_node(rustc::dep_graph::DepKind::CrateMetadata); // The DepNodeIndex of the DepNode::CrateMetadata should be // cached somewhere, so that we can use read_index(). $tcx.dep_graph.read(dep_node); @@ -421,7 +421,7 @@ impl cstore::CStore { use syntax::ext::base::SyntaxExtension; use syntax_ext::proc_macro_impl::BangProcMacro; - let client = ::proc_macro::bridge::client::Client::expand1(::proc_macro::quote); + let client = proc_macro::bridge::client::Client::expand1(proc_macro::quote); let ext = SyntaxExtension::ProcMacro { expander: Box::new(BangProcMacro { client }), allow_internal_unstable: true, diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index ad6296e1a3bd8..6d7907b096ac6 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -1,7 +1,7 @@ // Decoding metadata from a single crate's metadata -use cstore::{self, CrateMetadata, MetadataBlob, NativeLibrary, ForeignModule}; -use schema::*; +use crate::cstore::{self, CrateMetadata, MetadataBlob, NativeLibrary, ForeignModule}; +use crate::schema::*; use rustc_data_structures::sync::{Lrc, ReadGuard}; use rustc::hir::map::{DefKey, DefPath, DefPathData, DefPathHash, Definitions}; @@ -34,6 +34,7 @@ use syntax::symbol::InternedString; use syntax::ext::base::{MacroKind, SyntaxExtension}; use syntax::ext::hygiene::Mark; use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP, NO_EXPANSION}; +use log::debug; pub struct DecodeContext<'a, 'tcx: 'a> { opaque: opaque::Decoder<'a>, @@ -545,7 +546,7 @@ impl<'a, 'tcx> CrateMetadata { fn get_variant(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - item: &Entry, + item: &Entry<'_>, index: DefIndex, adt_kind: ty::AdtKind) -> ty::VariantDef diff --git a/src/librustc_metadata/diagnostics.rs b/src/librustc_metadata/diagnostics.rs index 1b1852434740c..c27d13be49358 100644 --- a/src/librustc_metadata/diagnostics.rs +++ b/src/librustc_metadata/diagnostics.rs @@ -1,5 +1,7 @@ #![allow(non_snake_case)] +use syntax::{register_diagnostic, register_diagnostics, register_long_diagnostics}; + register_long_diagnostics! { E0454: r##" A link name was given with an empty name. Erroneous code example: diff --git a/src/librustc_metadata/dynamic_lib.rs b/src/librustc_metadata/dynamic_lib.rs index 7d1c3c09d33e9..b9dc4195cb228 100644 --- a/src/librustc_metadata/dynamic_lib.rs +++ b/src/librustc_metadata/dynamic_lib.rs @@ -76,7 +76,6 @@ impl DynamicLibrary { #[cfg(test)] mod tests { use super::*; - use libc; use std::mem; #[test] @@ -127,7 +126,6 @@ mod tests { #[cfg(unix)] mod dl { - use libc; use std::ffi::{CStr, OsStr, CString}; use std::os::unix::prelude::*; use std::ptr; diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index 3b212f3b7472d..d68ab9750b970 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -1,7 +1,7 @@ -use index::Index; -use index_builder::{FromId, IndexBuilder, Untracked}; -use isolated_encoder::IsolatedEncoder; -use schema::*; +use crate::index::Index; +use crate::index_builder::{FromId, IndexBuilder, Untracked}; +use crate::isolated_encoder::IsolatedEncoder; +use crate::schema::*; use rustc::middle::cstore::{LinkagePreference, NativeLibrary, EncodedMetadata, ForeignModule}; @@ -34,6 +34,7 @@ use syntax::attr; use syntax::source_map::Spanned; use syntax::symbol::keywords; use syntax_pos::{self, hygiene, FileName, SourceFile, Span}; +use log::{debug, trace}; use rustc::hir::{self, PatKind}; use rustc::hir::itemlikevisit::ItemLikeVisitor; @@ -1521,7 +1522,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { // symbol associated with them (they weren't translated) or if they're an FFI // definition (as that's not defined in this crate). fn encode_exported_symbols(&mut self, - exported_symbols: &[(ExportedSymbol, SymbolExportLevel)]) + exported_symbols: &[(ExportedSymbol<'_>, SymbolExportLevel)]) -> EncodedExportedSymbols { // The metadata symbol name is special. It should not show up in // downstream crates. diff --git a/src/librustc_metadata/index.rs b/src/librustc_metadata/index.rs index ccf398241b191..18f30383090cd 100644 --- a/src/librustc_metadata/index.rs +++ b/src/librustc_metadata/index.rs @@ -1,9 +1,10 @@ -use schema::*; +use crate::schema::*; use rustc::hir::def_id::{DefId, DefIndex, DefIndexAddressSpace}; use rustc_serialize::opaque::Encoder; use std::slice; use std::u32; +use log::debug; /// While we are generating the metadata, we also track the position /// of each DefIndex. It is not required that all definitions appear @@ -24,12 +25,12 @@ impl Index { } } - pub fn record(&mut self, def_id: DefId, entry: Lazy) { + pub fn record(&mut self, def_id: DefId, entry: Lazy>) { assert!(def_id.is_local()); self.record_index(def_id.index, entry); } - pub fn record_index(&mut self, item: DefIndex, entry: Lazy) { + pub fn record_index(&mut self, item: DefIndex, entry: Lazy>) { assert!(entry.position < (u32::MAX as usize)); let position = entry.position as u32; let space_index = item.address_space().index(); diff --git a/src/librustc_metadata/index_builder.rs b/src/librustc_metadata/index_builder.rs index 3608b12aea934..4175f7acd0688 100644 --- a/src/librustc_metadata/index_builder.rs +++ b/src/librustc_metadata/index_builder.rs @@ -45,10 +45,10 @@ //! give a callback fn, rather than taking a closure: it allows us to //! easily control precisely what data is given to that fn. -use encoder::EncodeContext; -use index::Index; -use schema::*; -use isolated_encoder::IsolatedEncoder; +use crate::encoder::EncodeContext; +use crate::index::Index; +use crate::schema::*; +use crate::isolated_encoder::IsolatedEncoder; use rustc::hir; use rustc::hir::def_id::DefId; @@ -133,21 +133,21 @@ impl<'a, 'b, 'tcx> IndexBuilder<'a, 'b, 'tcx> { /// `DefId` index, or implement the `read` method so that it can add /// a read of whatever dep-graph nodes are appropriate. pub trait DepGraphRead { - fn read(&self, tcx: TyCtxt); + fn read(&self, tcx: TyCtxt<'_, '_, '_>); } impl DepGraphRead for DefId { - fn read(&self, _tcx: TyCtxt) {} + fn read(&self, _tcx: TyCtxt<'_, '_, '_>) {} } impl DepGraphRead for ast::NodeId { - fn read(&self, _tcx: TyCtxt) {} + fn read(&self, _tcx: TyCtxt<'_, '_, '_>) {} } impl DepGraphRead for Option where T: DepGraphRead { - fn read(&self, tcx: TyCtxt) { + fn read(&self, tcx: TyCtxt<'_, '_, '_>) { match *self { Some(ref v) => v.read(tcx), None => (), @@ -158,7 +158,7 @@ impl DepGraphRead for Option impl DepGraphRead for [T] where T: DepGraphRead { - fn read(&self, tcx: TyCtxt) { + fn read(&self, tcx: TyCtxt<'_, '_, '_>) { for i in self { i.read(tcx); } @@ -171,7 +171,7 @@ macro_rules! read_tuple { where $($name: DepGraphRead),* { #[allow(non_snake_case)] - fn read(&self, tcx: TyCtxt) { + fn read(&self, tcx: TyCtxt<'_, '_, '_>) { let &($(ref $name),*) = self; $($name.read(tcx);)* } @@ -184,7 +184,7 @@ read_tuple!(A, B, C); macro_rules! read_hir { ($t:ty) => { impl<'tcx> DepGraphRead for &'tcx $t { - fn read(&self, tcx: TyCtxt) { + fn read(&self, tcx: TyCtxt<'_, '_, '_>) { tcx.hir().read(self.id); } } @@ -208,7 +208,7 @@ read_hir!(hir::MacroDef); pub struct Untracked(pub T); impl DepGraphRead for Untracked { - fn read(&self, _tcx: TyCtxt) {} + fn read(&self, _tcx: TyCtxt<'_, '_, '_>) {} } /// Newtype that can be used to package up misc data extracted from a @@ -218,7 +218,7 @@ impl DepGraphRead for Untracked { pub struct FromId(pub ast::NodeId, pub T); impl DepGraphRead for FromId { - fn read(&self, tcx: TyCtxt) { + fn read(&self, tcx: TyCtxt<'_, '_, '_>) { tcx.hir().read(self.0); } } diff --git a/src/librustc_metadata/isolated_encoder.rs b/src/librustc_metadata/isolated_encoder.rs index c09d35d150a12..e879a73e650bb 100644 --- a/src/librustc_metadata/isolated_encoder.rs +++ b/src/librustc_metadata/isolated_encoder.rs @@ -1,5 +1,5 @@ -use encoder::EncodeContext; -use schema::{Lazy, LazySeq}; +use crate::encoder::EncodeContext; +use crate::schema::{Lazy, LazySeq}; use rustc::ty::TyCtxt; use rustc_serialize::Encodable; diff --git a/src/librustc_metadata/lib.rs b/src/librustc_metadata/lib.rs index 1a6614212407d..c8891296417d8 100644 --- a/src/librustc_metadata/lib.rs +++ b/src/librustc_metadata/lib.rs @@ -15,23 +15,15 @@ #![recursion_limit="256"] +#![deny(rust_2018_idioms)] + extern crate libc; -#[macro_use] -extern crate log; -extern crate memmap; -extern crate stable_deref_trait; -#[macro_use] -extern crate syntax; -extern crate syntax_pos; -extern crate flate2; +#[allow(unused_extern_crates)] extern crate serialize as rustc_serialize; // used by deriving -extern crate rustc_errors as errors; -extern crate syntax_ext; extern crate proc_macro; #[macro_use] extern crate rustc; -extern crate rustc_target; #[macro_use] extern crate rustc_data_structures; diff --git a/src/librustc_metadata/locator.rs b/src/librustc_metadata/locator.rs index 6b49d6b9e52cb..f120072b37c05 100644 --- a/src/librustc_metadata/locator.rs +++ b/src/librustc_metadata/locator.rs @@ -212,9 +212,9 @@ //! no means all of the necessary details. Take a look at the rest of //! metadata::locator or metadata::creader for all the juicy details! -use cstore::{MetadataRef, MetadataBlob}; -use creader::Library; -use schema::{METADATA_HEADER, rustc_version}; +use crate::cstore::{MetadataRef, MetadataBlob}; +use crate::creader::Library; +use crate::schema::{METADATA_HEADER, rustc_version}; use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::svh::Svh; @@ -226,6 +226,7 @@ use rustc::util::nodemap::FxHashMap; use errors::DiagnosticBuilder; use syntax::symbol::Symbol; +use syntax::struct_span_err; use syntax_pos::Span; use rustc_target::spec::{Target, TargetTriple}; @@ -241,6 +242,8 @@ use flate2::read::DeflateDecoder; use rustc_data_structures::owning_ref::OwningRef; +use log::{debug, info, warn}; + pub struct CrateMismatch { path: PathBuf, got: String, @@ -283,7 +286,7 @@ enum CrateFlavor { } impl fmt::Display for CrateFlavor { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.write_str(match *self { CrateFlavor::Rlib => "rlib", CrateFlavor::Rmeta => "rmeta", @@ -600,7 +603,7 @@ impl<'a> Context<'a> { } } - let mut err: Option = None; + let mut err: Option> = None; for (lib, kind) in m { info!("{} reading metadata from: {}", flavor, lib.display()); let (hash, metadata) = diff --git a/src/librustc_metadata/native_libs.rs b/src/librustc_metadata/native_libs.rs index 1f00086e32fe1..118fb203c69a1 100644 --- a/src/librustc_metadata/native_libs.rs +++ b/src/librustc_metadata/native_libs.rs @@ -9,6 +9,7 @@ use syntax::attr; use syntax::source_map::Span; use syntax::feature_gate::{self, GateIssue}; use syntax::symbol::Symbol; +use syntax::{span_err, struct_span_err}; pub fn collect<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec { let mut collector = Collector { diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs index f3ff9747625f5..af79ea37dff55 100644 --- a/src/librustc_metadata/schema.rs +++ b/src/librustc_metadata/schema.rs @@ -1,4 +1,4 @@ -use index; +use crate::index; use rustc::hir; use rustc::hir::def::{self, CtorKind}; @@ -518,7 +518,7 @@ pub enum AssociatedContainer { ImplFinal, } -impl_stable_hash_for!(enum ::schema::AssociatedContainer { +impl_stable_hash_for!(enum crate::schema::AssociatedContainer { TraitRequired, TraitWithDefault, ImplDefault, From fed677e56fadde3cbdc2a7161765165407be47b6 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 20:55:12 +0900 Subject: [PATCH 211/278] librustc_cratesio_shim => 2018 --- src/librustc_cratesio_shim/Cargo.toml | 1 + src/librustc_cratesio_shim/src/lib.rs | 2 ++ 2 files changed, 3 insertions(+) diff --git a/src/librustc_cratesio_shim/Cargo.toml b/src/librustc_cratesio_shim/Cargo.toml index b8e494e4040ec..6bdfbe09354b4 100644 --- a/src/librustc_cratesio_shim/Cargo.toml +++ b/src/librustc_cratesio_shim/Cargo.toml @@ -15,6 +15,7 @@ authors = ["The Rust Project Developers"] name = "rustc_cratesio_shim" version = "0.0.0" +edition = "2018" [lib] crate-type = ["dylib"] diff --git a/src/librustc_cratesio_shim/src/lib.rs b/src/librustc_cratesio_shim/src/lib.rs index 4024087f4d3ef..4c170f4f5f6f9 100644 --- a/src/librustc_cratesio_shim/src/lib.rs +++ b/src/librustc_cratesio_shim/src/lib.rs @@ -1,3 +1,5 @@ +#![deny(rust_2018_idioms)] + // See Cargo.toml for a comment explaining this crate. #![allow(unused_extern_crates)] From a7241c8ca6e37d4861c0ddc5639aee9d66fdbe8f Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 21:00:07 +0900 Subject: [PATCH 212/278] librustc_target => 2018 --- src/librustc_target/Cargo.toml | 1 + src/librustc_target/abi/call/aarch64.rs | 4 ++-- src/librustc_target/abi/call/amdgpu.rs | 4 ++-- src/librustc_target/abi/call/arm.rs | 6 +++--- src/librustc_target/abi/call/asmjs.rs | 6 +++--- src/librustc_target/abi/call/hexagon.rs | 8 ++++---- src/librustc_target/abi/call/mips.rs | 10 +++++----- src/librustc_target/abi/call/mips64.rs | 6 +++--- src/librustc_target/abi/call/mod.rs | 18 +++++++++--------- src/librustc_target/abi/call/msp430.rs | 8 ++++---- src/librustc_target/abi/call/nvptx.rs | 8 ++++---- src/librustc_target/abi/call/nvptx64.rs | 8 ++++---- src/librustc_target/abi/call/powerpc.rs | 10 +++++----- src/librustc_target/abi/call/powerpc64.rs | 8 ++++---- src/librustc_target/abi/call/riscv.rs | 8 ++++---- src/librustc_target/abi/call/s390x.rs | 6 +++--- src/librustc_target/abi/call/sparc.rs | 10 +++++----- src/librustc_target/abi/call/sparc64.rs | 4 ++-- src/librustc_target/abi/call/wasm32.rs | 8 ++++---- src/librustc_target/abi/call/x86.rs | 6 +++--- src/librustc_target/abi/call/x86_64.rs | 4 ++-- src/librustc_target/abi/call/x86_win64.rs | 8 ++++---- src/librustc_target/abi/mod.rs | 10 +++++----- src/librustc_target/lib.rs | 6 +++--- src/librustc_target/spec/aarch64_apple_ios.rs | 2 +- src/librustc_target/spec/aarch64_fuchsia.rs | 2 +- .../spec/aarch64_linux_android.rs | 2 +- .../spec/aarch64_pc_windows_msvc.rs | 2 +- .../spec/aarch64_unknown_cloudabi.rs | 2 +- .../spec/aarch64_unknown_freebsd.rs | 2 +- .../spec/aarch64_unknown_hermit.rs | 2 +- .../spec/aarch64_unknown_linux_gnu.rs | 2 +- .../spec/aarch64_unknown_linux_musl.rs | 2 +- .../spec/aarch64_unknown_netbsd.rs | 2 +- .../spec/aarch64_unknown_openbsd.rs | 2 +- src/librustc_target/spec/abi.rs | 2 +- src/librustc_target/spec/android_base.rs | 2 +- src/librustc_target/spec/apple_base.rs | 2 +- src/librustc_target/spec/apple_ios_base.rs | 4 ++-- src/librustc_target/spec/arm_base.rs | 2 +- .../spec/arm_linux_androideabi.rs | 2 +- .../spec/arm_unknown_linux_gnueabi.rs | 2 +- .../spec/arm_unknown_linux_gnueabihf.rs | 2 +- .../spec/arm_unknown_linux_musleabi.rs | 2 +- .../spec/arm_unknown_linux_musleabihf.rs | 2 +- src/librustc_target/spec/armebv7r_none_eabi.rs | 2 +- .../spec/armebv7r_none_eabihf.rs | 2 +- .../spec/armv4t_unknown_linux_gnueabi.rs | 2 +- .../spec/armv5te_unknown_linux_gnueabi.rs | 2 +- .../spec/armv5te_unknown_linux_musleabi.rs | 2 +- .../spec/armv6_unknown_netbsd_eabihf.rs | 2 +- src/librustc_target/spec/armv7_apple_ios.rs | 2 +- .../spec/armv7_linux_androideabi.rs | 2 +- .../spec/armv7_unknown_cloudabi_eabihf.rs | 2 +- .../spec/armv7_unknown_linux_gnueabihf.rs | 2 +- .../spec/armv7_unknown_linux_musleabihf.rs | 2 +- .../spec/armv7_unknown_netbsd_eabihf.rs | 2 +- src/librustc_target/spec/armv7r_none_eabi.rs | 2 +- src/librustc_target/spec/armv7r_none_eabihf.rs | 2 +- src/librustc_target/spec/armv7s_apple_ios.rs | 2 +- src/librustc_target/spec/bitrig_base.rs | 2 +- src/librustc_target/spec/cloudabi_base.rs | 2 +- src/librustc_target/spec/dragonfly_base.rs | 2 +- src/librustc_target/spec/freebsd_base.rs | 2 +- src/librustc_target/spec/fuchsia_base.rs | 2 +- src/librustc_target/spec/haiku_base.rs | 2 +- src/librustc_target/spec/hermit_base.rs | 2 +- src/librustc_target/spec/i386_apple_ios.rs | 2 +- .../spec/i586_pc_windows_msvc.rs | 2 +- .../spec/i586_unknown_linux_gnu.rs | 2 +- .../spec/i586_unknown_linux_musl.rs | 2 +- src/librustc_target/spec/i686_apple_darwin.rs | 2 +- src/librustc_target/spec/i686_linux_android.rs | 2 +- .../spec/i686_pc_windows_gnu.rs | 2 +- .../spec/i686_pc_windows_msvc.rs | 2 +- .../spec/i686_unknown_cloudabi.rs | 2 +- .../spec/i686_unknown_dragonfly.rs | 2 +- .../spec/i686_unknown_freebsd.rs | 2 +- src/librustc_target/spec/i686_unknown_haiku.rs | 2 +- .../spec/i686_unknown_linux_gnu.rs | 2 +- .../spec/i686_unknown_linux_musl.rs | 2 +- .../spec/i686_unknown_netbsd.rs | 2 +- .../spec/i686_unknown_openbsd.rs | 2 +- src/librustc_target/spec/l4re_base.rs | 2 +- src/librustc_target/spec/linux_base.rs | 2 +- src/librustc_target/spec/linux_musl_base.rs | 2 +- .../spec/mips64_unknown_linux_gnuabi64.rs | 2 +- .../spec/mips64el_unknown_linux_gnuabi64.rs | 2 +- .../spec/mips_unknown_linux_gnu.rs | 2 +- .../spec/mips_unknown_linux_musl.rs | 2 +- .../spec/mips_unknown_linux_uclibc.rs | 2 +- .../spec/mipsel_unknown_linux_gnu.rs | 2 +- .../spec/mipsel_unknown_linux_musl.rs | 2 +- .../spec/mipsel_unknown_linux_uclibc.rs | 2 +- src/librustc_target/spec/mod.rs | 4 ++-- src/librustc_target/spec/msp430_none_elf.rs | 2 +- src/librustc_target/spec/netbsd_base.rs | 2 +- .../spec/nvptx64_nvidia_cuda.rs | 4 ++-- src/librustc_target/spec/openbsd_base.rs | 2 +- .../spec/powerpc64_unknown_freebsd.rs | 2 +- .../spec/powerpc64_unknown_linux_gnu.rs | 2 +- .../spec/powerpc64_unknown_linux_musl.rs | 2 +- .../spec/powerpc64le_unknown_linux_gnu.rs | 2 +- .../spec/powerpc64le_unknown_linux_musl.rs | 2 +- .../spec/powerpc_unknown_linux_gnu.rs | 2 +- .../spec/powerpc_unknown_linux_gnuspe.rs | 2 +- .../spec/powerpc_unknown_linux_musl.rs | 2 +- .../spec/powerpc_unknown_netbsd.rs | 2 +- src/librustc_target/spec/redox_base.rs | 2 +- .../spec/riscv32imac_unknown_none_elf.rs | 2 +- .../spec/riscv32imc_unknown_none_elf.rs | 2 +- src/librustc_target/spec/riscv_base.rs | 2 +- .../spec/s390x_unknown_linux_gnu.rs | 2 +- src/librustc_target/spec/solaris_base.rs | 2 +- .../spec/sparc64_unknown_linux_gnu.rs | 2 +- .../spec/sparc64_unknown_netbsd.rs | 2 +- .../spec/sparc_unknown_linux_gnu.rs | 2 +- .../spec/sparcv9_sun_solaris.rs | 2 +- src/librustc_target/spec/thumb_base.rs | 2 +- src/librustc_target/spec/thumbv6m_none_eabi.rs | 2 +- .../spec/thumbv7a_pc_windows_msvc.rs | 2 +- .../spec/thumbv7em_none_eabi.rs | 2 +- .../spec/thumbv7em_none_eabihf.rs | 2 +- src/librustc_target/spec/thumbv7m_none_eabi.rs | 2 +- .../spec/thumbv7neon_linux_androideabi.rs | 2 +- .../thumbv7neon_unknown_linux_gnueabihf.rs | 2 +- .../spec/thumbv8m_base_none_eabi.rs | 2 +- .../spec/thumbv8m_main_none_eabi.rs | 2 +- .../spec/thumbv8m_main_none_eabihf.rs | 2 +- src/librustc_target/spec/uefi_base.rs | 2 +- src/librustc_target/spec/windows_base.rs | 2 +- src/librustc_target/spec/windows_msvc_base.rs | 2 +- .../spec/x86_64_apple_darwin.rs | 2 +- src/librustc_target/spec/x86_64_apple_ios.rs | 2 +- src/librustc_target/spec/x86_64_fuchsia.rs | 2 +- .../spec/x86_64_linux_android.rs | 2 +- .../spec/x86_64_pc_windows_gnu.rs | 2 +- .../spec/x86_64_pc_windows_msvc.rs | 2 +- .../spec/x86_64_rumprun_netbsd.rs | 2 +- src/librustc_target/spec/x86_64_sun_solaris.rs | 2 +- .../spec/x86_64_unknown_bitrig.rs | 2 +- .../spec/x86_64_unknown_cloudabi.rs | 2 +- .../spec/x86_64_unknown_dragonfly.rs | 2 +- .../spec/x86_64_unknown_freebsd.rs | 2 +- .../spec/x86_64_unknown_haiku.rs | 2 +- .../spec/x86_64_unknown_hermit.rs | 2 +- .../spec/x86_64_unknown_l4re_uclibc.rs | 2 +- .../spec/x86_64_unknown_linux_gnu.rs | 2 +- .../spec/x86_64_unknown_linux_gnux32.rs | 2 +- .../spec/x86_64_unknown_linux_musl.rs | 2 +- .../spec/x86_64_unknown_netbsd.rs | 2 +- .../spec/x86_64_unknown_openbsd.rs | 2 +- .../spec/x86_64_unknown_redox.rs | 2 +- .../spec/x86_64_unknown_uefi.rs | 2 +- 154 files changed, 221 insertions(+), 220 deletions(-) diff --git a/src/librustc_target/Cargo.toml b/src/librustc_target/Cargo.toml index dfdd7f0ae58e5..ecea15a992250 100644 --- a/src/librustc_target/Cargo.toml +++ b/src/librustc_target/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_target" version = "0.0.0" +edition = "2018" [lib] name = "rustc_target" diff --git a/src/librustc_target/abi/call/aarch64.rs b/src/librustc_target/abi/call/aarch64.rs index 9f9bba14b963e..f50ec6c2e7e3a 100644 --- a/src/librustc_target/abi/call/aarch64.rs +++ b/src/librustc_target/abi/call/aarch64.rs @@ -1,5 +1,5 @@ -use abi::call::{FnType, ArgType, Reg, RegKind, Uniform}; -use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; +use crate::abi::call::{FnType, ArgType, Reg, RegKind, Uniform}; +use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; fn is_homogeneous_aggregate<'a, Ty, C>(cx: &C, arg: &mut ArgType<'a, Ty>) -> Option diff --git a/src/librustc_target/abi/call/amdgpu.rs b/src/librustc_target/abi/call/amdgpu.rs index ea9d4172cbc23..6bfd1f4387385 100644 --- a/src/librustc_target/abi/call/amdgpu.rs +++ b/src/librustc_target/abi/call/amdgpu.rs @@ -1,5 +1,5 @@ -use abi::call::{ArgType, FnType, }; -use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; +use crate::abi::call::{ArgType, FnType, }; +use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; fn classify_ret_ty<'a, Ty, C>(_cx: &C, ret: &mut ArgType<'a, Ty>) where Ty: TyLayoutMethods<'a, C> + Copy, diff --git a/src/librustc_target/abi/call/arm.rs b/src/librustc_target/abi/call/arm.rs index 228dd36216158..52d7f3ac3dcbf 100644 --- a/src/librustc_target/abi/call/arm.rs +++ b/src/librustc_target/abi/call/arm.rs @@ -1,6 +1,6 @@ -use abi::call::{Conv, FnType, ArgType, Reg, RegKind, Uniform}; -use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; -use spec::HasTargetSpec; +use crate::abi::call::{Conv, FnType, ArgType, Reg, RegKind, Uniform}; +use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; +use crate::spec::HasTargetSpec; fn is_homogeneous_aggregate<'a, Ty, C>(cx: &C, arg: &mut ArgType<'a, Ty>) -> Option diff --git a/src/librustc_target/abi/call/asmjs.rs b/src/librustc_target/abi/call/asmjs.rs index 85444500c5e11..92c86372a86f3 100644 --- a/src/librustc_target/abi/call/asmjs.rs +++ b/src/librustc_target/abi/call/asmjs.rs @@ -1,5 +1,5 @@ -use abi::call::{FnType, ArgType, Uniform}; -use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; +use crate::abi::call::{FnType, ArgType, Uniform}; +use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; // Data layout: e-p:32:32-i64:64-v128:32:128-n32-S128 @@ -26,7 +26,7 @@ fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType<'a, Ty>) } } -fn classify_arg_ty(arg: &mut ArgType) { +fn classify_arg_ty(arg: &mut ArgType<'_, Ty>) { if arg.layout.is_aggregate() { arg.make_indirect_byval(); } diff --git a/src/librustc_target/abi/call/hexagon.rs b/src/librustc_target/abi/call/hexagon.rs index d538a8068ac4a..db8c915cdb4bd 100644 --- a/src/librustc_target/abi/call/hexagon.rs +++ b/src/librustc_target/abi/call/hexagon.rs @@ -1,8 +1,8 @@ #![allow(non_upper_case_globals)] -use abi::call::{FnType, ArgType}; +use crate::abi::call::{FnType, ArgType}; -fn classify_ret_ty(ret: &mut ArgType) { +fn classify_ret_ty(ret: &mut ArgType<'_, Ty>) { if ret.layout.is_aggregate() && ret.layout.size.bits() > 64 { ret.make_indirect(); } else { @@ -10,7 +10,7 @@ fn classify_ret_ty(ret: &mut ArgType) { } } -fn classify_arg_ty(arg: &mut ArgType) { +fn classify_arg_ty(arg: &mut ArgType<'_, Ty>) { if arg.layout.is_aggregate() && arg.layout.size.bits() > 64 { arg.make_indirect(); } else { @@ -18,7 +18,7 @@ fn classify_arg_ty(arg: &mut ArgType) { } } -pub fn compute_abi_info(fty: &mut FnType) { +pub fn compute_abi_info(fty: &mut FnType<'_,Ty>) { if !fty.ret.is_ignore() { classify_ret_ty(&mut fty.ret); } diff --git a/src/librustc_target/abi/call/mips.rs b/src/librustc_target/abi/call/mips.rs index 2335bfbb5b87b..d496abf8e8b28 100644 --- a/src/librustc_target/abi/call/mips.rs +++ b/src/librustc_target/abi/call/mips.rs @@ -1,7 +1,7 @@ -use abi::call::{ArgType, FnType, Reg, Uniform}; -use abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods}; +use crate::abi::call::{ArgType, FnType, Reg, Uniform}; +use crate::abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods}; -fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType, offset: &mut Size) +fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType<'_, Ty>, offset: &mut Size) where Ty: TyLayoutMethods<'a, C>, C: LayoutOf + HasDataLayout { if !ret.layout.is_aggregate() { @@ -12,7 +12,7 @@ fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType, offset: &mut Size) } } -fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType, offset: &mut Size) +fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType<'_, Ty>, offset: &mut Size) where Ty: TyLayoutMethods<'a, C>, C: LayoutOf + HasDataLayout { let dl = cx.data_layout(); @@ -34,7 +34,7 @@ fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType, offset: &mut Size) *offset = offset.align_to(align) + size.align_to(align); } -pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType) +pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<'_, Ty>) where Ty: TyLayoutMethods<'a, C>, C: LayoutOf + HasDataLayout { let mut offset = Size::ZERO; diff --git a/src/librustc_target/abi/call/mips64.rs b/src/librustc_target/abi/call/mips64.rs index 6f3e6494a4ae8..5ba05c6bcde37 100644 --- a/src/librustc_target/abi/call/mips64.rs +++ b/src/librustc_target/abi/call/mips64.rs @@ -1,7 +1,7 @@ -use abi::call::{ArgAttribute, ArgType, CastTarget, FnType, PassMode, Reg, RegKind, Uniform}; -use abi::{self, HasDataLayout, LayoutOf, Size, TyLayout, TyLayoutMethods}; +use crate::abi::call::{ArgAttribute, ArgType, CastTarget, FnType, PassMode, Reg, RegKind, Uniform}; +use crate::abi::{self, HasDataLayout, LayoutOf, Size, TyLayout, TyLayoutMethods}; -fn extend_integer_width_mips(arg: &mut ArgType, bits: u64) { +fn extend_integer_width_mips(arg: &mut ArgType<'_, Ty>, bits: u64) { // Always sign extend u32 values on 64-bit mips if let abi::Abi::Scalar(ref scalar) = arg.layout.abi { if let abi::Int(i, signed) = scalar.value { diff --git a/src/librustc_target/abi/call/mod.rs b/src/librustc_target/abi/call/mod.rs index 0d50439c67ec0..839c9a857e64a 100644 --- a/src/librustc_target/abi/call/mod.rs +++ b/src/librustc_target/abi/call/mod.rs @@ -1,6 +1,6 @@ -use abi::{self, Abi, Align, FieldPlacement, Size}; -use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; -use spec::HasTargetSpec; +use crate::abi::{self, Abi, Align, FieldPlacement, Size}; +use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; +use crate::spec::{self, HasTargetSpec}; mod aarch64; mod amdgpu; @@ -42,13 +42,13 @@ pub enum PassMode { // Hack to disable non_upper_case_globals only for the bitflags! and not for the rest // of this module -pub use self::attr_impl::ArgAttribute; +pub use attr_impl::ArgAttribute; #[allow(non_upper_case_globals)] #[allow(unused)] mod attr_impl { // The subset of llvm::Attribute needed for arguments, packed into a bitfield. - bitflags! { + bitflags::bitflags! { #[derive(Default)] pub struct ArgAttribute: u16 { const ByVal = 1 << 0; @@ -526,22 +526,22 @@ pub struct FnType<'a, Ty> { } impl<'a, Ty> FnType<'a, Ty> { - pub fn adjust_for_cabi(&mut self, cx: &C, abi: ::spec::abi::Abi) -> Result<(), String> + pub fn adjust_for_cabi(&mut self, cx: &C, abi: spec::abi::Abi) -> Result<(), String> where Ty: TyLayoutMethods<'a, C> + Copy, C: LayoutOf> + HasDataLayout + HasTargetSpec { match &cx.target_spec().arch[..] { "x86" => { - let flavor = if abi == ::spec::abi::Abi::Fastcall { + let flavor = if abi == spec::abi::Abi::Fastcall { x86::Flavor::Fastcall } else { x86::Flavor::General }; x86::compute_abi_info(cx, self, flavor); }, - "x86_64" => if abi == ::spec::abi::Abi::SysV64 { + "x86_64" => if abi == spec::abi::Abi::SysV64 { x86_64::compute_abi_info(cx, self); - } else if abi == ::spec::abi::Abi::Win64 || cx.target_spec().options.is_like_windows { + } else if abi == spec::abi::Abi::Win64 || cx.target_spec().options.is_like_windows { x86_win64::compute_abi_info(self); } else { x86_64::compute_abi_info(cx, self); diff --git a/src/librustc_target/abi/call/msp430.rs b/src/librustc_target/abi/call/msp430.rs index d8ba37db53d4d..7ae1116cba847 100644 --- a/src/librustc_target/abi/call/msp430.rs +++ b/src/librustc_target/abi/call/msp430.rs @@ -1,7 +1,7 @@ // Reference: MSP430 Embedded Application Binary Interface // http://www.ti.com/lit/an/slaa534/slaa534.pdf -use abi::call::{ArgType, FnType}; +use crate::abi::call::{ArgType, FnType}; // 3.5 Structures or Unions Passed and Returned by Reference // @@ -9,7 +9,7 @@ use abi::call::{ArgType, FnType}; // returned by reference. To pass a structure or union by reference, the caller // places its address in the appropriate location: either in a register or on // the stack, according to its position in the argument list. (..)" -fn classify_ret_ty(ret: &mut ArgType) { +fn classify_ret_ty(ret: &mut ArgType<'_, Ty>) { if ret.layout.is_aggregate() && ret.layout.size.bits() > 32 { ret.make_indirect(); } else { @@ -17,7 +17,7 @@ fn classify_ret_ty(ret: &mut ArgType) { } } -fn classify_arg_ty(arg: &mut ArgType) { +fn classify_arg_ty(arg: &mut ArgType<'_, Ty>) { if arg.layout.is_aggregate() && arg.layout.size.bits() > 32 { arg.make_indirect(); } else { @@ -25,7 +25,7 @@ fn classify_arg_ty(arg: &mut ArgType) { } } -pub fn compute_abi_info(fty: &mut FnType) { +pub fn compute_abi_info(fty: &mut FnType<'_, Ty>) { if !fty.ret.is_ignore() { classify_ret_ty(&mut fty.ret); } diff --git a/src/librustc_target/abi/call/nvptx.rs b/src/librustc_target/abi/call/nvptx.rs index 4cf0f11eb1e4a..4722249f73007 100644 --- a/src/librustc_target/abi/call/nvptx.rs +++ b/src/librustc_target/abi/call/nvptx.rs @@ -1,9 +1,9 @@ // Reference: PTX Writer's Guide to Interoperability // http://docs.nvidia.com/cuda/ptx-writers-guide-to-interoperability -use abi::call::{ArgType, FnType}; +use crate::abi::call::{ArgType, FnType}; -fn classify_ret_ty(ret: &mut ArgType) { +fn classify_ret_ty(ret: &mut ArgType<'_, Ty>) { if ret.layout.is_aggregate() && ret.layout.size.bits() > 32 { ret.make_indirect(); } else { @@ -11,7 +11,7 @@ fn classify_ret_ty(ret: &mut ArgType) { } } -fn classify_arg_ty(arg: &mut ArgType) { +fn classify_arg_ty(arg: &mut ArgType<'_, Ty>) { if arg.layout.is_aggregate() && arg.layout.size.bits() > 32 { arg.make_indirect(); } else { @@ -19,7 +19,7 @@ fn classify_arg_ty(arg: &mut ArgType) { } } -pub fn compute_abi_info(fty: &mut FnType) { +pub fn compute_abi_info(fty: &mut FnType<'_, Ty>) { if !fty.ret.is_ignore() { classify_ret_ty(&mut fty.ret); } diff --git a/src/librustc_target/abi/call/nvptx64.rs b/src/librustc_target/abi/call/nvptx64.rs index 8ccc77598c90a..51c00ae007c3c 100644 --- a/src/librustc_target/abi/call/nvptx64.rs +++ b/src/librustc_target/abi/call/nvptx64.rs @@ -1,9 +1,9 @@ // Reference: PTX Writer's Guide to Interoperability // http://docs.nvidia.com/cuda/ptx-writers-guide-to-interoperability -use abi::call::{ArgType, FnType}; +use crate::abi::call::{ArgType, FnType}; -fn classify_ret_ty(ret: &mut ArgType) { +fn classify_ret_ty(ret: &mut ArgType<'_, Ty>) { if ret.layout.is_aggregate() && ret.layout.size.bits() > 64 { ret.make_indirect(); } else { @@ -11,7 +11,7 @@ fn classify_ret_ty(ret: &mut ArgType) { } } -fn classify_arg_ty(arg: &mut ArgType) { +fn classify_arg_ty(arg: &mut ArgType<'_, Ty>) { if arg.layout.is_aggregate() && arg.layout.size.bits() > 64 { arg.make_indirect(); } else { @@ -19,7 +19,7 @@ fn classify_arg_ty(arg: &mut ArgType) { } } -pub fn compute_abi_info(fty: &mut FnType) { +pub fn compute_abi_info(fty: &mut FnType<'_, Ty>) { if !fty.ret.is_ignore() { classify_ret_ty(&mut fty.ret); } diff --git a/src/librustc_target/abi/call/powerpc.rs b/src/librustc_target/abi/call/powerpc.rs index 2335bfbb5b87b..d496abf8e8b28 100644 --- a/src/librustc_target/abi/call/powerpc.rs +++ b/src/librustc_target/abi/call/powerpc.rs @@ -1,7 +1,7 @@ -use abi::call::{ArgType, FnType, Reg, Uniform}; -use abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods}; +use crate::abi::call::{ArgType, FnType, Reg, Uniform}; +use crate::abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods}; -fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType, offset: &mut Size) +fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType<'_, Ty>, offset: &mut Size) where Ty: TyLayoutMethods<'a, C>, C: LayoutOf + HasDataLayout { if !ret.layout.is_aggregate() { @@ -12,7 +12,7 @@ fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType, offset: &mut Size) } } -fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType, offset: &mut Size) +fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType<'_, Ty>, offset: &mut Size) where Ty: TyLayoutMethods<'a, C>, C: LayoutOf + HasDataLayout { let dl = cx.data_layout(); @@ -34,7 +34,7 @@ fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType, offset: &mut Size) *offset = offset.align_to(align) + size.align_to(align); } -pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType) +pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<'_, Ty>) where Ty: TyLayoutMethods<'a, C>, C: LayoutOf + HasDataLayout { let mut offset = Size::ZERO; diff --git a/src/librustc_target/abi/call/powerpc64.rs b/src/librustc_target/abi/call/powerpc64.rs index 305a2d4225056..a9683104d164e 100644 --- a/src/librustc_target/abi/call/powerpc64.rs +++ b/src/librustc_target/abi/call/powerpc64.rs @@ -2,16 +2,16 @@ // Alignment of 128 bit types is not currently handled, this will // need to be fixed when PowerPC vector support is added. -use abi::call::{FnType, ArgType, Reg, RegKind, Uniform}; -use abi::{Endian, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; -use spec::HasTargetSpec; +use crate::abi::call::{FnType, ArgType, Reg, RegKind, Uniform}; +use crate::abi::{Endian, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; +use crate::spec::HasTargetSpec; #[derive(Debug, Clone, Copy, PartialEq)] enum ABI { ELFv1, // original ABI used for powerpc64 (big-endian) ELFv2, // newer ABI used for powerpc64le and musl (both endians) } -use self::ABI::*; +use ABI::*; fn is_homogeneous_aggregate<'a, Ty, C>(cx: &C, arg: &mut ArgType<'a, Ty>, abi: ABI) -> Option diff --git a/src/librustc_target/abi/call/riscv.rs b/src/librustc_target/abi/call/riscv.rs index 4950bcd3330aa..ba82e49ddb03e 100644 --- a/src/librustc_target/abi/call/riscv.rs +++ b/src/librustc_target/abi/call/riscv.rs @@ -1,9 +1,9 @@ // Reference: RISC-V ELF psABI specification // https://github.com/riscv/riscv-elf-psabi-doc -use abi::call::{ArgType, FnType}; +use crate::abi::call::{ArgType, FnType}; -fn classify_ret_ty(arg: &mut ArgType, xlen: u64) { +fn classify_ret_ty(arg: &mut ArgType<'_, Ty>, xlen: u64) { // "Scalars wider than 2✕XLEN are passed by reference and are replaced in // the argument list with the address." // "Aggregates larger than 2✕XLEN bits are passed by reference and are @@ -19,7 +19,7 @@ fn classify_ret_ty(arg: &mut ArgType, xlen: u64) { arg.extend_integer_width_to(xlen); // this method only affects integer scalars } -fn classify_arg_ty(arg: &mut ArgType, xlen: u64) { +fn classify_arg_ty(arg: &mut ArgType<'_, Ty>, xlen: u64) { // "Scalars wider than 2✕XLEN are passed by reference and are replaced in // the argument list with the address." // "Aggregates larger than 2✕XLEN bits are passed by reference and are @@ -35,7 +35,7 @@ fn classify_arg_ty(arg: &mut ArgType, xlen: u64) { arg.extend_integer_width_to(xlen); // this method only affects integer scalars } -pub fn compute_abi_info(fty: &mut FnType, xlen: u64) { +pub fn compute_abi_info(fty: &mut FnType<'_, Ty>, xlen: u64) { if !fty.ret.is_ignore() { classify_ret_ty(&mut fty.ret, xlen); } diff --git a/src/librustc_target/abi/call/s390x.rs b/src/librustc_target/abi/call/s390x.rs index 954c37fee42dd..c2717b1bcb815 100644 --- a/src/librustc_target/abi/call/s390x.rs +++ b/src/librustc_target/abi/call/s390x.rs @@ -1,10 +1,10 @@ // FIXME: The assumes we're using the non-vector ABI, i.e., compiling // for a pre-z13 machine or using -mno-vx. -use abi::call::{FnType, ArgType, Reg}; -use abi::{self, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; +use crate::abi::call::{FnType, ArgType, Reg}; +use crate::abi::{self, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; -fn classify_ret_ty<'a, Ty, C>(ret: &mut ArgType) +fn classify_ret_ty<'a, Ty, C>(ret: &mut ArgType<'_, Ty>) where Ty: TyLayoutMethods<'a, C>, C: LayoutOf + HasDataLayout { if !ret.layout.is_aggregate() && ret.layout.size.bits() <= 64 { diff --git a/src/librustc_target/abi/call/sparc.rs b/src/librustc_target/abi/call/sparc.rs index 2335bfbb5b87b..d496abf8e8b28 100644 --- a/src/librustc_target/abi/call/sparc.rs +++ b/src/librustc_target/abi/call/sparc.rs @@ -1,7 +1,7 @@ -use abi::call::{ArgType, FnType, Reg, Uniform}; -use abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods}; +use crate::abi::call::{ArgType, FnType, Reg, Uniform}; +use crate::abi::{HasDataLayout, LayoutOf, Size, TyLayoutMethods}; -fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType, offset: &mut Size) +fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType<'_, Ty>, offset: &mut Size) where Ty: TyLayoutMethods<'a, C>, C: LayoutOf + HasDataLayout { if !ret.layout.is_aggregate() { @@ -12,7 +12,7 @@ fn classify_ret_ty<'a, Ty, C>(cx: &C, ret: &mut ArgType, offset: &mut Size) } } -fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType, offset: &mut Size) +fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType<'_, Ty>, offset: &mut Size) where Ty: TyLayoutMethods<'a, C>, C: LayoutOf + HasDataLayout { let dl = cx.data_layout(); @@ -34,7 +34,7 @@ fn classify_arg_ty<'a, Ty, C>(cx: &C, arg: &mut ArgType, offset: &mut Size) *offset = offset.align_to(align) + size.align_to(align); } -pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType) +pub fn compute_abi_info<'a, Ty, C>(cx: &C, fty: &mut FnType<'_, Ty>) where Ty: TyLayoutMethods<'a, C>, C: LayoutOf + HasDataLayout { let mut offset = Size::ZERO; diff --git a/src/librustc_target/abi/call/sparc64.rs b/src/librustc_target/abi/call/sparc64.rs index 150b48a8d0255..d8930a875efbc 100644 --- a/src/librustc_target/abi/call/sparc64.rs +++ b/src/librustc_target/abi/call/sparc64.rs @@ -1,7 +1,7 @@ // FIXME: This needs an audit for correctness and completeness. -use abi::call::{FnType, ArgType, Reg, RegKind, Uniform}; -use abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; +use crate::abi::call::{FnType, ArgType, Reg, RegKind, Uniform}; +use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; fn is_homogeneous_aggregate<'a, Ty, C>(cx: &C, arg: &mut ArgType<'a, Ty>) -> Option diff --git a/src/librustc_target/abi/call/wasm32.rs b/src/librustc_target/abi/call/wasm32.rs index 78f43f8b508b3..1fdcbb8e39bdf 100644 --- a/src/librustc_target/abi/call/wasm32.rs +++ b/src/librustc_target/abi/call/wasm32.rs @@ -1,14 +1,14 @@ -use abi::call::{FnType, ArgType}; +use crate::abi::call::{FnType, ArgType}; -fn classify_ret_ty(ret: &mut ArgType) { +fn classify_ret_ty(ret: &mut ArgType<'_, Ty>) { ret.extend_integer_width_to(32); } -fn classify_arg_ty(arg: &mut ArgType) { +fn classify_arg_ty(arg: &mut ArgType<'_, Ty>) { arg.extend_integer_width_to(32); } -pub fn compute_abi_info(fty: &mut FnType) { +pub fn compute_abi_info(fty: &mut FnType<'_, Ty>) { if !fty.ret.is_ignore() { classify_ret_ty(&mut fty.ret); } diff --git a/src/librustc_target/abi/call/x86.rs b/src/librustc_target/abi/call/x86.rs index 648a4b5bb9d79..2e809571ab18b 100644 --- a/src/librustc_target/abi/call/x86.rs +++ b/src/librustc_target/abi/call/x86.rs @@ -1,6 +1,6 @@ -use abi::call::{ArgAttribute, FnType, PassMode, Reg, RegKind}; -use abi::{self, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; -use spec::HasTargetSpec; +use crate::abi::call::{ArgAttribute, FnType, PassMode, Reg, RegKind}; +use crate::abi::{self, HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods}; +use crate::spec::HasTargetSpec; #[derive(PartialEq)] pub enum Flavor { diff --git a/src/librustc_target/abi/call/x86_64.rs b/src/librustc_target/abi/call/x86_64.rs index 9d8cc19aac524..680e529b108e0 100644 --- a/src/librustc_target/abi/call/x86_64.rs +++ b/src/librustc_target/abi/call/x86_64.rs @@ -1,8 +1,8 @@ // The classification code for the x86_64 ABI is taken from the clay language // https://github.com/jckarter/clay/blob/master/compiler/src/externals.cpp -use abi::call::{ArgType, CastTarget, FnType, Reg, RegKind}; -use abi::{self, Abi, HasDataLayout, LayoutOf, Size, TyLayout, TyLayoutMethods}; +use crate::abi::call::{ArgType, CastTarget, FnType, Reg, RegKind}; +use crate::abi::{self, Abi, HasDataLayout, LayoutOf, Size, TyLayout, TyLayoutMethods}; /// Classification of "eightbyte" components. // N.B., the order of the variants is from general to specific, diff --git a/src/librustc_target/abi/call/x86_win64.rs b/src/librustc_target/abi/call/x86_win64.rs index c583f7a0a2a24..ebdeb63150a46 100644 --- a/src/librustc_target/abi/call/x86_win64.rs +++ b/src/librustc_target/abi/call/x86_win64.rs @@ -1,10 +1,10 @@ -use abi::call::{ArgType, FnType, Reg}; -use abi::Abi; +use crate::abi::call::{ArgType, FnType, Reg}; +use crate::abi::Abi; // Win64 ABI: http://msdn.microsoft.com/en-us/library/zthk2dkh.aspx -pub fn compute_abi_info(fty: &mut FnType) { - let fixup = |a: &mut ArgType| { +pub fn compute_abi_info(fty: &mut FnType<'_, Ty>) { + let fixup = |a: &mut ArgType<'_, Ty>| { match a.layout.abi { Abi::Uninhabited => {} Abi::ScalarPair(..) | diff --git a/src/librustc_target/abi/mod.rs b/src/librustc_target/abi/mod.rs index 3f95e666535be..bb194d5bb1285 100644 --- a/src/librustc_target/abi/mod.rs +++ b/src/librustc_target/abi/mod.rs @@ -1,7 +1,7 @@ -pub use self::Integer::*; -pub use self::Primitive::*; +pub use Integer::*; +pub use Primitive::*; -use spec::Target; +use crate::spec::Target; use std::fmt; use std::ops::{Add, Deref, Sub, Mul, AddAssign, Range, RangeInclusive}; @@ -533,13 +533,13 @@ pub enum FloatTy { } impl fmt::Debug for FloatTy { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Display::fmt(self, f) } } impl fmt::Display for FloatTy { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.ty_to_string()) } } diff --git a/src/librustc_target/lib.rs b/src/librustc_target/lib.rs index 0df0027c171aa..aab286a4a7d1b 100644 --- a/src/librustc_target/lib.rs +++ b/src/librustc_target/lib.rs @@ -17,11 +17,11 @@ #![feature(slice_patterns)] #![feature(step_trait)] -#[macro_use] -extern crate bitflags; -extern crate serialize; +#![deny(rust_2018_idioms)] + #[macro_use] extern crate log; +#[allow(unused_extern_crates)] extern crate serialize as rustc_serialize; // used by deriving // See librustc_cratesio_shim/Cargo.toml for a comment explaining this. diff --git a/src/librustc_target/spec/aarch64_apple_ios.rs b/src/librustc_target/spec/aarch64_apple_ios.rs index 2210fd1e9e7c9..8bdc08c788d01 100644 --- a/src/librustc_target/spec/aarch64_apple_ios.rs +++ b/src/librustc_target/spec/aarch64_apple_ios.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; use super::apple_ios_base::{opts, Arch}; pub fn target() -> TargetResult { diff --git a/src/librustc_target/spec/aarch64_fuchsia.rs b/src/librustc_target/spec/aarch64_fuchsia.rs index e39a1c2e1068c..308954d56f8bf 100644 --- a/src/librustc_target/spec/aarch64_fuchsia.rs +++ b/src/librustc_target/spec/aarch64_fuchsia.rs @@ -1,4 +1,4 @@ -use spec::{LldFlavor, LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LldFlavor, LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let mut base = super::fuchsia_base::opts(); diff --git a/src/librustc_target/spec/aarch64_linux_android.rs b/src/librustc_target/spec/aarch64_linux_android.rs index c05964295d37a..65160f6231e8c 100644 --- a/src/librustc_target/spec/aarch64_linux_android.rs +++ b/src/librustc_target/spec/aarch64_linux_android.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; // See https://developer.android.com/ndk/guides/abis.html#arm64-v8a // for target ABI requirements. diff --git a/src/librustc_target/spec/aarch64_pc_windows_msvc.rs b/src/librustc_target/spec/aarch64_pc_windows_msvc.rs index b33430b59e8f9..1aee381d604c3 100644 --- a/src/librustc_target/spec/aarch64_pc_windows_msvc.rs +++ b/src/librustc_target/spec/aarch64_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult, PanicStrategy}; +use crate::spec::{LinkerFlavor, Target, TargetResult, PanicStrategy}; pub fn target() -> TargetResult { let mut base = super::windows_msvc_base::opts(); diff --git a/src/librustc_target/spec/aarch64_unknown_cloudabi.rs b/src/librustc_target/spec/aarch64_unknown_cloudabi.rs index ac3345ce3f214..7141954306769 100644 --- a/src/librustc_target/spec/aarch64_unknown_cloudabi.rs +++ b/src/librustc_target/spec/aarch64_unknown_cloudabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::cloudabi_base::opts(); diff --git a/src/librustc_target/spec/aarch64_unknown_freebsd.rs b/src/librustc_target/spec/aarch64_unknown_freebsd.rs index 1fb0a2bcf7c22..36860649c53ad 100644 --- a/src/librustc_target/spec/aarch64_unknown_freebsd.rs +++ b/src/librustc_target/spec/aarch64_unknown_freebsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let mut base = super::freebsd_base::opts(); diff --git a/src/librustc_target/spec/aarch64_unknown_hermit.rs b/src/librustc_target/spec/aarch64_unknown_hermit.rs index 26006d0060d49..7b020605102b1 100644 --- a/src/librustc_target/spec/aarch64_unknown_hermit.rs +++ b/src/librustc_target/spec/aarch64_unknown_hermit.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::hermit_base::opts(); diff --git a/src/librustc_target/spec/aarch64_unknown_linux_gnu.rs b/src/librustc_target/spec/aarch64_unknown_linux_gnu.rs index d30d927b6dd3d..e772d8b532cb0 100644 --- a/src/librustc_target/spec/aarch64_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/aarch64_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/aarch64_unknown_linux_musl.rs b/src/librustc_target/spec/aarch64_unknown_linux_musl.rs index 258725fed15be..8123ee82ed524 100644 --- a/src/librustc_target/spec/aarch64_unknown_linux_musl.rs +++ b/src/librustc_target/spec/aarch64_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/aarch64_unknown_netbsd.rs b/src/librustc_target/spec/aarch64_unknown_netbsd.rs index 10aef8f923d4c..47ae08ade9a6b 100644 --- a/src/librustc_target/spec/aarch64_unknown_netbsd.rs +++ b/src/librustc_target/spec/aarch64_unknown_netbsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::netbsd_base::opts(); diff --git a/src/librustc_target/spec/aarch64_unknown_openbsd.rs b/src/librustc_target/spec/aarch64_unknown_openbsd.rs index 815e11a919c0f..c9cd64c3a84af 100644 --- a/src/librustc_target/spec/aarch64_unknown_openbsd.rs +++ b/src/librustc_target/spec/aarch64_unknown_openbsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::openbsd_base::opts(); diff --git a/src/librustc_target/spec/abi.rs b/src/librustc_target/spec/abi.rs index 46606e707d757..c9c41f1092240 100644 --- a/src/librustc_target/spec/abi.rs +++ b/src/librustc_target/spec/abi.rs @@ -96,7 +96,7 @@ impl Abi { } impl fmt::Display for Abi { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "\"{}\"", self.name()) } } diff --git a/src/librustc_target/spec/android_base.rs b/src/librustc_target/spec/android_base.rs index a8f8ad3185f0d..684c059b41482 100644 --- a/src/librustc_target/spec/android_base.rs +++ b/src/librustc_target/spec/android_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, TargetOptions}; +use crate::spec::{LinkerFlavor, TargetOptions}; pub fn opts() -> TargetOptions { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/apple_base.rs b/src/librustc_target/spec/apple_base.rs index a80d1904a7471..c21f7f38ca5a3 100644 --- a/src/librustc_target/spec/apple_base.rs +++ b/src/librustc_target/spec/apple_base.rs @@ -1,6 +1,6 @@ use std::env; -use spec::{LinkArgs, TargetOptions}; +use crate::spec::{LinkArgs, TargetOptions}; pub fn opts() -> TargetOptions { // ELF TLS is only available in macOS 10.7+. If you try to compile for 10.6 diff --git a/src/librustc_target/spec/apple_ios_base.rs b/src/librustc_target/spec/apple_ios_base.rs index 72346ab1f34b6..3068ed8d206cd 100644 --- a/src/librustc_target/spec/apple_ios_base.rs +++ b/src/librustc_target/spec/apple_ios_base.rs @@ -1,8 +1,8 @@ use std::io; use std::process::Command; -use spec::{LinkArgs, LinkerFlavor, TargetOptions}; +use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions}; -use self::Arch::*; +use Arch::*; #[allow(non_camel_case_types)] #[derive(Copy, Clone)] diff --git a/src/librustc_target/spec/arm_base.rs b/src/librustc_target/spec/arm_base.rs index 1d51d60c8f258..77e7bfac62d58 100644 --- a/src/librustc_target/spec/arm_base.rs +++ b/src/librustc_target/spec/arm_base.rs @@ -1,4 +1,4 @@ -use spec::abi::Abi; +use crate::spec::abi::Abi; // All the calling conventions trigger an assertion(Unsupported calling convention) in llvm on arm pub fn abi_blacklist() -> Vec { diff --git a/src/librustc_target/spec/arm_linux_androideabi.rs b/src/librustc_target/spec/arm_linux_androideabi.rs index 5e4bebfa1c1a4..bb066dc9ad833 100644 --- a/src/librustc_target/spec/arm_linux_androideabi.rs +++ b/src/librustc_target/spec/arm_linux_androideabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let mut base = super::android_base::opts(); diff --git a/src/librustc_target/spec/arm_unknown_linux_gnueabi.rs b/src/librustc_target/spec/arm_unknown_linux_gnueabi.rs index 0f891dacc6dbf..f291818ba80f5 100644 --- a/src/librustc_target/spec/arm_unknown_linux_gnueabi.rs +++ b/src/librustc_target/spec/arm_unknown_linux_gnueabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/arm_unknown_linux_gnueabihf.rs b/src/librustc_target/spec/arm_unknown_linux_gnueabihf.rs index 5503bf326cd7b..32b509d9721ef 100644 --- a/src/librustc_target/spec/arm_unknown_linux_gnueabihf.rs +++ b/src/librustc_target/spec/arm_unknown_linux_gnueabihf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/arm_unknown_linux_musleabi.rs b/src/librustc_target/spec/arm_unknown_linux_musleabi.rs index c2162beba26e8..7637577e7e848 100644 --- a/src/librustc_target/spec/arm_unknown_linux_musleabi.rs +++ b/src/librustc_target/spec/arm_unknown_linux_musleabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/arm_unknown_linux_musleabihf.rs b/src/librustc_target/spec/arm_unknown_linux_musleabihf.rs index b3f00331b3c9e..9def151b3ef29 100644 --- a/src/librustc_target/spec/arm_unknown_linux_musleabihf.rs +++ b/src/librustc_target/spec/arm_unknown_linux_musleabihf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/armebv7r_none_eabi.rs b/src/librustc_target/spec/armebv7r_none_eabi.rs index cd41ffbab4d9c..86c62daa6180a 100644 --- a/src/librustc_target/spec/armebv7r_none_eabi.rs +++ b/src/librustc_target/spec/armebv7r_none_eabi.rs @@ -1,7 +1,7 @@ // Targets the Big endian Cortex-R4/R5 processor (ARMv7-R) use std::default::Default; -use spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/armebv7r_none_eabihf.rs b/src/librustc_target/spec/armebv7r_none_eabihf.rs index 05b12dd28bacd..50ee76414ef9a 100644 --- a/src/librustc_target/spec/armebv7r_none_eabihf.rs +++ b/src/librustc_target/spec/armebv7r_none_eabihf.rs @@ -1,7 +1,7 @@ // Targets the Cortex-R4F/R5F processor (ARMv7-R) use std::default::Default; -use spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/armv4t_unknown_linux_gnueabi.rs b/src/librustc_target/spec/armv4t_unknown_linux_gnueabi.rs index 7fe021e5327b9..7cd4b14cdebc8 100644 --- a/src/librustc_target/spec/armv4t_unknown_linux_gnueabi.rs +++ b/src/librustc_target/spec/armv4t_unknown_linux_gnueabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/armv5te_unknown_linux_gnueabi.rs b/src/librustc_target/spec/armv5te_unknown_linux_gnueabi.rs index c85a80f6e8a4c..15f614827718b 100644 --- a/src/librustc_target/spec/armv5te_unknown_linux_gnueabi.rs +++ b/src/librustc_target/spec/armv5te_unknown_linux_gnueabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/armv5te_unknown_linux_musleabi.rs b/src/librustc_target/spec/armv5te_unknown_linux_musleabi.rs index dce767898c06b..74915b942ea4f 100644 --- a/src/librustc_target/spec/armv5te_unknown_linux_musleabi.rs +++ b/src/librustc_target/spec/armv5te_unknown_linux_musleabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs b/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs index 95cc41e6c98fb..e460b6c574a26 100644 --- a/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs +++ b/src/librustc_target/spec/armv6_unknown_netbsd_eabihf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let mut base = super::netbsd_base::opts(); diff --git a/src/librustc_target/spec/armv7_apple_ios.rs b/src/librustc_target/spec/armv7_apple_ios.rs index 98018215c805a..2052d17403dfd 100644 --- a/src/librustc_target/spec/armv7_apple_ios.rs +++ b/src/librustc_target/spec/armv7_apple_ios.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; use super::apple_ios_base::{opts, Arch}; pub fn target() -> TargetResult { diff --git a/src/librustc_target/spec/armv7_linux_androideabi.rs b/src/librustc_target/spec/armv7_linux_androideabi.rs index 65c3c7f7057ab..92f1a55e024d7 100644 --- a/src/librustc_target/spec/armv7_linux_androideabi.rs +++ b/src/librustc_target/spec/armv7_linux_androideabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; // This target if is for the baseline of the Android v7a ABI // in thumb mode. It's named armv7-* instead of thumbv7-* diff --git a/src/librustc_target/spec/armv7_unknown_cloudabi_eabihf.rs b/src/librustc_target/spec/armv7_unknown_cloudabi_eabihf.rs index fa43879dccab8..a6c7fb537c785 100644 --- a/src/librustc_target/spec/armv7_unknown_cloudabi_eabihf.rs +++ b/src/librustc_target/spec/armv7_unknown_cloudabi_eabihf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::cloudabi_base::opts(); diff --git a/src/librustc_target/spec/armv7_unknown_linux_gnueabihf.rs b/src/librustc_target/spec/armv7_unknown_linux_gnueabihf.rs index 864c59b81844e..f16215433c766 100644 --- a/src/librustc_target/spec/armv7_unknown_linux_gnueabihf.rs +++ b/src/librustc_target/spec/armv7_unknown_linux_gnueabihf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; // This target is for glibc Linux on ARMv7 without NEON or // thumb-mode. See the thumbv7neon variant for enabling both. diff --git a/src/librustc_target/spec/armv7_unknown_linux_musleabihf.rs b/src/librustc_target/spec/armv7_unknown_linux_musleabihf.rs index ae0cb2c08b430..45a26966b716b 100644 --- a/src/librustc_target/spec/armv7_unknown_linux_musleabihf.rs +++ b/src/librustc_target/spec/armv7_unknown_linux_musleabihf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; // This target is for musl Linux on ARMv7 without thumb-mode or NEON. diff --git a/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs b/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs index f9e416fd06e92..44e2636e9188e 100644 --- a/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs +++ b/src/librustc_target/spec/armv7_unknown_netbsd_eabihf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { let base = super::netbsd_base::opts(); diff --git a/src/librustc_target/spec/armv7r_none_eabi.rs b/src/librustc_target/spec/armv7r_none_eabi.rs index 38d115bc85e7f..19d332467dec5 100644 --- a/src/librustc_target/spec/armv7r_none_eabi.rs +++ b/src/librustc_target/spec/armv7r_none_eabi.rs @@ -1,7 +1,7 @@ // Targets the Little-endian Cortex-R4/R5 processor (ARMv7-R) use std::default::Default; -use spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/armv7r_none_eabihf.rs b/src/librustc_target/spec/armv7r_none_eabihf.rs index cb707f7183a49..06ef9f3ec4e37 100644 --- a/src/librustc_target/spec/armv7r_none_eabihf.rs +++ b/src/librustc_target/spec/armv7r_none_eabihf.rs @@ -1,7 +1,7 @@ // Targets the Little-endian Cortex-R4F/R5F processor (ARMv7-R) use std::default::Default; -use spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/armv7s_apple_ios.rs b/src/librustc_target/spec/armv7s_apple_ios.rs index 6d9635b308e90..29e290285e4a9 100644 --- a/src/librustc_target/spec/armv7s_apple_ios.rs +++ b/src/librustc_target/spec/armv7s_apple_ios.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; use super::apple_ios_base::{opts, Arch}; pub fn target() -> TargetResult { diff --git a/src/librustc_target/spec/bitrig_base.rs b/src/librustc_target/spec/bitrig_base.rs index 3b6985fa4c826..9b34119fc00c9 100644 --- a/src/librustc_target/spec/bitrig_base.rs +++ b/src/librustc_target/spec/bitrig_base.rs @@ -1,4 +1,4 @@ -use spec::{TargetOptions, RelroLevel}; +use crate::spec::{TargetOptions, RelroLevel}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/cloudabi_base.rs b/src/librustc_target/spec/cloudabi_base.rs index 145de0ebe6995..a34122d3e0fe2 100644 --- a/src/librustc_target/spec/cloudabi_base.rs +++ b/src/librustc_target/spec/cloudabi_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; +use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; pub fn opts() -> TargetOptions { let mut args = LinkArgs::new(); diff --git a/src/librustc_target/spec/dragonfly_base.rs b/src/librustc_target/spec/dragonfly_base.rs index 6ce2912da75cf..766030e8015d0 100644 --- a/src/librustc_target/spec/dragonfly_base.rs +++ b/src/librustc_target/spec/dragonfly_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; +use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/freebsd_base.rs b/src/librustc_target/spec/freebsd_base.rs index 47316f77e634e..51f030f59084d 100644 --- a/src/librustc_target/spec/freebsd_base.rs +++ b/src/librustc_target/spec/freebsd_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; +use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/fuchsia_base.rs b/src/librustc_target/spec/fuchsia_base.rs index 5d94f308410a6..4e4f2fa0cf34c 100644 --- a/src/librustc_target/spec/fuchsia_base.rs +++ b/src/librustc_target/spec/fuchsia_base.rs @@ -1,4 +1,4 @@ -use spec::{LldFlavor, LinkArgs, LinkerFlavor, TargetOptions}; +use crate::spec::{LldFlavor, LinkArgs, LinkerFlavor, TargetOptions}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/haiku_base.rs b/src/librustc_target/spec/haiku_base.rs index 00c6bd40dc584..d071062705306 100644 --- a/src/librustc_target/spec/haiku_base.rs +++ b/src/librustc_target/spec/haiku_base.rs @@ -1,4 +1,4 @@ -use spec::{TargetOptions, RelroLevel}; +use crate::spec::{TargetOptions, RelroLevel}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/hermit_base.rs b/src/librustc_target/spec/hermit_base.rs index d7d8562e055d8..ee753393ddb3d 100644 --- a/src/librustc_target/spec/hermit_base.rs +++ b/src/librustc_target/spec/hermit_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, PanicStrategy, TargetOptions}; +use crate::spec::{LinkArgs, LinkerFlavor, PanicStrategy, TargetOptions}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/i386_apple_ios.rs b/src/librustc_target/spec/i386_apple_ios.rs index d0e317630013b..78e9cbb61ef58 100644 --- a/src/librustc_target/spec/i386_apple_ios.rs +++ b/src/librustc_target/spec/i386_apple_ios.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; use super::apple_ios_base::{opts, Arch}; pub fn target() -> TargetResult { diff --git a/src/librustc_target/spec/i586_pc_windows_msvc.rs b/src/librustc_target/spec/i586_pc_windows_msvc.rs index 12a7f98beff95..ba712aced8474 100644 --- a/src/librustc_target/spec/i586_pc_windows_msvc.rs +++ b/src/librustc_target/spec/i586_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use spec::TargetResult; +use crate::spec::TargetResult; pub fn target() -> TargetResult { let mut base = super::i686_pc_windows_msvc::target()?; diff --git a/src/librustc_target/spec/i586_unknown_linux_gnu.rs b/src/librustc_target/spec/i586_unknown_linux_gnu.rs index 76f6a4eba389f..49f4f2cb6b999 100644 --- a/src/librustc_target/spec/i586_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/i586_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::TargetResult; +use crate::spec::TargetResult; pub fn target() -> TargetResult { let mut base = super::i686_unknown_linux_gnu::target()?; diff --git a/src/librustc_target/spec/i586_unknown_linux_musl.rs b/src/librustc_target/spec/i586_unknown_linux_musl.rs index 2b56fd7a7e370..0f2ccebd6dace 100644 --- a/src/librustc_target/spec/i586_unknown_linux_musl.rs +++ b/src/librustc_target/spec/i586_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use spec::TargetResult; +use crate::spec::TargetResult; pub fn target() -> TargetResult { let mut base = super::i686_unknown_linux_musl::target()?; diff --git a/src/librustc_target/spec/i686_apple_darwin.rs b/src/librustc_target/spec/i686_apple_darwin.rs index 40d9588e463a6..c8a61296d33d2 100644 --- a/src/librustc_target/spec/i686_apple_darwin.rs +++ b/src/librustc_target/spec/i686_apple_darwin.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::apple_base::opts(); diff --git a/src/librustc_target/spec/i686_linux_android.rs b/src/librustc_target/spec/i686_linux_android.rs index 5b8cb7ac55d58..3f73d24ee848b 100644 --- a/src/librustc_target/spec/i686_linux_android.rs +++ b/src/librustc_target/spec/i686_linux_android.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; // See https://developer.android.com/ndk/guides/abis.html#x86 // for target ABI requirements. diff --git a/src/librustc_target/spec/i686_pc_windows_gnu.rs b/src/librustc_target/spec/i686_pc_windows_gnu.rs index d7bc38ca172d5..12214a7d53119 100644 --- a/src/librustc_target/spec/i686_pc_windows_gnu.rs +++ b/src/librustc_target/spec/i686_pc_windows_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::windows_base::opts(); diff --git a/src/librustc_target/spec/i686_pc_windows_msvc.rs b/src/librustc_target/spec/i686_pc_windows_msvc.rs index f0d75ae4e9bdd..1967834819ab2 100644 --- a/src/librustc_target/spec/i686_pc_windows_msvc.rs +++ b/src/librustc_target/spec/i686_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::windows_msvc_base::opts(); diff --git a/src/librustc_target/spec/i686_unknown_cloudabi.rs b/src/librustc_target/spec/i686_unknown_cloudabi.rs index 3a9e424698127..f3b40633b4007 100644 --- a/src/librustc_target/spec/i686_unknown_cloudabi.rs +++ b/src/librustc_target/spec/i686_unknown_cloudabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::cloudabi_base::opts(); diff --git a/src/librustc_target/spec/i686_unknown_dragonfly.rs b/src/librustc_target/spec/i686_unknown_dragonfly.rs index 9d71c5a823361..20315e7145c73 100644 --- a/src/librustc_target/spec/i686_unknown_dragonfly.rs +++ b/src/librustc_target/spec/i686_unknown_dragonfly.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::dragonfly_base::opts(); diff --git a/src/librustc_target/spec/i686_unknown_freebsd.rs b/src/librustc_target/spec/i686_unknown_freebsd.rs index 627dffa89d247..71f05a140f3df 100644 --- a/src/librustc_target/spec/i686_unknown_freebsd.rs +++ b/src/librustc_target/spec/i686_unknown_freebsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::freebsd_base::opts(); diff --git a/src/librustc_target/spec/i686_unknown_haiku.rs b/src/librustc_target/spec/i686_unknown_haiku.rs index 86c64ce684bb8..b807e4eee39a5 100644 --- a/src/librustc_target/spec/i686_unknown_haiku.rs +++ b/src/librustc_target/spec/i686_unknown_haiku.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::haiku_base::opts(); diff --git a/src/librustc_target/spec/i686_unknown_linux_gnu.rs b/src/librustc_target/spec/i686_unknown_linux_gnu.rs index ab38832831157..5875cbf78bfe6 100644 --- a/src/librustc_target/spec/i686_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/i686_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/i686_unknown_linux_musl.rs b/src/librustc_target/spec/i686_unknown_linux_musl.rs index 81cbf57e577a6..732949034e824 100644 --- a/src/librustc_target/spec/i686_unknown_linux_musl.rs +++ b/src/librustc_target/spec/i686_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/i686_unknown_netbsd.rs b/src/librustc_target/spec/i686_unknown_netbsd.rs index 1027e240224c9..e8a9f29ea5f4c 100644 --- a/src/librustc_target/spec/i686_unknown_netbsd.rs +++ b/src/librustc_target/spec/i686_unknown_netbsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::netbsd_base::opts(); diff --git a/src/librustc_target/spec/i686_unknown_openbsd.rs b/src/librustc_target/spec/i686_unknown_openbsd.rs index d2bbc6bb2dbaf..d7c323e0d8a8a 100644 --- a/src/librustc_target/spec/i686_unknown_openbsd.rs +++ b/src/librustc_target/spec/i686_unknown_openbsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::openbsd_base::opts(); diff --git a/src/librustc_target/spec/l4re_base.rs b/src/librustc_target/spec/l4re_base.rs index 951005998be07..9317f053efe70 100644 --- a/src/librustc_target/spec/l4re_base.rs +++ b/src/librustc_target/spec/l4re_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, PanicStrategy, TargetOptions}; +use crate::spec::{LinkArgs, LinkerFlavor, PanicStrategy, TargetOptions}; use std::default::Default; //use std::process::Command; diff --git a/src/librustc_target/spec/linux_base.rs b/src/librustc_target/spec/linux_base.rs index b036bf81a7542..195fba3915f94 100644 --- a/src/librustc_target/spec/linux_base.rs +++ b/src/librustc_target/spec/linux_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; +use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/linux_musl_base.rs b/src/librustc_target/spec/linux_musl_base.rs index 1bc90d1a73287..e294e63982de4 100644 --- a/src/librustc_target/spec/linux_musl_base.rs +++ b/src/librustc_target/spec/linux_musl_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, TargetOptions}; +use crate::spec::{LinkerFlavor, TargetOptions}; pub fn opts() -> TargetOptions { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/mips64_unknown_linux_gnuabi64.rs b/src/librustc_target/spec/mips64_unknown_linux_gnuabi64.rs index 650f38702b67b..3b38e64050f3b 100644 --- a/src/librustc_target/spec/mips64_unknown_linux_gnuabi64.rs +++ b/src/librustc_target/spec/mips64_unknown_linux_gnuabi64.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/mips64el_unknown_linux_gnuabi64.rs b/src/librustc_target/spec/mips64el_unknown_linux_gnuabi64.rs index cb348d49479b9..0f6cd86d616d8 100644 --- a/src/librustc_target/spec/mips64el_unknown_linux_gnuabi64.rs +++ b/src/librustc_target/spec/mips64el_unknown_linux_gnuabi64.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/mips_unknown_linux_gnu.rs b/src/librustc_target/spec/mips_unknown_linux_gnu.rs index 6cc3d30be1fb0..b4d29c5fbeaf4 100644 --- a/src/librustc_target/spec/mips_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/mips_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/mips_unknown_linux_musl.rs b/src/librustc_target/spec/mips_unknown_linux_musl.rs index 152b11b4aeeb5..c56c6e3822959 100644 --- a/src/librustc_target/spec/mips_unknown_linux_musl.rs +++ b/src/librustc_target/spec/mips_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/mips_unknown_linux_uclibc.rs b/src/librustc_target/spec/mips_unknown_linux_uclibc.rs index 99cd20e9a52e8..cb02769c7dfe4 100644 --- a/src/librustc_target/spec/mips_unknown_linux_uclibc.rs +++ b/src/librustc_target/spec/mips_unknown_linux_uclibc.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/mipsel_unknown_linux_gnu.rs b/src/librustc_target/spec/mipsel_unknown_linux_gnu.rs index 476cf15270649..ed49ddd49937f 100644 --- a/src/librustc_target/spec/mipsel_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/mipsel_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/mipsel_unknown_linux_musl.rs b/src/librustc_target/spec/mipsel_unknown_linux_musl.rs index 9df131dbe2510..bcc49cf5ffe4f 100644 --- a/src/librustc_target/spec/mipsel_unknown_linux_musl.rs +++ b/src/librustc_target/spec/mipsel_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/mipsel_unknown_linux_uclibc.rs b/src/librustc_target/spec/mipsel_unknown_linux_uclibc.rs index 37c55d11f25c9..205f328a24cec 100644 --- a/src/librustc_target/spec/mipsel_unknown_linux_uclibc.rs +++ b/src/librustc_target/spec/mipsel_unknown_linux_uclibc.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/mod.rs b/src/librustc_target/spec/mod.rs index aeecce49b0c67..107583e4fc0a0 100644 --- a/src/librustc_target/spec/mod.rs +++ b/src/librustc_target/spec/mod.rs @@ -40,7 +40,7 @@ use std::default::Default; use std::{fmt, io}; use std::path::{Path, PathBuf}; use std::str::FromStr; -use spec::abi::{Abi, lookup as lookup_abi}; +use crate::spec::abi::{Abi, lookup as lookup_abi}; pub mod abi; mod android_base; @@ -1408,7 +1408,7 @@ impl TargetTriple { } impl fmt::Display for TargetTriple { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{}", self.debug_triple()) } } diff --git a/src/librustc_target/spec/msp430_none_elf.rs b/src/librustc_target/spec/msp430_none_elf.rs index df564bc924baf..90af5898089b8 100644 --- a/src/librustc_target/spec/msp430_none_elf.rs +++ b/src/librustc_target/spec/msp430_none_elf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/netbsd_base.rs b/src/librustc_target/spec/netbsd_base.rs index b88d360dd3785..e9cd98c0e7151 100644 --- a/src/librustc_target/spec/netbsd_base.rs +++ b/src/librustc_target/spec/netbsd_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; +use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/nvptx64_nvidia_cuda.rs b/src/librustc_target/spec/nvptx64_nvidia_cuda.rs index e8512415e66a3..db9d6a7409ee5 100644 --- a/src/librustc_target/spec/nvptx64_nvidia_cuda.rs +++ b/src/librustc_target/spec/nvptx64_nvidia_cuda.rs @@ -1,5 +1,5 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult, PanicStrategy, MergeFunctions}; -use spec::abi::Abi; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult, PanicStrategy, MergeFunctions}; +use crate::spec::abi::Abi; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/openbsd_base.rs b/src/librustc_target/spec/openbsd_base.rs index 4bdf73fc92213..5bcfd62d75bd4 100644 --- a/src/librustc_target/spec/openbsd_base.rs +++ b/src/librustc_target/spec/openbsd_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; +use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions, RelroLevel}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/powerpc64_unknown_freebsd.rs b/src/librustc_target/spec/powerpc64_unknown_freebsd.rs index cc7b87bfdebc3..360876b9ff557 100644 --- a/src/librustc_target/spec/powerpc64_unknown_freebsd.rs +++ b/src/librustc_target/spec/powerpc64_unknown_freebsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::freebsd_base::opts(); diff --git a/src/librustc_target/spec/powerpc64_unknown_linux_gnu.rs b/src/librustc_target/spec/powerpc64_unknown_linux_gnu.rs index 1f7ae933cedd1..c16db7583f32b 100644 --- a/src/librustc_target/spec/powerpc64_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/powerpc64_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult, RelroLevel}; +use crate::spec::{LinkerFlavor, Target, TargetResult, RelroLevel}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/powerpc64_unknown_linux_musl.rs b/src/librustc_target/spec/powerpc64_unknown_linux_musl.rs index 6fc8be8a5c4d8..ac0b7431f91a4 100644 --- a/src/librustc_target/spec/powerpc64_unknown_linux_musl.rs +++ b/src/librustc_target/spec/powerpc64_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/powerpc64le_unknown_linux_gnu.rs b/src/librustc_target/spec/powerpc64le_unknown_linux_gnu.rs index 21791a75d2a29..038b925a28692 100644 --- a/src/librustc_target/spec/powerpc64le_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/powerpc64le_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/powerpc64le_unknown_linux_musl.rs b/src/librustc_target/spec/powerpc64le_unknown_linux_musl.rs index 38f7fe887f5a9..57103345f0a0c 100644 --- a/src/librustc_target/spec/powerpc64le_unknown_linux_musl.rs +++ b/src/librustc_target/spec/powerpc64le_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/powerpc_unknown_linux_gnu.rs b/src/librustc_target/spec/powerpc_unknown_linux_gnu.rs index 286d177c864e4..38a801d5ab507 100644 --- a/src/librustc_target/spec/powerpc_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/powerpc_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/powerpc_unknown_linux_gnuspe.rs b/src/librustc_target/spec/powerpc_unknown_linux_gnuspe.rs index ae144af047232..675b2c749d648 100644 --- a/src/librustc_target/spec/powerpc_unknown_linux_gnuspe.rs +++ b/src/librustc_target/spec/powerpc_unknown_linux_gnuspe.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/powerpc_unknown_linux_musl.rs b/src/librustc_target/spec/powerpc_unknown_linux_musl.rs index 3b61889163b4c..240443aa98db4 100644 --- a/src/librustc_target/spec/powerpc_unknown_linux_musl.rs +++ b/src/librustc_target/spec/powerpc_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/powerpc_unknown_netbsd.rs b/src/librustc_target/spec/powerpc_unknown_netbsd.rs index e8662a7851907..10e7089cf1c4c 100644 --- a/src/librustc_target/spec/powerpc_unknown_netbsd.rs +++ b/src/librustc_target/spec/powerpc_unknown_netbsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::netbsd_base::opts(); diff --git a/src/librustc_target/spec/redox_base.rs b/src/librustc_target/spec/redox_base.rs index dd32f02e34049..dc51aeb58391f 100644 --- a/src/librustc_target/spec/redox_base.rs +++ b/src/librustc_target/spec/redox_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, TargetOptions}; +use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/riscv32imac_unknown_none_elf.rs b/src/librustc_target/spec/riscv32imac_unknown_none_elf.rs index 8adf562ca7e52..5064393d31135 100644 --- a/src/librustc_target/spec/riscv32imac_unknown_none_elf.rs +++ b/src/librustc_target/spec/riscv32imac_unknown_none_elf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, LldFlavor, PanicStrategy, +use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { diff --git a/src/librustc_target/spec/riscv32imc_unknown_none_elf.rs b/src/librustc_target/spec/riscv32imc_unknown_none_elf.rs index 5d8157ee59a0a..31e74c5920cf9 100644 --- a/src/librustc_target/spec/riscv32imc_unknown_none_elf.rs +++ b/src/librustc_target/spec/riscv32imc_unknown_none_elf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, LldFlavor, PanicStrategy, +use crate::spec::{LinkerFlavor, LldFlavor, PanicStrategy, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { diff --git a/src/librustc_target/spec/riscv_base.rs b/src/librustc_target/spec/riscv_base.rs index ea7fdc39a9a96..ec1dc9b4918bd 100644 --- a/src/librustc_target/spec/riscv_base.rs +++ b/src/librustc_target/spec/riscv_base.rs @@ -1,4 +1,4 @@ -use spec::abi::Abi; +use crate::spec::abi::Abi; // All the calling conventions trigger an assertion(Unsupported calling // convention) in llvm on RISCV diff --git a/src/librustc_target/spec/s390x_unknown_linux_gnu.rs b/src/librustc_target/spec/s390x_unknown_linux_gnu.rs index c18c94511f8d7..f259787e1d54d 100644 --- a/src/librustc_target/spec/s390x_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/s390x_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/solaris_base.rs b/src/librustc_target/spec/solaris_base.rs index f5f8509210570..0dfbb13b77317 100644 --- a/src/librustc_target/spec/solaris_base.rs +++ b/src/librustc_target/spec/solaris_base.rs @@ -1,4 +1,4 @@ -use spec::TargetOptions; +use crate::spec::TargetOptions; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/sparc64_unknown_linux_gnu.rs b/src/librustc_target/spec/sparc64_unknown_linux_gnu.rs index e5e3752be7f82..c842b22d4e16e 100644 --- a/src/librustc_target/spec/sparc64_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/sparc64_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/sparc64_unknown_netbsd.rs b/src/librustc_target/spec/sparc64_unknown_netbsd.rs index 62efd41dbb8ee..78d53e69e8b52 100644 --- a/src/librustc_target/spec/sparc64_unknown_netbsd.rs +++ b/src/librustc_target/spec/sparc64_unknown_netbsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::netbsd_base::opts(); diff --git a/src/librustc_target/spec/sparc_unknown_linux_gnu.rs b/src/librustc_target/spec/sparc_unknown_linux_gnu.rs index b6468993790d8..162cd311a3826 100644 --- a/src/librustc_target/spec/sparc_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/sparc_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/sparcv9_sun_solaris.rs b/src/librustc_target/spec/sparcv9_sun_solaris.rs index f1c5c5ac44f1a..acc03fd0d79ee 100644 --- a/src/librustc_target/spec/sparcv9_sun_solaris.rs +++ b/src/librustc_target/spec/sparcv9_sun_solaris.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::solaris_base::opts(); diff --git a/src/librustc_target/spec/thumb_base.rs b/src/librustc_target/spec/thumb_base.rs index 06cb6a8d823ef..ed0dbb766a835 100644 --- a/src/librustc_target/spec/thumb_base.rs +++ b/src/librustc_target/spec/thumb_base.rs @@ -28,7 +28,7 @@ // build scripts / gcc flags. use std::default::Default; -use spec::{PanicStrategy, TargetOptions}; +use crate::spec::{PanicStrategy, TargetOptions}; pub fn opts() -> TargetOptions { // See rust-lang/rfcs#1645 for a discussion about these defaults diff --git a/src/librustc_target/spec/thumbv6m_none_eabi.rs b/src/librustc_target/spec/thumbv6m_none_eabi.rs index 98c46e9c600a3..2ab61b57f6bb6 100644 --- a/src/librustc_target/spec/thumbv6m_none_eabi.rs +++ b/src/librustc_target/spec/thumbv6m_none_eabi.rs @@ -1,6 +1,6 @@ // Targets the Cortex-M0, Cortex-M0+ and Cortex-M1 processors (ARMv6-M architecture) -use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs b/src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs index eaa08fadbc0f3..310fac31c0c5b 100644 --- a/src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs +++ b/src/librustc_target/spec/thumbv7a_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult, PanicStrategy}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult, PanicStrategy}; pub fn target() -> TargetResult { let mut base = super::windows_msvc_base::opts(); diff --git a/src/librustc_target/spec/thumbv7em_none_eabi.rs b/src/librustc_target/spec/thumbv7em_none_eabi.rs index 8a1fe09cdb07a..97114c342cdc7 100644 --- a/src/librustc_target/spec/thumbv7em_none_eabi.rs +++ b/src/librustc_target/spec/thumbv7em_none_eabi.rs @@ -9,7 +9,7 @@ // To opt-in to hardware accelerated floating point operations, you can use, for example, // `-C target-feature=+vfp4` or `-C target-cpu=cortex-m4`. -use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/thumbv7em_none_eabihf.rs b/src/librustc_target/spec/thumbv7em_none_eabihf.rs index 0c9aa1c5149ff..e4358bdd7991e 100644 --- a/src/librustc_target/spec/thumbv7em_none_eabihf.rs +++ b/src/librustc_target/spec/thumbv7em_none_eabihf.rs @@ -8,7 +8,7 @@ // // To opt into double precision hardware support, use the `-C target-feature=-fp-only-sp` flag. -use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/thumbv7m_none_eabi.rs b/src/librustc_target/spec/thumbv7m_none_eabi.rs index 9bff3473c58af..daf25b16d58d6 100644 --- a/src/librustc_target/spec/thumbv7m_none_eabi.rs +++ b/src/librustc_target/spec/thumbv7m_none_eabi.rs @@ -1,6 +1,6 @@ // Targets the Cortex-M3 processor (ARMv7-M) -use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/thumbv7neon_linux_androideabi.rs b/src/librustc_target/spec/thumbv7neon_linux_androideabi.rs index 2d92e29c09d96..e248b930e6e4c 100644 --- a/src/librustc_target/spec/thumbv7neon_linux_androideabi.rs +++ b/src/librustc_target/spec/thumbv7neon_linux_androideabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; // This target if is for the Android v7a ABI in thumb mode with // NEON unconditionally enabled and, therefore, with 32 FPU registers diff --git a/src/librustc_target/spec/thumbv7neon_unknown_linux_gnueabihf.rs b/src/librustc_target/spec/thumbv7neon_unknown_linux_gnueabihf.rs index bdf57969154c0..bef62b0a2ebe6 100644 --- a/src/librustc_target/spec/thumbv7neon_unknown_linux_gnueabihf.rs +++ b/src/librustc_target/spec/thumbv7neon_unknown_linux_gnueabihf.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; // This target is for glibc Linux on ARMv7 with thumb mode enabled // (for consistency with Android and Debian-based distributions) diff --git a/src/librustc_target/spec/thumbv8m_base_none_eabi.rs b/src/librustc_target/spec/thumbv8m_base_none_eabi.rs index 0e0e73efd45cc..be8a476db4dbc 100644 --- a/src/librustc_target/spec/thumbv8m_base_none_eabi.rs +++ b/src/librustc_target/spec/thumbv8m_base_none_eabi.rs @@ -1,6 +1,6 @@ // Targets the Cortex-M23 processor (Baseline ARMv8-M) -use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/thumbv8m_main_none_eabi.rs b/src/librustc_target/spec/thumbv8m_main_none_eabi.rs index dc2454d749780..49ab643d484bc 100644 --- a/src/librustc_target/spec/thumbv8m_main_none_eabi.rs +++ b/src/librustc_target/spec/thumbv8m_main_none_eabi.rs @@ -1,7 +1,7 @@ // Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile), // without the Floating Point extension. -use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/thumbv8m_main_none_eabihf.rs b/src/librustc_target/spec/thumbv8m_main_none_eabihf.rs index 5fa1f42288d1a..6a3d8e61d7fe8 100644 --- a/src/librustc_target/spec/thumbv8m_main_none_eabihf.rs +++ b/src/librustc_target/spec/thumbv8m_main_none_eabihf.rs @@ -1,7 +1,7 @@ // Targets the Cortex-M33 processor (Armv8-M Mainline architecture profile), // with the Floating Point extension. -use spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetOptions, TargetResult}; pub fn target() -> TargetResult { Ok(Target { diff --git a/src/librustc_target/spec/uefi_base.rs b/src/librustc_target/spec/uefi_base.rs index 4628089ffe1f4..5078d500679d1 100644 --- a/src/librustc_target/spec/uefi_base.rs +++ b/src/librustc_target/spec/uefi_base.rs @@ -9,7 +9,7 @@ // the timer-interrupt. Device-drivers are required to use polling-based models. Furthermore, all // code runs in the same environment, no process separation is supported. -use spec::{LinkArgs, LinkerFlavor, LldFlavor, PanicStrategy, TargetOptions}; +use crate::spec::{LinkArgs, LinkerFlavor, LldFlavor, PanicStrategy, TargetOptions}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/windows_base.rs b/src/librustc_target/spec/windows_base.rs index 65d618232a249..38db9cd356cd8 100644 --- a/src/librustc_target/spec/windows_base.rs +++ b/src/librustc_target/spec/windows_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, TargetOptions}; +use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/windows_msvc_base.rs b/src/librustc_target/spec/windows_msvc_base.rs index 89f6b1bcc71c5..fdd747cdb865a 100644 --- a/src/librustc_target/spec/windows_msvc_base.rs +++ b/src/librustc_target/spec/windows_msvc_base.rs @@ -1,4 +1,4 @@ -use spec::{LinkArgs, LinkerFlavor, TargetOptions}; +use crate::spec::{LinkArgs, LinkerFlavor, TargetOptions}; use std::default::Default; pub fn opts() -> TargetOptions { diff --git a/src/librustc_target/spec/x86_64_apple_darwin.rs b/src/librustc_target/spec/x86_64_apple_darwin.rs index 7de33fe8ac52a..0911ce06c13d7 100644 --- a/src/librustc_target/spec/x86_64_apple_darwin.rs +++ b/src/librustc_target/spec/x86_64_apple_darwin.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::apple_base::opts(); diff --git a/src/librustc_target/spec/x86_64_apple_ios.rs b/src/librustc_target/spec/x86_64_apple_ios.rs index 286a73d48048c..1f9594b906282 100644 --- a/src/librustc_target/spec/x86_64_apple_ios.rs +++ b/src/librustc_target/spec/x86_64_apple_ios.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetOptions, TargetResult}; use super::apple_ios_base::{opts, Arch}; pub fn target() -> TargetResult { diff --git a/src/librustc_target/spec/x86_64_fuchsia.rs b/src/librustc_target/spec/x86_64_fuchsia.rs index 00fb7066ca28f..a24d432c591d2 100644 --- a/src/librustc_target/spec/x86_64_fuchsia.rs +++ b/src/librustc_target/spec/x86_64_fuchsia.rs @@ -1,4 +1,4 @@ -use spec::{LldFlavor, LinkerFlavor, Target, TargetResult}; +use crate::spec::{LldFlavor, LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::fuchsia_base::opts(); diff --git a/src/librustc_target/spec/x86_64_linux_android.rs b/src/librustc_target/spec/x86_64_linux_android.rs index 29d5dfa5790a1..c3c6c7bf56fef 100644 --- a/src/librustc_target/spec/x86_64_linux_android.rs +++ b/src/librustc_target/spec/x86_64_linux_android.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::android_base::opts(); diff --git a/src/librustc_target/spec/x86_64_pc_windows_gnu.rs b/src/librustc_target/spec/x86_64_pc_windows_gnu.rs index c3c36d22cef5e..35e0d55cd045e 100644 --- a/src/librustc_target/spec/x86_64_pc_windows_gnu.rs +++ b/src/librustc_target/spec/x86_64_pc_windows_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::windows_base::opts(); diff --git a/src/librustc_target/spec/x86_64_pc_windows_msvc.rs b/src/librustc_target/spec/x86_64_pc_windows_msvc.rs index 178d67784e653..073d49be5a9ab 100644 --- a/src/librustc_target/spec/x86_64_pc_windows_msvc.rs +++ b/src/librustc_target/spec/x86_64_pc_windows_msvc.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::windows_msvc_base::opts(); diff --git a/src/librustc_target/spec/x86_64_rumprun_netbsd.rs b/src/librustc_target/spec/x86_64_rumprun_netbsd.rs index 37c7925c6985e..a2c706c4c7232 100644 --- a/src/librustc_target/spec/x86_64_rumprun_netbsd.rs +++ b/src/librustc_target/spec/x86_64_rumprun_netbsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::netbsd_base::opts(); diff --git a/src/librustc_target/spec/x86_64_sun_solaris.rs b/src/librustc_target/spec/x86_64_sun_solaris.rs index 3534f9e6436b4..3bf3f51ae2512 100644 --- a/src/librustc_target/spec/x86_64_sun_solaris.rs +++ b/src/librustc_target/spec/x86_64_sun_solaris.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::solaris_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_bitrig.rs b/src/librustc_target/spec/x86_64_unknown_bitrig.rs index fa5392175606a..999d93a7e6090 100644 --- a/src/librustc_target/spec/x86_64_unknown_bitrig.rs +++ b/src/librustc_target/spec/x86_64_unknown_bitrig.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::bitrig_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_cloudabi.rs b/src/librustc_target/spec/x86_64_unknown_cloudabi.rs index c1253a3b2727b..d48120c5401c2 100644 --- a/src/librustc_target/spec/x86_64_unknown_cloudabi.rs +++ b/src/librustc_target/spec/x86_64_unknown_cloudabi.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::cloudabi_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_dragonfly.rs b/src/librustc_target/spec/x86_64_unknown_dragonfly.rs index 815aa57252561..f55ee6969092b 100644 --- a/src/librustc_target/spec/x86_64_unknown_dragonfly.rs +++ b/src/librustc_target/spec/x86_64_unknown_dragonfly.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::dragonfly_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_freebsd.rs b/src/librustc_target/spec/x86_64_unknown_freebsd.rs index 8d43883f33bf3..1d9c5cce3f729 100644 --- a/src/librustc_target/spec/x86_64_unknown_freebsd.rs +++ b/src/librustc_target/spec/x86_64_unknown_freebsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::freebsd_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_haiku.rs b/src/librustc_target/spec/x86_64_unknown_haiku.rs index 608354732d9d1..4ab15fa4e90f5 100644 --- a/src/librustc_target/spec/x86_64_unknown_haiku.rs +++ b/src/librustc_target/spec/x86_64_unknown_haiku.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::haiku_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_hermit.rs b/src/librustc_target/spec/x86_64_unknown_hermit.rs index de5992cbf5ef2..a696ee16d7c9e 100644 --- a/src/librustc_target/spec/x86_64_unknown_hermit.rs +++ b/src/librustc_target/spec/x86_64_unknown_hermit.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::hermit_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_l4re_uclibc.rs b/src/librustc_target/spec/x86_64_unknown_l4re_uclibc.rs index cf04cc1bdc2f5..e5fdb386ef301 100644 --- a/src/librustc_target/spec/x86_64_unknown_l4re_uclibc.rs +++ b/src/librustc_target/spec/x86_64_unknown_l4re_uclibc.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::l4re_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_linux_gnu.rs b/src/librustc_target/spec/x86_64_unknown_linux_gnu.rs index c6ec8de5b7312..cb279e86f1498 100644 --- a/src/librustc_target/spec/x86_64_unknown_linux_gnu.rs +++ b/src/librustc_target/spec/x86_64_unknown_linux_gnu.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_linux_gnux32.rs b/src/librustc_target/spec/x86_64_unknown_linux_gnux32.rs index e4dfb8d05cdfa..0b2d7aacc4ddf 100644 --- a/src/librustc_target/spec/x86_64_unknown_linux_gnux32.rs +++ b/src/librustc_target/spec/x86_64_unknown_linux_gnux32.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_linux_musl.rs b/src/librustc_target/spec/x86_64_unknown_linux_musl.rs index 95321fe2f783e..2e1bc839873c7 100644 --- a/src/librustc_target/spec/x86_64_unknown_linux_musl.rs +++ b/src/librustc_target/spec/x86_64_unknown_linux_musl.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::linux_musl_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_netbsd.rs b/src/librustc_target/spec/x86_64_unknown_netbsd.rs index fbd07ecce1afb..ffc4f1d5c49b7 100644 --- a/src/librustc_target/spec/x86_64_unknown_netbsd.rs +++ b/src/librustc_target/spec/x86_64_unknown_netbsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::netbsd_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_openbsd.rs b/src/librustc_target/spec/x86_64_unknown_openbsd.rs index 68496247b1596..f2abd1071227e 100644 --- a/src/librustc_target/spec/x86_64_unknown_openbsd.rs +++ b/src/librustc_target/spec/x86_64_unknown_openbsd.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::openbsd_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_redox.rs b/src/librustc_target/spec/x86_64_unknown_redox.rs index d04bc5cc6ec21..f0a4519f59548 100644 --- a/src/librustc_target/spec/x86_64_unknown_redox.rs +++ b/src/librustc_target/spec/x86_64_unknown_redox.rs @@ -1,4 +1,4 @@ -use spec::{LinkerFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::redox_base::opts(); diff --git a/src/librustc_target/spec/x86_64_unknown_uefi.rs b/src/librustc_target/spec/x86_64_unknown_uefi.rs index 0d7b4fc060bd9..9ac17a1693fb5 100644 --- a/src/librustc_target/spec/x86_64_unknown_uefi.rs +++ b/src/librustc_target/spec/x86_64_unknown_uefi.rs @@ -5,7 +5,7 @@ // The win64 ABI is used. It differs from the sysv64 ABI, so we must use a windows target with // LLVM. "x86_64-unknown-windows" is used to get the minimal subset of windows-specific features. -use spec::{LinkerFlavor, LldFlavor, Target, TargetResult}; +use crate::spec::{LinkerFlavor, LldFlavor, Target, TargetResult}; pub fn target() -> TargetResult { let mut base = super::uefi_base::opts(); From 0e622a8ba1d43904ff16231e4fe8a1907e66d563 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 21:06:07 +0900 Subject: [PATCH 213/278] librustc_codegen_utils => 2018 --- src/librustc_codegen_utils/Cargo.toml | 1 + src/librustc_codegen_utils/codegen_backend.rs | 22 +++++++++---------- src/librustc_codegen_utils/lib.rs | 12 ++-------- src/librustc_codegen_utils/link.rs | 2 +- src/librustc_codegen_utils/symbol_names.rs | 4 +++- 5 files changed, 18 insertions(+), 23 deletions(-) diff --git a/src/librustc_codegen_utils/Cargo.toml b/src/librustc_codegen_utils/Cargo.toml index 34a09f30b6411..5f241eb20fb55 100644 --- a/src/librustc_codegen_utils/Cargo.toml +++ b/src/librustc_codegen_utils/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_codegen_utils" version = "0.0.0" +edition = "2018" [lib] name = "rustc_codegen_utils" diff --git a/src/librustc_codegen_utils/codegen_backend.rs b/src/librustc_codegen_utils/codegen_backend.rs index 8981c542961e2..8270d2a4077cf 100644 --- a/src/librustc_codegen_utils/codegen_backend.rs +++ b/src/librustc_codegen_utils/codegen_backend.rs @@ -31,7 +31,7 @@ use rustc::middle::cstore::EncodedMetadata; use rustc::middle::cstore::MetadataLoader; use rustc::dep_graph::DepGraph; use rustc_target::spec::Target; -use link::out_filename; +use crate::link::out_filename; pub use rustc_data_structures::sync::MetadataRef; @@ -44,8 +44,8 @@ pub trait CodegenBackend { fn diagnostics(&self) -> &[(&'static str, &'static str)] { &[] } fn metadata_loader(&self) -> Box; - fn provide(&self, _providers: &mut Providers); - fn provide_extern(&self, _providers: &mut Providers); + fn provide(&self, _providers: &mut Providers<'_>); + fn provide_extern(&self, _providers: &mut Providers<'_>); fn codegen_crate<'a, 'tcx>( &self, tcx: TyCtxt<'a, 'tcx, 'tcx>, @@ -111,8 +111,8 @@ impl CodegenBackend for MetadataOnlyCodegenBackend { box NoLlvmMetadataLoader } - fn provide(&self, providers: &mut Providers) { - ::symbol_names::provide(providers); + fn provide(&self, providers: &mut Providers<'_>) { + crate::symbol_names::provide(providers); providers.target_features_whitelist = |_tcx, _cnum| { Default::default() // Just a dummy @@ -120,7 +120,7 @@ impl CodegenBackend for MetadataOnlyCodegenBackend { providers.is_reachable_non_generic = |_tcx, _defid| true; providers.exported_symbols = |_tcx, _crate| Arc::new(Vec::new()); } - fn provide_extern(&self, providers: &mut Providers) { + fn provide_extern(&self, providers: &mut Providers<'_>) { providers.is_reachable_non_generic = |_tcx, _defid| true; } @@ -131,12 +131,12 @@ impl CodegenBackend for MetadataOnlyCodegenBackend { ) -> Box { use rustc_mir::monomorphize::item::MonoItem; - ::check_for_rustc_errors_attr(tcx); - ::symbol_names_test::report_symbol_names(tcx); - ::rustc_incremental::assert_dep_graph(tcx); - ::rustc_incremental::assert_module_sources::assert_module_sources(tcx); + crate::check_for_rustc_errors_attr(tcx); + crate::symbol_names_test::report_symbol_names(tcx); + rustc_incremental::assert_dep_graph(tcx); + rustc_incremental::assert_module_sources::assert_module_sources(tcx); // FIXME: Fix this - // ::rustc::middle::dependency_format::calculate(tcx); + // rustc::middle::dependency_format::calculate(tcx); let _ = tcx.link_args(LOCAL_CRATE); let _ = tcx.native_libraries(LOCAL_CRATE); let (_, cgus) = tcx.collect_and_partition_mono_items(LOCAL_CRATE); diff --git a/src/librustc_codegen_utils/lib.rs b/src/librustc_codegen_utils/lib.rs index 8e96f98540117..4c01681320f2b 100644 --- a/src/librustc_codegen_utils/lib.rs +++ b/src/librustc_codegen_utils/lib.rs @@ -16,18 +16,10 @@ #![recursion_limit="256"] -extern crate flate2; -#[macro_use] -extern crate log; +#![deny(rust_2018_idioms)] #[macro_use] extern crate rustc; -extern crate rustc_target; -extern crate rustc_metadata; -extern crate rustc_mir; -extern crate rustc_incremental; -extern crate syntax; -extern crate syntax_pos; #[macro_use] extern crate rustc_data_structures; use rustc::ty::TyCtxt; @@ -42,7 +34,7 @@ pub mod symbol_names_test; /// error in codegen. This is used to write compile-fail tests /// that actually test that compilation succeeds without /// reporting an error. -pub fn check_for_rustc_errors_attr(tcx: TyCtxt) { +pub fn check_for_rustc_errors_attr(tcx: TyCtxt<'_, '_, '_>) { if let Some((def_id, _)) = tcx.entry_fn(LOCAL_CRATE) { if tcx.has_attr(def_id, "rustc_error") { tcx.sess.span_fatal(tcx.def_span(def_id), "compilation successful"); diff --git a/src/librustc_codegen_utils/link.rs b/src/librustc_codegen_utils/link.rs index 09e22bd2c91a9..f3a1b219f8a84 100644 --- a/src/librustc_codegen_utils/link.rs +++ b/src/librustc_codegen_utils/link.rs @@ -41,7 +41,7 @@ pub fn find_crate_name(sess: Option<&Session>, attrs: &[ast::Attribute], input: &Input) -> String { let validate = |s: String, span: Option| { - ::rustc_metadata::validate_crate_name(sess, &s, span); + rustc_metadata::validate_crate_name(sess, &s, span); s }; diff --git a/src/librustc_codegen_utils/symbol_names.rs b/src/librustc_codegen_utils/symbol_names.rs index 3238a0b10bfd6..8d105853d92f1 100644 --- a/src/librustc_codegen_utils/symbol_names.rs +++ b/src/librustc_codegen_utils/symbol_names.rs @@ -103,10 +103,12 @@ use rustc_mir::monomorphize::Instance; use syntax_pos::symbol::Symbol; +use log::debug; + use std::fmt::Write; use std::mem::discriminant; -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { *providers = Providers { def_symbol_name, symbol_name, From a2c4a36c6132ad6e462992e1c8ab9c2c22eb5e0f Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 21:11:10 +0900 Subject: [PATCH 214/278] librustc_borrowck => 2018 --- src/librustc_borrowck/Cargo.toml | 9 +++-- src/librustc_borrowck/borrowck/check_loans.rs | 11 +++--- .../borrowck/gather_loans/gather_moves.rs | 9 ++--- .../borrowck/gather_loans/lifetime.rs | 3 +- .../borrowck/gather_loans/mod.rs | 9 ++--- .../borrowck/gather_loans/move_error.rs | 9 ++--- .../borrowck/gather_loans/restrictions.rs | 5 +-- src/librustc_borrowck/borrowck/mod.rs | 35 ++++++++++--------- src/librustc_borrowck/borrowck/move_data.rs | 15 ++++---- src/librustc_borrowck/borrowck/unused.rs | 2 +- src/librustc_borrowck/dataflow.rs | 9 ++--- src/librustc_borrowck/graphviz.rs | 13 ++++--- src/librustc_borrowck/lib.rs | 11 +----- 13 files changed, 71 insertions(+), 69 deletions(-) diff --git a/src/librustc_borrowck/Cargo.toml b/src/librustc_borrowck/Cargo.toml index 3368bbf3855a5..f293739dec727 100644 --- a/src/librustc_borrowck/Cargo.toml +++ b/src/librustc_borrowck/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_borrowck" version = "0.0.0" +edition = "2018" [lib] name = "rustc_borrowck" @@ -13,8 +14,10 @@ test = false log = "0.4" syntax = { path = "../libsyntax" } syntax_pos = { path = "../libsyntax_pos" } -graphviz = { path = "../libgraphviz" } +# for "clarity", rename the graphviz crate to dot; graphviz within `borrowck` +# refers to the borrowck-specific graphviz adapter traits. +dot = { path = "../libgraphviz", package = "graphviz" } rustc = { path = "../librustc" } rustc_mir = { path = "../librustc_mir" } -rustc_errors = { path = "../librustc_errors" } -rustc_data_structures = { path = "../librustc_data_structures" } \ No newline at end of file +errors = { path = "../librustc_errors", package = "rustc_errors" } +rustc_data_structures = { path = "../librustc_data_structures" } diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index cafb29ed99a41..f675c8d38a676 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -7,10 +7,10 @@ // 3. assignments do not affect things loaned out as immutable // 4. moves do not affect things loaned out in any way -use self::UseError::*; +use UseError::*; -use borrowck::*; -use borrowck::InteriorKind::{InteriorElement, InteriorField}; +use crate::borrowck::*; +use crate::borrowck::InteriorKind::{InteriorElement, InteriorField}; use rustc::middle::expr_use_visitor as euv; use rustc::middle::expr_use_visitor::MutateMode; use rustc::middle::mem_categorization as mc; @@ -22,6 +22,7 @@ use syntax_pos::Span; use rustc::hir; use rustc::hir::Node; use rustc_mir::util::borrowck_errors::{BorrowckErrors, Origin}; +use log::debug; use std::rc::Rc; @@ -101,7 +102,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> { fn matched_pat(&mut self, _matched_pat: &hir::Pat, - _cmt: &mc::cmt_, + _cmt: &mc::cmt_<'_>, _mode: euv::MatchMode) { } fn consume_pat(&mut self, @@ -910,7 +911,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { pub fn report_illegal_mutation(&self, span: Span, loan_path: &LoanPath<'tcx>, - loan: &Loan) { + loan: &Loan<'_>) { self.bccx.cannot_assign_to_borrowed( span, loan.span, &self.bccx.loan_path_to_string(loan_path), Origin::Ast) .emit(); diff --git a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs index f5e27a953c27d..6b050fd9ba230 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs @@ -1,9 +1,9 @@ //! Computes moves. -use borrowck::*; -use borrowck::gather_loans::move_error::MovePlace; -use borrowck::gather_loans::move_error::{MoveError, MoveErrorCollector}; -use borrowck::move_data::*; +use crate::borrowck::*; +use crate::borrowck::gather_loans::move_error::MovePlace; +use crate::borrowck::gather_loans::move_error::{MoveError, MoveErrorCollector}; +use crate::borrowck::move_data::*; use rustc::middle::expr_use_visitor as euv; use rustc::middle::mem_categorization as mc; use rustc::middle::mem_categorization::Categorization; @@ -15,6 +15,7 @@ use syntax::ast; use syntax_pos::Span; use rustc::hir::*; use rustc::hir::Node; +use log::debug; struct GatherMoveInfo<'c, 'tcx: 'c> { id: hir::ItemLocalId, diff --git a/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs b/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs index 8fc0a3d63384a..11597455bca8f 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs @@ -1,7 +1,7 @@ //! This module implements the check that the lifetime of a borrow //! does not exceed the lifetime of the value being borrowed. -use borrowck::*; +use crate::borrowck::*; use rustc::middle::expr_use_visitor as euv; use rustc::middle::mem_categorization as mc; use rustc::middle::mem_categorization::Categorization; @@ -10,6 +10,7 @@ use rustc::ty; use syntax::ast; use syntax_pos::Span; +use log::debug; type R = Result<(),()>; diff --git a/src/librustc_borrowck/borrowck/gather_loans/mod.rs b/src/librustc_borrowck/borrowck/gather_loans/mod.rs index d681c771d2fa9..c21a43bc68333 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/mod.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/mod.rs @@ -6,8 +6,8 @@ // their associated scopes. In phase two, checking loans, we will then make // sure that all of these loans are honored. -use borrowck::*; -use borrowck::move_data::MoveData; +use crate::borrowck::*; +use crate::borrowck::move_data::MoveData; use rustc::middle::expr_use_visitor as euv; use rustc::middle::mem_categorization as mc; use rustc::middle::mem_categorization::Categorization; @@ -17,8 +17,9 @@ use rustc::ty::{self, TyCtxt}; use syntax::ast; use syntax_pos::Span; use rustc::hir; +use log::debug; -use self::restrictions::RestrictionResult; +use restrictions::RestrictionResult; mod lifetime; mod restrictions; @@ -427,7 +428,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> { // } } - pub fn mark_loan_path_as_mutated(&self, loan_path: &LoanPath) { + pub fn mark_loan_path_as_mutated(&self, loan_path: &LoanPath<'_>) { //! For mutable loans of content whose mutability derives //! from a local variable, mark the mutability decl as necessary. diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs index 00cbc250bd686..622dd8e891ac7 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs @@ -1,4 +1,4 @@ -use borrowck::BorrowckCtxt; +use crate::borrowck::BorrowckCtxt; use rustc::middle::mem_categorization as mc; use rustc::middle::mem_categorization::Categorization; use rustc::middle::mem_categorization::NoteClosureEnv; @@ -8,7 +8,8 @@ use rustc_mir::util::borrowck_errors::{BorrowckErrors, Origin}; use syntax::ast; use syntax_pos; use errors::{DiagnosticBuilder, Applicability}; -use borrowck::gather_loans::gather_moves::PatternSource; +use crate::borrowck::gather_loans::gather_moves::PatternSource; +use log::debug; pub struct MoveErrorCollector<'tcx> { errors: Vec> @@ -167,10 +168,10 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &'a BorrowckCtxt<'a, 'tcx>, } } -fn note_move_destination(mut err: DiagnosticBuilder, +fn note_move_destination(mut err: DiagnosticBuilder<'_>, move_to_span: syntax_pos::Span, pat_name: ast::Name, - is_first_note: bool) -> DiagnosticBuilder { + is_first_note: bool) -> DiagnosticBuilder<'_> { if is_first_note { err.span_label( move_to_span, diff --git a/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs b/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs index a43a7f1e09ae1..9f4c05a6b255f 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/restrictions.rs @@ -1,13 +1,14 @@ //! Computes the restrictions that result from a borrow. -use borrowck::*; +use crate::borrowck::*; use rustc::middle::expr_use_visitor as euv; use rustc::middle::mem_categorization as mc; use rustc::middle::mem_categorization::Categorization; use rustc::ty; use syntax_pos::Span; +use log::debug; -use borrowck::ToInteriorKind; +use crate::borrowck::ToInteriorKind; use std::rc::Rc; diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index e40c2b4508922..4ced72cd279b2 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -2,13 +2,13 @@ #![allow(non_camel_case_types)] -pub use self::LoanPathKind::*; -pub use self::LoanPathElem::*; -pub use self::bckerr_code::*; -pub use self::AliasableViolationKind::*; -pub use self::MovedValueUseKind::*; +pub use LoanPathKind::*; +pub use LoanPathElem::*; +pub use bckerr_code::*; +pub use AliasableViolationKind::*; +pub use MovedValueUseKind::*; -use self::InteriorKind::*; +use InteriorKind::*; use rustc::hir::HirId; use rustc::hir::Node; @@ -37,10 +37,11 @@ use std::hash::{Hash, Hasher}; use syntax::ast; use syntax_pos::{MultiSpan, Span}; use errors::{Applicability, DiagnosticBuilder, DiagnosticId}; +use log::debug; use rustc::hir; -use dataflow::{DataFlowContext, BitwiseOperator, DataFlowOperator, KillFrom}; +use crate::dataflow::{DataFlowContext, BitwiseOperator, DataFlowOperator, KillFrom}; pub mod check_loans; @@ -61,7 +62,7 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { }); } -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { *providers = Providers { borrowck, ..*providers @@ -398,7 +399,7 @@ pub enum LoanPathElem<'tcx> { } fn closure_to_block(closure_id: LocalDefId, - tcx: TyCtxt) -> ast::NodeId { + tcx: TyCtxt<'_, '_, '_>) -> ast::NodeId { let closure_id = tcx.hir().local_def_id_to_node_id(closure_id); match tcx.hir().get(closure_id) { Node::Expr(expr) => match expr.node { @@ -1214,8 +1215,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { } fn note_immutability_blame(&self, - db: &mut DiagnosticBuilder, - blame: Option, + db: &mut DiagnosticBuilder<'_>, + blame: Option>, error_node_id: ast::NodeId) { match blame { None => {} @@ -1271,7 +1272,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { // binding: either to make the binding mutable (if its type is // not a mutable reference) or to avoid borrowing altogether fn note_immutable_local(&self, - db: &mut DiagnosticBuilder, + db: &mut DiagnosticBuilder<'_>, borrowed_node_id: ast::NodeId, binding_node_id: ast::NodeId) { let let_span = self.tcx.hir().span(binding_node_id); @@ -1349,7 +1350,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { } } - fn note_and_explain_mutbl_error(&self, db: &mut DiagnosticBuilder, err: &BckError<'a, 'tcx>, + fn note_and_explain_mutbl_error(&self, db: &mut DiagnosticBuilder<'_>, err: &BckError<'a, 'tcx>, error_span: &Span) { match err.cmt.note { mc::NoteClosureEnv(upvar_id) | mc::NoteUpvarRef(upvar_id) => { @@ -1487,7 +1488,7 @@ impl DataFlowOperator for LoanDataFlowOperator { } impl<'tcx> fmt::Debug for InteriorKind { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match *self { InteriorField(mc::FieldIndex(_, info)) => write!(f, "{}", info), InteriorElement => write!(f, "[]"), @@ -1496,7 +1497,7 @@ impl<'tcx> fmt::Debug for InteriorKind { } impl<'tcx> fmt::Debug for Loan<'tcx> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "Loan_{}({:?}, {:?}, {:?}-{:?}, {:?})", self.index, self.loan_path, @@ -1508,7 +1509,7 @@ impl<'tcx> fmt::Debug for Loan<'tcx> { } impl<'tcx> fmt::Debug for LoanPath<'tcx> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self.kind { LpVar(id) => { write!(f, "$({})", ty::tls::with(|tcx| tcx.hir().node_to_string(id))) @@ -1543,7 +1544,7 @@ impl<'tcx> fmt::Debug for LoanPath<'tcx> { } impl<'tcx> fmt::Display for LoanPath<'tcx> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self.kind { LpVar(id) => { write!(f, "$({})", ty::tls::with(|tcx| tcx.hir().node_to_user_string(id))) diff --git a/src/librustc_borrowck/borrowck/move_data.rs b/src/librustc_borrowck/borrowck/move_data.rs index 56c9f928eb03a..a206c37e97b09 100644 --- a/src/librustc_borrowck/borrowck/move_data.rs +++ b/src/librustc_borrowck/borrowck/move_data.rs @@ -1,11 +1,11 @@ //! Data structures used for tracking moves. Please see the extensive //! comments in the section "Moves and initialization" in `README.md`. -pub use self::MoveKind::*; +pub use MoveKind::*; -use dataflow::{DataFlowContext, BitwiseOperator, DataFlowOperator, KillFrom}; +use crate::dataflow::{DataFlowContext, BitwiseOperator, DataFlowOperator, KillFrom}; -use borrowck::*; +use crate::borrowck::*; use rustc::cfg; use rustc::ty::{self, TyCtxt}; use rustc::util::nodemap::FxHashMap; @@ -15,6 +15,7 @@ use std::rc::Rc; use std::usize; use syntax_pos::Span; use rustc::hir; +use log::debug; #[derive(Default)] pub struct MoveData<'tcx> { @@ -145,7 +146,7 @@ pub struct AssignDataFlowOperator; pub type AssignDataFlow<'a, 'tcx> = DataFlowContext<'a, 'tcx, AssignDataFlowOperator>; -fn loan_path_is_precise(loan_path: &LoanPath) -> bool { +fn loan_path_is_precise(loan_path: &LoanPath<'_>) -> bool { match loan_path.kind { LpVar(_) | LpUpvar(_) => { true @@ -428,8 +429,8 @@ impl<'a, 'tcx> MoveData<'tcx> { /// killed by scoping. See `README.md` for more details. fn add_gen_kills(&self, bccx: &BorrowckCtxt<'a, 'tcx>, - dfcx_moves: &mut MoveDataFlow, - dfcx_assign: &mut AssignDataFlow) { + dfcx_moves: &mut MoveDataFlow<'_, '_>, + dfcx_assign: &mut AssignDataFlow<'_, '_>) { for (i, the_move) in self.moves.borrow().iter().enumerate() { dfcx_moves.add_gen(the_move.id, i); } @@ -537,7 +538,7 @@ impl<'a, 'tcx> MoveData<'tcx> { path: MovePathIndex, kill_id: hir::ItemLocalId, kill_kind: KillFrom, - dfcx_moves: &mut MoveDataFlow) { + dfcx_moves: &mut MoveDataFlow<'_, '_>) { // We can only perform kills for paths that refer to a unique location, // since otherwise we may kill a move from one location with an // assignment referring to another location. diff --git a/src/librustc_borrowck/borrowck/unused.rs b/src/librustc_borrowck/borrowck/unused.rs index 5db98f0e223e4..60a9c18e95ee9 100644 --- a/src/librustc_borrowck/borrowck/unused.rs +++ b/src/librustc_borrowck/borrowck/unused.rs @@ -7,7 +7,7 @@ use errors::Applicability; use std::slice; use syntax::ptr::P; -use borrowck::BorrowckCtxt; +use crate::borrowck::BorrowckCtxt; pub fn check<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, body: &'tcx hir::Body) { let mut used_mut = bccx.used_mut_nodes.borrow().clone(); diff --git a/src/librustc_borrowck/dataflow.rs b/src/librustc_borrowck/dataflow.rs index 8cf620567405c..90f33ede62c21 100644 --- a/src/librustc_borrowck/dataflow.rs +++ b/src/librustc_borrowck/dataflow.rs @@ -10,6 +10,7 @@ use std::io; use std::mem; use std::usize; use syntax::print::pprust::PrintState; +use log::debug; use rustc_data_structures::graph::implementation::OUTGOING; @@ -80,7 +81,7 @@ pub trait DataFlowOperator : BitwiseOperator { fn initial_value(&self) -> bool; } -struct PropagationContext<'a, 'b: 'a, 'tcx: 'b, O: 'a> { +struct PropagationContext<'a, 'b: 'a, 'tcx: 'b, O> { dfcx: &'a mut DataFlowContext<'b, 'tcx, O>, changed: bool } @@ -99,12 +100,12 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { } impl<'a, 'tcx, O:DataFlowOperator> pprust::PpAnn for DataFlowContext<'a, 'tcx, O> { - fn nested(&self, state: &mut pprust::State, nested: pprust::Nested) -> io::Result<()> { + fn nested(&self, state: &mut pprust::State<'_>, nested: pprust::Nested) -> io::Result<()> { pprust::PpAnn::nested(self.tcx.hir(), state, nested) } fn pre(&self, - ps: &mut pprust::State, - node: pprust::AnnNode) -> io::Result<()> { + ps: &mut pprust::State<'_>, + node: pprust::AnnNode<'_>) -> io::Result<()> { let id = match node { pprust::AnnNode::Name(_) => return Ok(()), pprust::AnnNode::Expr(expr) => expr.hir_id.local_id, diff --git a/src/librustc_borrowck/graphviz.rs b/src/librustc_borrowck/graphviz.rs index adad8c55f2159..77056d4d3eb15 100644 --- a/src/librustc_borrowck/graphviz.rs +++ b/src/librustc_borrowck/graphviz.rs @@ -2,16 +2,15 @@ //! libgraphviz traits, specialized to attaching borrowck analysis //! data to rendered labels. -pub use self::Variant::*; +pub use Variant::*; pub use rustc::cfg::graphviz::{Node, Edge}; use rustc::cfg::graphviz as cfg_dot; -use borrowck; -use borrowck::{BorrowckCtxt, LoanPath}; -use dot; +use crate::borrowck::{self, BorrowckCtxt, LoanPath}; +use crate::dataflow::{DataFlowOperator, DataFlowContext, EntryOrExit}; +use log::debug; use rustc::cfg::CFGIndex; -use dataflow::{DataFlowOperator, DataFlowContext, EntryOrExit}; use std::rc::Rc; #[derive(Debug, Copy, Clone)] @@ -53,7 +52,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { sets } - fn dataflow_for_variant(&self, e: EntryOrExit, n: &Node, v: Variant) -> String { + fn dataflow_for_variant(&self, e: EntryOrExit, n: &Node<'_>, v: Variant) -> String { let cfgidx = n.0; match v { Loans => self.dataflow_loans_for(e, cfgidx), @@ -89,7 +88,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> { let dfcx = &self.analysis_data.loans; let loan_index_to_path = |loan_index| { let all_loans = &self.analysis_data.all_loans; - let l: &borrowck::Loan = &all_loans[loan_index]; + let l: &borrowck::Loan<'_> = &all_loans[loan_index]; l.loan_path() }; self.build_set(e, cfgidx, dfcx, loan_index_to_path) diff --git a/src/librustc_borrowck/lib.rs b/src/librustc_borrowck/lib.rs index 8bdc4e1d5c1ea..75ac38209371a 100644 --- a/src/librustc_borrowck/lib.rs +++ b/src/librustc_borrowck/lib.rs @@ -3,23 +3,14 @@ html_root_url = "https://doc.rust-lang.org/nightly/")] #![allow(non_camel_case_types)] +#![deny(rust_2018_idioms)] #![feature(nll)] #![recursion_limit="256"] -#[macro_use] extern crate log; -extern crate syntax; -extern crate syntax_pos; -extern crate rustc_errors as errors; -extern crate rustc_data_structures; - -// for "clarity", rename the graphviz crate to dot; graphviz within `borrowck` -// refers to the borrowck-specific graphviz adapter traits. -extern crate graphviz as dot; #[macro_use] extern crate rustc; -extern crate rustc_mir; pub use borrowck::check_crate; pub use borrowck::build_borrowck_dataflow_data_for_fn; From 4f2e97e0ed4a988a037a132f1efdd9456f1c1315 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 21:16:35 +0900 Subject: [PATCH 215/278] librustc_incremental => 2018 --- src/librustc_incremental/Cargo.toml | 1 + src/librustc_incremental/assert_dep_graph.rs | 12 ++++----- src/librustc_incremental/lib.rs | 11 +++----- .../persist/dirty_clean.rs | 4 +-- src/librustc_incremental/persist/load.rs | 1 - src/librustc_incremental/persist/mod.rs | 26 +++++++++---------- src/librustc_incremental/persist/save.rs | 4 +-- .../persist/work_product.rs | 2 +- 8 files changed, 29 insertions(+), 32 deletions(-) diff --git a/src/librustc_incremental/Cargo.toml b/src/librustc_incremental/Cargo.toml index b8519ee1ab1a5..10b448b7fec3f 100644 --- a/src/librustc_incremental/Cargo.toml +++ b/src/librustc_incremental/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_incremental" version = "0.0.0" +edition = "2018" [lib] name = "rustc_incremental" diff --git a/src/librustc_incremental/assert_dep_graph.rs b/src/librustc_incremental/assert_dep_graph.rs index 57ab48493fa93..b715a32cb0573 100644 --- a/src/librustc_incremental/assert_dep_graph.rs +++ b/src/librustc_incremental/assert_dep_graph.rs @@ -217,7 +217,7 @@ fn check_paths<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } } -fn dump_graph(tcx: TyCtxt) { +fn dump_graph(tcx: TyCtxt<'_, '_, '_>) { let path: String = env::var("RUST_DEP_GRAPH").unwrap_or_else(|_| "dep_graph".to_string()); let query = tcx.dep_graph.query(); @@ -261,11 +261,11 @@ pub struct GraphvizDepGraph<'q>(FxHashSet<&'q DepNode>, impl<'a, 'tcx, 'q> dot::GraphWalk<'a> for GraphvizDepGraph<'q> { type Node = &'q DepNode; type Edge = (&'q DepNode, &'q DepNode); - fn nodes(&self) -> dot::Nodes<&'q DepNode> { + fn nodes(&self) -> dot::Nodes<'_, &'q DepNode> { let nodes: Vec<_> = self.0.iter().cloned().collect(); nodes.into() } - fn edges(&self) -> dot::Edges<(&'q DepNode, &'q DepNode)> { + fn edges(&self) -> dot::Edges<'_, (&'q DepNode, &'q DepNode)> { self.1[..].into() } fn source(&self, edge: &(&'q DepNode, &'q DepNode)) -> &'q DepNode { @@ -279,10 +279,10 @@ impl<'a, 'tcx, 'q> dot::GraphWalk<'a> for GraphvizDepGraph<'q> { impl<'a, 'tcx, 'q> dot::Labeller<'a> for GraphvizDepGraph<'q> { type Node = &'q DepNode; type Edge = (&'q DepNode, &'q DepNode); - fn graph_id(&self) -> dot::Id { + fn graph_id(&self) -> dot::Id<'_> { dot::Id::new("DependencyGraph").unwrap() } - fn node_id(&self, n: &&'q DepNode) -> dot::Id { + fn node_id(&self, n: &&'q DepNode) -> dot::Id<'_> { let s: String = format!("{:?}", n).chars() .map(|c| if c == '_' || c.is_alphanumeric() { c } else { '_' }) @@ -290,7 +290,7 @@ impl<'a, 'tcx, 'q> dot::Labeller<'a> for GraphvizDepGraph<'q> { debug!("n={:?} s={:?}", n, s); dot::Id::new(s).unwrap() } - fn node_label(&self, n: &&'q DepNode) -> dot::LabelText { + fn node_label(&self, n: &&'q DepNode) -> dot::LabelText<'_> { dot::LabelText::label(format!("{:?}", n)) } } diff --git a/src/librustc_incremental/lib.rs b/src/librustc_incremental/lib.rs index ae2e6e0b94cfc..1fc51c2731140 100644 --- a/src/librustc_incremental/lib.rs +++ b/src/librustc_incremental/lib.rs @@ -9,16 +9,13 @@ #![recursion_limit="256"] -extern crate graphviz; +#![deny(rust_2018_idioms)] + #[macro_use] extern crate rustc; -extern crate rustc_data_structures; -extern crate serialize as rustc_serialize; -extern crate rand; -extern crate rustc_fs_util; +#[allow(unused_extern_crates)] +extern crate serialize as rustc_serialize; // used by deriving #[macro_use] extern crate log; -extern crate syntax; -extern crate syntax_pos; mod assert_dep_graph; pub mod assert_module_sources; diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index 3ff4d2ec38dff..9b52199465b5c 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -538,7 +538,7 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for DirtyCleanVisitor<'a, 'tcx> { /// /// Also make sure that the `label` and `except` fields do not /// both exist. -fn check_config(tcx: TyCtxt, attr: &Attribute) -> bool { +fn check_config(tcx: TyCtxt<'_, '_, '_>, attr: &Attribute) -> bool { debug!("check_config(attr={:?})", attr); let config = &tcx.sess.parse_sess.config; debug!("check_config: config={:?}", config); @@ -573,7 +573,7 @@ fn check_config(tcx: TyCtxt, attr: &Attribute) -> bool { } } -fn expect_associated_value(tcx: TyCtxt, item: &NestedMetaItem) -> ast::Name { +fn expect_associated_value(tcx: TyCtxt<'_, '_, '_>, item: &NestedMetaItem) -> ast::Name { if let Some(value) = item.value_str() { value } else { diff --git a/src/librustc_incremental/persist/load.rs b/src/librustc_incremental/persist/load.rs index f330de7191865..ecf8bc4a88084 100644 --- a/src/librustc_incremental/persist/load.rs +++ b/src/librustc_incremental/persist/load.rs @@ -9,7 +9,6 @@ use rustc::util::common::time_ext; use rustc_serialize::Decodable as RustcDecodable; use rustc_serialize::opaque::Decoder; use std::path::Path; -use std; use super::data::*; use super::fs::*; diff --git a/src/librustc_incremental/persist/mod.rs b/src/librustc_incremental/persist/mod.rs index bd59f24d04e79..3aad4f5abb884 100644 --- a/src/librustc_incremental/persist/mod.rs +++ b/src/librustc_incremental/persist/mod.rs @@ -10,16 +10,16 @@ mod save; mod work_product; mod file_format; -pub use self::fs::finalize_session_directory; -pub use self::fs::garbage_collect_session_directories; -pub use self::fs::in_incr_comp_dir; -pub use self::fs::in_incr_comp_dir_sess; -pub use self::fs::prepare_session_directory; -pub use self::load::dep_graph_tcx_init; -pub use self::load::load_dep_graph; -pub use self::load::load_query_result_cache; -pub use self::load::LoadResult; -pub use self::save::save_dep_graph; -pub use self::save::save_work_product_index; -pub use self::work_product::copy_cgu_workproducts_to_incr_comp_cache_dir; -pub use self::work_product::delete_workproduct_files; +pub use fs::finalize_session_directory; +pub use fs::garbage_collect_session_directories; +pub use fs::in_incr_comp_dir; +pub use fs::in_incr_comp_dir_sess; +pub use fs::prepare_session_directory; +pub use load::dep_graph_tcx_init; +pub use load::load_dep_graph; +pub use load::load_query_result_cache; +pub use load::LoadResult; +pub use save::save_dep_graph; +pub use save::save_work_product_index; +pub use work_product::copy_cgu_workproducts_to_incr_comp_cache_dir; +pub use work_product::delete_workproduct_files; diff --git a/src/librustc_incremental/persist/save.rs b/src/librustc_incremental/persist/save.rs index 6a7553b388297..34fe2f1c25d04 100644 --- a/src/librustc_incremental/persist/save.rs +++ b/src/librustc_incremental/persist/save.rs @@ -129,7 +129,7 @@ fn save_in(sess: &Session, path_buf: PathBuf, encode: F) } } -fn encode_dep_graph(tcx: TyCtxt, +fn encode_dep_graph(tcx: TyCtxt<'_, '_, '_>, encoder: &mut Encoder) { // First encode the commandline arguments hash tcx.sess.opts.dep_tracking_hash().encode(encoder).unwrap(); @@ -234,7 +234,7 @@ fn encode_work_product_index(work_products: &FxHashMap, encoder: &mut Encoder) { time(tcx.sess, "serialize query result cache", || { tcx.serialize_query_result_cache(encoder).unwrap(); diff --git a/src/librustc_incremental/persist/work_product.rs b/src/librustc_incremental/persist/work_product.rs index 535f6930aa39a..3495b27c5ebca 100644 --- a/src/librustc_incremental/persist/work_product.rs +++ b/src/librustc_incremental/persist/work_product.rs @@ -1,6 +1,6 @@ //! This module contains files for saving intermediate work-products. -use persist::fs::*; +use crate::persist::fs::*; use rustc::dep_graph::{WorkProduct, WorkProductId, WorkProductFileKind}; use rustc::session::Session; use rustc_fs_util::link_or_copy; From fe276239b3e01129fe1c2ecf5d729a430a6e184e Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Fri, 8 Feb 2019 22:30:58 +0900 Subject: [PATCH 216/278] librustc_typeck => 2018 --- src/librustc_typeck/Cargo.toml | 3 +- src/librustc_typeck/astconv.rs | 20 ++++++------ src/librustc_typeck/check/_match.rs | 6 ++-- src/librustc_typeck/check/cast.rs | 8 ++--- src/librustc_typeck/check/closure.rs | 4 +-- src/librustc_typeck/check/coercion.rs | 2 +- src/librustc_typeck/check/demand.rs | 2 +- src/librustc_typeck/check/dropck.rs | 6 ++-- .../check/generator_interior.rs | 2 +- src/librustc_typeck/check/intrinsic.rs | 2 +- src/librustc_typeck/check/method/confirm.rs | 8 ++--- src/librustc_typeck/check/method/mod.rs | 6 ++-- src/librustc_typeck/check/method/probe.rs | 10 +++--- src/librustc_typeck/check/method/suggest.rs | 8 ++--- src/librustc_typeck/check/mod.rs | 32 +++++++++---------- src/librustc_typeck/check/regionck.rs | 10 +++--- src/librustc_typeck/check/upvar.rs | 6 ++-- src/librustc_typeck/check/wfcheck.rs | 6 ++-- src/librustc_typeck/check/writeback.rs | 2 +- src/librustc_typeck/check_unused.rs | 2 +- .../coherence/inherent_impls_overlap.rs | 4 +-- src/librustc_typeck/coherence/mod.rs | 2 +- src/librustc_typeck/collect.rs | 16 +++++----- .../constrained_type_params.rs | 2 +- src/librustc_typeck/impl_wf_check.rs | 4 +-- src/librustc_typeck/lib.rs | 16 ++++------ src/librustc_typeck/outlives/explicit.rs | 2 +- .../outlives/implicit_infer.rs | 3 +- src/librustc_typeck/outlives/mod.rs | 2 +- src/librustc_typeck/variance/terms.rs | 2 +- 30 files changed, 98 insertions(+), 100 deletions(-) diff --git a/src/librustc_typeck/Cargo.toml b/src/librustc_typeck/Cargo.toml index 68b28a60fdff7..dcfcd74257e6f 100644 --- a/src/librustc_typeck/Cargo.toml +++ b/src/librustc_typeck/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_typeck" version = "0.0.0" +edition = "2018" [lib] name = "rustc_typeck" @@ -14,7 +15,7 @@ arena = { path = "../libarena" } log = "0.4" rustc = { path = "../librustc" } rustc_data_structures = { path = "../librustc_data_structures" } -rustc_errors = { path = "../librustc_errors" } +errors = { path = "../librustc_errors", package = "rustc_errors" } rustc_target = { path = "../librustc_target" } smallvec = { version = "0.6.7", features = ["union", "may_dangle"] } syntax = { path = "../libsyntax" } diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 8da0b6dcbeac3..d6e9b5a4251e2 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -3,13 +3,13 @@ //! instance of `AstConv`. use errors::{Applicability, DiagnosticId}; -use hir::{self, GenericArg, GenericArgs}; -use hir::def::Def; -use hir::def_id::DefId; -use hir::HirVec; -use lint; -use middle::resolve_lifetime as rl; -use namespace::Namespace; +use crate::hir::{self, GenericArg, GenericArgs}; +use crate::hir::def::Def; +use crate::hir::def_id::DefId; +use crate::hir::HirVec; +use crate::lint; +use crate::middle::resolve_lifetime as rl; +use crate::namespace::Namespace; use rustc::lint::builtin::AMBIGUOUS_ASSOCIATED_ITEMS; use rustc::traits; use rustc::ty::{self, Ty, TyCtxt, ToPredicate, TypeFoldable}; @@ -18,15 +18,15 @@ use rustc::ty::subst::{Kind, Subst, Substs}; use rustc::ty::wf::object_region_bounds; use rustc_data_structures::sync::Lrc; use rustc_target::spec::abi; -use require_c_abi_if_variadic; +use crate::require_c_abi_if_variadic; use smallvec::SmallVec; use syntax::ast; use syntax::feature_gate::{GateIssue, emit_feature_err}; use syntax::ptr::P; use syntax::util::lev_distance::find_best_match_for_name; use syntax_pos::{DUMMY_SP, Span, MultiSpan}; -use util::common::ErrorReported; -use util::nodemap::FxHashMap; +use crate::util::common::ErrorReported; +use crate::util::nodemap::FxHashMap; use std::collections::BTreeSet; use std::iter; diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index a90d83f3f8be0..3a670c8e2f15e 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -1,5 +1,6 @@ -use check::{FnCtxt, Expectation, Diverges, Needs}; -use check::coercion::CoerceMany; +use crate::check::{FnCtxt, Expectation, Diverges, Needs}; +use crate::check::coercion::CoerceMany; +use crate::util::nodemap::FxHashMap; use errors::Applicability; use rustc::hir::{self, PatKind}; use rustc::hir::def::{Def, CtorKind}; @@ -13,7 +14,6 @@ use syntax::source_map::Spanned; use syntax::ptr::P; use syntax::util::lev_distance::find_best_match_for_name; use syntax_pos::Span; -use util::nodemap::FxHashMap; use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::cmp; diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index 85cae17fd8524..be6d432a67f9e 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -31,8 +31,8 @@ use super::FnCtxt; use errors::{DiagnosticBuilder,Applicability}; -use hir::def_id::DefId; -use lint; +use crate::hir::def_id::DefId; +use crate::lint; use rustc::hir; use rustc::session::Session; use rustc::traits; @@ -43,7 +43,7 @@ use rustc::ty::subst::Substs; use rustc::middle::lang_items; use syntax::ast; use syntax_pos::Span; -use util::common::ErrorReported; +use crate::util::common::ErrorReported; /// Reifies a cast check to be checked once we have full type information for /// a function context. @@ -294,7 +294,7 @@ impl<'a, 'gcx, 'tcx> CastCheck<'tcx> { .emit(); } CastError::SizedUnsizedCast => { - use structured_errors::{SizedUnsizedCastError, StructuredDiagnostic}; + use crate::structured_errors::{SizedUnsizedCastError, StructuredDiagnostic}; SizedUnsizedCastError::new(&fcx.tcx.sess, self.span, self.expr_ty, diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index df83c92fde5b4..24c300911b384 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -2,8 +2,8 @@ use super::{check_fn, Expectation, FnCtxt, GeneratorTypes}; -use astconv::AstConv; -use middle::region; +use crate::astconv::AstConv; +use crate::middle::region; use rustc::hir::def_id::DefId; use rustc::infer::{InferOk, InferResult}; use rustc::infer::LateBoundRegionConversionTime; diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index d1dfe9469fb77..8a91e425db7bf 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -50,7 +50,7 @@ //! sort of a minor point so I've opted to leave it for later---after all //! we may want to adjust precisely when coercions occur. -use check::{FnCtxt, Needs}; +use crate::check::{FnCtxt, Needs}; use errors::DiagnosticBuilder; use rustc::hir; use rustc::hir::def_id::DefId; diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 0d4690c83170a..82f00374521bd 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -1,4 +1,4 @@ -use check::FnCtxt; +use crate::check::FnCtxt; use rustc::infer::InferOk; use rustc::traits::{ObligationCause, ObligationCauseCode}; diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index 60b5db0d12cc4..d7ed949006a6b 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -1,13 +1,13 @@ -use check::regionck::RegionCtxt; +use crate::check::regionck::RegionCtxt; -use hir::def_id::DefId; +use crate::hir::def_id::DefId; use rustc::infer::outlives::env::OutlivesEnvironment; use rustc::infer::{self, InferOk, SuppressRegionErrors}; use rustc::middle::region; use rustc::traits::{ObligationCause, TraitEngine, TraitEngineExt}; use rustc::ty::subst::{Subst, Substs, UnpackedKind}; use rustc::ty::{self, Ty, TyCtxt}; -use util::common::ErrorReported; +use crate::util::common::ErrorReported; use syntax::ast; use syntax_pos::Span; diff --git a/src/librustc_typeck/check/generator_interior.rs b/src/librustc_typeck/check/generator_interior.rs index 225fa1dc4f45c..7f4b0a96a15ab 100644 --- a/src/librustc_typeck/check/generator_interior.rs +++ b/src/librustc_typeck/check/generator_interior.rs @@ -11,7 +11,7 @@ use rustc::ty::{self, Ty}; use rustc_data_structures::sync::Lrc; use syntax_pos::Span; use super::FnCtxt; -use util::nodemap::FxHashMap; +use crate::util::nodemap::FxHashMap; struct InteriorVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> { fcx: &'a FnCtxt<'a, 'gcx, 'tcx>, diff --git a/src/librustc_typeck/check/intrinsic.rs b/src/librustc_typeck/check/intrinsic.rs index 82d4300d99687..912ea39dce3ce 100644 --- a/src/librustc_typeck/check/intrinsic.rs +++ b/src/librustc_typeck/check/intrinsic.rs @@ -4,7 +4,7 @@ use rustc::traits::{ObligationCause, ObligationCauseCode}; use rustc::ty::{self, TyCtxt, Ty}; use rustc::ty::subst::Subst; -use require_same_types; +use crate::require_same_types; use rustc_target::spec::abi::Abi; use syntax::symbol::Symbol; diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index 2cf2974a45a1c..34b248a106cb0 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -1,9 +1,9 @@ use super::{probe, MethodCallee}; -use astconv::AstConv; -use check::{FnCtxt, PlaceOp, callee, Needs}; -use hir::GenericArg; -use hir::def_id::DefId; +use crate::astconv::AstConv; +use crate::check::{FnCtxt, PlaceOp, callee, Needs}; +use crate::hir::GenericArg; +use crate::hir::def_id::DefId; use rustc::ty::subst::Substs; use rustc::traits; use rustc::ty::{self, Ty, GenericParamDefKind}; diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs index b7d015729b42d..02cd5b7985594 100644 --- a/src/librustc_typeck/check/method/mod.rs +++ b/src/librustc_typeck/check/method/mod.rs @@ -10,9 +10,9 @@ pub use self::MethodError::*; pub use self::CandidateSource::*; pub use self::suggest::{SelfSource, TraitInfo}; -use check::FnCtxt; +use crate::check::FnCtxt; +use crate::namespace::Namespace; use errors::{Applicability, DiagnosticBuilder}; -use namespace::Namespace; use rustc_data_structures::sync::Lrc; use rustc::hir; use rustc::hir::def::Def; @@ -29,7 +29,7 @@ use syntax_pos::Span; use crate::{check_type_alias_enum_variants_enabled}; use self::probe::{IsSuggestion, ProbeScope}; -pub fn provide(providers: &mut ty::query::Providers) { +pub fn provide(providers: &mut ty::query::Providers<'_>) { suggest::provide(providers); probe::provide(providers); } diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 623677482db34..3636c1fa2ffb5 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -3,11 +3,11 @@ use super::NoMatchData; use super::{CandidateSource, ImplSource, TraitSource}; use super::suggest; -use check::autoderef::{self, Autoderef}; -use check::FnCtxt; -use hir::def_id::DefId; -use hir::def::Def; -use namespace::Namespace; +use crate::check::autoderef::{self, Autoderef}; +use crate::check::FnCtxt; +use crate::hir::def_id::DefId; +use crate::hir::def::Def; +use crate::namespace::Namespace; use rustc_data_structures::sync::Lrc; use rustc::hir; diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index 55b6e8f099ea9..8f98b347b4cc6 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -1,10 +1,11 @@ //! Give useful errors and suggestions to users when an item can't be //! found or is otherwise invalid. -use check::FnCtxt; +use crate::check::FnCtxt; +use crate::middle::lang_items::FnOnceTraitLangItem; +use crate::namespace::Namespace; +use crate::util::nodemap::FxHashSet; use errors::{Applicability, DiagnosticBuilder}; -use middle::lang_items::FnOnceTraitLangItem; -use namespace::Namespace; use rustc_data_structures::sync::Lrc; use rustc::hir::{self, ExprKind, Node, QPath}; use rustc::hir::def::Def; @@ -15,7 +16,6 @@ use rustc::infer::type_variable::TypeVariableOrigin; use rustc::traits::Obligation; use rustc::ty::{self, Adt, Ty, TyCtxt, ToPolyTraitRef, ToPredicate, TypeFoldable}; use rustc::ty::item_path::with_crate_prefix; -use util::nodemap::FxHashSet; use syntax_pos::{Span, FileName}; use syntax::ast; use syntax::util::lev_distance::find_best_match_for_name; diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 3e2a9d720f1c1..01da7179c5763 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -83,15 +83,15 @@ mod generator_interior; pub mod intrinsic; mod op; -use astconv::{AstConv, PathSeg}; +use crate::astconv::{AstConv, PathSeg}; use errors::{Applicability, DiagnosticBuilder, DiagnosticId}; use rustc::hir::{self, ExprKind, GenericArg, ItemKind, Node, PatKind, QPath}; use rustc::hir::def::{CtorKind, Def}; use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap}; use rustc::hir::itemlikevisit::ItemLikeVisitor; -use middle::lang_items; -use namespace::Namespace; +use crate::middle::lang_items; +use crate::namespace::Namespace; use rustc::infer::{self, InferCtxt, InferOk, InferResult, RegionVariableOrigin}; use rustc::infer::canonical::{Canonical, OriginalQueryValues, QueryResponse}; use rustc_data_structures::indexed_vec::Idx; @@ -130,14 +130,14 @@ use std::mem::replace; use std::ops::{self, Deref}; use std::slice; -use require_c_abi_if_variadic; -use session::{CompileIncomplete, Session}; -use session::config::EntryFnType; -use TypeAndSubsts; -use lint; -use util::captures::Captures; -use util::common::{ErrorReported, indenter}; -use util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap}; +use crate::require_c_abi_if_variadic; +use crate::session::{CompileIncomplete, Session}; +use crate::session::config::EntryFnType; +use crate::TypeAndSubsts; +use crate::lint; +use crate::util::captures::Captures; +use crate::util::common::{ErrorReported, indenter}; +use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap}; pub use self::Expectation::*; use self::autoderef::Autoderef; @@ -3044,7 +3044,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // arguments which we skipped above. if variadic { fn variadic_error<'tcx>(s: &Session, span: Span, t: Ty<'tcx>, cast_ty: &str) { - use structured_errors::{VariadicError, StructuredDiagnostic}; + use crate::structured_errors::{VariadicError, StructuredDiagnostic}; VariadicError::new(s, span, t, cast_ty).diagnostic().emit(); } @@ -3685,8 +3685,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { display } - fn no_such_field_err(&self, span: Span, field: T, expr_t: &ty::TyS) - -> DiagnosticBuilder { + fn no_such_field_err(&self, span: Span, field: T, expr_t: &ty::TyS<'_>) + -> DiagnosticBuilder<'_> { type_error_struct!(self.tcx().sess, span, expr_t, E0609, "no field `{}` on type `{}`", field, expr_t) @@ -5257,7 +5257,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { &self, blk: &'gcx hir::Block, expected_ty: Ty<'tcx>, - err: &mut DiagnosticBuilder, + err: &mut DiagnosticBuilder<'_>, ) { if let Some(span_semi) = self.could_remove_semicolon(blk, expected_ty) { err.span_suggestion( @@ -5725,7 +5725,7 @@ fn fatally_break_rust(sess: &Session) { ); handler.note_without_error(&format!("rustc {} running on {}", option_env!("CFG_VERSION").unwrap_or("unknown_version"), - ::session::config::host_triple(), + crate::session::config::host_triple(), )); } diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index b90c18eb41cb5..c058977181c9b 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -72,11 +72,11 @@ //! relation, except that a borrowed pointer never owns its //! contents. -use check::dropck; -use check::FnCtxt; -use middle::mem_categorization as mc; -use middle::mem_categorization::Categorization; -use middle::region; +use crate::check::dropck; +use crate::check::FnCtxt; +use crate::middle::mem_categorization as mc; +use crate::middle::mem_categorization::Categorization; +use crate::middle::region; use rustc::hir::def_id::DefId; use rustc::infer::outlives::env::OutlivesEnvironment; use rustc::infer::{self, RegionObligation, SuppressRegionErrors}; diff --git a/src/librustc_typeck/check/upvar.rs b/src/librustc_typeck/check/upvar.rs index ffd7c2114e5ab..f28de9bc5876d 100644 --- a/src/librustc_typeck/check/upvar.rs +++ b/src/librustc_typeck/check/upvar.rs @@ -32,9 +32,9 @@ use super::FnCtxt; -use middle::expr_use_visitor as euv; -use middle::mem_categorization as mc; -use middle::mem_categorization::Categorization; +use crate::middle::expr_use_visitor as euv; +use crate::middle::mem_categorization as mc; +use crate::middle::mem_categorization::Categorization; use rustc::hir; use rustc::hir::def_id::DefId; use rustc::hir::def_id::LocalDefId; diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs index 97881708b0a07..3b80429532da0 100644 --- a/src/librustc_typeck/check/wfcheck.rs +++ b/src/librustc_typeck/check/wfcheck.rs @@ -1,7 +1,7 @@ -use check::{Inherited, FnCtxt}; -use constrained_type_params::{identify_constrained_type_params, Parameter}; +use crate::check::{Inherited, FnCtxt}; +use crate::constrained_type_params::{identify_constrained_type_params, Parameter}; -use hir::def_id::DefId; +use crate::hir::def_id::DefId; use rustc::traits::{self, ObligationCauseCode}; use rustc::ty::{self, Lift, Ty, TyCtxt, TyKind, GenericParamDefKind, TypeFoldable, ToPredicate}; use rustc::ty::subst::{Subst, Substs}; diff --git a/src/librustc_typeck/check/writeback.rs b/src/librustc_typeck/check/writeback.rs index 238b087fe32f8..46ca538546460 100644 --- a/src/librustc_typeck/check/writeback.rs +++ b/src/librustc_typeck/check/writeback.rs @@ -2,7 +2,7 @@ // unresolved type variables and replaces "ty_var" types with their // substitutions. -use check::FnCtxt; +use crate::check::FnCtxt; use errors::DiagnosticBuilder; use rustc::hir; use rustc::hir::def_id::{DefId, DefIndex}; diff --git a/src/librustc_typeck/check_unused.rs b/src/librustc_typeck/check_unused.rs index a7e19fc4237cc..18194eeba80a2 100644 --- a/src/librustc_typeck/check_unused.rs +++ b/src/librustc_typeck/check_unused.rs @@ -1,4 +1,4 @@ -use lint; +use crate::lint; use rustc::ty::TyCtxt; use errors::Applicability; diff --git a/src/librustc_typeck/coherence/inherent_impls_overlap.rs b/src/librustc_typeck/coherence/inherent_impls_overlap.rs index 52dee29294cb7..138c598a7bbf0 100644 --- a/src/librustc_typeck/coherence/inherent_impls_overlap.rs +++ b/src/librustc_typeck/coherence/inherent_impls_overlap.rs @@ -1,11 +1,11 @@ -use namespace::Namespace; +use crate::namespace::Namespace; use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; use rustc::hir; use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::traits::{self, IntercrateMode}; use rustc::ty::TyCtxt; -use lint; +use crate::lint; pub fn crate_inherent_impls_overlap_check<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum) { diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index 853c4c85d3f3b..4eee68b99d968 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -5,7 +5,7 @@ // done by the orphan and overlap modules. Then we build up various // mappings. That mapping code resides here. -use hir::def_id::{DefId, LOCAL_CRATE}; +use crate::hir::def_id::{DefId, LOCAL_CRATE}; use rustc::traits; use rustc::ty::{self, TyCtxt, TypeFoldable}; use rustc::ty::query::Providers; diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 9dc74c5d63a4e..94d20b9db2507 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -14,13 +14,13 @@ //! At present, however, we do run collection across all items in the //! crate as a kind of pass. This should eventually be factored away. -use astconv::{AstConv, Bounds}; -use constrained_type_params as ctp; -use check::intrinsic::intrisic_operation_unsafety; -use lint; -use middle::lang_items::SizedTraitLangItem; -use middle::resolve_lifetime as rl; -use middle::weak_lang_items; +use crate::astconv::{AstConv, Bounds}; +use crate::constrained_type_params as ctp; +use crate::check::intrinsic::intrisic_operation_unsafety; +use crate::lint; +use crate::middle::lang_items::SizedTraitLangItem; +use crate::middle::resolve_lifetime as rl; +use crate::middle::weak_lang_items; use rustc::mir::mono::Linkage; use rustc::ty::query::Providers; use rustc::ty::subst::Substs; @@ -68,7 +68,7 @@ fn collect_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefI ); } -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { *providers = Providers { type_of, generics_of, diff --git a/src/librustc_typeck/constrained_type_params.rs b/src/librustc_typeck/constrained_type_params.rs index 199ea315896df..d1f33b65fc07a 100644 --- a/src/librustc_typeck/constrained_type_params.rs +++ b/src/librustc_typeck/constrained_type_params.rs @@ -124,7 +124,7 @@ pub fn identify_constrained_type_params<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, /// which is determined by 1, which requires `U`, that is determined /// by 0. I should probably pick a less tangled example, but I can't /// think of any. -pub fn setup_constraining_predicates<'tcx>(tcx: TyCtxt, +pub fn setup_constraining_predicates<'tcx>(tcx: TyCtxt<'_, '_, '_>, predicates: &mut [(ty::Predicate<'tcx>, Span)], impl_trait_ref: Option>, input_parameters: &mut FxHashSet) diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs index 07f5fca6fe68e..6de06b6481695 100644 --- a/src/librustc_typeck/impl_wf_check.rs +++ b/src/librustc_typeck/impl_wf_check.rs @@ -8,7 +8,7 @@ //! specialization errors. These things can (and probably should) be //! fixed, but for the moment it's easier to do these checks early. -use constrained_type_params as ctp; +use crate::constrained_type_params as ctp; use rustc::hir; use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir::def_id::DefId; @@ -162,7 +162,7 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // used elsewhere are not projected back out. } -fn report_unused_parameter(tcx: TyCtxt, +fn report_unused_parameter(tcx: TyCtxt<'_, '_, '_>, span: Span, kind: &str, name: &str) diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 8d77310f3d427..e99ec539c7721 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -72,17 +72,15 @@ This API is completely unstable and subject to change. #![recursion_limit="256"] +#![deny(rust_2018_idioms)] +#![allow(explicit_outlives_requirements)] + +#![allow(elided_lifetimes_in_paths)] // WIP + #[macro_use] extern crate log; #[macro_use] extern crate syntax; -extern crate syntax_pos; - -extern crate arena; #[macro_use] extern crate rustc; -extern crate rustc_data_structures; -extern crate rustc_errors as errors; -extern crate rustc_target; -extern crate smallvec; // N.B., this module needs to be declared first so diagnostics are // registered before they are used. @@ -141,7 +139,7 @@ fn check_type_alias_enum_variants_enabled<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, } } -fn require_c_abi_if_variadic(tcx: TyCtxt, +fn require_c_abi_if_variadic(tcx: TyCtxt<'_, '_, '_>, decl: &hir::FnDecl, abi: Abi, span: Span) { @@ -310,7 +308,7 @@ fn check_for_entry_fn<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { } } -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { collect::provide(providers); coherence::provide(providers); check::provide(providers); diff --git a/src/librustc_typeck/outlives/explicit.rs b/src/librustc_typeck/outlives/explicit.rs index 38f4b37b29289..574086f780a9d 100644 --- a/src/librustc_typeck/outlives/explicit.rs +++ b/src/librustc_typeck/outlives/explicit.rs @@ -1,6 +1,6 @@ use rustc::hir::def_id::DefId; use rustc::ty::{self, OutlivesPredicate, TyCtxt}; -use util::nodemap::FxHashMap; +use crate::util::nodemap::FxHashMap; use super::utils::*; diff --git a/src/librustc_typeck/outlives/implicit_infer.rs b/src/librustc_typeck/outlives/implicit_infer.rs index e388a3e0d0c2f..0ff884d72b19f 100644 --- a/src/librustc_typeck/outlives/implicit_infer.rs +++ b/src/librustc_typeck/outlives/implicit_infer.rs @@ -1,5 +1,4 @@ -use rustc::hir; -use hir::Node; +use rustc::hir::{self, Node}; use rustc::hir::def_id::DefId; use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::ty::subst::{Kind, Subst, UnpackedKind}; diff --git a/src/librustc_typeck/outlives/mod.rs b/src/librustc_typeck/outlives/mod.rs index f0310f250a9bd..b3634d37cc2b8 100644 --- a/src/librustc_typeck/outlives/mod.rs +++ b/src/librustc_typeck/outlives/mod.rs @@ -12,7 +12,7 @@ mod implicit_infer; pub mod test; mod utils; -pub fn provide(providers: &mut Providers) { +pub fn provide(providers: &mut Providers<'_>) { *providers = Providers { inferred_outlives_of, inferred_outlives_crate, diff --git a/src/librustc_typeck/variance/terms.rs b/src/librustc_typeck/variance/terms.rs index d53e2d2ad7883..ec0acfb63a89a 100644 --- a/src/librustc_typeck/variance/terms.rs +++ b/src/librustc_typeck/variance/terms.rs @@ -15,7 +15,7 @@ use std::fmt; use syntax::ast; use rustc::hir; use rustc::hir::itemlikevisit::ItemLikeVisitor; -use util::nodemap::NodeMap; +use crate::util::nodemap::NodeMap; use self::VarianceTerm::*; From 5f41f8be30ea93e4fc86be2faea5e981ff3f8c2f Mon Sep 17 00:00:00 2001 From: varkor Date: Fri, 8 Feb 2019 16:44:50 +0100 Subject: [PATCH 217/278] Deny warnings in std stage 0 --- src/bootstrap/builder.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs index b0d15e6a5df5f..8540d92f74917 100644 --- a/src/bootstrap/builder.rs +++ b/src/bootstrap/builder.rs @@ -1018,8 +1018,7 @@ impl<'a> Builder<'a> { cargo.env("RUSTC_VERBOSE", self.verbosity.to_string()); - // in std, we want to avoid denying warnings for stage 0 as that makes cfg's painful. - if self.config.deny_warnings && !(mode == Mode::Std && stage == 0) { + if self.config.deny_warnings { cargo.env("RUSTC_DENY_WARNINGS", "1"); } From 3e2b5a4b08d9647f7438f4e945d4c8b37c36a58c Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Sat, 9 Feb 2019 01:36:22 +0900 Subject: [PATCH 218/278] librustc_data_structures => 2018 --- src/librustc_data_structures/Cargo.toml | 5 +-- src/librustc_data_structures/bit_set.rs | 8 ++--- src/librustc_data_structures/fingerprint.rs | 4 +-- src/librustc_data_structures/flock.rs | 13 ------- .../graph/dominators/mod.rs | 8 ++--- .../graph/implementation/mod.rs | 26 ++++++-------- .../graph/implementation/tests.rs | 2 +- src/librustc_data_structures/graph/scc/mod.rs | 8 ++--- .../graph/scc/test.rs | 2 +- src/librustc_data_structures/graph/test.rs | 2 +- src/librustc_data_structures/indexed_vec.rs | 8 ++--- src/librustc_data_structures/lib.rs | 13 ++----- .../obligation_forest/graphviz.rs | 14 ++++---- .../obligation_forest/mod.rs | 4 +-- .../owning_ref/mod.rs | 6 ++-- src/librustc_data_structures/ptr_key.rs | 2 +- .../snapshot_map/mod.rs | 2 +- src/librustc_data_structures/sorted_map.rs | 2 +- src/librustc_data_structures/stable_hasher.rs | 10 +++--- src/librustc_data_structures/svh.rs | 4 +-- src/librustc_data_structures/sync.rs | 34 +++++++++---------- src/librustc_data_structures/tiny_list.rs | 2 +- .../transitive_relation.rs | 8 ++--- .../vec_linked_list.rs | 2 +- src/librustc_data_structures/work_queue.rs | 4 +-- 25 files changed, 86 insertions(+), 107 deletions(-) diff --git a/src/librustc_data_structures/Cargo.toml b/src/librustc_data_structures/Cargo.toml index 1754376a5d7f9..f781952d4172c 100644 --- a/src/librustc_data_structures/Cargo.toml +++ b/src/librustc_data_structures/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_data_structures" version = "0.0.0" +edition = "2018" [lib] name = "rustc_data_structures" @@ -16,8 +17,8 @@ serialize = { path = "../libserialize" } graphviz = { path = "../libgraphviz" } cfg-if = "0.1.2" stable_deref_trait = "1.0.0" -rustc-rayon = "0.1.1" -rustc-rayon-core = "0.1.1" +rayon = { version = "0.1.1", package = "rustc-rayon" } +rayon-core = { version = "0.1.1", package = "rustc-rayon-core" } rustc-hash = "1.0.1" smallvec = { version = "0.6.7", features = ["union", "may_dangle"] } diff --git a/src/librustc_data_structures/bit_set.rs b/src/librustc_data_structures/bit_set.rs index 8adfe3749af8e..05d2185ae69b4 100644 --- a/src/librustc_data_structures/bit_set.rs +++ b/src/librustc_data_structures/bit_set.rs @@ -1,4 +1,4 @@ -use indexed_vec::{Idx, IndexVec}; +use crate::indexed_vec::{Idx, IndexVec}; use smallvec::SmallVec; use std::fmt; use std::iter; @@ -208,7 +208,7 @@ impl SubtractFromBitSet for BitSet { } impl fmt::Debug for BitSet { - fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result { w.debug_list() .entries(self.iter()) .finish() @@ -366,7 +366,7 @@ impl SparseBitSet { dense } - fn iter(&self) -> slice::Iter { + fn iter(&self) -> slice::Iter<'_, T> { self.elems.iter() } } @@ -536,7 +536,7 @@ impl HybridBitSet { } } - pub fn iter(&self) -> HybridIter { + pub fn iter(&self) -> HybridIter<'_, T> { match self { HybridBitSet::Sparse(sparse) => HybridIter::Sparse(sparse.iter()), HybridBitSet::Dense(dense) => HybridIter::Dense(dense.iter()), diff --git a/src/librustc_data_structures/fingerprint.rs b/src/librustc_data_structures/fingerprint.rs index 2e596ca3e44f1..c4c0db5801209 100644 --- a/src/librustc_data_structures/fingerprint.rs +++ b/src/librustc_data_structures/fingerprint.rs @@ -1,5 +1,5 @@ +use crate::stable_hasher; use std::mem; -use stable_hasher; use serialize; use serialize::opaque::{EncodeResult, Encoder, Decoder}; @@ -70,7 +70,7 @@ impl Fingerprint { } impl ::std::fmt::Display for Fingerprint { - fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + fn fmt(&self, formatter: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { write!(formatter, "{:x}-{:x}", self.0, self.1) } } diff --git a/src/librustc_data_structures/flock.rs b/src/librustc_data_structures/flock.rs index 2dea249f1c07c..255c5fd7fe7ec 100644 --- a/src/librustc_data_structures/flock.rs +++ b/src/librustc_data_structures/flock.rs @@ -14,12 +14,9 @@ cfg_if! { if #[cfg(unix)] { use std::ffi::{CString, OsStr}; use std::os::unix::prelude::*; - use libc; #[cfg(any(target_os = "linux", target_os = "android"))] mod os { - use libc; - #[repr(C)] pub struct flock { pub l_type: libc::c_short, @@ -35,8 +32,6 @@ cfg_if! { #[cfg(target_os = "freebsd")] mod os { - use libc; - #[repr(C)] pub struct flock { pub l_start: libc::off_t, @@ -53,8 +48,6 @@ cfg_if! { target_os = "netbsd", target_os = "openbsd"))] mod os { - use libc; - #[repr(C)] pub struct flock { pub l_start: libc::off_t, @@ -70,8 +63,6 @@ cfg_if! { #[cfg(target_os = "haiku")] mod os { - use libc; - #[repr(C)] pub struct flock { pub l_type: libc::c_short, @@ -87,8 +78,6 @@ cfg_if! { #[cfg(any(target_os = "macos", target_os = "ios"))] mod os { - use libc; - #[repr(C)] pub struct flock { pub l_start: libc::off_t, @@ -104,8 +93,6 @@ cfg_if! { #[cfg(target_os = "solaris")] mod os { - use libc; - #[repr(C)] pub struct flock { pub l_type: libc::c_short, diff --git a/src/librustc_data_structures/graph/dominators/mod.rs b/src/librustc_data_structures/graph/dominators/mod.rs index 536efffbb22f4..aaed41d9fa362 100644 --- a/src/librustc_data_structures/graph/dominators/mod.rs +++ b/src/librustc_data_structures/graph/dominators/mod.rs @@ -117,7 +117,7 @@ impl Dominators { self.immediate_dominators[node].unwrap() } - pub fn dominators(&self, node: Node) -> Iter { + pub fn dominators(&self, node: Node) -> Iter<'_, Node> { assert!(self.is_reachable(node), "node {:?} is not reachable", node); Iter { dominators: self, @@ -136,7 +136,7 @@ impl Dominators { } } -pub struct Iter<'dom, Node: Idx + 'dom> { +pub struct Iter<'dom, Node: Idx> { dominators: &'dom Dominators, node: Option, } @@ -171,7 +171,7 @@ impl DominatorTree { } impl fmt::Debug for DominatorTree { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt( &DominatorTreeNode { tree: self, @@ -188,7 +188,7 @@ struct DominatorTreeNode<'tree, Node: Idx> { } impl<'tree, Node: Idx> fmt::Debug for DominatorTreeNode<'tree, Node> { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { let subtrees: Vec<_> = self.tree .children(self.node) .iter() diff --git a/src/librustc_data_structures/graph/implementation/mod.rs b/src/librustc_data_structures/graph/implementation/mod.rs index 0768873f83626..a8b734094064a 100644 --- a/src/librustc_data_structures/graph/implementation/mod.rs +++ b/src/librustc_data_structures/graph/implementation/mod.rs @@ -20,10 +20,10 @@ //! the field `next_edge`). Each of those fields is an array that should //! be indexed by the direction (see the type `Direction`). -use bit_set::BitSet; +use crate::bit_set::BitSet; +use crate::snapshot_vec::{SnapshotVec, SnapshotVecDelegate}; use std::fmt::Debug; use std::usize; -use snapshot_vec::{SnapshotVec, SnapshotVecDelegate}; #[cfg(test)] mod tests; @@ -212,15 +212,19 @@ impl Graph { .all(|(edge_idx, edge)| f(edge_idx, edge)) } - pub fn outgoing_edges(&self, source: NodeIndex) -> AdjacentEdges { + pub fn outgoing_edges(&self, source: NodeIndex) -> AdjacentEdges<'_, N, E> { self.adjacent_edges(source, OUTGOING) } - pub fn incoming_edges(&self, source: NodeIndex) -> AdjacentEdges { + pub fn incoming_edges(&self, source: NodeIndex) -> AdjacentEdges<'_, N, E> { self.adjacent_edges(source, INCOMING) } - pub fn adjacent_edges(&self, source: NodeIndex, direction: Direction) -> AdjacentEdges { + pub fn adjacent_edges( + &self, + source: NodeIndex, + direction: Direction + ) -> AdjacentEdges<'_, N, E> { let first_edge = self.node(source).first_edge[direction.repr]; AdjacentEdges { graph: self, @@ -291,11 +295,7 @@ impl Graph { // # Iterators -pub struct AdjacentEdges<'g, N, E> -where - N: 'g, - E: 'g, -{ +pub struct AdjacentEdges<'g, N, E> { graph: &'g Graph, direction: Direction, next: EdgeIndex, @@ -331,11 +331,7 @@ impl<'g, N: Debug, E: Debug> Iterator for AdjacentEdges<'g, N, E> { } } -pub struct DepthFirstTraversal<'g, N, E> -where - N: 'g, - E: 'g, -{ +pub struct DepthFirstTraversal<'g, N, E> { graph: &'g Graph, stack: Vec, visited: BitSet, diff --git a/src/librustc_data_structures/graph/implementation/tests.rs b/src/librustc_data_structures/graph/implementation/tests.rs index a7a2504239610..82c6da3f42711 100644 --- a/src/librustc_data_structures/graph/implementation/tests.rs +++ b/src/librustc_data_structures/graph/implementation/tests.rs @@ -1,4 +1,4 @@ -use graph::implementation::*; +use crate::graph::implementation::*; use std::fmt::Debug; type TestGraph = Graph<&'static str, &'static str>; diff --git a/src/librustc_data_structures/graph/scc/mod.rs b/src/librustc_data_structures/graph/scc/mod.rs index baab377ef1276..e3264fda2629c 100644 --- a/src/librustc_data_structures/graph/scc/mod.rs +++ b/src/librustc_data_structures/graph/scc/mod.rs @@ -3,9 +3,9 @@ //! node in the graph. This uses Tarjan's algorithm that completes in //! O(n) time. -use fx::FxHashSet; -use graph::{DirectedGraph, WithNumNodes, WithSuccessors}; -use indexed_vec::{Idx, IndexVec}; +use crate::fx::FxHashSet; +use crate::graph::{DirectedGraph, WithNumNodes, WithSuccessors}; +use crate::indexed_vec::{Idx, IndexVec}; use std::ops::Range; mod test; @@ -93,7 +93,7 @@ impl SccData { } } -struct SccsConstruction<'c, G: DirectedGraph + WithNumNodes + WithSuccessors + 'c, S: Idx> { +struct SccsConstruction<'c, G: DirectedGraph + WithNumNodes + WithSuccessors, S: Idx> { graph: &'c G, /// The state of each node; used during walk to record the stack diff --git a/src/librustc_data_structures/graph/scc/test.rs b/src/librustc_data_structures/graph/scc/test.rs index e23cb1348b015..da3a1ceefe94b 100644 --- a/src/librustc_data_structures/graph/scc/test.rs +++ b/src/librustc_data_structures/graph/scc/test.rs @@ -1,6 +1,6 @@ #![cfg(test)] -use graph::test::TestGraph; +use crate::graph::test::TestGraph; use super::*; #[test] diff --git a/src/librustc_data_structures/graph/test.rs b/src/librustc_data_structures/graph/test.rs index 3d482e448bdb7..b390c41957294 100644 --- a/src/librustc_data_structures/graph/test.rs +++ b/src/librustc_data_structures/graph/test.rs @@ -1,4 +1,4 @@ -use fx::FxHashMap; +use crate::fx::FxHashMap; use std::cmp::max; use std::slice; use std::iter; diff --git a/src/librustc_data_structures/indexed_vec.rs b/src/librustc_data_structures/indexed_vec.rs index 8d8fbe588a021..516ea7fb7d946 100644 --- a/src/librustc_data_structures/indexed_vec.rs +++ b/src/librustc_data_structures/indexed_vec.rs @@ -257,7 +257,7 @@ macro_rules! newtype_index { @type [$type:ident] @debug_format [$debug_format:tt]) => ( impl ::std::fmt::Debug for $type { - fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { write!(fmt, $debug_format, self.as_u32()) } } @@ -495,7 +495,7 @@ impl serialize::Decodable for IndexVec { } impl fmt::Debug for IndexVec { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(&self.raw, fmt) } } @@ -573,7 +573,7 @@ impl IndexVec { } #[inline] - pub fn iter(&self) -> slice::Iter { + pub fn iter(&self) -> slice::Iter<'_, T> { self.raw.iter() } @@ -589,7 +589,7 @@ impl IndexVec { } #[inline] - pub fn iter_mut(&mut self) -> slice::IterMut { + pub fn iter_mut(&mut self) -> slice::IterMut<'_, T> { self.raw.iter_mut() } diff --git a/src/librustc_data_structures/lib.rs b/src/librustc_data_structures/lib.rs index a46f8aed32499..08b453cf493f8 100644 --- a/src/librustc_data_structures/lib.rs +++ b/src/librustc_data_structures/lib.rs @@ -24,23 +24,16 @@ #![cfg_attr(unix, feature(libc))] #![cfg_attr(test, feature(test))] -extern crate core; -extern crate ena; +#![deny(rust_2018_idioms)] + #[macro_use] extern crate log; +#[allow(unused_extern_crates)] extern crate serialize as rustc_serialize; // used by deriving #[cfg(unix)] extern crate libc; -extern crate parking_lot; #[macro_use] extern crate cfg_if; -extern crate stable_deref_trait; -extern crate rustc_rayon as rayon; -extern crate rustc_rayon_core as rayon_core; -extern crate rustc_hash; -extern crate serialize; -extern crate graphviz; -extern crate smallvec; // See librustc_cratesio_shim/Cargo.toml for a comment explaining this. #[allow(unused_extern_crates)] diff --git a/src/librustc_data_structures/obligation_forest/graphviz.rs b/src/librustc_data_structures/obligation_forest/graphviz.rs index c2e3938b305d2..72551b42324d0 100644 --- a/src/librustc_data_structures/obligation_forest/graphviz.rs +++ b/src/librustc_data_structures/obligation_forest/graphviz.rs @@ -1,5 +1,5 @@ +use crate::obligation_forest::{ForestObligation, ObligationForest}; use graphviz as dot; -use obligation_forest::{ForestObligation, ObligationForest}; use std::env::var_os; use std::fs::File; use std::path::Path; @@ -41,22 +41,22 @@ impl<'a, O: ForestObligation + 'a> dot::Labeller<'a> for &'a ObligationForest type Node = usize; type Edge = (usize, usize); - fn graph_id(&self) -> dot::Id { + fn graph_id(&self) -> dot::Id<'_> { dot::Id::new("trait_obligation_forest").unwrap() } - fn node_id(&self, index: &Self::Node) -> dot::Id { + fn node_id(&self, index: &Self::Node) -> dot::Id<'_> { dot::Id::new(format!("obligation_{}", index)).unwrap() } - fn node_label(&self, index: &Self::Node) -> dot::LabelText { + fn node_label(&self, index: &Self::Node) -> dot::LabelText<'_> { let node = &self.nodes[*index]; let label = format!("{:?} ({:?})", node.obligation.as_predicate(), node.state.get()); dot::LabelText::LabelStr(label.into()) } - fn edge_label(&self, (_index_source, _index_target): &Self::Edge) -> dot::LabelText { + fn edge_label(&self, (_index_source, _index_target): &Self::Edge) -> dot::LabelText<'_> { dot::LabelText::LabelStr("".into()) } } @@ -65,11 +65,11 @@ impl<'a, O: ForestObligation + 'a> dot::GraphWalk<'a> for &'a ObligationForest dot::Nodes { + fn nodes(&self) -> dot::Nodes<'_, Self::Node> { (0..self.nodes.len()).collect() } - fn edges(&self) -> dot::Edges { + fn edges(&self) -> dot::Edges<'_, Self::Edge> { (0..self.nodes.len()) .flat_map(|i| { let node = &self.nodes[i]; diff --git a/src/librustc_data_structures/obligation_forest/mod.rs b/src/librustc_data_structures/obligation_forest/mod.rs index 9dd7d204f0373..546bb64168e14 100644 --- a/src/librustc_data_structures/obligation_forest/mod.rs +++ b/src/librustc_data_structures/obligation_forest/mod.rs @@ -80,7 +80,7 @@ //! processing step, we compress the vector to remove completed and error //! nodes, which aren't needed anymore. -use fx::{FxHashMap, FxHashSet}; +use crate::fx::{FxHashMap, FxHashSet}; use std::cell::Cell; use std::collections::hash_map::Entry; @@ -733,7 +733,7 @@ impl Node { // I need a Clone closure #[derive(Clone)] -struct GetObligation<'a, O: 'a>(&'a [Node]); +struct GetObligation<'a, O>(&'a [Node]); impl<'a, 'b, O> FnOnce<(&'b usize,)> for GetObligation<'a, O> { type Output = &'a O; diff --git a/src/librustc_data_structures/owning_ref/mod.rs b/src/librustc_data_structures/owning_ref/mod.rs index 0b126e5c572ed..30e510cc5b055 100644 --- a/src/librustc_data_structures/owning_ref/mod.rs +++ b/src/librustc_data_structures/owning_ref/mod.rs @@ -1002,7 +1002,7 @@ impl Debug for OwningRef where O: Debug, T: Debug, { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "OwningRef {{ owner: {:?}, reference: {:?} }}", self.owner(), @@ -1014,7 +1014,7 @@ impl Debug for OwningRefMut where O: Debug, T: Debug, { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "OwningRefMut {{ owner: {:?}, reference: {:?} }}", self.owner(), @@ -1047,7 +1047,7 @@ unsafe impl Sync for OwningRefMut where O: Sync, for<'a> (&'a mut T): Sync {} impl Debug for dyn Erased { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "",) } } diff --git a/src/librustc_data_structures/ptr_key.rs b/src/librustc_data_structures/ptr_key.rs index 322dcbe8f08fb..bf3ae2d7af58f 100644 --- a/src/librustc_data_structures/ptr_key.rs +++ b/src/librustc_data_structures/ptr_key.rs @@ -4,7 +4,7 @@ use std::ops::Deref; /// A wrapper around reference that compares and hashes like a pointer. /// Can be used as a key in sets/maps indexed by pointers to avoid `unsafe`. #[derive(Debug)] -pub struct PtrKey<'a, T: 'a>(pub &'a T); +pub struct PtrKey<'a, T>(pub &'a T); impl<'a, T> Clone for PtrKey<'a, T> { fn clone(&self) -> Self { *self } diff --git a/src/librustc_data_structures/snapshot_map/mod.rs b/src/librustc_data_structures/snapshot_map/mod.rs index d408727aea504..91d6e29237002 100644 --- a/src/librustc_data_structures/snapshot_map/mod.rs +++ b/src/librustc_data_structures/snapshot_map/mod.rs @@ -1,4 +1,4 @@ -use fx::FxHashMap; +use crate::fx::FxHashMap; use std::hash::Hash; use std::ops; use std::mem; diff --git a/src/librustc_data_structures/sorted_map.rs b/src/librustc_data_structures/sorted_map.rs index 64bbb8d7c08d1..1f674c1c664e4 100644 --- a/src/librustc_data_structures/sorted_map.rs +++ b/src/librustc_data_structures/sorted_map.rs @@ -111,7 +111,7 @@ impl SortedMap { /// Iterate over elements, sorted by key #[inline] - pub fn iter(&self) -> ::std::slice::Iter<(K, V)> { + pub fn iter(&self) -> ::std::slice::Iter<'_, (K, V)> { self.data.iter() } diff --git a/src/librustc_data_structures/stable_hasher.rs b/src/librustc_data_structures/stable_hasher.rs index 4583f12ec8cbc..19343a9250df3 100644 --- a/src/librustc_data_structures/stable_hasher.rs +++ b/src/librustc_data_structures/stable_hasher.rs @@ -1,7 +1,9 @@ use std::hash::{Hash, Hasher, BuildHasher}; use std::marker::PhantomData; use std::mem; -use sip128::SipHasher128; +use crate::sip128::SipHasher128; +use crate::indexed_vec; +use crate::bit_set; /// When hashing something that ends up affecting properties like symbol names, /// we want these symbol names to be calculated independently of other factors @@ -17,7 +19,7 @@ pub struct StableHasher { } impl ::std::fmt::Debug for StableHasher { - fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { write!(f, "{:?}", self.state) } } @@ -433,7 +435,7 @@ impl HashStable for ::std::mem::Discriminant { } } -impl HashStable for ::indexed_vec::IndexVec +impl HashStable for indexed_vec::IndexVec where T: HashStable, { fn hash_stable(&self, @@ -447,7 +449,7 @@ impl HashStable for ::indexed_vec::IndexVec< } -impl HashStable for ::bit_set::BitSet +impl HashStable for bit_set::BitSet { fn hash_stable(&self, ctx: &mut CTX, diff --git a/src/librustc_data_structures/svh.rs b/src/librustc_data_structures/svh.rs index 749479534979c..3757f921098f2 100644 --- a/src/librustc_data_structures/svh.rs +++ b/src/librustc_data_structures/svh.rs @@ -9,7 +9,7 @@ use std::fmt; use std::hash::{Hash, Hasher}; use serialize::{Encodable, Decodable, Encoder, Decoder}; -use stable_hasher; +use crate::stable_hasher; #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub struct Svh { @@ -40,7 +40,7 @@ impl Hash for Svh { } impl fmt::Display for Svh { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.pad(&self.to_string()) } } diff --git a/src/librustc_data_structures/sync.rs b/src/librustc_data_structures/sync.rs index 7fef1f374d6fd..ba1f6eb56fe88 100644 --- a/src/librustc_data_structures/sync.rs +++ b/src/librustc_data_structures/sync.rs @@ -21,7 +21,7 @@ use std::collections::HashMap; use std::hash::{Hash, BuildHasher}; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; -use owning_ref::{Erased, OwningRef}; +use crate::owning_ref::{Erased, OwningRef}; pub fn serial_join(oper_a: A, oper_b: B) -> (RA, RB) where A: FnOnce() -> RA, @@ -261,12 +261,12 @@ cfg_if! { } #[inline(always)] - pub fn lock(&self) -> LockGuard { + pub fn lock(&self) -> LockGuard<'_, T> { self.0.lock() } #[inline(always)] - pub fn lock_mut(&self) -> LockGuard { + pub fn lock_mut(&self) -> LockGuard<'_, T> { self.lock() } } @@ -490,19 +490,19 @@ impl Lock { #[cfg(parallel_compiler)] #[inline(always)] - pub fn try_lock(&self) -> Option> { + pub fn try_lock(&self) -> Option> { self.0.try_lock() } #[cfg(not(parallel_compiler))] #[inline(always)] - pub fn try_lock(&self) -> Option> { + pub fn try_lock(&self) -> Option> { self.0.try_borrow_mut().ok() } #[cfg(parallel_compiler)] #[inline(always)] - pub fn lock(&self) -> LockGuard { + pub fn lock(&self) -> LockGuard<'_, T> { if ERROR_CHECKING { self.0.try_lock().expect("lock was already held") } else { @@ -512,7 +512,7 @@ impl Lock { #[cfg(not(parallel_compiler))] #[inline(always)] - pub fn lock(&self) -> LockGuard { + pub fn lock(&self) -> LockGuard<'_, T> { self.0.borrow_mut() } @@ -522,12 +522,12 @@ impl Lock { } #[inline(always)] - pub fn borrow(&self) -> LockGuard { + pub fn borrow(&self) -> LockGuard<'_, T> { self.lock() } #[inline(always)] - pub fn borrow_mut(&self) -> LockGuard { + pub fn borrow_mut(&self) -> LockGuard<'_, T> { self.lock() } } @@ -568,13 +568,13 @@ impl RwLock { #[cfg(not(parallel_compiler))] #[inline(always)] - pub fn read(&self) -> ReadGuard { + pub fn read(&self) -> ReadGuard<'_, T> { self.0.borrow() } #[cfg(parallel_compiler)] #[inline(always)] - pub fn read(&self) -> ReadGuard { + pub fn read(&self) -> ReadGuard<'_, T> { if ERROR_CHECKING { self.0.try_read().expect("lock was already held") } else { @@ -589,25 +589,25 @@ impl RwLock { #[cfg(not(parallel_compiler))] #[inline(always)] - pub fn try_write(&self) -> Result, ()> { + pub fn try_write(&self) -> Result, ()> { self.0.try_borrow_mut().map_err(|_| ()) } #[cfg(parallel_compiler)] #[inline(always)] - pub fn try_write(&self) -> Result, ()> { + pub fn try_write(&self) -> Result, ()> { self.0.try_write().ok_or(()) } #[cfg(not(parallel_compiler))] #[inline(always)] - pub fn write(&self) -> WriteGuard { + pub fn write(&self) -> WriteGuard<'_, T> { self.0.borrow_mut() } #[cfg(parallel_compiler)] #[inline(always)] - pub fn write(&self) -> WriteGuard { + pub fn write(&self) -> WriteGuard<'_, T> { if ERROR_CHECKING { self.0.try_write().expect("lock was already held") } else { @@ -621,12 +621,12 @@ impl RwLock { } #[inline(always)] - pub fn borrow(&self) -> ReadGuard { + pub fn borrow(&self) -> ReadGuard<'_, T> { self.read() } #[inline(always)] - pub fn borrow_mut(&self) -> WriteGuard { + pub fn borrow_mut(&self) -> WriteGuard<'_, T> { self.write() } } diff --git a/src/librustc_data_structures/tiny_list.rs b/src/librustc_data_structures/tiny_list.rs index d660486d58446..3d74516d9c326 100644 --- a/src/librustc_data_structures/tiny_list.rs +++ b/src/librustc_data_structures/tiny_list.rs @@ -123,7 +123,7 @@ impl Element { mod test { use super::*; extern crate test; - use self::test::Bencher; + use test::Bencher; #[test] fn test_contains_and_insert() { diff --git a/src/librustc_data_structures/transitive_relation.rs b/src/librustc_data_structures/transitive_relation.rs index 9d675ed3096e0..39aed9833607f 100644 --- a/src/librustc_data_structures/transitive_relation.rs +++ b/src/librustc_data_structures/transitive_relation.rs @@ -1,8 +1,8 @@ -use bit_set::BitMatrix; -use fx::FxHashMap; -use sync::Lock; +use crate::bit_set::BitMatrix; +use crate::fx::FxHashMap; +use crate::stable_hasher::{HashStable, StableHasher, StableHasherResult}; +use crate::sync::Lock; use rustc_serialize::{Encodable, Encoder, Decodable, Decoder}; -use stable_hasher::{HashStable, StableHasher, StableHasherResult}; use std::fmt::Debug; use std::hash::Hash; use std::mem; diff --git a/src/librustc_data_structures/vec_linked_list.rs b/src/librustc_data_structures/vec_linked_list.rs index 3b6984dd07599..c00c707a43542 100644 --- a/src/librustc_data_structures/vec_linked_list.rs +++ b/src/librustc_data_structures/vec_linked_list.rs @@ -1,4 +1,4 @@ -use indexed_vec::{Idx, IndexVec}; +use crate::indexed_vec::{Idx, IndexVec}; pub fn iter( first: Option, diff --git a/src/librustc_data_structures/work_queue.rs b/src/librustc_data_structures/work_queue.rs index 0a928de7961b5..06418b1051ac3 100644 --- a/src/librustc_data_structures/work_queue.rs +++ b/src/librustc_data_structures/work_queue.rs @@ -1,5 +1,5 @@ -use bit_set::BitSet; -use indexed_vec::Idx; +use crate::bit_set::BitSet; +use crate::indexed_vec::Idx; use std::collections::VecDeque; /// A work queue is a handy data structure for tracking work left to From 7854067044466de2dd123ca4a3fb6251c0683ead Mon Sep 17 00:00:00 2001 From: Patrick McCarter Date: Fri, 8 Feb 2019 13:04:11 -0500 Subject: [PATCH 219/278] Saturating add/sub intrinsic emulation refactor/comments #58030 --- src/librustc_mir/interpret/intrinsics.rs | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/src/librustc_mir/interpret/intrinsics.rs b/src/librustc_mir/interpret/intrinsics.rs index e8dc22b8a596f..48fa856839602 100644 --- a/src/librustc_mir/interpret/intrinsics.rs +++ b/src/librustc_mir/interpret/intrinsics.rs @@ -132,15 +132,22 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> BinOp::Sub }, l, r)?; let val = if overflowed { - // For signed ints the saturated value depends on the - // sign of the first term - let first_term: u128 = l.to_scalar()?.to_bits(l.layout.size)?; let num_bits = l.layout.size.bits(); if l.layout.abi.is_signed() { - if first_term & (1 << (num_bits-1)) == 0 { // first term is positive + // For signed ints the saturated value depends on the sign of the first + // term since the sign of the second term can be inferred from this and + // the fact that the operation has overflowed (if either is 0 no + // overflow can occur) + let first_term: u128 = l.to_scalar()?.to_bits(l.layout.size)?; + let first_term_pos = first_term & (1 << (num_bits-1)) == 0; + if first_term_pos { + // Negative overflow not possible since the positive first term + // can only increase an (in range) negative term for addition + // or corresponding negated positive term for subtraction Scalar::from_uint((1u128 << (num_bits - 1)) - 1, // max positive Size::from_bits(num_bits)) - } else { // first term is negative + } else { + // Positive overflow not possible for similar reason // max negative Scalar::from_uint(1u128 << (num_bits - 1), Size::from_bits(num_bits)) } From caf7126ee83ad0ebbc6e8c15df54bf02a1e3b9e6 Mon Sep 17 00:00:00 2001 From: Robert Hayek Date: Sat, 9 Feb 2019 00:46:27 -0500 Subject: [PATCH 220/278] Some writing improvement, conciseness of intro --- src/doc/rustdoc/src/unstable-features.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/doc/rustdoc/src/unstable-features.md b/src/doc/rustdoc/src/unstable-features.md index d3eb8cb3d3b8a..3463cdb126cc6 100644 --- a/src/doc/rustdoc/src/unstable-features.md +++ b/src/doc/rustdoc/src/unstable-features.md @@ -1,9 +1,8 @@ # Unstable features Rustdoc is under active development, and like the Rust compiler, some features are only available -on the nightly releases. Some of these are new and need some more testing before they're able to get -released to the world at large, and some of them are tied to features in the Rust compiler that are -themselves unstable. Several features here require a matching `#![feature(...)]` attribute to +on nightly releases. Some of these features are new and need some more testing before they're able to be +released to the world at large, and some of them are tied to features in the Rust compiler that are unstable. Several features here require a matching `#![feature(...)]` attribute to enable, and thus are more fully documented in the [Unstable Book]. Those sections will link over there as necessary. @@ -428,4 +427,4 @@ $ rustdoc src/lib.rs --test -Z unstable-options --persist-doctests target/rustdo This flag allows you to keep doctest executables around after they're compiled or run. Usually, rustdoc will immediately discard a compiled doctest after it's been tested, but -with this option, you can keep those binaries around for farther testing. \ No newline at end of file +with this option, you can keep those binaries around for farther testing. From 360e65db7a75817b957e0b9d5f69e024fb5a78c3 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Sat, 9 Feb 2019 17:12:04 +0900 Subject: [PATCH 221/278] Move some tests into the tests directory This moves tests in opaque.rs and tests other than tests that require private items in json.rs into tests/opaque.rs and tests/json.rs. --- src/libserialize/json.rs | 1285 +----------------------------- src/libserialize/lib.rs | 4 - src/libserialize/opaque.rs | 285 ------- src/libserialize/tests/json.rs | 1282 +++++++++++++++++++++++++++++ src/libserialize/tests/opaque.rs | 282 +++++++ 5 files changed, 1568 insertions(+), 1570 deletions(-) create mode 100644 src/libserialize/tests/json.rs create mode 100644 src/libserialize/tests/opaque.rs diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index dc089218a9fac..60b1d2e17f12a 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -2584,1220 +2584,13 @@ impl FromStr for Json { #[cfg(test)] mod tests { + // Benchmarks and tests that require private items + extern crate test; - use self::Animal::*; - use self::test::Bencher; - use crate::{Encodable, Decodable}; - use super::Json::*; - use super::ErrorCode::*; - use super::ParserError::*; - use super::DecoderError::*; - use super::JsonEvent::*; - use super::{Json, from_str, DecodeResult, DecoderError, JsonEvent, Parser, - StackElement, Stack, Decoder, Encoder, EncoderError}; - use std::{i64, u64, f32, f64}; - use std::io::prelude::*; - use std::collections::BTreeMap; + use test::Bencher; + use super::{from_str, Parser, StackElement, Stack}; use std::string; - #[derive(RustcDecodable, Eq, PartialEq, Debug)] - struct OptionData { - opt: Option, - } - - #[test] - fn test_decode_option_none() { - let s ="{}"; - let obj: OptionData = super::decode(s).unwrap(); - assert_eq!(obj, OptionData { opt: None }); - } - - #[test] - fn test_decode_option_some() { - let s = "{ \"opt\": 10 }"; - let obj: OptionData = super::decode(s).unwrap(); - assert_eq!(obj, OptionData { opt: Some(10) }); - } - - #[test] - fn test_decode_option_malformed() { - check_err::("{ \"opt\": [] }", - ExpectedError("Number".to_string(), "[]".to_string())); - check_err::("{ \"opt\": false }", - ExpectedError("Number".to_string(), "false".to_string())); - } - - #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] - enum Animal { - Dog, - Frog(string::String, isize) - } - - #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] - struct Inner { - a: (), - b: usize, - c: Vec, - } - - #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] - struct Outer { - inner: Vec, - } - - fn mk_object(items: &[(string::String, Json)]) -> Json { - let mut d = BTreeMap::new(); - - for item in items { - match *item { - (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); }, - } - }; - - Object(d) - } - - #[test] - fn test_from_str_trait() { - let s = "null"; - assert!(s.parse::().unwrap() == s.parse().unwrap()); - } - - #[test] - fn test_write_null() { - assert_eq!(Null.to_string(), "null"); - assert_eq!(Null.pretty().to_string(), "null"); - } - - #[test] - fn test_write_i64() { - assert_eq!(U64(0).to_string(), "0"); - assert_eq!(U64(0).pretty().to_string(), "0"); - - assert_eq!(U64(1234).to_string(), "1234"); - assert_eq!(U64(1234).pretty().to_string(), "1234"); - - assert_eq!(I64(-5678).to_string(), "-5678"); - assert_eq!(I64(-5678).pretty().to_string(), "-5678"); - - assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000"); - assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000"); - } - - #[test] - fn test_write_f64() { - assert_eq!(F64(3.0).to_string(), "3.0"); - assert_eq!(F64(3.0).pretty().to_string(), "3.0"); - - assert_eq!(F64(3.1).to_string(), "3.1"); - assert_eq!(F64(3.1).pretty().to_string(), "3.1"); - - assert_eq!(F64(-1.5).to_string(), "-1.5"); - assert_eq!(F64(-1.5).pretty().to_string(), "-1.5"); - - assert_eq!(F64(0.5).to_string(), "0.5"); - assert_eq!(F64(0.5).pretty().to_string(), "0.5"); - - assert_eq!(F64(f64::NAN).to_string(), "null"); - assert_eq!(F64(f64::NAN).pretty().to_string(), "null"); - - assert_eq!(F64(f64::INFINITY).to_string(), "null"); - assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null"); - - assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null"); - assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null"); - } - - #[test] - fn test_write_str() { - assert_eq!(String("".to_string()).to_string(), "\"\""); - assert_eq!(String("".to_string()).pretty().to_string(), "\"\""); - - assert_eq!(String("homura".to_string()).to_string(), "\"homura\""); - assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\""); - } - - #[test] - fn test_write_bool() { - assert_eq!(Boolean(true).to_string(), "true"); - assert_eq!(Boolean(true).pretty().to_string(), "true"); - - assert_eq!(Boolean(false).to_string(), "false"); - assert_eq!(Boolean(false).pretty().to_string(), "false"); - } - - #[test] - fn test_write_array() { - assert_eq!(Array(vec![]).to_string(), "[]"); - assert_eq!(Array(vec![]).pretty().to_string(), "[]"); - - assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]"); - assert_eq!( - Array(vec![Boolean(true)]).pretty().to_string(), - "\ - [\n \ - true\n\ - ]" - ); - - let long_test_array = Array(vec![ - Boolean(false), - Null, - Array(vec![String("foo\nbar".to_string()), F64(3.5)])]); - - assert_eq!(long_test_array.to_string(), - "[false,null,[\"foo\\nbar\",3.5]]"); - assert_eq!( - long_test_array.pretty().to_string(), - "\ - [\n \ - false,\n \ - null,\n \ - [\n \ - \"foo\\nbar\",\n \ - 3.5\n \ - ]\n\ - ]" - ); - } - - #[test] - fn test_write_object() { - assert_eq!(mk_object(&[]).to_string(), "{}"); - assert_eq!(mk_object(&[]).pretty().to_string(), "{}"); - - assert_eq!( - mk_object(&[ - ("a".to_string(), Boolean(true)) - ]).to_string(), - "{\"a\":true}" - ); - assert_eq!( - mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(), - "\ - {\n \ - \"a\": true\n\ - }" - ); - - let complex_obj = mk_object(&[ - ("b".to_string(), Array(vec![ - mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]), - mk_object(&[("d".to_string(), String("".to_string()))]) - ])) - ]); - - assert_eq!( - complex_obj.to_string(), - "{\ - \"b\":[\ - {\"c\":\"\\f\\r\"},\ - {\"d\":\"\"}\ - ]\ - }" - ); - assert_eq!( - complex_obj.pretty().to_string(), - "\ - {\n \ - \"b\": [\n \ - {\n \ - \"c\": \"\\f\\r\"\n \ - },\n \ - {\n \ - \"d\": \"\"\n \ - }\n \ - ]\n\ - }" - ); - - let a = mk_object(&[ - ("a".to_string(), Boolean(true)), - ("b".to_string(), Array(vec![ - mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]), - mk_object(&[("d".to_string(), String("".to_string()))]) - ])) - ]); - - // We can't compare the strings directly because the object fields be - // printed in a different order. - assert_eq!(a.clone(), a.to_string().parse().unwrap()); - assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap()); - } - - #[test] - fn test_write_enum() { - let animal = Dog; - assert_eq!( - super::as_json(&animal).to_string(), - "\"Dog\"" - ); - assert_eq!( - super::as_pretty_json(&animal).to_string(), - "\"Dog\"" - ); - - let animal = Frog("Henry".to_string(), 349); - assert_eq!( - super::as_json(&animal).to_string(), - "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}" - ); - assert_eq!( - super::as_pretty_json(&animal).to_string(), - "{\n \ - \"variant\": \"Frog\",\n \ - \"fields\": [\n \ - \"Henry\",\n \ - 349\n \ - ]\n\ - }" - ); - } - - macro_rules! check_encoder_for_simple { - ($value:expr, $expected:expr) => ({ - let s = super::as_json(&$value).to_string(); - assert_eq!(s, $expected); - - let s = super::as_pretty_json(&$value).to_string(); - assert_eq!(s, $expected); - }) - } - - #[test] - fn test_write_some() { - check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\""); - } - - #[test] - fn test_write_none() { - check_encoder_for_simple!(None::, "null"); - } - - #[test] - fn test_write_char() { - check_encoder_for_simple!('a', "\"a\""); - check_encoder_for_simple!('\t', "\"\\t\""); - check_encoder_for_simple!('\u{0000}', "\"\\u0000\""); - check_encoder_for_simple!('\u{001b}', "\"\\u001b\""); - check_encoder_for_simple!('\u{007f}', "\"\\u007f\""); - check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\""); - check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\""); - check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\""); - } - - #[test] - fn test_trailing_characters() { - assert_eq!(from_str("nulla"), Err(SyntaxError(TrailingCharacters, 1, 5))); - assert_eq!(from_str("truea"), Err(SyntaxError(TrailingCharacters, 1, 5))); - assert_eq!(from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6))); - assert_eq!(from_str("1a"), Err(SyntaxError(TrailingCharacters, 1, 2))); - assert_eq!(from_str("[]a"), Err(SyntaxError(TrailingCharacters, 1, 3))); - assert_eq!(from_str("{}a"), Err(SyntaxError(TrailingCharacters, 1, 3))); - } - - #[test] - fn test_read_identifiers() { - assert_eq!(from_str("n"), Err(SyntaxError(InvalidSyntax, 1, 2))); - assert_eq!(from_str("nul"), Err(SyntaxError(InvalidSyntax, 1, 4))); - assert_eq!(from_str("t"), Err(SyntaxError(InvalidSyntax, 1, 2))); - assert_eq!(from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4))); - assert_eq!(from_str("f"), Err(SyntaxError(InvalidSyntax, 1, 2))); - assert_eq!(from_str("faz"), Err(SyntaxError(InvalidSyntax, 1, 3))); - - assert_eq!(from_str("null"), Ok(Null)); - assert_eq!(from_str("true"), Ok(Boolean(true))); - assert_eq!(from_str("false"), Ok(Boolean(false))); - assert_eq!(from_str(" null "), Ok(Null)); - assert_eq!(from_str(" true "), Ok(Boolean(true))); - assert_eq!(from_str(" false "), Ok(Boolean(false))); - } - - #[test] - fn test_decode_identifiers() { - let v: () = super::decode("null").unwrap(); - assert_eq!(v, ()); - - let v: bool = super::decode("true").unwrap(); - assert_eq!(v, true); - - let v: bool = super::decode("false").unwrap(); - assert_eq!(v, false); - } - - #[test] - fn test_read_number() { - assert_eq!(from_str("+"), Err(SyntaxError(InvalidSyntax, 1, 1))); - assert_eq!(from_str("."), Err(SyntaxError(InvalidSyntax, 1, 1))); - assert_eq!(from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1))); - assert_eq!(from_str("-"), Err(SyntaxError(InvalidNumber, 1, 2))); - assert_eq!(from_str("00"), Err(SyntaxError(InvalidNumber, 1, 2))); - assert_eq!(from_str("1."), Err(SyntaxError(InvalidNumber, 1, 3))); - assert_eq!(from_str("1e"), Err(SyntaxError(InvalidNumber, 1, 3))); - assert_eq!(from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4))); - - assert_eq!(from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20))); - assert_eq!(from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21))); - - assert_eq!(from_str("3"), Ok(U64(3))); - assert_eq!(from_str("3.1"), Ok(F64(3.1))); - assert_eq!(from_str("-1.2"), Ok(F64(-1.2))); - assert_eq!(from_str("0.4"), Ok(F64(0.4))); - assert_eq!(from_str("0.4e5"), Ok(F64(0.4e5))); - assert_eq!(from_str("0.4e+15"), Ok(F64(0.4e15))); - assert_eq!(from_str("0.4e-01"), Ok(F64(0.4e-01))); - assert_eq!(from_str(" 3 "), Ok(U64(3))); - - assert_eq!(from_str("-9223372036854775808"), Ok(I64(i64::MIN))); - assert_eq!(from_str("9223372036854775807"), Ok(U64(i64::MAX as u64))); - assert_eq!(from_str("18446744073709551615"), Ok(U64(u64::MAX))); - } - - #[test] - fn test_decode_numbers() { - let v: f64 = super::decode("3").unwrap(); - assert_eq!(v, 3.0); - - let v: f64 = super::decode("3.1").unwrap(); - assert_eq!(v, 3.1); - - let v: f64 = super::decode("-1.2").unwrap(); - assert_eq!(v, -1.2); - - let v: f64 = super::decode("0.4").unwrap(); - assert_eq!(v, 0.4); - - let v: f64 = super::decode("0.4e5").unwrap(); - assert_eq!(v, 0.4e5); - - let v: f64 = super::decode("0.4e15").unwrap(); - assert_eq!(v, 0.4e15); - - let v: f64 = super::decode("0.4e-01").unwrap(); - assert_eq!(v, 0.4e-01); - - let v: u64 = super::decode("0").unwrap(); - assert_eq!(v, 0); - - let v: u64 = super::decode("18446744073709551615").unwrap(); - assert_eq!(v, u64::MAX); - - let v: i64 = super::decode("-9223372036854775808").unwrap(); - assert_eq!(v, i64::MIN); - - let v: i64 = super::decode("9223372036854775807").unwrap(); - assert_eq!(v, i64::MAX); - - let res: DecodeResult = super::decode("765.25"); - assert_eq!(res, Err(ExpectedError("Integer".to_string(), - "765.25".to_string()))); - } - - #[test] - fn test_read_str() { - assert_eq!(from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2))); - assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5))); - - assert_eq!(from_str("\"\""), Ok(String("".to_string()))); - assert_eq!(from_str("\"foo\""), Ok(String("foo".to_string()))); - assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string()))); - assert_eq!(from_str("\"\\b\""), Ok(String("\x08".to_string()))); - assert_eq!(from_str("\"\\n\""), Ok(String("\n".to_string()))); - assert_eq!(from_str("\"\\r\""), Ok(String("\r".to_string()))); - assert_eq!(from_str("\"\\t\""), Ok(String("\t".to_string()))); - assert_eq!(from_str(" \"foo\" "), Ok(String("foo".to_string()))); - assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string()))); - assert_eq!(from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string()))); - } - - #[test] - fn test_decode_str() { - let s = [("\"\"", ""), - ("\"foo\"", "foo"), - ("\"\\\"\"", "\""), - ("\"\\b\"", "\x08"), - ("\"\\n\"", "\n"), - ("\"\\r\"", "\r"), - ("\"\\t\"", "\t"), - ("\"\\u12ab\"", "\u{12ab}"), - ("\"\\uAB12\"", "\u{AB12}")]; - - for &(i, o) in &s { - let v: string::String = super::decode(i).unwrap(); - assert_eq!(v, o); - } - } - - #[test] - fn test_read_array() { - assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2))); - assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3))); - assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4))); - assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4))); - assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4))); - - assert_eq!(from_str("[]"), Ok(Array(vec![]))); - assert_eq!(from_str("[ ]"), Ok(Array(vec![]))); - assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)]))); - assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)]))); - assert_eq!(from_str("[null]"), Ok(Array(vec![Null]))); - assert_eq!(from_str("[3, 1]"), - Ok(Array(vec![U64(3), U64(1)]))); - assert_eq!(from_str("\n[3, 2]\n"), - Ok(Array(vec![U64(3), U64(2)]))); - assert_eq!(from_str("[2, [4, 1]]"), - Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])]))); - } - - #[test] - fn test_decode_array() { - let v: Vec<()> = super::decode("[]").unwrap(); - assert_eq!(v, []); - - let v: Vec<()> = super::decode("[null]").unwrap(); - assert_eq!(v, [()]); - - let v: Vec = super::decode("[true]").unwrap(); - assert_eq!(v, [true]); - - let v: Vec = super::decode("[3, 1]").unwrap(); - assert_eq!(v, [3, 1]); - - let v: Vec> = super::decode("[[3], [1, 2]]").unwrap(); - assert_eq!(v, [vec![3], vec![1, 2]]); - } - - #[test] - fn test_decode_tuple() { - let t: (usize, usize, usize) = super::decode("[1, 2, 3]").unwrap(); - assert_eq!(t, (1, 2, 3)); - - let t: (usize, string::String) = super::decode("[1, \"two\"]").unwrap(); - assert_eq!(t, (1, "two".to_string())); - } - - #[test] - fn test_decode_tuple_malformed_types() { - assert!(super::decode::<(usize, string::String)>("[1, 2]").is_err()); - } - - #[test] - fn test_decode_tuple_malformed_length() { - assert!(super::decode::<(usize, usize)>("[1, 2, 3]").is_err()); - } - - #[test] - fn test_read_object() { - assert_eq!(from_str("{"), Err(SyntaxError(EOFWhileParsingObject, 1, 2))); - assert_eq!(from_str("{ "), Err(SyntaxError(EOFWhileParsingObject, 1, 3))); - assert_eq!(from_str("{1"), Err(SyntaxError(KeyMustBeAString, 1, 2))); - assert_eq!(from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6))); - assert_eq!(from_str("{\"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 5))); - assert_eq!(from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6))); - - assert_eq!(from_str("{\"a\" 1"), Err(SyntaxError(ExpectedColon, 1, 6))); - assert_eq!(from_str("{\"a\":"), Err(SyntaxError(EOFWhileParsingValue, 1, 6))); - assert_eq!(from_str("{\"a\":1"), Err(SyntaxError(EOFWhileParsingObject, 1, 7))); - assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8))); - assert_eq!(from_str("{\"a\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8))); - - assert_eq!(from_str("{}").unwrap(), mk_object(&[])); - assert_eq!(from_str("{\"a\": 3}").unwrap(), - mk_object(&[("a".to_string(), U64(3))])); - - assert_eq!(from_str( - "{ \"a\": null, \"b\" : true }").unwrap(), - mk_object(&[ - ("a".to_string(), Null), - ("b".to_string(), Boolean(true))])); - assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(), - mk_object(&[ - ("a".to_string(), Null), - ("b".to_string(), Boolean(true))])); - assert_eq!(from_str( - "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(), - mk_object(&[ - ("a".to_string(), F64(1.0)), - ("b".to_string(), Array(vec![Boolean(true)])) - ])); - assert_eq!(from_str( - "{\ - \"a\": 1.0, \ - \"b\": [\ - true,\ - \"foo\\nbar\", \ - { \"c\": {\"d\": null} } \ - ]\ - }").unwrap(), - mk_object(&[ - ("a".to_string(), F64(1.0)), - ("b".to_string(), Array(vec![ - Boolean(true), - String("foo\nbar".to_string()), - mk_object(&[ - ("c".to_string(), mk_object(&[("d".to_string(), Null)])) - ]) - ])) - ])); - } - - #[test] - fn test_decode_struct() { - let s = "{ - \"inner\": [ - { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] } - ] - }"; - - let v: Outer = super::decode(s).unwrap(); - assert_eq!( - v, - Outer { - inner: vec![ - Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] } - ] - } - ); - } - - #[derive(RustcDecodable)] - struct FloatStruct { - f: f64, - a: Vec - } - #[test] - fn test_decode_struct_with_nan() { - let s = "{\"f\":null,\"a\":[null,123]}"; - let obj: FloatStruct = super::decode(s).unwrap(); - assert!(obj.f.is_nan()); - assert!(obj.a[0].is_nan()); - assert_eq!(obj.a[1], 123f64); - } - - #[test] - fn test_decode_option() { - let value: Option = super::decode("null").unwrap(); - assert_eq!(value, None); - - let value: Option = super::decode("\"jodhpurs\"").unwrap(); - assert_eq!(value, Some("jodhpurs".to_string())); - } - - #[test] - fn test_decode_enum() { - let value: Animal = super::decode("\"Dog\"").unwrap(); - assert_eq!(value, Dog); - - let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"; - let value: Animal = super::decode(s).unwrap(); - assert_eq!(value, Frog("Henry".to_string(), 349)); - } - - #[test] - fn test_decode_map() { - let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\ - \"fields\":[\"Henry\", 349]}}"; - let mut map: BTreeMap = super::decode(s).unwrap(); - - assert_eq!(map.remove(&"a".to_string()), Some(Dog)); - assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349))); - } - - #[test] - fn test_multiline_errors() { - assert_eq!(from_str("{\n \"foo\":\n \"bar\""), - Err(SyntaxError(EOFWhileParsingObject, 3, 8))); - } - - #[derive(RustcDecodable)] - #[allow(dead_code)] - struct DecodeStruct { - x: f64, - y: bool, - z: string::String, - w: Vec - } - #[derive(RustcDecodable)] - enum DecodeEnum { - A(f64), - B(string::String) - } - fn check_err(to_parse: &'static str, expected: DecoderError) { - let res: DecodeResult = match from_str(to_parse) { - Err(e) => Err(ParseError(e)), - Ok(json) => Decodable::decode(&mut Decoder::new(json)) - }; - match res { - Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`", - to_parse, expected), - Err(ParseError(e)) => panic!("`{:?}` is not valid json: {:?}", - to_parse, e), - Err(e) => { - assert_eq!(e, expected); - } - } - } - #[test] - fn test_decode_errors_struct() { - check_err::("[]", ExpectedError("Object".to_string(), "[]".to_string())); - check_err::("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}", - ExpectedError("Number".to_string(), "true".to_string())); - check_err::("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}", - ExpectedError("Boolean".to_string(), "[]".to_string())); - check_err::("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}", - ExpectedError("String".to_string(), "{}".to_string())); - check_err::("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}", - ExpectedError("Array".to_string(), "null".to_string())); - check_err::("{\"x\": 1, \"y\": true, \"z\": \"\"}", - MissingFieldError("w".to_string())); - } - #[test] - fn test_decode_errors_enum() { - check_err::("{}", - MissingFieldError("variant".to_string())); - check_err::("{\"variant\": 1}", - ExpectedError("String".to_string(), "1".to_string())); - check_err::("{\"variant\": \"A\"}", - MissingFieldError("fields".to_string())); - check_err::("{\"variant\": \"A\", \"fields\": null}", - ExpectedError("Array".to_string(), "null".to_string())); - check_err::("{\"variant\": \"C\", \"fields\": []}", - UnknownVariantError("C".to_string())); - } - - #[test] - fn test_find(){ - let json_value = from_str("{\"dog\" : \"cat\"}").unwrap(); - let found_str = json_value.find("dog"); - assert!(found_str.unwrap().as_string().unwrap() == "cat"); - } - - #[test] - fn test_find_path(){ - let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap(); - let found_str = json_value.find_path(&["dog", "cat", "mouse"]); - assert!(found_str.unwrap().as_string().unwrap() == "cheese"); - } - - #[test] - fn test_search(){ - let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap(); - let found_str = json_value.search("mouse").and_then(|j| j.as_string()); - assert!(found_str.unwrap() == "cheese"); - } - - #[test] - fn test_index(){ - let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap(); - let ref array = json_value["animals"]; - assert_eq!(array[0].as_string().unwrap(), "dog"); - assert_eq!(array[1].as_string().unwrap(), "cat"); - assert_eq!(array[2].as_string().unwrap(), "mouse"); - } - - #[test] - fn test_is_object(){ - let json_value = from_str("{}").unwrap(); - assert!(json_value.is_object()); - } - - #[test] - fn test_as_object(){ - let json_value = from_str("{}").unwrap(); - let json_object = json_value.as_object(); - assert!(json_object.is_some()); - } - - #[test] - fn test_is_array(){ - let json_value = from_str("[1, 2, 3]").unwrap(); - assert!(json_value.is_array()); - } - - #[test] - fn test_as_array(){ - let json_value = from_str("[1, 2, 3]").unwrap(); - let json_array = json_value.as_array(); - let expected_length = 3; - assert!(json_array.is_some() && json_array.unwrap().len() == expected_length); - } - - #[test] - fn test_is_string(){ - let json_value = from_str("\"dog\"").unwrap(); - assert!(json_value.is_string()); - } - - #[test] - fn test_as_string(){ - let json_value = from_str("\"dog\"").unwrap(); - let json_str = json_value.as_string(); - let expected_str = "dog"; - assert_eq!(json_str, Some(expected_str)); - } - - #[test] - fn test_is_number(){ - let json_value = from_str("12").unwrap(); - assert!(json_value.is_number()); - } - - #[test] - fn test_is_i64(){ - let json_value = from_str("-12").unwrap(); - assert!(json_value.is_i64()); - - let json_value = from_str("12").unwrap(); - assert!(!json_value.is_i64()); - - let json_value = from_str("12.0").unwrap(); - assert!(!json_value.is_i64()); - } - - #[test] - fn test_is_u64(){ - let json_value = from_str("12").unwrap(); - assert!(json_value.is_u64()); - - let json_value = from_str("-12").unwrap(); - assert!(!json_value.is_u64()); - - let json_value = from_str("12.0").unwrap(); - assert!(!json_value.is_u64()); - } - - #[test] - fn test_is_f64(){ - let json_value = from_str("12").unwrap(); - assert!(!json_value.is_f64()); - - let json_value = from_str("-12").unwrap(); - assert!(!json_value.is_f64()); - - let json_value = from_str("12.0").unwrap(); - assert!(json_value.is_f64()); - - let json_value = from_str("-12.0").unwrap(); - assert!(json_value.is_f64()); - } - - #[test] - fn test_as_i64(){ - let json_value = from_str("-12").unwrap(); - let json_num = json_value.as_i64(); - assert_eq!(json_num, Some(-12)); - } - - #[test] - fn test_as_u64(){ - let json_value = from_str("12").unwrap(); - let json_num = json_value.as_u64(); - assert_eq!(json_num, Some(12)); - } - - #[test] - fn test_as_f64(){ - let json_value = from_str("12.0").unwrap(); - let json_num = json_value.as_f64(); - assert_eq!(json_num, Some(12f64)); - } - - #[test] - fn test_is_boolean(){ - let json_value = from_str("false").unwrap(); - assert!(json_value.is_boolean()); - } - - #[test] - fn test_as_boolean(){ - let json_value = from_str("false").unwrap(); - let json_bool = json_value.as_boolean(); - let expected_bool = false; - assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool); - } - - #[test] - fn test_is_null(){ - let json_value = from_str("null").unwrap(); - assert!(json_value.is_null()); - } - - #[test] - fn test_as_null(){ - let json_value = from_str("null").unwrap(); - let json_null = json_value.as_null(); - let expected_null = (); - assert!(json_null.is_some() && json_null.unwrap() == expected_null); - } - - #[test] - fn test_encode_hashmap_with_numeric_key() { - use std::str::from_utf8; - use std::collections::HashMap; - let mut hm: HashMap = HashMap::new(); - hm.insert(1, true); - let mut mem_buf = Vec::new(); - write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap(); - let json_str = from_utf8(&mem_buf[..]).unwrap(); - match from_str(json_str) { - Err(_) => panic!("Unable to parse json_str: {:?}", json_str), - _ => {} // it parsed and we are good to go - } - } - - #[test] - fn test_prettyencode_hashmap_with_numeric_key() { - use std::str::from_utf8; - use std::collections::HashMap; - let mut hm: HashMap = HashMap::new(); - hm.insert(1, true); - let mut mem_buf = Vec::new(); - write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap(); - let json_str = from_utf8(&mem_buf[..]).unwrap(); - match from_str(json_str) { - Err(_) => panic!("Unable to parse json_str: {:?}", json_str), - _ => {} // it parsed and we are good to go - } - } - - #[test] - fn test_prettyencoder_indent_level_param() { - use std::str::from_utf8; - use std::collections::BTreeMap; - - let mut tree = BTreeMap::new(); - - tree.insert("hello".to_string(), String("guten tag".to_string())); - tree.insert("goodbye".to_string(), String("sayonara".to_string())); - - let json = Array( - // The following layout below should look a lot like - // the pretty-printed JSON (indent * x) - vec! - ( // 0x - String("greetings".to_string()), // 1x - Object(tree), // 1x + 2x + 2x + 1x - ) // 0x - // End JSON array (7 lines) - ); - - // Helper function for counting indents - fn indents(source: &str) -> usize { - let trimmed = source.trim_start_matches(' '); - source.len() - trimmed.len() - } - - // Test up to 4 spaces of indents (more?) - for i in 0..4 { - let mut writer = Vec::new(); - write!(&mut writer, "{}", - super::as_pretty_json(&json).indent(i)).unwrap(); - - let printed = from_utf8(&writer[..]).unwrap(); - - // Check for indents at each line - let lines: Vec<&str> = printed.lines().collect(); - assert_eq!(lines.len(), 7); // JSON should be 7 lines - - assert_eq!(indents(lines[0]), 0 * i); // [ - assert_eq!(indents(lines[1]), 1 * i); // "greetings", - assert_eq!(indents(lines[2]), 1 * i); // { - assert_eq!(indents(lines[3]), 2 * i); // "hello": "guten tag", - assert_eq!(indents(lines[4]), 2 * i); // "goodbye": "sayonara" - assert_eq!(indents(lines[5]), 1 * i); // }, - assert_eq!(indents(lines[6]), 0 * i); // ] - - // Finally, test that the pretty-printed JSON is valid - from_str(printed).ok().expect("Pretty-printed JSON is invalid!"); - } - } - - #[test] - fn test_hashmap_with_enum_key() { - use std::collections::HashMap; - use crate::json; - #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)] - enum Enum { - Foo, - #[allow(dead_code)] - Bar, - } - let mut map = HashMap::new(); - map.insert(Enum::Foo, 0); - let result = json::encode(&map).unwrap(); - assert_eq!(&result[..], r#"{"Foo":0}"#); - let decoded: HashMap = json::decode(&result).unwrap(); - assert_eq!(map, decoded); - } - - #[test] - fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() { - use std::collections::HashMap; - use Decodable; - let json_str = "{\"1\":true}"; - let json_obj = match from_str(json_str) { - Err(_) => panic!("Unable to parse json_str: {:?}", json_str), - Ok(o) => o - }; - let mut decoder = Decoder::new(json_obj); - let _hm: HashMap = Decodable::decode(&mut decoder).unwrap(); - } - - #[test] - fn test_hashmap_with_numeric_key_will_error_with_string_keys() { - use std::collections::HashMap; - use Decodable; - let json_str = "{\"a\":true}"; - let json_obj = match from_str(json_str) { - Err(_) => panic!("Unable to parse json_str: {:?}", json_str), - Ok(o) => o - }; - let mut decoder = Decoder::new(json_obj); - let result: Result, DecoderError> = Decodable::decode(&mut decoder); - assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string()))); - } - - fn assert_stream_equal(src: &str, - expected: Vec<(JsonEvent, Vec)>) { - let mut parser = Parser::new(src.chars()); - let mut i = 0; - loop { - let evt = match parser.next() { - Some(e) => e, - None => { break; } - }; - let (ref expected_evt, ref expected_stack) = expected[i]; - if !parser.stack().is_equal_to(expected_stack) { - panic!("Parser stack is not equal to {:?}", expected_stack); - } - assert_eq!(&evt, expected_evt); - i+=1; - } - } - #[test] - fn test_streaming_parser() { - assert_stream_equal( - r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#, - vec![ - (ObjectStart, vec![]), - (StringValue("bar".to_string()), vec![StackElement::Key("foo")]), - (ArrayStart, vec![StackElement::Key("array")]), - (U64Value(0), vec![StackElement::Key("array"), StackElement::Index(0)]), - (U64Value(1), vec![StackElement::Key("array"), StackElement::Index(1)]), - (U64Value(2), vec![StackElement::Key("array"), StackElement::Index(2)]), - (U64Value(3), vec![StackElement::Key("array"), StackElement::Index(3)]), - (U64Value(4), vec![StackElement::Key("array"), StackElement::Index(4)]), - (U64Value(5), vec![StackElement::Key("array"), StackElement::Index(5)]), - (ArrayEnd, vec![StackElement::Key("array")]), - (ArrayStart, vec![StackElement::Key("idents")]), - (NullValue, vec![StackElement::Key("idents"), - StackElement::Index(0)]), - (BooleanValue(true), vec![StackElement::Key("idents"), - StackElement::Index(1)]), - (BooleanValue(false), vec![StackElement::Key("idents"), - StackElement::Index(2)]), - (ArrayEnd, vec![StackElement::Key("idents")]), - (ObjectEnd, vec![]), - ] - ); - } - fn last_event(src: &str) -> JsonEvent { - let mut parser = Parser::new(src.chars()); - let mut evt = NullValue; - loop { - evt = match parser.next() { - Some(e) => e, - None => return evt, - } - } - } - - #[test] - fn test_read_object_streaming() { - assert_eq!(last_event("{ "), Error(SyntaxError(EOFWhileParsingObject, 1, 3))); - assert_eq!(last_event("{1"), Error(SyntaxError(KeyMustBeAString, 1, 2))); - assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6))); - assert_eq!(last_event("{\"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 5))); - assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6))); - - assert_eq!(last_event("{\"a\" 1"), Error(SyntaxError(ExpectedColon, 1, 6))); - assert_eq!(last_event("{\"a\":"), Error(SyntaxError(EOFWhileParsingValue, 1, 6))); - assert_eq!(last_event("{\"a\":1"), Error(SyntaxError(EOFWhileParsingObject, 1, 7))); - assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax, 1, 8))); - assert_eq!(last_event("{\"a\":1,"), Error(SyntaxError(EOFWhileParsingObject, 1, 8))); - assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8))); - - assert_stream_equal( - "{}", - vec![(ObjectStart, vec![]), (ObjectEnd, vec![])] - ); - assert_stream_equal( - "{\"a\": 3}", - vec![ - (ObjectStart, vec![]), - (U64Value(3), vec![StackElement::Key("a")]), - (ObjectEnd, vec![]), - ] - ); - assert_stream_equal( - "{ \"a\": null, \"b\" : true }", - vec![ - (ObjectStart, vec![]), - (NullValue, vec![StackElement::Key("a")]), - (BooleanValue(true), vec![StackElement::Key("b")]), - (ObjectEnd, vec![]), - ] - ); - assert_stream_equal( - "{\"a\" : 1.0 ,\"b\": [ true ]}", - vec![ - (ObjectStart, vec![]), - (F64Value(1.0), vec![StackElement::Key("a")]), - (ArrayStart, vec![StackElement::Key("b")]), - (BooleanValue(true),vec![StackElement::Key("b"), StackElement::Index(0)]), - (ArrayEnd, vec![StackElement::Key("b")]), - (ObjectEnd, vec![]), - ] - ); - assert_stream_equal( - r#"{ - "a": 1.0, - "b": [ - true, - "foo\nbar", - { "c": {"d": null} } - ] - }"#, - vec![ - (ObjectStart, vec![]), - (F64Value(1.0), vec![StackElement::Key("a")]), - (ArrayStart, vec![StackElement::Key("b")]), - (BooleanValue(true), vec![StackElement::Key("b"), - StackElement::Index(0)]), - (StringValue("foo\nbar".to_string()), vec![StackElement::Key("b"), - StackElement::Index(1)]), - (ObjectStart, vec![StackElement::Key("b"), - StackElement::Index(2)]), - (ObjectStart, vec![StackElement::Key("b"), - StackElement::Index(2), - StackElement::Key("c")]), - (NullValue, vec![StackElement::Key("b"), - StackElement::Index(2), - StackElement::Key("c"), - StackElement::Key("d")]), - (ObjectEnd, vec![StackElement::Key("b"), - StackElement::Index(2), - StackElement::Key("c")]), - (ObjectEnd, vec![StackElement::Key("b"), - StackElement::Index(2)]), - (ArrayEnd, vec![StackElement::Key("b")]), - (ObjectEnd, vec![]), - ] - ); - } - #[test] - fn test_read_array_streaming() { - assert_stream_equal( - "[]", - vec![ - (ArrayStart, vec![]), - (ArrayEnd, vec![]), - ] - ); - assert_stream_equal( - "[ ]", - vec![ - (ArrayStart, vec![]), - (ArrayEnd, vec![]), - ] - ); - assert_stream_equal( - "[true]", - vec![ - (ArrayStart, vec![]), - (BooleanValue(true), vec![StackElement::Index(0)]), - (ArrayEnd, vec![]), - ] - ); - assert_stream_equal( - "[ false ]", - vec![ - (ArrayStart, vec![]), - (BooleanValue(false), vec![StackElement::Index(0)]), - (ArrayEnd, vec![]), - ] - ); - assert_stream_equal( - "[null]", - vec![ - (ArrayStart, vec![]), - (NullValue, vec![StackElement::Index(0)]), - (ArrayEnd, vec![]), - ] - ); - assert_stream_equal( - "[3, 1]", - vec![ - (ArrayStart, vec![]), - (U64Value(3), vec![StackElement::Index(0)]), - (U64Value(1), vec![StackElement::Index(1)]), - (ArrayEnd, vec![]), - ] - ); - assert_stream_equal( - "\n[3, 2]\n", - vec![ - (ArrayStart, vec![]), - (U64Value(3), vec![StackElement::Index(0)]), - (U64Value(2), vec![StackElement::Index(1)]), - (ArrayEnd, vec![]), - ] - ); - assert_stream_equal( - "[2, [4, 1]]", - vec![ - (ArrayStart, vec![]), - (U64Value(2), vec![StackElement::Index(0)]), - (ArrayStart, vec![StackElement::Index(1)]), - (U64Value(4), vec![StackElement::Index(1), StackElement::Index(0)]), - (U64Value(1), vec![StackElement::Index(1), StackElement::Index(1)]), - (ArrayEnd, vec![StackElement::Index(1)]), - (ArrayEnd, vec![]), - ] - ); - - assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2))); - - assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2))); - assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3))); - assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4))); - assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4))); - assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4))); - - } - #[test] - fn test_trailing_characters_streaming() { - assert_eq!(last_event("nulla"), Error(SyntaxError(TrailingCharacters, 1, 5))); - assert_eq!(last_event("truea"), Error(SyntaxError(TrailingCharacters, 1, 5))); - assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6))); - assert_eq!(last_event("1a"), Error(SyntaxError(TrailingCharacters, 1, 2))); - assert_eq!(last_event("[]a"), Error(SyntaxError(TrailingCharacters, 1, 3))); - assert_eq!(last_event("{}a"), Error(SyntaxError(TrailingCharacters, 1, 3))); - } - #[test] - fn test_read_identifiers_streaming() { - assert_eq!(Parser::new("null".chars()).next(), Some(NullValue)); - assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true))); - assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false))); - - assert_eq!(last_event("n"), Error(SyntaxError(InvalidSyntax, 1, 2))); - assert_eq!(last_event("nul"), Error(SyntaxError(InvalidSyntax, 1, 4))); - assert_eq!(last_event("t"), Error(SyntaxError(InvalidSyntax, 1, 2))); - assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4))); - assert_eq!(last_event("f"), Error(SyntaxError(InvalidSyntax, 1, 2))); - assert_eq!(last_event("faz"), Error(SyntaxError(InvalidSyntax, 1, 3))); - } - #[test] fn test_stack() { let mut stack = Stack::new(); @@ -3862,76 +2655,6 @@ mod tests { assert!(stack.get(1) == StackElement::Key("foo")); } - #[test] - fn test_to_json() { - use std::collections::{HashMap,BTreeMap}; - use super::ToJson; - - let array2 = Array(vec![U64(1), U64(2)]); - let array3 = Array(vec![U64(1), U64(2), U64(3)]); - let object = { - let mut tree_map = BTreeMap::new(); - tree_map.insert("a".to_string(), U64(1)); - tree_map.insert("b".to_string(), U64(2)); - Object(tree_map) - }; - - assert_eq!(array2.to_json(), array2); - assert_eq!(object.to_json(), object); - assert_eq!(3_isize.to_json(), I64(3)); - assert_eq!(4_i8.to_json(), I64(4)); - assert_eq!(5_i16.to_json(), I64(5)); - assert_eq!(6_i32.to_json(), I64(6)); - assert_eq!(7_i64.to_json(), I64(7)); - assert_eq!(8_usize.to_json(), U64(8)); - assert_eq!(9_u8.to_json(), U64(9)); - assert_eq!(10_u16.to_json(), U64(10)); - assert_eq!(11_u32.to_json(), U64(11)); - assert_eq!(12_u64.to_json(), U64(12)); - assert_eq!(13.0_f32.to_json(), F64(13.0_f64)); - assert_eq!(14.0_f64.to_json(), F64(14.0_f64)); - assert_eq!(().to_json(), Null); - assert_eq!(f32::INFINITY.to_json(), Null); - assert_eq!(f64::NAN.to_json(), Null); - assert_eq!(true.to_json(), Boolean(true)); - assert_eq!(false.to_json(), Boolean(false)); - assert_eq!("abc".to_json(), String("abc".to_string())); - assert_eq!("abc".to_string().to_json(), String("abc".to_string())); - assert_eq!((1_usize, 2_usize).to_json(), array2); - assert_eq!((1_usize, 2_usize, 3_usize).to_json(), array3); - assert_eq!([1_usize, 2_usize].to_json(), array2); - assert_eq!((&[1_usize, 2_usize, 3_usize]).to_json(), array3); - assert_eq!((vec![1_usize, 2_usize]).to_json(), array2); - assert_eq!(vec![1_usize, 2_usize, 3_usize].to_json(), array3); - let mut tree_map = BTreeMap::new(); - tree_map.insert("a".to_string(), 1 as usize); - tree_map.insert("b".to_string(), 2); - assert_eq!(tree_map.to_json(), object); - let mut hash_map = HashMap::new(); - hash_map.insert("a".to_string(), 1 as usize); - hash_map.insert("b".to_string(), 2); - assert_eq!(hash_map.to_json(), object); - assert_eq!(Some(15).to_json(), I64(15)); - assert_eq!(Some(15 as usize).to_json(), U64(15)); - assert_eq!(None::.to_json(), Null); - } - - #[test] - fn test_encode_hashmap_with_arbitrary_key() { - use std::collections::HashMap; - #[derive(PartialEq, Eq, Hash, RustcEncodable)] - struct ArbitraryType(usize); - let mut hm: HashMap = HashMap::new(); - hm.insert(ArbitraryType(1), true); - let mut mem_buf = string::String::new(); - let mut encoder = Encoder::new(&mut mem_buf); - let result = hm.encode(&mut encoder); - match result.unwrap_err() { - EncoderError::BadHashmapKey => (), - _ => panic!("expected bad hash map key") - } - } - #[bench] fn bench_streaming_small(b: &mut Bencher) { b.iter( || { diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index 9b73a5e686ead..1fb0d773d6ad2 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -32,7 +32,3 @@ pub mod json; pub mod opaque; pub mod leb128; - -mod rustc_serialize { - pub use crate::serialize::*; -} diff --git a/src/libserialize/opaque.rs b/src/libserialize/opaque.rs index 8636c202d66ef..d6e8560195c2b 100644 --- a/src/libserialize/opaque.rs +++ b/src/libserialize/opaque.rs @@ -324,288 +324,3 @@ impl<'a> serialize::Decoder for Decoder<'a> { err.to_string() } } - - -#[cfg(test)] -mod tests { - use crate::serialize::{Encodable, Decodable}; - use std::fmt::Debug; - use super::{Encoder, Decoder}; - - #[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)] - struct Struct { - a: (), - b: u8, - c: u16, - d: u32, - e: u64, - f: usize, - - g: i8, - h: i16, - i: i32, - j: i64, - k: isize, - - l: char, - m: String, - n: f32, - o: f64, - p: bool, - q: Option, - } - - - fn check_round_trip(values: Vec) { - let mut encoder = Encoder::new(Vec::new()); - - for value in &values { - Encodable::encode(&value, &mut encoder).unwrap(); - } - - let data = encoder.into_inner(); - let mut decoder = Decoder::new(&data[..], 0); - - for value in values { - let decoded = Decodable::decode(&mut decoder).unwrap(); - assert_eq!(value, decoded); - } - } - - #[test] - fn test_unit() { - check_round_trip(vec![(), (), (), ()]); - } - - #[test] - fn test_u8() { - let mut vec = vec![]; - for i in ::std::u8::MIN..::std::u8::MAX { - vec.push(i); - } - check_round_trip(vec); - } - - #[test] - fn test_u16() { - for i in ::std::u16::MIN..::std::u16::MAX { - check_round_trip(vec![1, 2, 3, i, i, i]); - } - } - - #[test] - fn test_u32() { - check_round_trip(vec![1, 2, 3, ::std::u32::MIN, 0, 1, ::std::u32::MAX, 2, 1]); - } - - #[test] - fn test_u64() { - check_round_trip(vec![1, 2, 3, ::std::u64::MIN, 0, 1, ::std::u64::MAX, 2, 1]); - } - - #[test] - fn test_usize() { - check_round_trip(vec![1, 2, 3, ::std::usize::MIN, 0, 1, ::std::usize::MAX, 2, 1]); - } - - #[test] - fn test_i8() { - let mut vec = vec![]; - for i in ::std::i8::MIN..::std::i8::MAX { - vec.push(i); - } - check_round_trip(vec); - } - - #[test] - fn test_i16() { - for i in ::std::i16::MIN..::std::i16::MAX { - check_round_trip(vec![-1, 2, -3, i, i, i, 2]); - } - } - - #[test] - fn test_i32() { - check_round_trip(vec![-1, 2, -3, ::std::i32::MIN, 0, 1, ::std::i32::MAX, 2, 1]); - } - - #[test] - fn test_i64() { - check_round_trip(vec![-1, 2, -3, ::std::i64::MIN, 0, 1, ::std::i64::MAX, 2, 1]); - } - - #[test] - fn test_isize() { - check_round_trip(vec![-1, 2, -3, ::std::isize::MIN, 0, 1, ::std::isize::MAX, 2, 1]); - } - - #[test] - fn test_bool() { - check_round_trip(vec![false, true, true, false, false]); - } - - #[test] - fn test_f32() { - let mut vec = vec![]; - for i in -100..100 { - vec.push((i as f32) / 3.0); - } - check_round_trip(vec); - } - - #[test] - fn test_f64() { - let mut vec = vec![]; - for i in -100..100 { - vec.push((i as f64) / 3.0); - } - check_round_trip(vec); - } - - #[test] - fn test_char() { - let vec = vec!['a', 'b', 'c', 'd', 'A', 'X', ' ', '#', 'Ö', 'Ä', 'µ', '€']; - check_round_trip(vec); - } - - #[test] - fn test_string() { - let vec = vec!["abcbuÖeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(), - "abcbuÖganeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(), - "abcbuÖganeiovÄnameÜavmpßvmea€µsbpapmaebn".to_string(), - "abcbuÖganeiovÄnameÜavmpßvmeabpnvapeapmaebn".to_string(), - "abcbuÖganeiÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(), - "abcbuÖganeiovÄnameÜavmpßvmea€µsbpmaebn".to_string(), - "abcbuÖganeiovÄnameÜavmpßvmea€µnvapeapmaebn".to_string()]; - - check_round_trip(vec); - } - - #[test] - fn test_option() { - check_round_trip(vec![Some(-1i8)]); - check_round_trip(vec![Some(-2i16)]); - check_round_trip(vec![Some(-3i32)]); - check_round_trip(vec![Some(-4i64)]); - check_round_trip(vec![Some(-5isize)]); - - let none_i8: Option = None; - check_round_trip(vec![none_i8]); - - let none_i16: Option = None; - check_round_trip(vec![none_i16]); - - let none_i32: Option = None; - check_round_trip(vec![none_i32]); - - let none_i64: Option = None; - check_round_trip(vec![none_i64]); - - let none_isize: Option = None; - check_round_trip(vec![none_isize]); - } - - #[test] - fn test_struct() { - check_round_trip(vec![Struct { - a: (), - b: 10, - c: 11, - d: 12, - e: 13, - f: 14, - - g: 15, - h: 16, - i: 17, - j: 18, - k: 19, - - l: 'x', - m: "abc".to_string(), - n: 20.5, - o: 21.5, - p: false, - q: None, - }]); - - check_round_trip(vec![Struct { - a: (), - b: 101, - c: 111, - d: 121, - e: 131, - f: 141, - - g: -15, - h: -16, - i: -17, - j: -18, - k: -19, - - l: 'y', - m: "def".to_string(), - n: -20.5, - o: -21.5, - p: true, - q: Some(1234567), - }]); - } - - #[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)] - enum Enum { - Variant1, - Variant2(usize, f32), - Variant3 { - a: i32, - b: char, - c: bool, - }, - } - - #[test] - fn test_enum() { - check_round_trip(vec![Enum::Variant1, - Enum::Variant2(1, 2.5), - Enum::Variant3 { - a: 3, - b: 'b', - c: false, - }, - Enum::Variant3 { - a: -4, - b: 'f', - c: true, - }]); - } - - #[test] - fn test_sequence() { - let mut vec = vec![]; - for i in -100i64..100i64 { - vec.push(i * 100000); - } - - check_round_trip(vec![vec]); - } - - #[test] - fn test_hash_map() { - use std::collections::HashMap; - let mut map = HashMap::new(); - for i in -100i64..100i64 { - map.insert(i * 100000, i * 10000); - } - - check_round_trip(vec![map]); - } - - #[test] - fn test_tuples() { - check_round_trip(vec![('x', (), false, 0.5f32)]); - check_round_trip(vec![(9i8, 10u16, 1.5f64)]); - check_round_trip(vec![(-12i16, 11u8, 12usize)]); - check_round_trip(vec![(1234567isize, 100000000000000u64, 99999999999999i64)]); - check_round_trip(vec![(String::new(), "some string".to_string())]); - } -} diff --git a/src/libserialize/tests/json.rs b/src/libserialize/tests/json.rs new file mode 100644 index 0000000000000..3fb6bda679bc1 --- /dev/null +++ b/src/libserialize/tests/json.rs @@ -0,0 +1,1282 @@ +extern crate serialize as rustc_serialize; + +use rustc_serialize::{Encodable, Decodable}; +use rustc_serialize::json; +use json::Json::*; +use json::ErrorCode::*; +use json::ParserError::*; +use json::DecoderError::*; +use json::JsonEvent::*; +use json::{Json, from_str, DecodeResult, DecoderError, JsonEvent, Parser, StackElement, + Decoder, Encoder, EncoderError}; + +use Animal::*; +use std::{i64, u64, f32, f64}; +use std::io::prelude::*; +use std::collections::BTreeMap; +use std::string; + +#[derive(RustcDecodable, Eq, PartialEq, Debug)] +struct OptionData { + opt: Option, +} + +#[test] +fn test_decode_option_none() { + let s ="{}"; + let obj: OptionData = json::decode(s).unwrap(); + assert_eq!(obj, OptionData { opt: None }); +} + +#[test] +fn test_decode_option_some() { + let s = "{ \"opt\": 10 }"; + let obj: OptionData = json::decode(s).unwrap(); + assert_eq!(obj, OptionData { opt: Some(10) }); +} + +#[test] +fn test_decode_option_malformed() { + check_err::("{ \"opt\": [] }", + ExpectedError("Number".to_string(), "[]".to_string())); + check_err::("{ \"opt\": false }", + ExpectedError("Number".to_string(), "false".to_string())); +} + +#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] +enum Animal { + Dog, + Frog(string::String, isize) +} + +#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] +struct Inner { + a: (), + b: usize, + c: Vec, +} + +#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)] +struct Outer { + inner: Vec, +} + +fn mk_object(items: &[(string::String, Json)]) -> Json { + let mut d = BTreeMap::new(); + + for item in items { + match *item { + (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); }, + } + }; + + Object(d) +} + +#[test] +fn test_from_str_trait() { + let s = "null"; + assert!(s.parse::().unwrap() == s.parse().unwrap()); +} + +#[test] +fn test_write_null() { + assert_eq!(Null.to_string(), "null"); + assert_eq!(Null.pretty().to_string(), "null"); +} + +#[test] +fn test_write_i64() { + assert_eq!(U64(0).to_string(), "0"); + assert_eq!(U64(0).pretty().to_string(), "0"); + + assert_eq!(U64(1234).to_string(), "1234"); + assert_eq!(U64(1234).pretty().to_string(), "1234"); + + assert_eq!(I64(-5678).to_string(), "-5678"); + assert_eq!(I64(-5678).pretty().to_string(), "-5678"); + + assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000"); + assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000"); +} + +#[test] +fn test_write_f64() { + assert_eq!(F64(3.0).to_string(), "3.0"); + assert_eq!(F64(3.0).pretty().to_string(), "3.0"); + + assert_eq!(F64(3.1).to_string(), "3.1"); + assert_eq!(F64(3.1).pretty().to_string(), "3.1"); + + assert_eq!(F64(-1.5).to_string(), "-1.5"); + assert_eq!(F64(-1.5).pretty().to_string(), "-1.5"); + + assert_eq!(F64(0.5).to_string(), "0.5"); + assert_eq!(F64(0.5).pretty().to_string(), "0.5"); + + assert_eq!(F64(f64::NAN).to_string(), "null"); + assert_eq!(F64(f64::NAN).pretty().to_string(), "null"); + + assert_eq!(F64(f64::INFINITY).to_string(), "null"); + assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null"); + + assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null"); + assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null"); +} + +#[test] +fn test_write_str() { + assert_eq!(String("".to_string()).to_string(), "\"\""); + assert_eq!(String("".to_string()).pretty().to_string(), "\"\""); + + assert_eq!(String("homura".to_string()).to_string(), "\"homura\""); + assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\""); +} + +#[test] +fn test_write_bool() { + assert_eq!(Boolean(true).to_string(), "true"); + assert_eq!(Boolean(true).pretty().to_string(), "true"); + + assert_eq!(Boolean(false).to_string(), "false"); + assert_eq!(Boolean(false).pretty().to_string(), "false"); +} + +#[test] +fn test_write_array() { + assert_eq!(Array(vec![]).to_string(), "[]"); + assert_eq!(Array(vec![]).pretty().to_string(), "[]"); + + assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]"); + assert_eq!( + Array(vec![Boolean(true)]).pretty().to_string(), + "\ + [\n \ + true\n\ + ]" + ); + + let long_test_array = Array(vec![ + Boolean(false), + Null, + Array(vec![String("foo\nbar".to_string()), F64(3.5)])]); + + assert_eq!(long_test_array.to_string(), + "[false,null,[\"foo\\nbar\",3.5]]"); + assert_eq!( + long_test_array.pretty().to_string(), + "\ + [\n \ + false,\n \ + null,\n \ + [\n \ + \"foo\\nbar\",\n \ + 3.5\n \ + ]\n\ + ]" + ); +} + +#[test] +fn test_write_object() { + assert_eq!(mk_object(&[]).to_string(), "{}"); + assert_eq!(mk_object(&[]).pretty().to_string(), "{}"); + + assert_eq!( + mk_object(&[ + ("a".to_string(), Boolean(true)) + ]).to_string(), + "{\"a\":true}" + ); + assert_eq!( + mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(), + "\ + {\n \ + \"a\": true\n\ + }" + ); + + let complex_obj = mk_object(&[ + ("b".to_string(), Array(vec![ + mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]), + mk_object(&[("d".to_string(), String("".to_string()))]) + ])) + ]); + + assert_eq!( + complex_obj.to_string(), + "{\ + \"b\":[\ + {\"c\":\"\\f\\r\"},\ + {\"d\":\"\"}\ + ]\ + }" + ); + assert_eq!( + complex_obj.pretty().to_string(), + "\ + {\n \ + \"b\": [\n \ + {\n \ + \"c\": \"\\f\\r\"\n \ + },\n \ + {\n \ + \"d\": \"\"\n \ + }\n \ + ]\n\ + }" + ); + + let a = mk_object(&[ + ("a".to_string(), Boolean(true)), + ("b".to_string(), Array(vec![ + mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]), + mk_object(&[("d".to_string(), String("".to_string()))]) + ])) + ]); + + // We can't compare the strings directly because the object fields be + // printed in a different order. + assert_eq!(a.clone(), a.to_string().parse().unwrap()); + assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap()); +} + +#[test] +fn test_write_enum() { + let animal = Dog; + assert_eq!( + json::as_json(&animal).to_string(), + "\"Dog\"" + ); + assert_eq!( + json::as_pretty_json(&animal).to_string(), + "\"Dog\"" + ); + + let animal = Frog("Henry".to_string(), 349); + assert_eq!( + json::as_json(&animal).to_string(), + "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}" + ); + assert_eq!( + json::as_pretty_json(&animal).to_string(), + "{\n \ + \"variant\": \"Frog\",\n \ + \"fields\": [\n \ + \"Henry\",\n \ + 349\n \ + ]\n\ + }" + ); +} + +macro_rules! check_encoder_for_simple { + ($value:expr, $expected:expr) => ({ + let s = json::as_json(&$value).to_string(); + assert_eq!(s, $expected); + + let s = json::as_pretty_json(&$value).to_string(); + assert_eq!(s, $expected); + }) +} + +#[test] +fn test_write_some() { + check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\""); +} + +#[test] +fn test_write_none() { + check_encoder_for_simple!(None::, "null"); +} + +#[test] +fn test_write_char() { + check_encoder_for_simple!('a', "\"a\""); + check_encoder_for_simple!('\t', "\"\\t\""); + check_encoder_for_simple!('\u{0000}', "\"\\u0000\""); + check_encoder_for_simple!('\u{001b}', "\"\\u001b\""); + check_encoder_for_simple!('\u{007f}', "\"\\u007f\""); + check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\""); + check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\""); + check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\""); +} + +#[test] +fn test_trailing_characters() { + assert_eq!(from_str("nulla"), Err(SyntaxError(TrailingCharacters, 1, 5))); + assert_eq!(from_str("truea"), Err(SyntaxError(TrailingCharacters, 1, 5))); + assert_eq!(from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6))); + assert_eq!(from_str("1a"), Err(SyntaxError(TrailingCharacters, 1, 2))); + assert_eq!(from_str("[]a"), Err(SyntaxError(TrailingCharacters, 1, 3))); + assert_eq!(from_str("{}a"), Err(SyntaxError(TrailingCharacters, 1, 3))); +} + +#[test] +fn test_read_identifiers() { + assert_eq!(from_str("n"), Err(SyntaxError(InvalidSyntax, 1, 2))); + assert_eq!(from_str("nul"), Err(SyntaxError(InvalidSyntax, 1, 4))); + assert_eq!(from_str("t"), Err(SyntaxError(InvalidSyntax, 1, 2))); + assert_eq!(from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4))); + assert_eq!(from_str("f"), Err(SyntaxError(InvalidSyntax, 1, 2))); + assert_eq!(from_str("faz"), Err(SyntaxError(InvalidSyntax, 1, 3))); + + assert_eq!(from_str("null"), Ok(Null)); + assert_eq!(from_str("true"), Ok(Boolean(true))); + assert_eq!(from_str("false"), Ok(Boolean(false))); + assert_eq!(from_str(" null "), Ok(Null)); + assert_eq!(from_str(" true "), Ok(Boolean(true))); + assert_eq!(from_str(" false "), Ok(Boolean(false))); +} + +#[test] +fn test_decode_identifiers() { + let v: () = json::decode("null").unwrap(); + assert_eq!(v, ()); + + let v: bool = json::decode("true").unwrap(); + assert_eq!(v, true); + + let v: bool = json::decode("false").unwrap(); + assert_eq!(v, false); +} + +#[test] +fn test_read_number() { + assert_eq!(from_str("+"), Err(SyntaxError(InvalidSyntax, 1, 1))); + assert_eq!(from_str("."), Err(SyntaxError(InvalidSyntax, 1, 1))); + assert_eq!(from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1))); + assert_eq!(from_str("-"), Err(SyntaxError(InvalidNumber, 1, 2))); + assert_eq!(from_str("00"), Err(SyntaxError(InvalidNumber, 1, 2))); + assert_eq!(from_str("1."), Err(SyntaxError(InvalidNumber, 1, 3))); + assert_eq!(from_str("1e"), Err(SyntaxError(InvalidNumber, 1, 3))); + assert_eq!(from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4))); + + assert_eq!(from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20))); + assert_eq!(from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21))); + + assert_eq!(from_str("3"), Ok(U64(3))); + assert_eq!(from_str("3.1"), Ok(F64(3.1))); + assert_eq!(from_str("-1.2"), Ok(F64(-1.2))); + assert_eq!(from_str("0.4"), Ok(F64(0.4))); + assert_eq!(from_str("0.4e5"), Ok(F64(0.4e5))); + assert_eq!(from_str("0.4e+15"), Ok(F64(0.4e15))); + assert_eq!(from_str("0.4e-01"), Ok(F64(0.4e-01))); + assert_eq!(from_str(" 3 "), Ok(U64(3))); + + assert_eq!(from_str("-9223372036854775808"), Ok(I64(i64::MIN))); + assert_eq!(from_str("9223372036854775807"), Ok(U64(i64::MAX as u64))); + assert_eq!(from_str("18446744073709551615"), Ok(U64(u64::MAX))); +} + +#[test] +fn test_decode_numbers() { + let v: f64 = json::decode("3").unwrap(); + assert_eq!(v, 3.0); + + let v: f64 = json::decode("3.1").unwrap(); + assert_eq!(v, 3.1); + + let v: f64 = json::decode("-1.2").unwrap(); + assert_eq!(v, -1.2); + + let v: f64 = json::decode("0.4").unwrap(); + assert_eq!(v, 0.4); + + let v: f64 = json::decode("0.4e5").unwrap(); + assert_eq!(v, 0.4e5); + + let v: f64 = json::decode("0.4e15").unwrap(); + assert_eq!(v, 0.4e15); + + let v: f64 = json::decode("0.4e-01").unwrap(); + assert_eq!(v, 0.4e-01); + + let v: u64 = json::decode("0").unwrap(); + assert_eq!(v, 0); + + let v: u64 = json::decode("18446744073709551615").unwrap(); + assert_eq!(v, u64::MAX); + + let v: i64 = json::decode("-9223372036854775808").unwrap(); + assert_eq!(v, i64::MIN); + + let v: i64 = json::decode("9223372036854775807").unwrap(); + assert_eq!(v, i64::MAX); + + let res: DecodeResult = json::decode("765.25"); + assert_eq!(res, Err(ExpectedError("Integer".to_string(), + "765.25".to_string()))); +} + +#[test] +fn test_read_str() { + assert_eq!(from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2))); + assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5))); + + assert_eq!(from_str("\"\""), Ok(String("".to_string()))); + assert_eq!(from_str("\"foo\""), Ok(String("foo".to_string()))); + assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string()))); + assert_eq!(from_str("\"\\b\""), Ok(String("\x08".to_string()))); + assert_eq!(from_str("\"\\n\""), Ok(String("\n".to_string()))); + assert_eq!(from_str("\"\\r\""), Ok(String("\r".to_string()))); + assert_eq!(from_str("\"\\t\""), Ok(String("\t".to_string()))); + assert_eq!(from_str(" \"foo\" "), Ok(String("foo".to_string()))); + assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string()))); + assert_eq!(from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string()))); +} + +#[test] +fn test_decode_str() { + let s = [("\"\"", ""), + ("\"foo\"", "foo"), + ("\"\\\"\"", "\""), + ("\"\\b\"", "\x08"), + ("\"\\n\"", "\n"), + ("\"\\r\"", "\r"), + ("\"\\t\"", "\t"), + ("\"\\u12ab\"", "\u{12ab}"), + ("\"\\uAB12\"", "\u{AB12}")]; + + for &(i, o) in &s { + let v: string::String = json::decode(i).unwrap(); + assert_eq!(v, o); + } +} + +#[test] +fn test_read_array() { + assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2))); + assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3))); + assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4))); + assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4))); + assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4))); + + assert_eq!(from_str("[]"), Ok(Array(vec![]))); + assert_eq!(from_str("[ ]"), Ok(Array(vec![]))); + assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)]))); + assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)]))); + assert_eq!(from_str("[null]"), Ok(Array(vec![Null]))); + assert_eq!(from_str("[3, 1]"), + Ok(Array(vec![U64(3), U64(1)]))); + assert_eq!(from_str("\n[3, 2]\n"), + Ok(Array(vec![U64(3), U64(2)]))); + assert_eq!(from_str("[2, [4, 1]]"), + Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])]))); +} + +#[test] +fn test_decode_array() { + let v: Vec<()> = json::decode("[]").unwrap(); + assert_eq!(v, []); + + let v: Vec<()> = json::decode("[null]").unwrap(); + assert_eq!(v, [()]); + + let v: Vec = json::decode("[true]").unwrap(); + assert_eq!(v, [true]); + + let v: Vec = json::decode("[3, 1]").unwrap(); + assert_eq!(v, [3, 1]); + + let v: Vec> = json::decode("[[3], [1, 2]]").unwrap(); + assert_eq!(v, [vec![3], vec![1, 2]]); +} + +#[test] +fn test_decode_tuple() { + let t: (usize, usize, usize) = json::decode("[1, 2, 3]").unwrap(); + assert_eq!(t, (1, 2, 3)); + + let t: (usize, string::String) = json::decode("[1, \"two\"]").unwrap(); + assert_eq!(t, (1, "two".to_string())); +} + +#[test] +fn test_decode_tuple_malformed_types() { + assert!(json::decode::<(usize, string::String)>("[1, 2]").is_err()); +} + +#[test] +fn test_decode_tuple_malformed_length() { + assert!(json::decode::<(usize, usize)>("[1, 2, 3]").is_err()); +} + +#[test] +fn test_read_object() { + assert_eq!(from_str("{"), Err(SyntaxError(EOFWhileParsingObject, 1, 2))); + assert_eq!(from_str("{ "), Err(SyntaxError(EOFWhileParsingObject, 1, 3))); + assert_eq!(from_str("{1"), Err(SyntaxError(KeyMustBeAString, 1, 2))); + assert_eq!(from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6))); + assert_eq!(from_str("{\"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 5))); + assert_eq!(from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6))); + + assert_eq!(from_str("{\"a\" 1"), Err(SyntaxError(ExpectedColon, 1, 6))); + assert_eq!(from_str("{\"a\":"), Err(SyntaxError(EOFWhileParsingValue, 1, 6))); + assert_eq!(from_str("{\"a\":1"), Err(SyntaxError(EOFWhileParsingObject, 1, 7))); + assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8))); + assert_eq!(from_str("{\"a\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8))); + + assert_eq!(from_str("{}").unwrap(), mk_object(&[])); + assert_eq!(from_str("{\"a\": 3}").unwrap(), + mk_object(&[("a".to_string(), U64(3))])); + + assert_eq!(from_str( + "{ \"a\": null, \"b\" : true }").unwrap(), + mk_object(&[ + ("a".to_string(), Null), + ("b".to_string(), Boolean(true))])); + assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(), + mk_object(&[ + ("a".to_string(), Null), + ("b".to_string(), Boolean(true))])); + assert_eq!(from_str( + "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(), + mk_object(&[ + ("a".to_string(), F64(1.0)), + ("b".to_string(), Array(vec![Boolean(true)])) + ])); + assert_eq!(from_str( + "{\ + \"a\": 1.0, \ + \"b\": [\ + true,\ + \"foo\\nbar\", \ + { \"c\": {\"d\": null} } \ + ]\ + }").unwrap(), + mk_object(&[ + ("a".to_string(), F64(1.0)), + ("b".to_string(), Array(vec![ + Boolean(true), + String("foo\nbar".to_string()), + mk_object(&[ + ("c".to_string(), mk_object(&[("d".to_string(), Null)])) + ]) + ])) + ])); +} + +#[test] +fn test_decode_struct() { + let s = "{ + \"inner\": [ + { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] } + ] + }"; + + let v: Outer = json::decode(s).unwrap(); + assert_eq!( + v, + Outer { + inner: vec![ + Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] } + ] + } + ); +} + +#[derive(RustcDecodable)] +struct FloatStruct { + f: f64, + a: Vec +} +#[test] +fn test_decode_struct_with_nan() { + let s = "{\"f\":null,\"a\":[null,123]}"; + let obj: FloatStruct = json::decode(s).unwrap(); + assert!(obj.f.is_nan()); + assert!(obj.a[0].is_nan()); + assert_eq!(obj.a[1], 123f64); +} + +#[test] +fn test_decode_option() { + let value: Option = json::decode("null").unwrap(); + assert_eq!(value, None); + + let value: Option = json::decode("\"jodhpurs\"").unwrap(); + assert_eq!(value, Some("jodhpurs".to_string())); +} + +#[test] +fn test_decode_enum() { + let value: Animal = json::decode("\"Dog\"").unwrap(); + assert_eq!(value, Dog); + + let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"; + let value: Animal = json::decode(s).unwrap(); + assert_eq!(value, Frog("Henry".to_string(), 349)); +} + +#[test] +fn test_decode_map() { + let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\ + \"fields\":[\"Henry\", 349]}}"; + let mut map: BTreeMap = json::decode(s).unwrap(); + + assert_eq!(map.remove(&"a".to_string()), Some(Dog)); + assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349))); +} + +#[test] +fn test_multiline_errors() { + assert_eq!(from_str("{\n \"foo\":\n \"bar\""), + Err(SyntaxError(EOFWhileParsingObject, 3, 8))); +} + +#[derive(RustcDecodable)] +#[allow(dead_code)] +struct DecodeStruct { + x: f64, + y: bool, + z: string::String, + w: Vec +} +#[derive(RustcDecodable)] +enum DecodeEnum { + A(f64), + B(string::String) +} +fn check_err(to_parse: &'static str, expected: DecoderError) { + let res: DecodeResult = match from_str(to_parse) { + Err(e) => Err(ParseError(e)), + Ok(json) => Decodable::decode(&mut Decoder::new(json)) + }; + match res { + Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`", + to_parse, expected), + Err(ParseError(e)) => panic!("`{:?}` is not valid json: {:?}", + to_parse, e), + Err(e) => { + assert_eq!(e, expected); + } + } +} +#[test] +fn test_decode_errors_struct() { + check_err::("[]", ExpectedError("Object".to_string(), "[]".to_string())); + check_err::("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}", + ExpectedError("Number".to_string(), "true".to_string())); + check_err::("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}", + ExpectedError("Boolean".to_string(), "[]".to_string())); + check_err::("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}", + ExpectedError("String".to_string(), "{}".to_string())); + check_err::("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}", + ExpectedError("Array".to_string(), "null".to_string())); + check_err::("{\"x\": 1, \"y\": true, \"z\": \"\"}", + MissingFieldError("w".to_string())); +} +#[test] +fn test_decode_errors_enum() { + check_err::("{}", + MissingFieldError("variant".to_string())); + check_err::("{\"variant\": 1}", + ExpectedError("String".to_string(), "1".to_string())); + check_err::("{\"variant\": \"A\"}", + MissingFieldError("fields".to_string())); + check_err::("{\"variant\": \"A\", \"fields\": null}", + ExpectedError("Array".to_string(), "null".to_string())); + check_err::("{\"variant\": \"C\", \"fields\": []}", + UnknownVariantError("C".to_string())); +} + +#[test] +fn test_find(){ + let json_value = from_str("{\"dog\" : \"cat\"}").unwrap(); + let found_str = json_value.find("dog"); + assert!(found_str.unwrap().as_string().unwrap() == "cat"); +} + +#[test] +fn test_find_path(){ + let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap(); + let found_str = json_value.find_path(&["dog", "cat", "mouse"]); + assert!(found_str.unwrap().as_string().unwrap() == "cheese"); +} + +#[test] +fn test_search(){ + let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap(); + let found_str = json_value.search("mouse").and_then(|j| j.as_string()); + assert!(found_str.unwrap() == "cheese"); +} + +#[test] +fn test_index(){ + let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap(); + let ref array = json_value["animals"]; + assert_eq!(array[0].as_string().unwrap(), "dog"); + assert_eq!(array[1].as_string().unwrap(), "cat"); + assert_eq!(array[2].as_string().unwrap(), "mouse"); +} + +#[test] +fn test_is_object(){ + let json_value = from_str("{}").unwrap(); + assert!(json_value.is_object()); +} + +#[test] +fn test_as_object(){ + let json_value = from_str("{}").unwrap(); + let json_object = json_value.as_object(); + assert!(json_object.is_some()); +} + +#[test] +fn test_is_array(){ + let json_value = from_str("[1, 2, 3]").unwrap(); + assert!(json_value.is_array()); +} + +#[test] +fn test_as_array(){ + let json_value = from_str("[1, 2, 3]").unwrap(); + let json_array = json_value.as_array(); + let expected_length = 3; + assert!(json_array.is_some() && json_array.unwrap().len() == expected_length); +} + +#[test] +fn test_is_string(){ + let json_value = from_str("\"dog\"").unwrap(); + assert!(json_value.is_string()); +} + +#[test] +fn test_as_string(){ + let json_value = from_str("\"dog\"").unwrap(); + let json_str = json_value.as_string(); + let expected_str = "dog"; + assert_eq!(json_str, Some(expected_str)); +} + +#[test] +fn test_is_number(){ + let json_value = from_str("12").unwrap(); + assert!(json_value.is_number()); +} + +#[test] +fn test_is_i64(){ + let json_value = from_str("-12").unwrap(); + assert!(json_value.is_i64()); + + let json_value = from_str("12").unwrap(); + assert!(!json_value.is_i64()); + + let json_value = from_str("12.0").unwrap(); + assert!(!json_value.is_i64()); +} + +#[test] +fn test_is_u64(){ + let json_value = from_str("12").unwrap(); + assert!(json_value.is_u64()); + + let json_value = from_str("-12").unwrap(); + assert!(!json_value.is_u64()); + + let json_value = from_str("12.0").unwrap(); + assert!(!json_value.is_u64()); +} + +#[test] +fn test_is_f64(){ + let json_value = from_str("12").unwrap(); + assert!(!json_value.is_f64()); + + let json_value = from_str("-12").unwrap(); + assert!(!json_value.is_f64()); + + let json_value = from_str("12.0").unwrap(); + assert!(json_value.is_f64()); + + let json_value = from_str("-12.0").unwrap(); + assert!(json_value.is_f64()); +} + +#[test] +fn test_as_i64(){ + let json_value = from_str("-12").unwrap(); + let json_num = json_value.as_i64(); + assert_eq!(json_num, Some(-12)); +} + +#[test] +fn test_as_u64(){ + let json_value = from_str("12").unwrap(); + let json_num = json_value.as_u64(); + assert_eq!(json_num, Some(12)); +} + +#[test] +fn test_as_f64(){ + let json_value = from_str("12.0").unwrap(); + let json_num = json_value.as_f64(); + assert_eq!(json_num, Some(12f64)); +} + +#[test] +fn test_is_boolean(){ + let json_value = from_str("false").unwrap(); + assert!(json_value.is_boolean()); +} + +#[test] +fn test_as_boolean(){ + let json_value = from_str("false").unwrap(); + let json_bool = json_value.as_boolean(); + let expected_bool = false; + assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool); +} + +#[test] +fn test_is_null(){ + let json_value = from_str("null").unwrap(); + assert!(json_value.is_null()); +} + +#[test] +fn test_as_null(){ + let json_value = from_str("null").unwrap(); + let json_null = json_value.as_null(); + let expected_null = (); + assert!(json_null.is_some() && json_null.unwrap() == expected_null); +} + +#[test] +fn test_encode_hashmap_with_numeric_key() { + use std::str::from_utf8; + use std::collections::HashMap; + let mut hm: HashMap = HashMap::new(); + hm.insert(1, true); + let mut mem_buf = Vec::new(); + write!(&mut mem_buf, "{}", json::as_pretty_json(&hm)).unwrap(); + let json_str = from_utf8(&mem_buf[..]).unwrap(); + match from_str(json_str) { + Err(_) => panic!("Unable to parse json_str: {:?}", json_str), + _ => {} // it parsed and we are good to go + } +} + +#[test] +fn test_prettyencode_hashmap_with_numeric_key() { + use std::str::from_utf8; + use std::collections::HashMap; + let mut hm: HashMap = HashMap::new(); + hm.insert(1, true); + let mut mem_buf = Vec::new(); + write!(&mut mem_buf, "{}", json::as_pretty_json(&hm)).unwrap(); + let json_str = from_utf8(&mem_buf[..]).unwrap(); + match from_str(json_str) { + Err(_) => panic!("Unable to parse json_str: {:?}", json_str), + _ => {} // it parsed and we are good to go + } +} + +#[test] +fn test_prettyencoder_indent_level_param() { + use std::str::from_utf8; + use std::collections::BTreeMap; + + let mut tree = BTreeMap::new(); + + tree.insert("hello".to_string(), String("guten tag".to_string())); + tree.insert("goodbye".to_string(), String("sayonara".to_string())); + + let json = Array( + // The following layout below should look a lot like + // the pretty-printed JSON (indent * x) + vec! + ( // 0x + String("greetings".to_string()), // 1x + Object(tree), // 1x + 2x + 2x + 1x + ) // 0x + // End JSON array (7 lines) + ); + + // Helper function for counting indents + fn indents(source: &str) -> usize { + let trimmed = source.trim_start_matches(' '); + source.len() - trimmed.len() + } + + // Test up to 4 spaces of indents (more?) + for i in 0..4 { + let mut writer = Vec::new(); + write!(&mut writer, "{}", + json::as_pretty_json(&json).indent(i)).unwrap(); + + let printed = from_utf8(&writer[..]).unwrap(); + + // Check for indents at each line + let lines: Vec<&str> = printed.lines().collect(); + assert_eq!(lines.len(), 7); // JSON should be 7 lines + + assert_eq!(indents(lines[0]), 0 * i); // [ + assert_eq!(indents(lines[1]), 1 * i); // "greetings", + assert_eq!(indents(lines[2]), 1 * i); // { + assert_eq!(indents(lines[3]), 2 * i); // "hello": "guten tag", + assert_eq!(indents(lines[4]), 2 * i); // "goodbye": "sayonara" + assert_eq!(indents(lines[5]), 1 * i); // }, + assert_eq!(indents(lines[6]), 0 * i); // ] + + // Finally, test that the pretty-printed JSON is valid + from_str(printed).ok().expect("Pretty-printed JSON is invalid!"); + } +} + +#[test] +fn test_hashmap_with_enum_key() { + use std::collections::HashMap; + #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)] + enum Enum { + Foo, + #[allow(dead_code)] + Bar, + } + let mut map = HashMap::new(); + map.insert(Enum::Foo, 0); + let result = json::encode(&map).unwrap(); + assert_eq!(&result[..], r#"{"Foo":0}"#); + let decoded: HashMap = json::decode(&result).unwrap(); + assert_eq!(map, decoded); +} + +#[test] +fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() { + use std::collections::HashMap; + let json_str = "{\"1\":true}"; + let json_obj = match from_str(json_str) { + Err(_) => panic!("Unable to parse json_str: {:?}", json_str), + Ok(o) => o + }; + let mut decoder = Decoder::new(json_obj); + let _hm: HashMap = Decodable::decode(&mut decoder).unwrap(); +} + +#[test] +fn test_hashmap_with_numeric_key_will_error_with_string_keys() { + use std::collections::HashMap; + let json_str = "{\"a\":true}"; + let json_obj = match from_str(json_str) { + Err(_) => panic!("Unable to parse json_str: {:?}", json_str), + Ok(o) => o + }; + let mut decoder = Decoder::new(json_obj); + let result: Result, DecoderError> = Decodable::decode(&mut decoder); + assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string()))); +} + +fn assert_stream_equal(src: &str, + expected: Vec<(JsonEvent, Vec>)>) { + let mut parser = Parser::new(src.chars()); + let mut i = 0; + loop { + let evt = match parser.next() { + Some(e) => e, + None => { break; } + }; + let (ref expected_evt, ref expected_stack) = expected[i]; + if !parser.stack().is_equal_to(expected_stack) { + panic!("Parser stack is not equal to {:?}", expected_stack); + } + assert_eq!(&evt, expected_evt); + i+=1; + } +} +#[test] +fn test_streaming_parser() { + assert_stream_equal( + r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#, + vec![ + (ObjectStart, vec![]), + (StringValue("bar".to_string()), vec![StackElement::Key("foo")]), + (ArrayStart, vec![StackElement::Key("array")]), + (U64Value(0), vec![StackElement::Key("array"), StackElement::Index(0)]), + (U64Value(1), vec![StackElement::Key("array"), StackElement::Index(1)]), + (U64Value(2), vec![StackElement::Key("array"), StackElement::Index(2)]), + (U64Value(3), vec![StackElement::Key("array"), StackElement::Index(3)]), + (U64Value(4), vec![StackElement::Key("array"), StackElement::Index(4)]), + (U64Value(5), vec![StackElement::Key("array"), StackElement::Index(5)]), + (ArrayEnd, vec![StackElement::Key("array")]), + (ArrayStart, vec![StackElement::Key("idents")]), + (NullValue, vec![StackElement::Key("idents"), + StackElement::Index(0)]), + (BooleanValue(true), vec![StackElement::Key("idents"), + StackElement::Index(1)]), + (BooleanValue(false), vec![StackElement::Key("idents"), + StackElement::Index(2)]), + (ArrayEnd, vec![StackElement::Key("idents")]), + (ObjectEnd, vec![]), + ] + ); +} +fn last_event(src: &str) -> JsonEvent { + let mut parser = Parser::new(src.chars()); + let mut evt = NullValue; + loop { + evt = match parser.next() { + Some(e) => e, + None => return evt, + } + } +} + +#[test] +fn test_read_object_streaming() { + assert_eq!(last_event("{ "), Error(SyntaxError(EOFWhileParsingObject, 1, 3))); + assert_eq!(last_event("{1"), Error(SyntaxError(KeyMustBeAString, 1, 2))); + assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6))); + assert_eq!(last_event("{\"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 5))); + assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6))); + + assert_eq!(last_event("{\"a\" 1"), Error(SyntaxError(ExpectedColon, 1, 6))); + assert_eq!(last_event("{\"a\":"), Error(SyntaxError(EOFWhileParsingValue, 1, 6))); + assert_eq!(last_event("{\"a\":1"), Error(SyntaxError(EOFWhileParsingObject, 1, 7))); + assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax, 1, 8))); + assert_eq!(last_event("{\"a\":1,"), Error(SyntaxError(EOFWhileParsingObject, 1, 8))); + assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8))); + + assert_stream_equal( + "{}", + vec![(ObjectStart, vec![]), (ObjectEnd, vec![])] + ); + assert_stream_equal( + "{\"a\": 3}", + vec![ + (ObjectStart, vec![]), + (U64Value(3), vec![StackElement::Key("a")]), + (ObjectEnd, vec![]), + ] + ); + assert_stream_equal( + "{ \"a\": null, \"b\" : true }", + vec![ + (ObjectStart, vec![]), + (NullValue, vec![StackElement::Key("a")]), + (BooleanValue(true), vec![StackElement::Key("b")]), + (ObjectEnd, vec![]), + ] + ); + assert_stream_equal( + "{\"a\" : 1.0 ,\"b\": [ true ]}", + vec![ + (ObjectStart, vec![]), + (F64Value(1.0), vec![StackElement::Key("a")]), + (ArrayStart, vec![StackElement::Key("b")]), + (BooleanValue(true),vec![StackElement::Key("b"), StackElement::Index(0)]), + (ArrayEnd, vec![StackElement::Key("b")]), + (ObjectEnd, vec![]), + ] + ); + assert_stream_equal( + r#"{ + "a": 1.0, + "b": [ + true, + "foo\nbar", + { "c": {"d": null} } + ] + }"#, + vec![ + (ObjectStart, vec![]), + (F64Value(1.0), vec![StackElement::Key("a")]), + (ArrayStart, vec![StackElement::Key("b")]), + (BooleanValue(true), vec![StackElement::Key("b"), + StackElement::Index(0)]), + (StringValue("foo\nbar".to_string()), vec![StackElement::Key("b"), + StackElement::Index(1)]), + (ObjectStart, vec![StackElement::Key("b"), + StackElement::Index(2)]), + (ObjectStart, vec![StackElement::Key("b"), + StackElement::Index(2), + StackElement::Key("c")]), + (NullValue, vec![StackElement::Key("b"), + StackElement::Index(2), + StackElement::Key("c"), + StackElement::Key("d")]), + (ObjectEnd, vec![StackElement::Key("b"), + StackElement::Index(2), + StackElement::Key("c")]), + (ObjectEnd, vec![StackElement::Key("b"), + StackElement::Index(2)]), + (ArrayEnd, vec![StackElement::Key("b")]), + (ObjectEnd, vec![]), + ] + ); +} +#[test] +fn test_read_array_streaming() { + assert_stream_equal( + "[]", + vec![ + (ArrayStart, vec![]), + (ArrayEnd, vec![]), + ] + ); + assert_stream_equal( + "[ ]", + vec![ + (ArrayStart, vec![]), + (ArrayEnd, vec![]), + ] + ); + assert_stream_equal( + "[true]", + vec![ + (ArrayStart, vec![]), + (BooleanValue(true), vec![StackElement::Index(0)]), + (ArrayEnd, vec![]), + ] + ); + assert_stream_equal( + "[ false ]", + vec![ + (ArrayStart, vec![]), + (BooleanValue(false), vec![StackElement::Index(0)]), + (ArrayEnd, vec![]), + ] + ); + assert_stream_equal( + "[null]", + vec![ + (ArrayStart, vec![]), + (NullValue, vec![StackElement::Index(0)]), + (ArrayEnd, vec![]), + ] + ); + assert_stream_equal( + "[3, 1]", + vec![ + (ArrayStart, vec![]), + (U64Value(3), vec![StackElement::Index(0)]), + (U64Value(1), vec![StackElement::Index(1)]), + (ArrayEnd, vec![]), + ] + ); + assert_stream_equal( + "\n[3, 2]\n", + vec![ + (ArrayStart, vec![]), + (U64Value(3), vec![StackElement::Index(0)]), + (U64Value(2), vec![StackElement::Index(1)]), + (ArrayEnd, vec![]), + ] + ); + assert_stream_equal( + "[2, [4, 1]]", + vec![ + (ArrayStart, vec![]), + (U64Value(2), vec![StackElement::Index(0)]), + (ArrayStart, vec![StackElement::Index(1)]), + (U64Value(4), vec![StackElement::Index(1), StackElement::Index(0)]), + (U64Value(1), vec![StackElement::Index(1), StackElement::Index(1)]), + (ArrayEnd, vec![StackElement::Index(1)]), + (ArrayEnd, vec![]), + ] + ); + + assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1, 2))); + + assert_eq!(from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2))); + assert_eq!(from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3))); + assert_eq!(from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4))); + assert_eq!(from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4))); + assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4))); + +} +#[test] +fn test_trailing_characters_streaming() { + assert_eq!(last_event("nulla"), Error(SyntaxError(TrailingCharacters, 1, 5))); + assert_eq!(last_event("truea"), Error(SyntaxError(TrailingCharacters, 1, 5))); + assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6))); + assert_eq!(last_event("1a"), Error(SyntaxError(TrailingCharacters, 1, 2))); + assert_eq!(last_event("[]a"), Error(SyntaxError(TrailingCharacters, 1, 3))); + assert_eq!(last_event("{}a"), Error(SyntaxError(TrailingCharacters, 1, 3))); +} +#[test] +fn test_read_identifiers_streaming() { + assert_eq!(Parser::new("null".chars()).next(), Some(NullValue)); + assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true))); + assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false))); + + assert_eq!(last_event("n"), Error(SyntaxError(InvalidSyntax, 1, 2))); + assert_eq!(last_event("nul"), Error(SyntaxError(InvalidSyntax, 1, 4))); + assert_eq!(last_event("t"), Error(SyntaxError(InvalidSyntax, 1, 2))); + assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4))); + assert_eq!(last_event("f"), Error(SyntaxError(InvalidSyntax, 1, 2))); + assert_eq!(last_event("faz"), Error(SyntaxError(InvalidSyntax, 1, 3))); +} + +#[test] +fn test_to_json() { + use std::collections::{HashMap,BTreeMap}; + use json::ToJson; + + let array2 = Array(vec![U64(1), U64(2)]); + let array3 = Array(vec![U64(1), U64(2), U64(3)]); + let object = { + let mut tree_map = BTreeMap::new(); + tree_map.insert("a".to_string(), U64(1)); + tree_map.insert("b".to_string(), U64(2)); + Object(tree_map) + }; + + assert_eq!(array2.to_json(), array2); + assert_eq!(object.to_json(), object); + assert_eq!(3_isize.to_json(), I64(3)); + assert_eq!(4_i8.to_json(), I64(4)); + assert_eq!(5_i16.to_json(), I64(5)); + assert_eq!(6_i32.to_json(), I64(6)); + assert_eq!(7_i64.to_json(), I64(7)); + assert_eq!(8_usize.to_json(), U64(8)); + assert_eq!(9_u8.to_json(), U64(9)); + assert_eq!(10_u16.to_json(), U64(10)); + assert_eq!(11_u32.to_json(), U64(11)); + assert_eq!(12_u64.to_json(), U64(12)); + assert_eq!(13.0_f32.to_json(), F64(13.0_f64)); + assert_eq!(14.0_f64.to_json(), F64(14.0_f64)); + assert_eq!(().to_json(), Null); + assert_eq!(f32::INFINITY.to_json(), Null); + assert_eq!(f64::NAN.to_json(), Null); + assert_eq!(true.to_json(), Boolean(true)); + assert_eq!(false.to_json(), Boolean(false)); + assert_eq!("abc".to_json(), String("abc".to_string())); + assert_eq!("abc".to_string().to_json(), String("abc".to_string())); + assert_eq!((1_usize, 2_usize).to_json(), array2); + assert_eq!((1_usize, 2_usize, 3_usize).to_json(), array3); + assert_eq!([1_usize, 2_usize].to_json(), array2); + assert_eq!((&[1_usize, 2_usize, 3_usize]).to_json(), array3); + assert_eq!((vec![1_usize, 2_usize]).to_json(), array2); + assert_eq!(vec![1_usize, 2_usize, 3_usize].to_json(), array3); + let mut tree_map = BTreeMap::new(); + tree_map.insert("a".to_string(), 1 as usize); + tree_map.insert("b".to_string(), 2); + assert_eq!(tree_map.to_json(), object); + let mut hash_map = HashMap::new(); + hash_map.insert("a".to_string(), 1 as usize); + hash_map.insert("b".to_string(), 2); + assert_eq!(hash_map.to_json(), object); + assert_eq!(Some(15).to_json(), I64(15)); + assert_eq!(Some(15 as usize).to_json(), U64(15)); + assert_eq!(None::.to_json(), Null); +} + +#[test] +fn test_encode_hashmap_with_arbitrary_key() { + use std::collections::HashMap; + #[derive(PartialEq, Eq, Hash, RustcEncodable)] + struct ArbitraryType(usize); + let mut hm: HashMap = HashMap::new(); + hm.insert(ArbitraryType(1), true); + let mut mem_buf = string::String::new(); + let mut encoder = Encoder::new(&mut mem_buf); + let result = hm.encode(&mut encoder); + match result.unwrap_err() { + EncoderError::BadHashmapKey => (), + _ => panic!("expected bad hash map key") + } +} diff --git a/src/libserialize/tests/opaque.rs b/src/libserialize/tests/opaque.rs new file mode 100644 index 0000000000000..fff6fc69e7842 --- /dev/null +++ b/src/libserialize/tests/opaque.rs @@ -0,0 +1,282 @@ +extern crate serialize as rustc_serialize; + +use rustc_serialize::{Encodable, Decodable}; +use rustc_serialize::opaque::{Encoder, Decoder}; +use std::fmt::Debug; + +#[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)] +struct Struct { + a: (), + b: u8, + c: u16, + d: u32, + e: u64, + f: usize, + + g: i8, + h: i16, + i: i32, + j: i64, + k: isize, + + l: char, + m: String, + n: f32, + o: f64, + p: bool, + q: Option, +} + + +fn check_round_trip(values: Vec) { + let mut encoder = Encoder::new(Vec::new()); + + for value in &values { + Encodable::encode(&value, &mut encoder).unwrap(); + } + + let data = encoder.into_inner(); + let mut decoder = Decoder::new(&data[..], 0); + + for value in values { + let decoded = Decodable::decode(&mut decoder).unwrap(); + assert_eq!(value, decoded); + } +} + +#[test] +fn test_unit() { + check_round_trip(vec![(), (), (), ()]); +} + +#[test] +fn test_u8() { + let mut vec = vec![]; + for i in ::std::u8::MIN..::std::u8::MAX { + vec.push(i); + } + check_round_trip(vec); +} + +#[test] +fn test_u16() { + for i in ::std::u16::MIN..::std::u16::MAX { + check_round_trip(vec![1, 2, 3, i, i, i]); + } +} + +#[test] +fn test_u32() { + check_round_trip(vec![1, 2, 3, ::std::u32::MIN, 0, 1, ::std::u32::MAX, 2, 1]); +} + +#[test] +fn test_u64() { + check_round_trip(vec![1, 2, 3, ::std::u64::MIN, 0, 1, ::std::u64::MAX, 2, 1]); +} + +#[test] +fn test_usize() { + check_round_trip(vec![1, 2, 3, ::std::usize::MIN, 0, 1, ::std::usize::MAX, 2, 1]); +} + +#[test] +fn test_i8() { + let mut vec = vec![]; + for i in ::std::i8::MIN..::std::i8::MAX { + vec.push(i); + } + check_round_trip(vec); +} + +#[test] +fn test_i16() { + for i in ::std::i16::MIN..::std::i16::MAX { + check_round_trip(vec![-1, 2, -3, i, i, i, 2]); + } +} + +#[test] +fn test_i32() { + check_round_trip(vec![-1, 2, -3, ::std::i32::MIN, 0, 1, ::std::i32::MAX, 2, 1]); +} + +#[test] +fn test_i64() { + check_round_trip(vec![-1, 2, -3, ::std::i64::MIN, 0, 1, ::std::i64::MAX, 2, 1]); +} + +#[test] +fn test_isize() { + check_round_trip(vec![-1, 2, -3, ::std::isize::MIN, 0, 1, ::std::isize::MAX, 2, 1]); +} + +#[test] +fn test_bool() { + check_round_trip(vec![false, true, true, false, false]); +} + +#[test] +fn test_f32() { + let mut vec = vec![]; + for i in -100..100 { + vec.push((i as f32) / 3.0); + } + check_round_trip(vec); +} + +#[test] +fn test_f64() { + let mut vec = vec![]; + for i in -100..100 { + vec.push((i as f64) / 3.0); + } + check_round_trip(vec); +} + +#[test] +fn test_char() { + let vec = vec!['a', 'b', 'c', 'd', 'A', 'X', ' ', '#', 'Ö', 'Ä', 'µ', '€']; + check_round_trip(vec); +} + +#[test] +fn test_string() { + let vec = vec!["abcbuÖeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(), + "abcbuÖganeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(), + "abcbuÖganeiovÄnameÜavmpßvmea€µsbpapmaebn".to_string(), + "abcbuÖganeiovÄnameÜavmpßvmeabpnvapeapmaebn".to_string(), + "abcbuÖganeiÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(), + "abcbuÖganeiovÄnameÜavmpßvmea€µsbpmaebn".to_string(), + "abcbuÖganeiovÄnameÜavmpßvmea€µnvapeapmaebn".to_string()]; + + check_round_trip(vec); +} + +#[test] +fn test_option() { + check_round_trip(vec![Some(-1i8)]); + check_round_trip(vec![Some(-2i16)]); + check_round_trip(vec![Some(-3i32)]); + check_round_trip(vec![Some(-4i64)]); + check_round_trip(vec![Some(-5isize)]); + + let none_i8: Option = None; + check_round_trip(vec![none_i8]); + + let none_i16: Option = None; + check_round_trip(vec![none_i16]); + + let none_i32: Option = None; + check_round_trip(vec![none_i32]); + + let none_i64: Option = None; + check_round_trip(vec![none_i64]); + + let none_isize: Option = None; + check_round_trip(vec![none_isize]); +} + +#[test] +fn test_struct() { + check_round_trip(vec![Struct { + a: (), + b: 10, + c: 11, + d: 12, + e: 13, + f: 14, + + g: 15, + h: 16, + i: 17, + j: 18, + k: 19, + + l: 'x', + m: "abc".to_string(), + n: 20.5, + o: 21.5, + p: false, + q: None, + }]); + + check_round_trip(vec![Struct { + a: (), + b: 101, + c: 111, + d: 121, + e: 131, + f: 141, + + g: -15, + h: -16, + i: -17, + j: -18, + k: -19, + + l: 'y', + m: "def".to_string(), + n: -20.5, + o: -21.5, + p: true, + q: Some(1234567), + }]); +} + +#[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)] +enum Enum { + Variant1, + Variant2(usize, f32), + Variant3 { + a: i32, + b: char, + c: bool, + }, +} + +#[test] +fn test_enum() { + check_round_trip(vec![Enum::Variant1, + Enum::Variant2(1, 2.5), + Enum::Variant3 { + a: 3, + b: 'b', + c: false, + }, + Enum::Variant3 { + a: -4, + b: 'f', + c: true, + }]); +} + +#[test] +fn test_sequence() { + let mut vec = vec![]; + for i in -100i64..100i64 { + vec.push(i * 100000); + } + + check_round_trip(vec![vec]); +} + +#[test] +fn test_hash_map() { + use std::collections::HashMap; + let mut map = HashMap::new(); + for i in -100i64..100i64 { + map.insert(i * 100000, i * 10000); + } + + check_round_trip(vec![map]); +} + +#[test] +fn test_tuples() { + check_round_trip(vec![('x', (), false, 0.5f32)]); + check_round_trip(vec![(9i8, 10u16, 1.5f64)]); + check_round_trip(vec![(-12i16, 11u8, 12usize)]); + check_round_trip(vec![(1234567isize, 100000000000000u64, 99999999999999i64)]); + check_round_trip(vec![(String::new(), "some string".to_string())]); +} From 06b63046b298fad478e69007ee207396bc1a9a2d Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Sat, 9 Feb 2019 17:13:39 +0900 Subject: [PATCH 222/278] Cleanup imports --- src/libserialize/hex.rs | 2 +- src/libserialize/json.rs | 1 - src/libserialize/opaque.rs | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/src/libserialize/hex.rs b/src/libserialize/hex.rs index c5217b962ce79..73b9122b13cea 100644 --- a/src/libserialize/hex.rs +++ b/src/libserialize/hex.rs @@ -145,7 +145,7 @@ impl FromHex for str { #[cfg(test)] mod tests { extern crate test; - use self::test::Bencher; + use test::Bencher; use crate::hex::{FromHex, ToHex}; #[test] diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 60b1d2e17f12a..5b3444b9f456f 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -199,7 +199,6 @@ use std::ops::Index; use std::str::FromStr; use std::string; use std::{char, f64, fmt, str}; -use std; use crate::Encodable; diff --git a/src/libserialize/opaque.rs b/src/libserialize/opaque.rs index d6e8560195c2b..a6a5c318079f1 100644 --- a/src/libserialize/opaque.rs +++ b/src/libserialize/opaque.rs @@ -1,6 +1,6 @@ use crate::leb128::{self, read_signed_leb128, write_signed_leb128}; -use std::borrow::Cow; use crate::serialize; +use std::borrow::Cow; // ----------------------------------------------------------------------------- // Encoder From f5bbcf3818285abd253930554da90fc97cba3690 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Thu, 22 Nov 2018 17:17:45 +0100 Subject: [PATCH 223/278] use pass infrastructure for mir shims, so that they can get dumped --- src/librustc_mir/shim.rs | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs index 942e7a1f1bbbd..7edd725544c5e 100644 --- a/src/librustc_mir/shim.rs +++ b/src/librustc_mir/shim.rs @@ -16,8 +16,10 @@ use syntax_pos::Span; use std::fmt; use std::iter; -use crate::transform::{add_moves_for_packed_drops, add_call_guards}; -use crate::transform::{remove_noop_landing_pads, no_landing_pads, simplify}; +use crate::transform::{ + add_moves_for_packed_drops, add_call_guards, + remove_noop_landing_pads, no_landing_pads, simplify, run_passes +}; use crate::util::elaborate_drops::{self, DropElaborator, DropStyle, DropFlagMode}; use crate::util::patch::MirPatch; @@ -113,12 +115,15 @@ fn make_shim<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } }; debug!("make_shim({:?}) = untransformed {:?}", instance, result); - add_moves_for_packed_drops::add_moves_for_packed_drops( - tcx, &mut result, instance.def_id()); - no_landing_pads::no_landing_pads(tcx, &mut result); - remove_noop_landing_pads::remove_noop_landing_pads(tcx, &mut result); - simplify::simplify_cfg(&mut result); - add_call_guards::CriticalCallEdges.add_call_guards(&mut result); + + run_passes(tcx, &mut result, instance.def_id(), MirPhase::Const, &[ + &add_moves_for_packed_drops::AddMovesForPackedDrops, + &no_landing_pads::NoLandingPads, + &remove_noop_landing_pads::RemoveNoopLandingPads, + &simplify::SimplifyCfg::new("make_shim"), + &add_call_guards::CriticalCallEdges, + ]); + debug!("make_shim({:?}) = {:?}", instance, result); tcx.alloc_mir(result) From 276219e0e2ead9dfbe38c4f80ce53f078d25cd63 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 2 Feb 2019 16:59:20 +0100 Subject: [PATCH 224/278] fix dumping MIR from another crate --- src/librustc_mir/util/pretty.rs | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs index 2e1fc756833b8..bef880ad38609 100644 --- a/src/librustc_mir/util/pretty.rs +++ b/src/librustc_mir/util/pretty.rs @@ -1,4 +1,3 @@ -use rustc::hir; use rustc::hir::def_id::{DefId, LOCAL_CRATE}; use rustc::mir::*; use rustc::mir::visit::Visitor; @@ -184,7 +183,7 @@ fn dump_path( let mut file_path = PathBuf::new(); file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir)); - let item_name = tcx.hir() + let item_name = tcx .def_path(source.def_id) .to_filename_friendly_no_crate(); @@ -574,15 +573,17 @@ fn write_mir_sig( mir: &Mir<'_>, w: &mut dyn Write, ) -> io::Result<()> { - let id = tcx.hir().as_local_node_id(src.def_id).unwrap(); - let body_owner_kind = tcx.hir().body_owner_kind(id); - match (body_owner_kind, src.promoted) { + use rustc::hir::def::Def; + + debug!("write_mir_sig: {:?}", src.def_id); + let descr = tcx.describe_def(src.def_id).unwrap(); + match (descr, src.promoted) { (_, Some(i)) => write!(w, "{:?} in", i)?, - (hir::BodyOwnerKind::Closure, _) | - (hir::BodyOwnerKind::Fn, _) => write!(w, "fn")?, - (hir::BodyOwnerKind::Const, _) => write!(w, "const")?, - (hir::BodyOwnerKind::Static(hir::MutImmutable), _) => write!(w, "static")?, - (hir::BodyOwnerKind::Static(hir::MutMutable), _) => write!(w, "static mut")?, + (Def::Fn(_), _) => write!(w, "fn")?, + (Def::Const(_), _) => write!(w, "const")?, + (Def::Static(_, /*is_mutbl*/false), _) => write!(w, "static")?, + (Def::Static(_, /*is_mutbl*/true), _) => write!(w, "static mut")?, + _ => bug!("Unexpected def description {:?}", descr), } item_path::with_forced_impl_filename_line(|| { @@ -590,9 +591,8 @@ fn write_mir_sig( write!(w, " {}", tcx.item_path_str(src.def_id)) })?; - match (body_owner_kind, src.promoted) { - (hir::BodyOwnerKind::Closure, None) | - (hir::BodyOwnerKind::Fn, None) => { + match (descr, src.promoted) { + (Def::Fn(_), None) => { write!(w, "(")?; // fn argument types. @@ -605,10 +605,11 @@ fn write_mir_sig( write!(w, ") -> {}", mir.return_ty())?; } - (hir::BodyOwnerKind::Const, _) | (hir::BodyOwnerKind::Static(_), _) | (_, Some(_)) => { + (Def::Const(_), _) | (Def::Static(_, _), _) | (_, Some(_)) => { assert_eq!(mir.arg_count, 0); write!(w, ": {} =", mir.return_ty())?; } + _ => bug!("Unexpected def description {:?}", descr), } if let Some(yield_ty) = mir.yield_ty { From cd2169682e456f8d8cd3d505b2206d4ed07ecd07 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 3 Feb 2019 10:06:57 +0100 Subject: [PATCH 225/278] fix rebase fallout: AnonConsts are Consts, and Methods are functions --- src/librustc/hir/map/mod.rs | 5 ++++- src/librustc_mir/util/pretty.rs | 6 +++--- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 91fc12639baf5..470bec9757831 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -371,8 +371,11 @@ impl<'hir> Map<'hir> { let def_id = self.local_def_id(variant.node.data.id()); Some(Def::Variant(def_id)) } + Node::AnonConst(item) => { + let def_id = self.local_def_id(item.id); + Some(Def::Const(def_id)) + } Node::Field(_) | - Node::AnonConst(_) | Node::Expr(_) | Node::Stmt(_) | Node::PathSegment(_) | diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs index bef880ad38609..0e4cfe03bf9ce 100644 --- a/src/librustc_mir/util/pretty.rs +++ b/src/librustc_mir/util/pretty.rs @@ -575,11 +575,11 @@ fn write_mir_sig( ) -> io::Result<()> { use rustc::hir::def::Def; - debug!("write_mir_sig: {:?}", src.def_id); + debug!("write_mir_sig: {:?} {:?}", src.def_id, tcx.hir().get_if_local(src.def_id)); let descr = tcx.describe_def(src.def_id).unwrap(); match (descr, src.promoted) { (_, Some(i)) => write!(w, "{:?} in", i)?, - (Def::Fn(_), _) => write!(w, "fn")?, + (Def::Fn(_), _) | (Def::Method(_), _) => write!(w, "fn")?, (Def::Const(_), _) => write!(w, "const")?, (Def::Static(_, /*is_mutbl*/false), _) => write!(w, "static")?, (Def::Static(_, /*is_mutbl*/true), _) => write!(w, "static mut")?, @@ -592,7 +592,7 @@ fn write_mir_sig( })?; match (descr, src.promoted) { - (Def::Fn(_), None) => { + (Def::Fn(_), None) | (Def::Method(_), None) => { write!(w, "(")?; // fn argument types. From 270894678792fa9a30acc6ebc3a13caf5fa0b9c6 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 3 Feb 2019 11:51:07 +0100 Subject: [PATCH 226/278] pass full InstanceDef to run_passes --- .../borrow_check/nll/type_check/mod.rs | 2 +- src/librustc_mir/shim.rs | 2 +- .../transform/add_moves_for_packed_drops.rs | 2 +- src/librustc_mir/transform/const_prop.rs | 40 +++++++++---------- src/librustc_mir/transform/elaborate_drops.rs | 4 +- src/librustc_mir/transform/generator.rs | 4 +- src/librustc_mir/transform/inline.rs | 10 ++--- src/librustc_mir/transform/mod.rs | 27 ++++++++----- src/librustc_mir/transform/qualify_consts.rs | 2 +- src/librustc_mir/transform/rustc_peek.rs | 2 +- src/librustc_mir/util/liveness.rs | 4 +- src/librustc_mir/util/pretty.rs | 16 ++++---- 12 files changed, 60 insertions(+), 55 deletions(-) diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs index 19ff47f9c390d..cc09b2ca530e1 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/mod.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/mod.rs @@ -2428,7 +2428,7 @@ pub struct TypeckMir; impl MirPass for TypeckMir { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, src: MirSource, mir: &mut Mir<'tcx>) { - let def_id = src.def_id; + let def_id = src.def_id(); debug!("run_pass: {:?}", def_id); // When NLL is enabled, the borrow checker runs the typeck diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs index 7edd725544c5e..7f3e4a2e1bc4f 100644 --- a/src/librustc_mir/shim.rs +++ b/src/librustc_mir/shim.rs @@ -116,7 +116,7 @@ fn make_shim<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, }; debug!("make_shim({:?}) = untransformed {:?}", instance, result); - run_passes(tcx, &mut result, instance.def_id(), MirPhase::Const, &[ + run_passes(tcx, &mut result, instance, MirPhase::Const, &[ &add_moves_for_packed_drops::AddMovesForPackedDrops, &no_landing_pads::NoLandingPads, &remove_noop_landing_pads::RemoveNoopLandingPads, diff --git a/src/librustc_mir/transform/add_moves_for_packed_drops.rs b/src/librustc_mir/transform/add_moves_for_packed_drops.rs index 1492f0c50a31a..fd31ba0422b57 100644 --- a/src/librustc_mir/transform/add_moves_for_packed_drops.rs +++ b/src/librustc_mir/transform/add_moves_for_packed_drops.rs @@ -46,7 +46,7 @@ impl MirPass for AddMovesForPackedDrops { mir: &mut Mir<'tcx>) { debug!("add_moves_for_packed_drops({:?} @ {:?})", src, mir.span); - add_moves_for_packed_drops(tcx, mir, src.def_id); + add_moves_for_packed_drops(tcx, mir, src.def_id()); } } diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs index dd1f37a591888..018f71c39e513 100644 --- a/src/librustc_mir/transform/const_prop.rs +++ b/src/librustc_mir/transform/const_prop.rs @@ -30,7 +30,7 @@ pub struct ConstProp; impl MirPass for ConstProp { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - source: MirSource, + source: MirSource<'tcx>, mir: &mut Mir<'tcx>) { // will be evaluated by miri and produce its errors there if source.promoted.is_some() { @@ -38,11 +38,11 @@ impl MirPass for ConstProp { } use rustc::hir::map::blocks::FnLikeNode; - let node_id = tcx.hir().as_local_node_id(source.def_id) + let node_id = tcx.hir().as_local_node_id(source.def_id()) .expect("Non-local call to local provider is_const_fn"); let is_fn_like = FnLikeNode::from_node(tcx.hir().get(node_id)).is_some(); - let is_assoc_const = match tcx.describe_def(source.def_id) { + let is_assoc_const = match tcx.describe_def(source.def_id()) { Some(Def::AssociatedConst(_)) => true, _ => false, }; @@ -50,11 +50,11 @@ impl MirPass for ConstProp { // Only run const prop on functions, methods, closures and associated constants if !is_fn_like && !is_assoc_const { // skip anon_const/statics/consts because they'll be evaluated by miri anyway - trace!("ConstProp skipped for {:?}", source.def_id); + trace!("ConstProp skipped for {:?}", source.def_id()); return } - trace!("ConstProp starting for {:?}", source.def_id); + trace!("ConstProp starting for {:?}", source.def_id()); // FIXME(oli-obk, eddyb) Optimize locals (or even local paths) to hold // constants, instead of just checking for const-folding succeeding. @@ -63,7 +63,7 @@ impl MirPass for ConstProp { let mut optimization_finder = ConstPropagator::new(mir, tcx, source); optimization_finder.visit_mir(mir); - trace!("ConstProp done for {:?}", source.def_id); + trace!("ConstProp done for {:?}", source.def_id()); } } @@ -74,7 +74,7 @@ struct ConstPropagator<'a, 'mir, 'tcx:'a+'mir> { ecx: EvalContext<'a, 'mir, 'tcx, CompileTimeInterpreter<'a, 'mir, 'tcx>>, mir: &'mir Mir<'tcx>, tcx: TyCtxt<'a, 'tcx, 'tcx>, - source: MirSource, + source: MirSource<'tcx>, places: IndexVec>>, can_const_prop: IndexVec, param_env: ParamEnv<'tcx>, @@ -107,10 +107,10 @@ impl<'a, 'mir, 'tcx> ConstPropagator<'a, 'mir, 'tcx> { fn new( mir: &'mir Mir<'tcx>, tcx: TyCtxt<'a, 'tcx, 'tcx>, - source: MirSource, + source: MirSource<'tcx>, ) -> ConstPropagator<'a, 'mir, 'tcx> { - let param_env = tcx.param_env(source.def_id); - let ecx = mk_eval_cx(tcx, tcx.def_span(source.def_id), param_env); + let param_env = tcx.param_env(source.def_id()); + let ecx = mk_eval_cx(tcx, tcx.def_span(source.def_id()), param_env); ConstPropagator { ecx, mir, @@ -284,13 +284,13 @@ impl<'a, 'mir, 'tcx> ConstPropagator<'a, 'mir, 'tcx> { _ => None, }, Place::Promoted(ref promoted) => { - let generics = self.tcx.generics_of(self.source.def_id); + let generics = self.tcx.generics_of(self.source.def_id()); if generics.requires_monomorphization(self.tcx) { // FIXME: can't handle code with generics return None; } - let substs = Substs::identity_for_item(self.tcx, self.source.def_id); - let instance = Instance::new(self.source.def_id, substs); + let substs = Substs::identity_for_item(self.tcx, self.source.def_id()); + let instance = Instance::new(self.source.def_id(), substs); let cid = GlobalId { instance, promoted: Some(promoted.0), @@ -358,10 +358,10 @@ impl<'a, 'mir, 'tcx> ConstPropagator<'a, 'mir, 'tcx> { ))) } Rvalue::UnaryOp(op, ref arg) => { - let def_id = if self.tcx.is_closure(self.source.def_id) { - self.tcx.closure_base_def_id(self.source.def_id) + let def_id = if self.tcx.is_closure(self.source.def_id()) { + self.tcx.closure_base_def_id(self.source.def_id()) } else { - self.source.def_id + self.source.def_id() }; let generics = self.tcx.generics_of(def_id); if generics.requires_monomorphization(self.tcx) { @@ -398,10 +398,10 @@ impl<'a, 'mir, 'tcx> ConstPropagator<'a, 'mir, 'tcx> { Rvalue::BinaryOp(op, ref left, ref right) => { trace!("rvalue binop {:?} for {:?} and {:?}", op, left, right); let right = self.eval_operand(right, source_info)?; - let def_id = if self.tcx.is_closure(self.source.def_id) { - self.tcx.closure_base_def_id(self.source.def_id) + let def_id = if self.tcx.is_closure(self.source.def_id()) { + self.tcx.closure_base_def_id(self.source.def_id()) } else { - self.source.def_id + self.source.def_id() }; let generics = self.tcx.generics_of(def_id); if generics.requires_monomorphization(self.tcx) { @@ -608,7 +608,7 @@ impl<'b, 'a, 'tcx> Visitor<'tcx> for ConstPropagator<'b, 'a, 'tcx> { let node_id = self .tcx .hir() - .as_local_node_id(self.source.def_id) + .as_local_node_id(self.source.def_id()) .expect("some part of a failing const eval must be local"); use rustc::mir::interpret::EvalErrorKind::*; let msg = match msg { diff --git a/src/librustc_mir/transform/elaborate_drops.rs b/src/librustc_mir/transform/elaborate_drops.rs index 4aaa0be7964a4..b3f72e3a7fc4e 100644 --- a/src/librustc_mir/transform/elaborate_drops.rs +++ b/src/librustc_mir/transform/elaborate_drops.rs @@ -28,8 +28,8 @@ impl MirPass for ElaborateDrops { { debug!("elaborate_drops({:?} @ {:?})", src, mir.span); - let id = tcx.hir().as_local_node_id(src.def_id).unwrap(); - let param_env = tcx.param_env(src.def_id).with_reveal_all(); + let id = tcx.hir().as_local_node_id(src.def_id()).unwrap(); + let param_env = tcx.param_env(src.def_id()).with_reveal_all(); let move_data = match MoveData::gather_moves(mir, tcx) { Ok(move_data) => move_data, Err((move_data, _move_errors)) => { diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs index 9897f9833ca62..ae2ba55c5083c 100644 --- a/src/librustc_mir/transform/generator.rs +++ b/src/librustc_mir/transform/generator.rs @@ -383,7 +383,7 @@ fn locals_live_across_suspend_points( FxHashMap>, ) { let dead_unwinds = BitSet::new_empty(mir.basic_blocks().len()); - let node_id = tcx.hir().as_local_node_id(source.def_id).unwrap(); + let node_id = tcx.hir().as_local_node_id(source.def_id()).unwrap(); // Calculate when MIR locals have live storage. This gives us an upper bound of their // lifetimes. @@ -880,7 +880,7 @@ impl MirPass for StateTransform { assert!(mir.generator_drop.is_none()); - let def_id = source.def_id; + let def_id = source.def_id(); // The first argument is the generator type passed by value let gen_ty = mir.local_decls.raw[1].ty; diff --git a/src/librustc_mir/transform/inline.rs b/src/librustc_mir/transform/inline.rs index 4fddf6f8e09c2..4cb7826698466 100644 --- a/src/librustc_mir/transform/inline.rs +++ b/src/librustc_mir/transform/inline.rs @@ -40,7 +40,7 @@ struct CallSite<'tcx> { impl MirPass for Inline { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - source: MirSource, + source: MirSource<'tcx>, mir: &mut Mir<'tcx>) { if tcx.sess.opts.debugging_opts.mir_opt_level >= 2 { Inliner { tcx, source }.run_pass(mir); @@ -50,7 +50,7 @@ impl MirPass for Inline { struct Inliner<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx>, - source: MirSource, + source: MirSource<'tcx>, } impl<'a, 'tcx> Inliner<'a, 'tcx> { @@ -69,10 +69,10 @@ impl<'a, 'tcx> Inliner<'a, 'tcx> { let mut callsites = VecDeque::new(); - let param_env = self.tcx.param_env(self.source.def_id); + let param_env = self.tcx.param_env(self.source.def_id()); // Only do inlining into fn bodies. - let id = self.tcx.hir().as_local_node_id(self.source.def_id).unwrap(); + let id = self.tcx.hir().as_local_node_id(self.source.def_id()).unwrap(); if self.tcx.hir().body_owner_kind(id).is_fn_or_closure() && self.source.promoted.is_none() { for (bb, bb_data) in caller_mir.basic_blocks().iter_enumerated() { if let Some(callsite) = self.get_valid_function_call(bb, @@ -274,7 +274,7 @@ impl<'a, 'tcx> Inliner<'a, 'tcx> { // FIXME: Give a bonus to functions with only a single caller - let param_env = tcx.param_env(self.source.def_id); + let param_env = tcx.param_env(self.source.def_id()); let mut first_block = true; let mut cost = 0; diff --git a/src/librustc_mir/transform/mod.rs b/src/librustc_mir/transform/mod.rs index cc37a8381f234..44061e689b3be 100644 --- a/src/librustc_mir/transform/mod.rs +++ b/src/librustc_mir/transform/mod.rs @@ -2,7 +2,7 @@ use crate::borrow_check::nll::type_check; use crate::build; use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; use rustc::mir::{Mir, MirPhase, Promoted}; -use rustc::ty::TyCtxt; +use rustc::ty::{TyCtxt, InstanceDef}; use rustc::ty::query::Providers; use rustc::ty::steal::Steal; use rustc::hir; @@ -104,20 +104,25 @@ fn mir_built<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx Stea /// Where a specific Mir comes from. #[derive(Debug, Copy, Clone)] -pub struct MirSource { - pub def_id: DefId, +pub struct MirSource<'tcx> { + pub instance: InstanceDef<'tcx>, /// If `Some`, this is a promoted rvalue within the parent function. pub promoted: Option, } -impl MirSource { +impl<'tcx> MirSource<'tcx> { pub fn item(def_id: DefId) -> Self { MirSource { - def_id, + instance: InstanceDef::Item(def_id), promoted: None } } + + #[inline] + pub fn def_id(&self) -> DefId { + self.instance.def_id() + } } /// Generates a default name for the pass based on the name of the @@ -141,14 +146,14 @@ pub trait MirPass { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - source: MirSource, + source: MirSource<'tcx>, mir: &mut Mir<'tcx>); } pub fn run_passes( tcx: TyCtxt<'a, 'tcx, 'tcx>, mir: &mut Mir<'tcx>, - def_id: DefId, + instance: InstanceDef<'tcx>, mir_phase: MirPhase, passes: &[&dyn MirPass], ) { @@ -160,7 +165,7 @@ pub fn run_passes( } let source = MirSource { - def_id, + instance, promoted, }; let mut index = 0; @@ -198,7 +203,7 @@ fn mir_const<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx Stea let _ = tcx.unsafety_check_result(def_id); let mut mir = tcx.mir_built(def_id).steal(); - run_passes(tcx, &mut mir, def_id, MirPhase::Const, &[ + run_passes(tcx, &mut mir, InstanceDef::Item(def_id), MirPhase::Const, &[ // What we need to do constant evaluation. &simplify::SimplifyCfg::new("initial"), &type_check::TypeckMir, @@ -217,7 +222,7 @@ fn mir_validated<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx } let mut mir = tcx.mir_const(def_id).steal(); - run_passes(tcx, &mut mir, def_id, MirPhase::Validated, &[ + run_passes(tcx, &mut mir, InstanceDef::Item(def_id), MirPhase::Validated, &[ // What we need to run borrowck etc. &qualify_consts::QualifyAndPromoteConstants, &simplify::SimplifyCfg::new("qualify-consts"), @@ -235,7 +240,7 @@ fn optimized_mir<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> &'tcx } let mut mir = tcx.mir_validated(def_id).steal(); - run_passes(tcx, &mut mir, def_id, MirPhase::Optimized, &[ + run_passes(tcx, &mut mir, InstanceDef::Item(def_id), MirPhase::Optimized, &[ // Remove all things not needed by analysis &no_landing_pads::NoLandingPads, &simplify_branches::SimplifyBranches::new("initial"), diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs index ab4e3ad23f69a..9b5c4f51a91a3 100644 --- a/src/librustc_mir/transform/qualify_consts.rs +++ b/src/librustc_mir/transform/qualify_consts.rs @@ -1171,7 +1171,7 @@ impl MirPass for QualifyAndPromoteConstants { return; } - let def_id = src.def_id; + let def_id = src.def_id(); let id = tcx.hir().as_local_node_id(def_id).unwrap(); let mut const_promoted_temps = None; let mode = match tcx.hir().body_owner_kind(id) { diff --git a/src/librustc_mir/transform/rustc_peek.rs b/src/librustc_mir/transform/rustc_peek.rs index 806c1c1cca457..d9a5d2fe8ce0b 100644 --- a/src/librustc_mir/transform/rustc_peek.rs +++ b/src/librustc_mir/transform/rustc_peek.rs @@ -25,7 +25,7 @@ pub struct SanityCheck; impl MirPass for SanityCheck { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, src: MirSource, mir: &mut Mir<'tcx>) { - let def_id = src.def_id; + let def_id = src.def_id(); let id = tcx.hir().as_local_node_id(def_id).unwrap(); if !tcx.has_attr(def_id, "rustc_mir") { debug!("skipping rustc_peek::SanityCheck on {}", tcx.item_path_str(def_id)); diff --git a/src/librustc_mir/util/liveness.rs b/src/librustc_mir/util/liveness.rs index 08ef58a232170..f72052c6e2840 100644 --- a/src/librustc_mir/util/liveness.rs +++ b/src/librustc_mir/util/liveness.rs @@ -317,7 +317,7 @@ pub fn dump_mir<'a, 'tcx, V: Idx>( } let node_path = item_path::with_forced_impl_filename_line(|| { // see notes on #41697 below - tcx.item_path_str(source.def_id) + tcx.item_path_str(source.def_id()) }); dump_matched_mir_node(tcx, pass_name, &node_path, source, mir, map, result); } @@ -333,7 +333,7 @@ fn dump_matched_mir_node<'a, 'tcx, V: Idx>( ) { let mut file_path = PathBuf::new(); file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir)); - let item_id = tcx.hir().as_local_node_id(source.def_id).unwrap(); + let item_id = tcx.hir().as_local_node_id(source.def_id()).unwrap(); let file_name = format!("rustc.node{}{}-liveness.mir", item_id, pass_name); file_path.push(&file_name); let _ = fs::File::create(&file_path).and_then(|mut file| { diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs index 0e4cfe03bf9ce..120055ad39764 100644 --- a/src/librustc_mir/util/pretty.rs +++ b/src/librustc_mir/util/pretty.rs @@ -80,7 +80,7 @@ pub fn dump_mir<'a, 'gcx, 'tcx, F>( let node_path = item_path::with_forced_impl_filename_line(|| { // see notes on #41697 below - tcx.item_path_str(source.def_id) + tcx.item_path_str(source.def_id()) }); dump_matched_mir_node( tcx, @@ -105,7 +105,7 @@ pub fn dump_enabled<'a, 'gcx, 'tcx>( }; let node_path = item_path::with_forced_impl_filename_line(|| { // see notes on #41697 below - tcx.item_path_str(source.def_id) + tcx.item_path_str(source.def_id()) }); filters.split('|').any(|or_filter| { or_filter.split('&').all(|and_filter| { @@ -150,7 +150,7 @@ fn dump_matched_mir_node<'a, 'gcx, 'tcx, F>( let _: io::Result<()> = try { let mut file = create_dump_file(tcx, "dot", pass_num, pass_name, disambiguator, source)?; - write_mir_fn_graphviz(tcx, source.def_id, mir, &mut file)?; + write_mir_fn_graphviz(tcx, source.def_id(), mir, &mut file)?; }; } } @@ -184,7 +184,7 @@ fn dump_path( file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir)); let item_name = tcx - .def_path(source.def_id) + .def_path(source.def_id()) .to_filename_friendly_no_crate(); let file_name = format!( @@ -252,7 +252,7 @@ pub fn write_mir_pretty<'a, 'gcx, 'tcx>( for (i, mir) in mir.promoted.iter_enumerated() { writeln!(w, "")?; let src = MirSource { - def_id, + instance: ty::InstanceDef::Item(def_id), promoted: Some(i), }; write_mir_fn(tcx, src, mir, &mut |_, _| Ok(()), w)?; @@ -575,8 +575,8 @@ fn write_mir_sig( ) -> io::Result<()> { use rustc::hir::def::Def; - debug!("write_mir_sig: {:?} {:?}", src.def_id, tcx.hir().get_if_local(src.def_id)); - let descr = tcx.describe_def(src.def_id).unwrap(); + trace!("write_mir_sig: {:?} {:?}", src, tcx.hir().get_if_local(src.def_id())); + let descr = tcx.describe_def(src.def_id()).unwrap(); match (descr, src.promoted) { (_, Some(i)) => write!(w, "{:?} in", i)?, (Def::Fn(_), _) | (Def::Method(_), _) => write!(w, "fn")?, @@ -588,7 +588,7 @@ fn write_mir_sig( item_path::with_forced_impl_filename_line(|| { // see notes on #41697 elsewhere - write!(w, " {}", tcx.item_path_str(src.def_id)) + write!(w, " {}", tcx.item_path_str(src.def_id())) })?; match (descr, src.promoted) { From fed4c5d9e13e7cde3399336342a64ba23308d4f5 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 3 Feb 2019 13:31:50 +0100 Subject: [PATCH 227/278] disambiguate filenames of multiple drop shims being dumped --- src/librustc_mir/util/pretty.rs | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs index 120055ad39764..48a6fd3a95df6 100644 --- a/src/librustc_mir/util/pretty.rs +++ b/src/librustc_mir/util/pretty.rs @@ -186,10 +186,29 @@ fn dump_path( let item_name = tcx .def_path(source.def_id()) .to_filename_friendly_no_crate(); + // All drop shims have the same DefId, so we have to add the type + // to get unique file names. + let shim_disambiguator = match source.instance { + ty::InstanceDef::DropGlue(_, Some(ty)) => { + // Unfortunately, pretty-printed typed are not very filename-friendly. + // We dome some filtering. + let mut s = ".".to_owned(); + s.extend(ty.to_string() + .chars() + .filter_map(|c| match c { + ' ' => None, + ':' => Some('_'), + c => Some(c) + })); + s + } + _ => String::new(), + }; let file_name = format!( - "rustc.{}{}{}.{}.{}.{}", + "rustc.{}{}{}{}.{}.{}.{}", item_name, + shim_disambiguator, promotion_id, pass_num, pass_name, From 27ce224a8f84d8ed2fdb01410d7b931fd29655c1 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 3 Feb 2019 14:09:56 +0100 Subject: [PATCH 228/278] fix --emit=mir: StructCtors are functions --- src/librustc/hir/map/mod.rs | 5 ++++- src/librustc_mir/util/pretty.rs | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 470bec9757831..8db4e52f3d630 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -375,6 +375,10 @@ impl<'hir> Map<'hir> { let def_id = self.local_def_id(item.id); Some(Def::Const(def_id)) } + Node::StructCtor(variant) => { + let def_id = self.local_def_id(variant.id()); + Some(Def::Fn(def_id)) + } Node::Field(_) | Node::Expr(_) | Node::Stmt(_) | @@ -383,7 +387,6 @@ impl<'hir> Map<'hir> { Node::TraitRef(_) | Node::Pat(_) | Node::Binding(_) | - Node::StructCtor(_) | Node::Lifetime(_) | Node::Visibility(_) | Node::Block(_) | diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs index 48a6fd3a95df6..ae07aad31172f 100644 --- a/src/librustc_mir/util/pretty.rs +++ b/src/librustc_mir/util/pretty.rs @@ -594,7 +594,7 @@ fn write_mir_sig( ) -> io::Result<()> { use rustc::hir::def::Def; - trace!("write_mir_sig: {:?} {:?}", src, tcx.hir().get_if_local(src.def_id())); + trace!("write_mir_sig: {:?}", src.instance); let descr = tcx.describe_def(src.def_id()).unwrap(); match (descr, src.promoted) { (_, Some(i)) => write!(w, "{:?} in", i)?, From 84d75dbd7ed128f8694b8a9807cffd5794a0c918 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Tue, 5 Feb 2019 21:49:53 +0100 Subject: [PATCH 229/278] fix node classification --- src/librustc/hir/map/mod.rs | 7 ++----- src/librustc_mir/util/pretty.rs | 27 +++++++++++++++++---------- 2 files changed, 19 insertions(+), 15 deletions(-) diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 8db4e52f3d630..955f834e40398 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -371,14 +371,11 @@ impl<'hir> Map<'hir> { let def_id = self.local_def_id(variant.node.data.id()); Some(Def::Variant(def_id)) } - Node::AnonConst(item) => { - let def_id = self.local_def_id(item.id); - Some(Def::Const(def_id)) - } Node::StructCtor(variant) => { let def_id = self.local_def_id(variant.id()); - Some(Def::Fn(def_id)) + Some(Def::StructCtor(def_id, def::CtorKind::from_hir(variant))) } + Node::AnonConst(_) | Node::Field(_) | Node::Expr(_) | Node::Stmt(_) | diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs index ae07aad31172f..7bbce405a8425 100644 --- a/src/librustc_mir/util/pretty.rs +++ b/src/librustc_mir/util/pretty.rs @@ -595,23 +595,28 @@ fn write_mir_sig( use rustc::hir::def::Def; trace!("write_mir_sig: {:?}", src.instance); - let descr = tcx.describe_def(src.def_id()).unwrap(); + let descr = tcx.describe_def(src.def_id()); match (descr, src.promoted) { - (_, Some(i)) => write!(w, "{:?} in", i)?, - (Def::Fn(_), _) | (Def::Method(_), _) => write!(w, "fn")?, - (Def::Const(_), _) => write!(w, "const")?, - (Def::Static(_, /*is_mutbl*/false), _) => write!(w, "static")?, - (Def::Static(_, /*is_mutbl*/true), _) => write!(w, "static mut")?, + (_, Some(i)) => write!(w, "{:?} in ", i)?, + (Some(Def::Fn(_)), _) | (Some(Def::Method(_)), _) => write!(w, "fn ")?, + (Some(Def::StructCtor(..)), _) => write!(w, "struct ")?, + (Some(Def::Const(_)), _) => write!(w, "const ")?, + (Some(Def::Static(_, /*is_mutbl*/false)), _) => write!(w, "static ")?, + (Some(Def::Static(_, /*is_mutbl*/true)), _) => write!(w, "static mut ")?, + (None, _) => {}, // things like anon const, not an item _ => bug!("Unexpected def description {:?}", descr), } item_path::with_forced_impl_filename_line(|| { // see notes on #41697 elsewhere - write!(w, " {}", tcx.item_path_str(src.def_id())) + write!(w, "{}", tcx.item_path_str(src.def_id())) })?; match (descr, src.promoted) { - (Def::Fn(_), None) | (Def::Method(_), None) => { + (Some(Def::Fn(_)), None) | + (Some(Def::Method(_)), None) | + (Some(Def::StructCtor(..)), None) => + { write!(w, "(")?; // fn argument types. @@ -624,11 +629,10 @@ fn write_mir_sig( write!(w, ") -> {}", mir.return_ty())?; } - (Def::Const(_), _) | (Def::Static(_, _), _) | (_, Some(_)) => { + _ => { assert_eq!(mir.arg_count, 0); write!(w, ": {} =", mir.return_ty())?; } - _ => bug!("Unexpected def description {:?}", descr), } if let Some(yield_ty) = mir.yield_ty { @@ -636,6 +640,9 @@ fn write_mir_sig( writeln!(w, "yields {}", yield_ty)?; } + write!(w, " ")?; + // Next thing that gets printed is the opening { + Ok(()) } From a413242efef8e398c385a695eecb255f2713d49d Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Tue, 5 Feb 2019 23:40:29 +0100 Subject: [PATCH 230/278] fix printing closures --- src/librustc_mir/util/pretty.rs | 38 ++++++++++++++++----------------- 1 file changed, 18 insertions(+), 20 deletions(-) diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs index 7bbce405a8425..b1aef28ca9808 100644 --- a/src/librustc_mir/util/pretty.rs +++ b/src/librustc_mir/util/pretty.rs @@ -596,13 +596,17 @@ fn write_mir_sig( trace!("write_mir_sig: {:?}", src.instance); let descr = tcx.describe_def(src.def_id()); + let is_function = match descr { + Some(Def::Fn(_)) | Some(Def::Method(_)) | Some(Def::StructCtor(..)) => true, + _ => tcx.is_closure(src.def_id()), + }; match (descr, src.promoted) { (_, Some(i)) => write!(w, "{:?} in ", i)?, - (Some(Def::Fn(_)), _) | (Some(Def::Method(_)), _) => write!(w, "fn ")?, (Some(Def::StructCtor(..)), _) => write!(w, "struct ")?, (Some(Def::Const(_)), _) => write!(w, "const ")?, (Some(Def::Static(_, /*is_mutbl*/false)), _) => write!(w, "static ")?, (Some(Def::Static(_, /*is_mutbl*/true)), _) => write!(w, "static mut ")?, + (_, _) if is_function => write!(w, "fn ")?, (None, _) => {}, // things like anon const, not an item _ => bug!("Unexpected def description {:?}", descr), } @@ -612,27 +616,21 @@ fn write_mir_sig( write!(w, "{}", tcx.item_path_str(src.def_id())) })?; - match (descr, src.promoted) { - (Some(Def::Fn(_)), None) | - (Some(Def::Method(_)), None) | - (Some(Def::StructCtor(..)), None) => - { - write!(w, "(")?; - - // fn argument types. - for (i, arg) in mir.args_iter().enumerate() { - if i != 0 { - write!(w, ", ")?; - } - write!(w, "{:?}: {}", Place::Local(arg), mir.local_decls[arg].ty)?; - } + if src.promoted.is_none() && is_function { + write!(w, "(")?; - write!(w, ") -> {}", mir.return_ty())?; - } - _ => { - assert_eq!(mir.arg_count, 0); - write!(w, ": {} =", mir.return_ty())?; + // fn argument types. + for (i, arg) in mir.args_iter().enumerate() { + if i != 0 { + write!(w, ", ")?; + } + write!(w, "{:?}: {}", Place::Local(arg), mir.local_decls[arg].ty)?; } + + write!(w, ") -> {}", mir.return_ty())?; + } else { + assert_eq!(mir.arg_count, 0); + write!(w, ": {} =", mir.return_ty())?; } if let Some(yield_ty) = mir.yield_ty { From 544b3a1bb476364f1e5d149cf82beb98a219dda5 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 9 Feb 2019 12:19:04 +0100 Subject: [PATCH 231/278] fix rebase fallout --- src/librustc_mir/borrow_check/nll/mod.rs | 2 +- .../borrow_check/nll/type_check/mod.rs | 7 ++++++- src/librustc_mir/transform/add_call_guards.rs | 2 +- .../transform/add_moves_for_packed_drops.rs | 2 +- src/librustc_mir/transform/add_retag.rs | 2 +- .../transform/cleanup_post_borrowck.rs | 4 ++-- src/librustc_mir/transform/copy_prop.rs | 2 +- src/librustc_mir/transform/deaggregator.rs | 2 +- src/librustc_mir/transform/dump_mir.rs | 4 ++-- src/librustc_mir/transform/elaborate_drops.rs | 2 +- src/librustc_mir/transform/erase_regions.rs | 2 +- src/librustc_mir/transform/generator.rs | 10 +++++----- src/librustc_mir/transform/instcombine.rs | 2 +- src/librustc_mir/transform/lower_128bit.rs | 2 +- src/librustc_mir/transform/no_landing_pads.rs | 2 +- src/librustc_mir/transform/qualify_consts.rs | 2 +- .../transform/remove_noop_landing_pads.rs | 2 +- src/librustc_mir/transform/rustc_peek.rs | 2 +- src/librustc_mir/transform/simplify.rs | 4 ++-- src/librustc_mir/transform/simplify_branches.rs | 2 +- .../transform/uniform_array_move_out.rs | 4 ++-- src/librustc_mir/util/liveness.rs | 6 +++--- src/librustc_mir/util/pretty.rs | 16 ++++++++-------- 23 files changed, 45 insertions(+), 40 deletions(-) diff --git a/src/librustc_mir/borrow_check/nll/mod.rs b/src/librustc_mir/borrow_check/nll/mod.rs index 1fca104cd3825..84fdbb9423e0a 100644 --- a/src/librustc_mir/borrow_check/nll/mod.rs +++ b/src/librustc_mir/borrow_check/nll/mod.rs @@ -209,7 +209,7 @@ pub(in crate::borrow_check) fn compute_regions<'cx, 'gcx, 'tcx>( fn dump_mir_results<'a, 'gcx, 'tcx>( infcx: &InferCtxt<'a, 'gcx, 'tcx>, - source: MirSource, + source: MirSource<'tcx>, mir: &Mir<'tcx>, regioncx: &RegionInferenceContext<'_>, closure_region_requirements: &Option>, diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs index cc09b2ca530e1..add07b1ddfe05 100644 --- a/src/librustc_mir/borrow_check/nll/type_check/mod.rs +++ b/src/librustc_mir/borrow_check/nll/type_check/mod.rs @@ -2427,7 +2427,12 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> { pub struct TypeckMir; impl MirPass for TypeckMir { - fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, src: MirSource, mir: &mut Mir<'tcx>) { + fn run_pass<'a, 'tcx>( + &self, + tcx: TyCtxt<'a, 'tcx, 'tcx>, + src: MirSource<'tcx>, + mir: &mut Mir<'tcx>, + ) { let def_id = src.def_id(); debug!("run_pass: {:?}", def_id); diff --git a/src/librustc_mir/transform/add_call_guards.rs b/src/librustc_mir/transform/add_call_guards.rs index dab96faaa2a5e..88042d64e96b7 100644 --- a/src/librustc_mir/transform/add_call_guards.rs +++ b/src/librustc_mir/transform/add_call_guards.rs @@ -33,7 +33,7 @@ pub use self::AddCallGuards::*; impl MirPass for AddCallGuards { fn run_pass<'a, 'tcx>(&self, _tcx: TyCtxt<'a, 'tcx, 'tcx>, - _src: MirSource, + _src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { self.add_call_guards(mir); } diff --git a/src/librustc_mir/transform/add_moves_for_packed_drops.rs b/src/librustc_mir/transform/add_moves_for_packed_drops.rs index fd31ba0422b57..4d4c89b8b6a40 100644 --- a/src/librustc_mir/transform/add_moves_for_packed_drops.rs +++ b/src/librustc_mir/transform/add_moves_for_packed_drops.rs @@ -42,7 +42,7 @@ pub struct AddMovesForPackedDrops; impl MirPass for AddMovesForPackedDrops { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - src: MirSource, + src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { debug!("add_moves_for_packed_drops({:?} @ {:?})", src, mir.span); diff --git a/src/librustc_mir/transform/add_retag.rs b/src/librustc_mir/transform/add_retag.rs index 7bfcd318afe2d..e66c11aa36e0e 100644 --- a/src/librustc_mir/transform/add_retag.rs +++ b/src/librustc_mir/transform/add_retag.rs @@ -77,7 +77,7 @@ fn may_have_reference<'a, 'gcx, 'tcx>(ty: Ty<'tcx>, tcx: TyCtxt<'a, 'gcx, 'tcx>) impl MirPass for AddRetag { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _src: MirSource, + _src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { if !tcx.sess.opts.debugging_opts.mir_emit_retag { diff --git a/src/librustc_mir/transform/cleanup_post_borrowck.rs b/src/librustc_mir/transform/cleanup_post_borrowck.rs index 240ef7c8ba42a..890d2c56f42b2 100644 --- a/src/librustc_mir/transform/cleanup_post_borrowck.rs +++ b/src/librustc_mir/transform/cleanup_post_borrowck.rs @@ -35,7 +35,7 @@ pub struct DeleteAscribeUserType; impl MirPass for CleanAscribeUserType { fn run_pass<'a, 'tcx>(&self, _tcx: TyCtxt<'a, 'tcx, 'tcx>, - _source: MirSource, + _source: MirSource<'tcx>, mir: &mut Mir<'tcx>) { let mut delete = DeleteAscribeUserType; delete.visit_mir(mir); @@ -69,7 +69,7 @@ pub struct DeleteFakeBorrows { impl MirPass for CleanFakeReadsAndBorrows { fn run_pass<'a, 'tcx>(&self, _tcx: TyCtxt<'a, 'tcx, 'tcx>, - _source: MirSource, + _source: MirSource<'tcx>, mir: &mut Mir<'tcx>) { let mut delete_reads = DeleteAndRecordFakeReads::default(); delete_reads.visit_mir(mir); diff --git a/src/librustc_mir/transform/copy_prop.rs b/src/librustc_mir/transform/copy_prop.rs index 4789c35740eb3..7d907ca3a215e 100644 --- a/src/librustc_mir/transform/copy_prop.rs +++ b/src/librustc_mir/transform/copy_prop.rs @@ -30,7 +30,7 @@ pub struct CopyPropagation; impl MirPass for CopyPropagation { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _source: MirSource, + _source: MirSource<'tcx>, mir: &mut Mir<'tcx>) { // We only run when the MIR optimization level is > 1. // This avoids a slow pass, and messing up debug info. diff --git a/src/librustc_mir/transform/deaggregator.rs b/src/librustc_mir/transform/deaggregator.rs index 669384e31dac3..9061dfff76fe8 100644 --- a/src/librustc_mir/transform/deaggregator.rs +++ b/src/librustc_mir/transform/deaggregator.rs @@ -8,7 +8,7 @@ pub struct Deaggregator; impl MirPass for Deaggregator { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _source: MirSource, + _source: MirSource<'tcx>, mir: &mut Mir<'tcx>) { let (basic_blocks, local_decls) = mir.basic_blocks_and_local_decls_mut(); let local_decls = &*local_decls; diff --git a/src/librustc_mir/transform/dump_mir.rs b/src/librustc_mir/transform/dump_mir.rs index d7f697a320049..81e48fe2dbe3b 100644 --- a/src/librustc_mir/transform/dump_mir.rs +++ b/src/librustc_mir/transform/dump_mir.rs @@ -20,7 +20,7 @@ impl MirPass for Marker { fn run_pass<'a, 'tcx>(&self, _tcx: TyCtxt<'a, 'tcx, 'tcx>, - _source: MirSource, + _source: MirSource<'tcx>, _mir: &mut Mir<'tcx>) { } @@ -41,7 +41,7 @@ impl fmt::Display for Disambiguator { pub fn on_mir_pass<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, pass_num: &dyn fmt::Display, pass_name: &str, - source: MirSource, + source: MirSource<'tcx>, mir: &Mir<'tcx>, is_after: bool) { if mir_util::dump_enabled(tcx, pass_name, source) { diff --git a/src/librustc_mir/transform/elaborate_drops.rs b/src/librustc_mir/transform/elaborate_drops.rs index b3f72e3a7fc4e..6e093a7e240b3 100644 --- a/src/librustc_mir/transform/elaborate_drops.rs +++ b/src/librustc_mir/transform/elaborate_drops.rs @@ -23,7 +23,7 @@ pub struct ElaborateDrops; impl MirPass for ElaborateDrops { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - src: MirSource, + src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { debug!("elaborate_drops({:?} @ {:?})", src, mir.span); diff --git a/src/librustc_mir/transform/erase_regions.rs b/src/librustc_mir/transform/erase_regions.rs index b555a2aa83ee3..d59bb3ec5b1c0 100644 --- a/src/librustc_mir/transform/erase_regions.rs +++ b/src/librustc_mir/transform/erase_regions.rs @@ -53,7 +53,7 @@ pub struct EraseRegions; impl MirPass for EraseRegions { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _: MirSource, + _: MirSource<'tcx>, mir: &mut Mir<'tcx>) { EraseRegionsVisitor::new(tcx).visit_mir(mir); } diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs index ae2ba55c5083c..33d98d8f076c8 100644 --- a/src/librustc_mir/transform/generator.rs +++ b/src/librustc_mir/transform/generator.rs @@ -376,7 +376,7 @@ impl<'tcx> Visitor<'tcx> for StorageIgnored { fn locals_live_across_suspend_points( tcx: TyCtxt<'a, 'tcx, 'tcx>, mir: &Mir<'tcx>, - source: MirSource, + source: MirSource<'tcx>, movable: bool, ) -> ( liveness::LiveVarSet, @@ -484,7 +484,7 @@ fn locals_live_across_suspend_points( } fn compute_layout<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, - source: MirSource, + source: MirSource<'tcx>, upvars: Vec>, interior: Ty<'tcx>, movable: bool, @@ -635,7 +635,7 @@ fn create_generator_drop_shim<'a, 'tcx>( tcx: TyCtxt<'a, 'tcx, 'tcx>, transform: &TransformVisitor<'a, 'tcx>, def_id: DefId, - source: MirSource, + source: MirSource<'tcx>, gen_ty: Ty<'tcx>, mir: &Mir<'tcx>, drop_clean: BasicBlock) -> Mir<'tcx> { @@ -758,7 +758,7 @@ fn create_generator_resume_function<'a, 'tcx>( tcx: TyCtxt<'a, 'tcx, 'tcx>, transform: TransformVisitor<'a, 'tcx>, def_id: DefId, - source: MirSource, + source: MirSource<'tcx>, mir: &mut Mir<'tcx>) { // Poison the generator when it unwinds for block in mir.basic_blocks_mut() { @@ -869,7 +869,7 @@ fn create_cases<'a, 'tcx, F>(mir: &mut Mir<'tcx>, impl MirPass for StateTransform { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - source: MirSource, + source: MirSource<'tcx>, mir: &mut Mir<'tcx>) { let yield_ty = if let Some(yield_ty) = mir.yield_ty { yield_ty diff --git a/src/librustc_mir/transform/instcombine.rs b/src/librustc_mir/transform/instcombine.rs index 21772e1f1cd5b..290915763e275 100644 --- a/src/librustc_mir/transform/instcombine.rs +++ b/src/librustc_mir/transform/instcombine.rs @@ -13,7 +13,7 @@ pub struct InstCombine; impl MirPass for InstCombine { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _: MirSource, + _: MirSource<'tcx>, mir: &mut Mir<'tcx>) { // We only run when optimizing MIR (at any level). if tcx.sess.opts.debugging_opts.mir_opt_level == 0 { diff --git a/src/librustc_mir/transform/lower_128bit.rs b/src/librustc_mir/transform/lower_128bit.rs index aa248ba7c53df..3d1f55e530e62 100644 --- a/src/librustc_mir/transform/lower_128bit.rs +++ b/src/librustc_mir/transform/lower_128bit.rs @@ -12,7 +12,7 @@ pub struct Lower128Bit; impl MirPass for Lower128Bit { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _src: MirSource, + _src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { let debugging_override = tcx.sess.opts.debugging_opts.lower_128bit_ops; let target_default = tcx.sess.host.options.i128_lowering; diff --git a/src/librustc_mir/transform/no_landing_pads.rs b/src/librustc_mir/transform/no_landing_pads.rs index 15b59d36d363c..089d9b9b54454 100644 --- a/src/librustc_mir/transform/no_landing_pads.rs +++ b/src/librustc_mir/transform/no_landing_pads.rs @@ -11,7 +11,7 @@ pub struct NoLandingPads; impl MirPass for NoLandingPads { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _: MirSource, + _: MirSource<'tcx>, mir: &mut Mir<'tcx>) { no_landing_pads(tcx, mir) } diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs index 9b5c4f51a91a3..76b8b83031a0a 100644 --- a/src/librustc_mir/transform/qualify_consts.rs +++ b/src/librustc_mir/transform/qualify_consts.rs @@ -1159,7 +1159,7 @@ pub struct QualifyAndPromoteConstants; impl MirPass for QualifyAndPromoteConstants { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - src: MirSource, + src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { // There's not really any point in promoting errorful MIR. if mir.return_ty().references_error() { diff --git a/src/librustc_mir/transform/remove_noop_landing_pads.rs b/src/librustc_mir/transform/remove_noop_landing_pads.rs index 4fcb4c10f9e6d..68832b73ccd87 100644 --- a/src/librustc_mir/transform/remove_noop_landing_pads.rs +++ b/src/librustc_mir/transform/remove_noop_landing_pads.rs @@ -24,7 +24,7 @@ pub fn remove_noop_landing_pads<'a, 'tcx>( impl MirPass for RemoveNoopLandingPads { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _src: MirSource, + _src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { remove_noop_landing_pads(tcx, mir); } diff --git a/src/librustc_mir/transform/rustc_peek.rs b/src/librustc_mir/transform/rustc_peek.rs index d9a5d2fe8ce0b..40e02e712c156 100644 --- a/src/librustc_mir/transform/rustc_peek.rs +++ b/src/librustc_mir/transform/rustc_peek.rs @@ -24,7 +24,7 @@ pub struct SanityCheck; impl MirPass for SanityCheck { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - src: MirSource, mir: &mut Mir<'tcx>) { + src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { let def_id = src.def_id(); let id = tcx.hir().as_local_node_id(def_id).unwrap(); if !tcx.has_attr(def_id, "rustc_mir") { diff --git a/src/librustc_mir/transform/simplify.rs b/src/librustc_mir/transform/simplify.rs index 90486d1566413..14e7895af0419 100644 --- a/src/librustc_mir/transform/simplify.rs +++ b/src/librustc_mir/transform/simplify.rs @@ -59,7 +59,7 @@ impl MirPass for SimplifyCfg { fn run_pass<'a, 'tcx>(&self, _tcx: TyCtxt<'a, 'tcx, 'tcx>, - _src: MirSource, + _src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { debug!("SimplifyCfg({:?}) - simplifying {:?}", self.label, mir); simplify_cfg(mir); @@ -298,7 +298,7 @@ pub struct SimplifyLocals; impl MirPass for SimplifyLocals { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _: MirSource, + _: MirSource<'tcx>, mir: &mut Mir<'tcx>) { let mut marker = DeclMarker { locals: BitSet::new_empty(mir.local_decls.len()) }; marker.visit_mir(mir); diff --git a/src/librustc_mir/transform/simplify_branches.rs b/src/librustc_mir/transform/simplify_branches.rs index 0dc89bfe14709..3c4d1227a691c 100644 --- a/src/librustc_mir/transform/simplify_branches.rs +++ b/src/librustc_mir/transform/simplify_branches.rs @@ -21,7 +21,7 @@ impl MirPass for SimplifyBranches { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _src: MirSource, + _src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { for block in mir.basic_blocks_mut() { let terminator = block.terminator_mut(); diff --git a/src/librustc_mir/transform/uniform_array_move_out.rs b/src/librustc_mir/transform/uniform_array_move_out.rs index 09918436817f3..fd8d68a482262 100644 --- a/src/librustc_mir/transform/uniform_array_move_out.rs +++ b/src/librustc_mir/transform/uniform_array_move_out.rs @@ -39,7 +39,7 @@ pub struct UniformArrayMoveOut; impl MirPass for UniformArrayMoveOut { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _src: MirSource, + _src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { let mut patch = MirPatch::new(mir); { @@ -161,7 +161,7 @@ pub struct RestoreSubsliceArrayMoveOut; impl MirPass for RestoreSubsliceArrayMoveOut { fn run_pass<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, - _src: MirSource, + _src: MirSource<'tcx>, mir: &mut Mir<'tcx>) { let mut patch = MirPatch::new(mir); { diff --git a/src/librustc_mir/util/liveness.rs b/src/librustc_mir/util/liveness.rs index f72052c6e2840..847699cc500c9 100644 --- a/src/librustc_mir/util/liveness.rs +++ b/src/librustc_mir/util/liveness.rs @@ -307,7 +307,7 @@ fn block<'tcx, V: Idx>( pub fn dump_mir<'a, 'tcx, V: Idx>( tcx: TyCtxt<'a, 'tcx, 'tcx>, pass_name: &str, - source: MirSource, + source: MirSource<'tcx>, mir: &Mir<'tcx>, map: &impl LiveVariableMap, result: &LivenessResult, @@ -326,7 +326,7 @@ fn dump_matched_mir_node<'a, 'tcx, V: Idx>( tcx: TyCtxt<'a, 'tcx, 'tcx>, pass_name: &str, node_path: &str, - source: MirSource, + source: MirSource<'tcx>, mir: &Mir<'tcx>, map: &dyn LiveVariableMap, result: &LivenessResult, @@ -348,7 +348,7 @@ fn dump_matched_mir_node<'a, 'tcx, V: Idx>( pub fn write_mir_fn<'a, 'tcx, V: Idx>( tcx: TyCtxt<'a, 'tcx, 'tcx>, - src: MirSource, + src: MirSource<'tcx>, mir: &Mir<'tcx>, map: &dyn LiveVariableMap, w: &mut dyn Write, diff --git a/src/librustc_mir/util/pretty.rs b/src/librustc_mir/util/pretty.rs index b1aef28ca9808..1357f8fe79a0d 100644 --- a/src/librustc_mir/util/pretty.rs +++ b/src/librustc_mir/util/pretty.rs @@ -68,7 +68,7 @@ pub fn dump_mir<'a, 'gcx, 'tcx, F>( pass_num: Option<&dyn Display>, pass_name: &str, disambiguator: &dyn Display, - source: MirSource, + source: MirSource<'tcx>, mir: &Mir<'tcx>, extra_data: F, ) where @@ -97,7 +97,7 @@ pub fn dump_mir<'a, 'gcx, 'tcx, F>( pub fn dump_enabled<'a, 'gcx, 'tcx>( tcx: TyCtxt<'a, 'gcx, 'tcx>, pass_name: &str, - source: MirSource, + source: MirSource<'tcx>, ) -> bool { let filters = match tcx.sess.opts.debugging_opts.dump_mir { None => return false, @@ -124,7 +124,7 @@ fn dump_matched_mir_node<'a, 'gcx, 'tcx, F>( pass_name: &str, node_path: &str, disambiguator: &dyn Display, - source: MirSource, + source: MirSource<'tcx>, mir: &Mir<'tcx>, mut extra_data: F, ) where @@ -164,7 +164,7 @@ fn dump_path( pass_num: Option<&dyn Display>, pass_name: &str, disambiguator: &dyn Display, - source: MirSource, + source: MirSource<'tcx>, ) -> PathBuf { let promotion_id = match source.promoted { Some(id) => format!("-{:?}", id), @@ -231,7 +231,7 @@ pub(crate) fn create_dump_file( pass_num: Option<&dyn Display>, pass_name: &str, disambiguator: &dyn Display, - source: MirSource, + source: MirSource<'tcx>, ) -> io::Result { let file_path = dump_path(tcx, extension, pass_num, pass_name, disambiguator, source); if let Some(parent) = file_path.parent() { @@ -282,7 +282,7 @@ pub fn write_mir_pretty<'a, 'gcx, 'tcx>( pub fn write_mir_fn<'a, 'gcx, 'tcx, F>( tcx: TyCtxt<'a, 'gcx, 'tcx>, - src: MirSource, + src: MirSource<'tcx>, mir: &Mir<'tcx>, extra_data: &mut F, w: &mut dyn Write, @@ -546,7 +546,7 @@ fn write_scope_tree( /// local variables (both user-defined bindings and compiler temporaries). pub fn write_mir_intro<'a, 'gcx, 'tcx>( tcx: TyCtxt<'a, 'gcx, 'tcx>, - src: MirSource, + src: MirSource<'tcx>, mir: &Mir<'_>, w: &mut dyn Write, ) -> io::Result<()> { @@ -588,7 +588,7 @@ pub fn write_mir_intro<'a, 'gcx, 'tcx>( fn write_mir_sig( tcx: TyCtxt<'_, '_, '_>, - src: MirSource, + src: MirSource<'tcx>, mir: &Mir<'_>, w: &mut dyn Write, ) -> io::Result<()> { From be71fccf11525118b62b40f78c65b6bb6abca823 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Sat, 9 Feb 2019 23:31:47 +0900 Subject: [PATCH 232/278] librustc_codegen_ssa => 2018 --- src/librustc_codegen_ssa/Cargo.toml | 1 + src/librustc_codegen_ssa/back/link.rs | 2 +- src/librustc_codegen_ssa/back/lto.rs | 4 ++-- src/librustc_codegen_ssa/back/write.rs | 7 +++--- src/librustc_codegen_ssa/base.rs | 24 +++++++++---------- src/librustc_codegen_ssa/callee.rs | 2 +- src/librustc_codegen_ssa/common.rs | 8 +++---- src/librustc_codegen_ssa/glue.rs | 8 +++---- src/librustc_codegen_ssa/lib.rs | 25 ++++---------------- src/librustc_codegen_ssa/meth.rs | 4 ++-- src/librustc_codegen_ssa/mir/analyze.rs | 2 +- src/librustc_codegen_ssa/mir/block.rs | 10 ++++---- src/librustc_codegen_ssa/mir/constant.rs | 2 +- src/librustc_codegen_ssa/mir/mod.rs | 6 ++--- src/librustc_codegen_ssa/mir/operand.rs | 8 +++---- src/librustc_codegen_ssa/mir/place.rs | 8 +++---- src/librustc_codegen_ssa/mir/rvalue.rs | 10 ++++---- src/librustc_codegen_ssa/mir/statement.rs | 4 ++-- src/librustc_codegen_ssa/mono_item.rs | 4 ++-- src/librustc_codegen_ssa/traits/asm.rs | 2 +- src/librustc_codegen_ssa/traits/builder.rs | 9 +++---- src/librustc_codegen_ssa/traits/consts.rs | 2 +- src/librustc_codegen_ssa/traits/debuginfo.rs | 2 +- src/librustc_codegen_ssa/traits/intrinsic.rs | 2 +- src/librustc_codegen_ssa/traits/type_.rs | 4 ++-- src/librustc_codegen_ssa/traits/write.rs | 6 ++--- 26 files changed, 75 insertions(+), 91 deletions(-) diff --git a/src/librustc_codegen_ssa/Cargo.toml b/src/librustc_codegen_ssa/Cargo.toml index 50994497c2843..0aba43580f1f6 100644 --- a/src/librustc_codegen_ssa/Cargo.toml +++ b/src/librustc_codegen_ssa/Cargo.toml @@ -2,6 +2,7 @@ authors = ["The Rust Project Developers"] name = "rustc_codegen_ssa" version = "0.0.0" +edition = "2018" [lib] name = "rustc_codegen_ssa" diff --git a/src/librustc_codegen_ssa/back/link.rs b/src/librustc_codegen_ssa/back/link.rs index 2a5ecf9a0593f..7f1aebace8fc6 100644 --- a/src/librustc_codegen_ssa/back/link.rs +++ b/src/librustc_codegen_ssa/back/link.rs @@ -9,7 +9,7 @@ use rustc_target::spec::LinkerFlavor; use rustc::hir::def_id::CrateNum; use super::command::Command; -use CrateInfo; +use crate::CrateInfo; use cc::windows_registry; use std::fs; diff --git a/src/librustc_codegen_ssa/back/lto.rs b/src/librustc_codegen_ssa/back/lto.rs index f0fb115f91b94..7f0eba7b0850b 100644 --- a/src/librustc_codegen_ssa/back/lto.rs +++ b/src/librustc_codegen_ssa/back/lto.rs @@ -1,6 +1,6 @@ use super::write::CodegenContext; -use traits::*; -use ModuleCodegen; +use crate::traits::*; +use crate::ModuleCodegen; use rustc::util::time_graph::Timeline; use rustc_errors::FatalError; diff --git a/src/librustc_codegen_ssa/back/write.rs b/src/librustc_codegen_ssa/back/write.rs index 67d4d408babfa..eeb191b09e249 100644 --- a/src/librustc_codegen_ssa/back/write.rs +++ b/src/librustc_codegen_ssa/back/write.rs @@ -1,12 +1,12 @@ -use {ModuleCodegen, ModuleKind, CachedModuleCodegen, CompiledModule, CrateInfo, CodegenResults, - RLIB_BYTECODE_EXTENSION}; +use crate::{ModuleCodegen, ModuleKind, CachedModuleCodegen, CompiledModule, CrateInfo, + CodegenResults, RLIB_BYTECODE_EXTENSION}; use super::linker::LinkerInfo; use super::lto::{self, SerializedModule}; use super::link::{self, remove, get_linker}; use super::command::Command; use super::symbol_export::ExportedSymbols; -use memmap; +use crate::traits::*; use rustc_incremental::{copy_cgu_workproducts_to_incr_comp_cache_dir, in_incr_comp_dir, in_incr_comp_dir_sess}; use rustc::dep_graph::{WorkProduct, WorkProductId, WorkProductFileKind}; @@ -16,7 +16,6 @@ use rustc::session::config::{self, OutputFilenames, OutputType, Passes, Sanitize use rustc::session::Session; use rustc::util::nodemap::FxHashMap; use rustc::util::time_graph::{self, TimeGraph, Timeline}; -use traits::*; use rustc::hir::def_id::{CrateNum, LOCAL_CRATE}; use rustc::ty::TyCtxt; use rustc::util::common::{time_depth, set_time_depth, print_time_passes_entry}; diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs index 84e55ce0f22c6..988e3bbd71d8a 100644 --- a/src/librustc_codegen_ssa/base.rs +++ b/src/librustc_codegen_ssa/base.rs @@ -13,7 +13,7 @@ //! but one llvm::Type corresponds to many `Ty`s; for instance, tup(int, int, //! int) and rec(x=int, y=int, z=int) will have the same llvm::Type. -use {ModuleCodegen, ModuleKind, CachedModuleCodegen}; +use crate::{ModuleCodegen, ModuleKind, CachedModuleCodegen}; use rustc::dep_graph::cgu_reuse_tracker::CguReuse; use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; @@ -28,26 +28,26 @@ use rustc::util::common::{time, print_time_passes_entry}; use rustc::util::profiling::ProfileCategory; use rustc::session::config::{self, EntryFnType, Lto}; use rustc::session::Session; -use mir::place::PlaceRef; -use back::write::{OngoingCodegen, start_async_codegen, submit_pre_lto_module_to_llvm, - submit_post_lto_module_to_llvm}; -use {MemFlags, CrateInfo}; -use callee; use rustc_mir::monomorphize::item::DefPathBasedNames; -use common::{RealPredicate, TypeKind, IntPredicate}; -use meth; -use mir; use rustc::util::time_graph; use rustc_mir::monomorphize::Instance; use rustc_mir::monomorphize::partitioning::{CodegenUnit, CodegenUnitExt}; -use mono_item::MonoItem; use rustc::util::nodemap::FxHashMap; use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::sync::Lrc; use rustc_codegen_utils::{symbol_names_test, check_for_rustc_errors_attr}; use rustc::ty::layout::{FAT_PTR_ADDR, FAT_PTR_EXTRA}; +use crate::mir::place::PlaceRef; +use crate::back::write::{OngoingCodegen, start_async_codegen, submit_pre_lto_module_to_llvm, + submit_post_lto_module_to_llvm}; +use crate::{MemFlags, CrateInfo}; +use crate::callee; +use crate::common::{RealPredicate, TypeKind, IntPredicate}; +use crate::meth; +use crate::mir; +use crate::mono_item::MonoItem; -use traits::*; +use crate::traits::*; use std::any::Any; use std::cmp; @@ -58,7 +58,7 @@ use syntax_pos::Span; use syntax::attr; use rustc::hir; -use mir::operand::OperandValue; +use crate::mir::operand::OperandValue; use std::marker::PhantomData; diff --git a/src/librustc_codegen_ssa/callee.rs b/src/librustc_codegen_ssa/callee.rs index aa13e525a73bf..3665d45d1e9c7 100644 --- a/src/librustc_codegen_ssa/callee.rs +++ b/src/librustc_codegen_ssa/callee.rs @@ -1,4 +1,4 @@ -use traits::*; +use crate::traits::*; use rustc::ty; use rustc::ty::subst::Substs; use rustc::hir::def_id::DefId; diff --git a/src/librustc_codegen_ssa/common.rs b/src/librustc_codegen_ssa/common.rs index cfb5d24fc12ef..1b87f160cc35d 100644 --- a/src/librustc_codegen_ssa/common.rs +++ b/src/librustc_codegen_ssa/common.rs @@ -5,11 +5,11 @@ use syntax_pos::{DUMMY_SP, Span}; use rustc::hir::def_id::DefId; use rustc::middle::lang_items::LangItem; -use base; -use traits::*; +use crate::base; +use crate::traits::*; use rustc::hir; -use traits::BuilderMethods; +use crate::traits::BuilderMethods; pub fn type_needs_drop<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> bool { ty.needs_drop(tcx, ty::ParamEnv::reveal_all()) @@ -123,7 +123,7 @@ pub enum TypeKind { mod temp_stable_hash_impls { use rustc_data_structures::stable_hasher::{StableHasherResult, StableHasher, HashStable}; - use ModuleCodegen; + use crate::ModuleCodegen; impl HashStable for ModuleCodegen { fn hash_stable(&self, diff --git a/src/librustc_codegen_ssa/glue.rs b/src/librustc_codegen_ssa/glue.rs index ed63e1e62ee5f..e2b49de05bd11 100644 --- a/src/librustc_codegen_ssa/glue.rs +++ b/src/librustc_codegen_ssa/glue.rs @@ -2,12 +2,10 @@ // // Code relating to drop glue. -use std; - -use common::IntPredicate; -use meth; use rustc::ty::{self, Ty}; -use traits::*; +use crate::common::IntPredicate; +use crate::meth; +use crate::traits::*; pub fn size_and_align_of_dst<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>( bx: &mut Bx, diff --git a/src/librustc_codegen_ssa/lib.rs b/src/librustc_codegen_ssa/lib.rs index 58b3f0434a623..ad894bfe1cdf1 100644 --- a/src/librustc_codegen_ssa/lib.rs +++ b/src/librustc_codegen_ssa/lib.rs @@ -10,6 +10,9 @@ #![feature(nll)] #![allow(unused_attributes)] #![allow(dead_code)] +#![deny(rust_2018_idioms)] +#![allow(explicit_outlives_requirements)] +#![allow(elided_lifetimes_in_paths)] #![recursion_limit="256"] @@ -17,27 +20,9 @@ //! The backend-agnostic functions of this crate use functions defined in various traits that //! have to be implemented by each backends. -#[macro_use] extern crate bitflags; #[macro_use] extern crate log; -extern crate rustc_apfloat; -#[macro_use] extern crate rustc; -extern crate rustc_target; -extern crate rustc_mir; +#[macro_use] extern crate rustc; #[macro_use] extern crate syntax; -extern crate syntax_pos; -extern crate rustc_incremental; -extern crate rustc_codegen_utils; -extern crate rustc_data_structures; -extern crate rustc_allocator; -extern crate rustc_fs_util; -extern crate serialize; -extern crate rustc_errors; -extern crate rustc_demangle; -extern crate cc; -extern crate libc; -extern crate jobserver; -extern crate memmap; -extern crate num_cpus; use std::path::PathBuf; use rustc::dep_graph::WorkProduct; @@ -133,7 +118,7 @@ pub enum ModuleKind { Allocator, } -bitflags! { +bitflags::bitflags! { pub struct MemFlags: u8 { const VOLATILE = 1 << 0; const NONTEMPORAL = 1 << 1; diff --git a/src/librustc_codegen_ssa/meth.rs b/src/librustc_codegen_ssa/meth.rs index 98ad2616eeaae..49f3c87ee2d9d 100644 --- a/src/librustc_codegen_ssa/meth.rs +++ b/src/librustc_codegen_ssa/meth.rs @@ -1,8 +1,8 @@ use rustc_target::abi::call::FnType; -use callee; use rustc_mir::monomorphize; -use traits::*; +use crate::callee; +use crate::traits::*; use rustc::ty::{self, Ty}; diff --git a/src/librustc_codegen_ssa/mir/analyze.rs b/src/librustc_codegen_ssa/mir/analyze.rs index f3475d1c48968..9fe2e58bc203c 100644 --- a/src/librustc_codegen_ssa/mir/analyze.rs +++ b/src/librustc_codegen_ssa/mir/analyze.rs @@ -10,7 +10,7 @@ use rustc::mir::traversal; use rustc::ty; use rustc::ty::layout::{LayoutOf, HasTyCtxt}; use super::FunctionCx; -use traits::*; +use crate::traits::*; pub fn non_ssa_locals<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>( fx: &FunctionCx<'a, 'tcx, Bx> diff --git a/src/librustc_codegen_ssa/mir/block.rs b/src/librustc_codegen_ssa/mir/block.rs index aa82c853257a3..af510d402eb8a 100644 --- a/src/librustc_codegen_ssa/mir/block.rs +++ b/src/librustc_codegen_ssa/mir/block.rs @@ -5,13 +5,13 @@ use rustc::mir; use rustc::mir::interpret::EvalErrorKind; use rustc_target::abi::call::{ArgType, FnType, PassMode}; use rustc_target::spec::abi::Abi; -use base; -use MemFlags; -use common::{self, IntPredicate}; -use meth; use rustc_mir::monomorphize; +use crate::base; +use crate::MemFlags; +use crate::common::{self, IntPredicate}; +use crate::meth; -use traits::*; +use crate::traits::*; use syntax::symbol::Symbol; use syntax_pos::Pos; diff --git a/src/librustc_codegen_ssa/mir/constant.rs b/src/librustc_codegen_ssa/mir/constant.rs index 56d4342e6e161..6bc69efa4a7d5 100644 --- a/src/librustc_codegen_ssa/mir/constant.rs +++ b/src/librustc_codegen_ssa/mir/constant.rs @@ -6,7 +6,7 @@ use rustc::mir::interpret::GlobalId; use rustc::ty::{self, Ty}; use rustc::ty::layout; use syntax::source_map::Span; -use traits::*; +use crate::traits::*; use super::FunctionCx; diff --git a/src/librustc_codegen_ssa/mir/mod.rs b/src/librustc_codegen_ssa/mir/mod.rs index c7e2131eed5da..2e2cb3dd46717 100644 --- a/src/librustc_codegen_ssa/mir/mod.rs +++ b/src/librustc_codegen_ssa/mir/mod.rs @@ -4,11 +4,11 @@ use rustc::ty::layout::{TyLayout, HasTyCtxt}; use rustc::mir::{self, Mir}; use rustc::ty::subst::Substs; use rustc::session::config::DebugInfo; -use base; -use debuginfo::{self, VariableAccess, VariableKind, FunctionDebugContext}; use rustc_mir::monomorphize::Instance; use rustc_target::abi::call::{FnType, PassMode}; -use traits::*; +use crate::base; +use crate::debuginfo::{self, VariableAccess, VariableKind, FunctionDebugContext}; +use crate::traits::*; use syntax_pos::{DUMMY_SP, NO_EXPANSION, BytePos, Span}; use syntax::symbol::keywords; diff --git a/src/librustc_codegen_ssa/mir/operand.rs b/src/librustc_codegen_ssa/mir/operand.rs index 8aad4c1f6e1c0..2c6d968bb032a 100644 --- a/src/librustc_codegen_ssa/mir/operand.rs +++ b/src/librustc_codegen_ssa/mir/operand.rs @@ -3,11 +3,11 @@ use rustc::mir; use rustc::ty; use rustc::ty::layout::{self, Align, LayoutOf, TyLayout}; -use base; -use MemFlags; -use glue; +use crate::base; +use crate::MemFlags; +use crate::glue; -use traits::*; +use crate::traits::*; use std::fmt; diff --git a/src/librustc_codegen_ssa/mir/place.rs b/src/librustc_codegen_ssa/mir/place.rs index 596f97a038892..ffc774c38ea36 100644 --- a/src/librustc_codegen_ssa/mir/place.rs +++ b/src/librustc_codegen_ssa/mir/place.rs @@ -2,11 +2,11 @@ use rustc::ty::{self, Ty}; use rustc::ty::layout::{self, Align, TyLayout, LayoutOf, VariantIdx, HasTyCtxt}; use rustc::mir; use rustc::mir::tcx::PlaceTy; -use MemFlags; -use common::IntPredicate; -use glue; +use crate::MemFlags; +use crate::common::IntPredicate; +use crate::glue; -use traits::*; +use crate::traits::*; use super::{FunctionCx, LocalRef}; use super::operand::OperandValue; diff --git a/src/librustc_codegen_ssa/mir/rvalue.rs b/src/librustc_codegen_ssa/mir/rvalue.rs index 9ca5414fa717e..25a7754d118d7 100644 --- a/src/librustc_codegen_ssa/mir/rvalue.rs +++ b/src/librustc_codegen_ssa/mir/rvalue.rs @@ -6,13 +6,13 @@ use rustc::middle::lang_items::ExchangeMallocFnLangItem; use rustc_apfloat::{ieee, Float, Status, Round}; use std::{u128, i128}; -use base; -use MemFlags; -use callee; -use common::{self, RealPredicate, IntPredicate}; +use crate::base; +use crate::MemFlags; +use crate::callee; +use crate::common::{self, RealPredicate, IntPredicate}; use rustc_mir::monomorphize; -use traits::*; +use crate::traits::*; use super::{FunctionCx, LocalRef}; use super::operand::{OperandRef, OperandValue}; diff --git a/src/librustc_codegen_ssa/mir/statement.rs b/src/librustc_codegen_ssa/mir/statement.rs index 9561a57d0a7de..a1bd919c43354 100644 --- a/src/librustc_codegen_ssa/mir/statement.rs +++ b/src/librustc_codegen_ssa/mir/statement.rs @@ -1,10 +1,10 @@ use rustc::mir; -use traits::BuilderMethods; +use crate::traits::BuilderMethods; use super::FunctionCx; use super::LocalRef; use super::OperandValue; -use traits::*; +use crate::traits::*; impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { pub fn codegen_statement( diff --git a/src/librustc_codegen_ssa/mono_item.rs b/src/librustc_codegen_ssa/mono_item.rs index 8488ab2ae862f..bfb6a9153809a 100644 --- a/src/librustc_codegen_ssa/mono_item.rs +++ b/src/librustc_codegen_ssa/mono_item.rs @@ -1,10 +1,10 @@ -use base; use rustc::hir; use rustc::hir::def::Def; use rustc::mir::mono::{Linkage, Visibility}; use rustc::ty::layout::HasTyCtxt; use std::fmt; -use traits::*; +use crate::base; +use crate::traits::*; pub use rustc::mir::mono::MonoItem; diff --git a/src/librustc_codegen_ssa/traits/asm.rs b/src/librustc_codegen_ssa/traits/asm.rs index 7fe16925a3f97..a95bf3af5bf27 100644 --- a/src/librustc_codegen_ssa/traits/asm.rs +++ b/src/librustc_codegen_ssa/traits/asm.rs @@ -1,5 +1,5 @@ use super::BackendTypes; -use mir::place::PlaceRef; +use crate::mir::place::PlaceRef; use rustc::hir::{GlobalAsm, InlineAsm}; pub trait AsmBuilderMethods<'tcx>: BackendTypes { diff --git a/src/librustc_codegen_ssa/traits/builder.rs b/src/librustc_codegen_ssa/traits/builder.rs index bc66087d3ce70..bda0f3dc77966 100644 --- a/src/librustc_codegen_ssa/traits/builder.rs +++ b/src/librustc_codegen_ssa/traits/builder.rs @@ -4,13 +4,14 @@ use super::debuginfo::DebugInfoBuilderMethods; use super::intrinsic::IntrinsicCallMethods; use super::type_::ArgTypeMethods; use super::{HasCodegen, StaticBuilderMethods}; -use common::{AtomicOrdering, AtomicRmwBinOp, IntPredicate, RealPredicate, SynchronizationScope}; -use mir::operand::OperandRef; -use mir::place::PlaceRef; +use crate::common::{AtomicOrdering, AtomicRmwBinOp, IntPredicate, RealPredicate, + SynchronizationScope}; +use crate::mir::operand::OperandRef; +use crate::mir::place::PlaceRef; +use crate::MemFlags; use rustc::ty::Ty; use rustc::ty::layout::{Align, Size}; use std::ffi::CStr; -use MemFlags; use std::borrow::Cow; use std::ops::Range; diff --git a/src/librustc_codegen_ssa/traits/consts.rs b/src/librustc_codegen_ssa/traits/consts.rs index 482fb67e2b0c2..319f4b4e5e4b5 100644 --- a/src/librustc_codegen_ssa/traits/consts.rs +++ b/src/librustc_codegen_ssa/traits/consts.rs @@ -1,5 +1,5 @@ use super::BackendTypes; -use mir::place::PlaceRef; +use crate::mir::place::PlaceRef; use rustc::mir::interpret::Allocation; use rustc::mir::interpret::Scalar; use rustc::ty::layout; diff --git a/src/librustc_codegen_ssa/traits/debuginfo.rs b/src/librustc_codegen_ssa/traits/debuginfo.rs index 4163faa591462..0e606e744c629 100644 --- a/src/librustc_codegen_ssa/traits/debuginfo.rs +++ b/src/librustc_codegen_ssa/traits/debuginfo.rs @@ -1,5 +1,5 @@ use super::BackendTypes; -use debuginfo::{FunctionDebugContext, MirDebugScope, VariableAccess, VariableKind}; +use crate::debuginfo::{FunctionDebugContext, MirDebugScope, VariableAccess, VariableKind}; use rustc::hir::def_id::CrateNum; use rustc::mir; use rustc::ty::{self, Ty}; diff --git a/src/librustc_codegen_ssa/traits/intrinsic.rs b/src/librustc_codegen_ssa/traits/intrinsic.rs index a2d6b0550f8ca..3cd0c39d4139a 100644 --- a/src/librustc_codegen_ssa/traits/intrinsic.rs +++ b/src/librustc_codegen_ssa/traits/intrinsic.rs @@ -1,5 +1,5 @@ use super::BackendTypes; -use mir::operand::OperandRef; +use crate::mir::operand::OperandRef; use rustc::ty::Ty; use rustc_target::abi::call::FnType; use syntax_pos::Span; diff --git a/src/librustc_codegen_ssa/traits/type_.rs b/src/librustc_codegen_ssa/traits/type_.rs index 2ec0c8e5a75cc..122aea035cea5 100644 --- a/src/librustc_codegen_ssa/traits/type_.rs +++ b/src/librustc_codegen_ssa/traits/type_.rs @@ -1,8 +1,8 @@ use super::misc::MiscMethods; use super::Backend; use super::HasCodegen; -use common::{self, TypeKind}; -use mir::place::PlaceRef; +use crate::common::{self, TypeKind}; +use crate::mir::place::PlaceRef; use rustc::ty::layout::{self, Align, Size, TyLayout}; use rustc::ty::{self, Ty}; use rustc::util::nodemap::FxHashMap; diff --git a/src/librustc_codegen_ssa/traits/write.rs b/src/librustc_codegen_ssa/traits/write.rs index cea89a7f99b1b..e8ef815b32acb 100644 --- a/src/librustc_codegen_ssa/traits/write.rs +++ b/src/librustc_codegen_ssa/traits/write.rs @@ -1,6 +1,6 @@ -use back::lto::{LtoModuleCodegen, SerializedModule, ThinModule}; -use back::write::{CodegenContext, ModuleConfig}; -use {CompiledModule, ModuleCodegen}; +use crate::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule}; +use crate::back::write::{CodegenContext, ModuleConfig}; +use crate::{CompiledModule, ModuleCodegen}; use rustc::dep_graph::WorkProduct; use rustc::util::time_graph::Timeline; From 66adf52e7dfd68f04e60744ea9bf130c45befe5e Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 9 Feb 2019 15:44:54 +0100 Subject: [PATCH 233/278] miri: give non-generic functions a stable address --- src/librustc/mir/interpret/mod.rs | 31 +++++++++++++++++++++++-------- 1 file changed, 23 insertions(+), 8 deletions(-) diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs index efd233f1f3854..bb25d1b42095a 100644 --- a/src/librustc/mir/interpret/mod.rs +++ b/src/librustc/mir/interpret/mod.rs @@ -27,7 +27,7 @@ pub use self::pointer::{Pointer, PointerArithmetic}; use std::fmt; use crate::mir; use crate::hir::def_id::DefId; -use crate::ty::{self, TyCtxt, Instance}; +use crate::ty::{self, TyCtxt, Instance, subst::UnpackedKind}; use crate::ty::layout::{self, Size}; use std::io; use crate::rustc_serialize::{Encoder, Decodable, Encodable}; @@ -318,14 +318,29 @@ impl<'tcx> AllocMap<'tcx> { id } - /// Functions cannot be identified by pointers, as asm-equal functions can get deduplicated - /// by the linker and functions can be duplicated across crates. - /// We thus generate a new `AllocId` for every mention of a function. This means that - /// `main as fn() == main as fn()` is false, while `let x = main as fn(); x == x` is true. pub fn create_fn_alloc(&mut self, instance: Instance<'tcx>) -> AllocId { - let id = self.reserve(); - self.id_to_kind.insert(id, AllocKind::Function(instance)); - id + // Functions cannot be identified by pointers, as asm-equal functions can get deduplicated + // by the linker (we set the "unnamed_addr" attribute for LLVM) and functions can be + // duplicated across crates. + // We thus generate a new `AllocId` for every mention of a function. This means that + // `main as fn() == main as fn()` is false, while `let x = main as fn(); x == x` is true. + // However, formatting code relies on function identity (see #58320), so we only do + // this for generic functions. Lifetime parameters are ignored. + let is_generic = instance.substs.into_iter().any(|kind| { + match kind.unpack() { + UnpackedKind::Lifetime(_) => false, + _ => true, + } + }); + if is_generic { + // Get a fresh ID + let id = self.reserve(); + self.id_to_kind.insert(id, AllocKind::Function(instance)); + id + } else { + // Deduplicate + self.intern(AllocKind::Function(instance)) + } } /// Returns `None` in case the `AllocId` is dangling. An `EvalContext` can still have a From 0a16b8754abe419f8541788c1092e4ef91fcf137 Mon Sep 17 00:00:00 2001 From: Matthew Jasper Date: Sat, 9 Feb 2019 16:29:31 +0000 Subject: [PATCH 234/278] Use ? in librustc macros --- src/librustc/macros.rs | 56 +++-- src/librustc/mir/visit.rs | 450 +++++++++++++++++++------------------- 2 files changed, 246 insertions(+), 260 deletions(-) diff --git a/src/librustc/macros.rs b/src/librustc/macros.rs index 2978b35319944..ccae9d3ad5a82 100644 --- a/src/librustc/macros.rs +++ b/src/librustc/macros.rs @@ -62,38 +62,36 @@ macro_rules! __impl_stable_hash_field { #[macro_export] macro_rules! impl_stable_hash_for { // Enums - // FIXME(mark-i-m): Some of these should be `?` rather than `*`. See the git blame and change - // them back when `?` is supported again. (enum $enum_name:path { $( $variant:ident // this incorrectly allows specifying both tuple-like and struct-like fields, as in `Variant(a,b){c,d}`, // when it should be only one or the other - $( ( $($field:ident $(-> $delegate:tt)*),* ) )* - $( { $($named_field:ident $(-> $named_delegate:tt)*),* } )* - ),* $(,)* + $( ( $($field:ident $(-> $delegate:tt)?),* ) )? + $( { $($named_field:ident $(-> $named_delegate:tt)?),* } )? + ),* $(,)? }) => { impl_stable_hash_for!( impl<> for enum $enum_name [ $enum_name ] { $( $variant - $( ( $($field $(-> $delegate)*),* ) )* - $( { $($named_field $(-> $named_delegate)*),* } )* + $( ( $($field $(-> $delegate)?),* ) )? + $( { $($named_field $(-> $named_delegate)?),* } )? ),* } ); }; // We want to use the enum name both in the `impl ... for $enum_name` as well as for // importing all the variants. Unfortunately it seems we have to take the name // twice for this purpose - (impl<$($lt:lifetime $(: $lt_bound:lifetime)* ),* $(,)* $($T:ident),* $(,)*> + (impl<$($lt:lifetime $(: $lt_bound:lifetime)? ),* $(,)? $($T:ident),* $(,)?> for enum $enum_name:path [ $enum_path:path ] { $( $variant:ident // this incorrectly allows specifying both tuple-like and struct-like fields, as in `Variant(a,b){c,d}`, // when it should be only one or the other - $( ( $($field:ident $(-> $delegate:tt)*),* ) )* - $( { $($named_field:ident $(-> $named_delegate:tt)*),* } )* - ),* $(,)* + $( ( $($field:ident $(-> $delegate:tt)?),* ) )? + $( { $($named_field:ident $(-> $named_delegate:tt)?),* } )? + ),* $(,)? }) => { - impl<'a, $($lt $(: $lt_bound)*,)* $($T,)*> + impl<'a, $($lt $(: $lt_bound)?,)* $($T,)*> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>> for $enum_name where $($T: ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>>),* @@ -107,9 +105,9 @@ macro_rules! impl_stable_hash_for { match *self { $( - $variant $( ( $(ref $field),* ) )* $( { $(ref $named_field),* } )* => { - $($( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)*) );*)* - $($( __impl_stable_hash_field!($named_field, __ctx, __hasher $(, $named_delegate)*) );*)* + $variant $( ( $(ref $field),* ) )? $( { $(ref $named_field),* } )? => { + $($( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)?) );*)? + $($( __impl_stable_hash_field!($named_field, __ctx, __hasher $(, $named_delegate)?) );*)? } )* } @@ -117,16 +115,15 @@ macro_rules! impl_stable_hash_for { } }; // Structs - // FIXME(mark-i-m): same here. - (struct $struct_name:path { $($field:ident $(-> $delegate:tt)*),* $(,)* }) => { + (struct $struct_name:path { $($field:ident $(-> $delegate:tt)?),* $(,)? }) => { impl_stable_hash_for!( - impl<'tcx> for struct $struct_name { $($field $(-> $delegate)*),* } + impl<'tcx> for struct $struct_name { $($field $(-> $delegate)?),* } ); }; - (impl<$($lt:lifetime $(: $lt_bound:lifetime)* ),* $(,)* $($T:ident),* $(,)*> for struct $struct_name:path { - $($field:ident $(-> $delegate:tt)*),* $(,)* + (impl<$($lt:lifetime $(: $lt_bound:lifetime)? ),* $(,)? $($T:ident),* $(,)?> for struct $struct_name:path { + $($field:ident $(-> $delegate:tt)?),* $(,)? }) => { - impl<'a, $($lt $(: $lt_bound)*,)* $($T,)*> + impl<'a, $($lt $(: $lt_bound)?,)* $($T,)*> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>> for $struct_name where $($T: ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>>),* { @@ -138,21 +135,20 @@ macro_rules! impl_stable_hash_for { $(ref $field),* } = *self; - $( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)*) );* + $( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)?) );* } } }; // Tuple structs - // We cannot use normale parentheses here, the parser won't allow it - // FIXME(mark-i-m): same here. - (tuple_struct $struct_name:path { $($field:ident $(-> $delegate:tt)*),* $(,)* }) => { + // We cannot use normal parentheses here, the parser won't allow it + (tuple_struct $struct_name:path { $($field:ident $(-> $delegate:tt)?),* $(,)? }) => { impl_stable_hash_for!( - impl<'tcx> for tuple_struct $struct_name { $($field $(-> $delegate)*),* } + impl<'tcx> for tuple_struct $struct_name { $($field $(-> $delegate)?),* } ); }; - (impl<$($lt:lifetime $(: $lt_bound:lifetime)* ),* $(,)* $($T:ident),* $(,)*> - for tuple_struct $struct_name:path { $($field:ident $(-> $delegate:tt)*),* $(,)* }) => { - impl<'a, $($lt $(: $lt_bound)*,)* $($T,)*> + (impl<$($lt:lifetime $(: $lt_bound:lifetime)? ),* $(,)? $($T:ident),* $(,)?> + for tuple_struct $struct_name:path { $($field:ident $(-> $delegate:tt)?),* $(,)? }) => { + impl<'a, $($lt $(: $lt_bound)?,)* $($T,)*> ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>> for $struct_name where $($T: ::rustc_data_structures::stable_hasher::HashStable<$crate::ich::StableHashingContext<'a>>),* { @@ -164,7 +160,7 @@ macro_rules! impl_stable_hash_for { $(ref $field),* ) = *self; - $( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)*) );* + $( __impl_stable_hash_field!($field, __ctx, __hasher $(, $delegate)?) );* } } }; diff --git a/src/librustc/mir/visit.rs b/src/librustc/mir/visit.rs index 0180256661630..e5828039ac29c 100644 --- a/src/librustc/mir/visit.rs +++ b/src/librustc/mir/visit.rs @@ -38,10 +38,10 @@ use syntax_pos::Span; // ```rust // fn super_basic_block_data(&mut self, // block: BasicBlock, -// data: & $($mutability)* BasicBlockData<'tcx>) { +// data: & $($mutability)? BasicBlockData<'tcx>) { // let BasicBlockData { -// ref $($mutability)* statements, -// ref $($mutability)* terminator, +// statements, +// terminator, // is_cleanup: _ // } = *data; // @@ -67,111 +67,111 @@ use syntax_pos::Span; // `is_cleanup` above. macro_rules! make_mir_visitor { - ($visitor_trait_name:ident, $($mutability:ident)*) => { + ($visitor_trait_name:ident, $($mutability:ident)?) => { pub trait $visitor_trait_name<'tcx> { // Override these, and call `self.super_xxx` to revert back to the // default behavior. - fn visit_mir(&mut self, mir: & $($mutability)* Mir<'tcx>) { + fn visit_mir(&mut self, mir: & $($mutability)? Mir<'tcx>) { self.super_mir(mir); } fn visit_basic_block_data(&mut self, block: BasicBlock, - data: & $($mutability)* BasicBlockData<'tcx>) { + data: & $($mutability)? BasicBlockData<'tcx>) { self.super_basic_block_data(block, data); } fn visit_source_scope_data(&mut self, - scope_data: & $($mutability)* SourceScopeData) { + scope_data: & $($mutability)? SourceScopeData) { self.super_source_scope_data(scope_data); } fn visit_statement(&mut self, block: BasicBlock, - statement: & $($mutability)* Statement<'tcx>, + statement: & $($mutability)? Statement<'tcx>, location: Location) { self.super_statement(block, statement, location); } fn visit_assign(&mut self, block: BasicBlock, - place: & $($mutability)* Place<'tcx>, - rvalue: & $($mutability)* Rvalue<'tcx>, + place: & $($mutability)? Place<'tcx>, + rvalue: & $($mutability)? Rvalue<'tcx>, location: Location) { self.super_assign(block, place, rvalue, location); } fn visit_terminator(&mut self, block: BasicBlock, - terminator: & $($mutability)* Terminator<'tcx>, + terminator: & $($mutability)? Terminator<'tcx>, location: Location) { self.super_terminator(block, terminator, location); } fn visit_terminator_kind(&mut self, block: BasicBlock, - kind: & $($mutability)* TerminatorKind<'tcx>, + kind: & $($mutability)? TerminatorKind<'tcx>, location: Location) { self.super_terminator_kind(block, kind, location); } fn visit_assert_message(&mut self, - msg: & $($mutability)* AssertMessage<'tcx>, + msg: & $($mutability)? AssertMessage<'tcx>, location: Location) { self.super_assert_message(msg, location); } fn visit_rvalue(&mut self, - rvalue: & $($mutability)* Rvalue<'tcx>, + rvalue: & $($mutability)? Rvalue<'tcx>, location: Location) { self.super_rvalue(rvalue, location); } fn visit_operand(&mut self, - operand: & $($mutability)* Operand<'tcx>, + operand: & $($mutability)? Operand<'tcx>, location: Location) { self.super_operand(operand, location); } fn visit_ascribe_user_ty(&mut self, - place: & $($mutability)* Place<'tcx>, - variance: & $($mutability)* ty::Variance, - user_ty: & $($mutability)* UserTypeProjection<'tcx>, + place: & $($mutability)? Place<'tcx>, + variance: & $($mutability)? ty::Variance, + user_ty: & $($mutability)? UserTypeProjection<'tcx>, location: Location) { self.super_ascribe_user_ty(place, variance, user_ty, location); } fn visit_retag(&mut self, - kind: & $($mutability)* RetagKind, - place: & $($mutability)* Place<'tcx>, + kind: & $($mutability)? RetagKind, + place: & $($mutability)? Place<'tcx>, location: Location) { self.super_retag(kind, place, location); } fn visit_place(&mut self, - place: & $($mutability)* Place<'tcx>, + place: & $($mutability)? Place<'tcx>, context: PlaceContext<'tcx>, location: Location) { self.super_place(place, context, location); } fn visit_static(&mut self, - static_: & $($mutability)* Static<'tcx>, + static_: & $($mutability)? Static<'tcx>, context: PlaceContext<'tcx>, location: Location) { self.super_static(static_, context, location); } fn visit_projection(&mut self, - place: & $($mutability)* PlaceProjection<'tcx>, + place: & $($mutability)? PlaceProjection<'tcx>, context: PlaceContext<'tcx>, location: Location) { self.super_projection(place, context, location); } fn visit_projection_elem(&mut self, - place: & $($mutability)* PlaceElem<'tcx>, + place: & $($mutability)? PlaceElem<'tcx>, location: Location) { self.super_projection_elem(place, location); } @@ -183,36 +183,36 @@ macro_rules! make_mir_visitor { } fn visit_constant(&mut self, - constant: & $($mutability)* Constant<'tcx>, + constant: & $($mutability)? Constant<'tcx>, location: Location) { self.super_constant(constant, location); } fn visit_def_id(&mut self, - def_id: & $($mutability)* DefId, + def_id: & $($mutability)? DefId, _: Location) { self.super_def_id(def_id); } fn visit_span(&mut self, - span: & $($mutability)* Span) { + span: & $($mutability)? Span) { self.super_span(span); } fn visit_source_info(&mut self, - source_info: & $($mutability)* SourceInfo) { + source_info: & $($mutability)? SourceInfo) { self.super_source_info(source_info); } fn visit_ty(&mut self, - ty: & $($mutability)* Ty<'tcx>, + ty: & $($mutability)? Ty<'tcx>, _: TyContext) { self.super_ty(ty); } fn visit_user_type_projection( &mut self, - ty: & $($mutability)* UserTypeProjection<'tcx>, + ty: & $($mutability)? UserTypeProjection<'tcx>, ) { self.super_user_type_projection(ty); } @@ -220,55 +220,55 @@ macro_rules! make_mir_visitor { fn visit_user_type_annotation( &mut self, index: UserTypeAnnotationIndex, - ty: & $($mutability)* CanonicalUserTypeAnnotation<'tcx>, + ty: & $($mutability)? CanonicalUserTypeAnnotation<'tcx>, ) { self.super_user_type_annotation(index, ty); } fn visit_region(&mut self, - region: & $($mutability)* ty::Region<'tcx>, + region: & $($mutability)? ty::Region<'tcx>, _: Location) { self.super_region(region); } fn visit_const(&mut self, - constant: & $($mutability)* &'tcx ty::LazyConst<'tcx>, + constant: & $($mutability)? &'tcx ty::LazyConst<'tcx>, _: Location) { self.super_const(constant); } fn visit_substs(&mut self, - substs: & $($mutability)* &'tcx Substs<'tcx>, + substs: & $($mutability)? &'tcx Substs<'tcx>, _: Location) { self.super_substs(substs); } fn visit_closure_substs(&mut self, - substs: & $($mutability)* ClosureSubsts<'tcx>, + substs: & $($mutability)? ClosureSubsts<'tcx>, _: Location) { self.super_closure_substs(substs); } fn visit_generator_substs(&mut self, - substs: & $($mutability)* GeneratorSubsts<'tcx>, + substs: & $($mutability)? GeneratorSubsts<'tcx>, _: Location) { self.super_generator_substs(substs); } fn visit_local_decl(&mut self, local: Local, - local_decl: & $($mutability)* LocalDecl<'tcx>) { + local_decl: & $($mutability)? LocalDecl<'tcx>) { self.super_local_decl(local, local_decl); } fn visit_local(&mut self, - _local: & $($mutability)* Local, + _local: & $($mutability)? Local, _context: PlaceContext<'tcx>, _location: Location) { } fn visit_source_scope(&mut self, - scope: & $($mutability)* SourceScope) { + scope: & $($mutability)? SourceScope) { self.super_source_scope(scope); } @@ -276,8 +276,8 @@ macro_rules! make_mir_visitor { // not meant to be overridden. fn super_mir(&mut self, - mir: & $($mutability)* Mir<'tcx>) { - if let Some(yield_ty) = &$($mutability)* mir.yield_ty { + mir: & $($mutability)? Mir<'tcx>) { + if let Some(yield_ty) = &$($mutability)? mir.yield_ty { self.visit_ty(yield_ty, TyContext::YieldTy(SourceInfo { span: mir.span, scope: OUTERMOST_SOURCE_SCOPE, @@ -291,21 +291,21 @@ macro_rules! make_mir_visitor { (mut) => (mir.basic_blocks_mut().iter_enumerated_mut()); () => (mir.basic_blocks().iter_enumerated()); }; - for (bb, data) in basic_blocks!($($mutability)*) { + for (bb, data) in basic_blocks!($($mutability)?) { self.visit_basic_block_data(bb, data); } - for scope in &$($mutability)* mir.source_scopes { + for scope in &$($mutability)? mir.source_scopes { self.visit_source_scope_data(scope); } - self.visit_ty(&$($mutability)* mir.return_ty(), TyContext::ReturnTy(SourceInfo { + self.visit_ty(&$($mutability)? mir.return_ty(), TyContext::ReturnTy(SourceInfo { span: mir.span, scope: OUTERMOST_SOURCE_SCOPE, })); for local in mir.local_decls.indices() { - self.visit_local_decl(local, & $($mutability)* mir.local_decls[local]); + self.visit_local_decl(local, & $($mutability)? mir.local_decls[local]); } macro_rules! type_annotations { @@ -313,23 +313,23 @@ macro_rules! make_mir_visitor { () => (mir.user_type_annotations.iter_enumerated()); }; - for (index, annotation) in type_annotations!($($mutability)*) { + for (index, annotation) in type_annotations!($($mutability)?) { self.visit_user_type_annotation( index, annotation ); } - self.visit_span(&$($mutability)* mir.span); + self.visit_span(&$($mutability)? mir.span); } fn super_basic_block_data(&mut self, block: BasicBlock, - data: & $($mutability)* BasicBlockData<'tcx>) { + data: & $($mutability)? BasicBlockData<'tcx>) { let BasicBlockData { - ref $($mutability)* statements, - ref $($mutability)* terminator, + statements, + terminator, is_cleanup: _ - } = *data; + } = data; let mut index = 0; for statement in statements { @@ -338,92 +338,83 @@ macro_rules! make_mir_visitor { index += 1; } - if let Some(ref $($mutability)* terminator) = *terminator { + if let Some(terminator) = terminator { let location = Location { block: block, statement_index: index }; self.visit_terminator(block, terminator, location); } } - fn super_source_scope_data(&mut self, - scope_data: & $($mutability)* SourceScopeData) { + fn super_source_scope_data(&mut self, scope_data: & $($mutability)? SourceScopeData) { let SourceScopeData { - ref $($mutability)* span, - ref $($mutability)* parent_scope, - } = *scope_data; + span, + parent_scope, + } = scope_data; self.visit_span(span); - if let Some(ref $($mutability)* parent_scope) = *parent_scope { + if let Some(parent_scope) = parent_scope { self.visit_source_scope(parent_scope); } } fn super_statement(&mut self, block: BasicBlock, - statement: & $($mutability)* Statement<'tcx>, + statement: & $($mutability)? Statement<'tcx>, location: Location) { let Statement { - ref $($mutability)* source_info, - ref $($mutability)* kind, - } = *statement; + source_info, + kind, + } = statement; self.visit_source_info(source_info); - match *kind { - StatementKind::Assign(ref $($mutability)* place, - ref $($mutability)* rvalue) => { + match kind { + StatementKind::Assign(place, rvalue) => { self.visit_assign(block, place, rvalue, location); } - StatementKind::FakeRead(_, ref $($mutability)* place) => { + StatementKind::FakeRead(_, place) => { self.visit_place( place, PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect), location ); } - StatementKind::SetDiscriminant{ ref $($mutability)* place, .. } => { + StatementKind::SetDiscriminant { place, .. } => { self.visit_place( place, PlaceContext::MutatingUse(MutatingUseContext::Store), location ); } - StatementKind::StorageLive(ref $($mutability)* local) => { + StatementKind::StorageLive(local) => { self.visit_local( local, PlaceContext::NonUse(NonUseContext::StorageLive), location ); } - StatementKind::StorageDead(ref $($mutability)* local) => { + StatementKind::StorageDead(local) => { self.visit_local( local, PlaceContext::NonUse(NonUseContext::StorageDead), location ); } - StatementKind::InlineAsm { ref $($mutability)* outputs, - ref $($mutability)* inputs, - asm: _ } => { - for output in & $($mutability)* outputs[..] { + StatementKind::InlineAsm { outputs, inputs, asm: _ } => { + for output in & $($mutability)? outputs[..] { self.visit_place( output, PlaceContext::MutatingUse(MutatingUseContext::AsmOutput), location ); } - for (span, input) in & $($mutability)* inputs[..] { + for (span, input) in & $($mutability)? inputs[..] { self.visit_span(span); self.visit_operand(input, location); } } - StatementKind::Retag ( ref $($mutability)* kind, - ref $($mutability)* place ) => { + StatementKind::Retag(kind, place) => { self.visit_retag(kind, place, location); } - StatementKind::AscribeUserType( - ref $($mutability)* place, - ref $($mutability)* variance, - ref $($mutability)* user_ty, - ) => { + StatementKind::AscribeUserType(place, variance, user_ty) => { self.visit_ascribe_user_ty(place, variance, user_ty, location); } StatementKind::Nop => {} @@ -432,8 +423,8 @@ macro_rules! make_mir_visitor { fn super_assign(&mut self, _block: BasicBlock, - place: &$($mutability)* Place<'tcx>, - rvalue: &$($mutability)* Rvalue<'tcx>, + place: &$($mutability)? Place<'tcx>, + rvalue: &$($mutability)? Rvalue<'tcx>, location: Location) { self.visit_place( place, @@ -445,12 +436,9 @@ macro_rules! make_mir_visitor { fn super_terminator(&mut self, block: BasicBlock, - terminator: &$($mutability)* Terminator<'tcx>, + terminator: &$($mutability)? Terminator<'tcx>, location: Location) { - let Terminator { - ref $($mutability)* source_info, - ref $($mutability)* kind, - } = *terminator; + let Terminator { source_info, kind } = terminator; self.visit_source_info(source_info); self.visit_terminator_kind(block, kind, location); @@ -458,21 +446,23 @@ macro_rules! make_mir_visitor { fn super_terminator_kind(&mut self, block: BasicBlock, - kind: & $($mutability)* TerminatorKind<'tcx>, + kind: & $($mutability)? TerminatorKind<'tcx>, source_location: Location) { - match *kind { + match kind { TerminatorKind::Goto { target } => { - self.visit_branch(block, target); + self.visit_branch(block, *target); } - TerminatorKind::SwitchInt { ref $($mutability)* discr, - ref $($mutability)* switch_ty, - values: _, - ref targets } => { + TerminatorKind::SwitchInt { + discr, + switch_ty, + values: _, + targets + } => { self.visit_operand(discr, source_location); self.visit_ty(switch_ty, TyContext::Location(source_location)); - for &target in targets { - self.visit_branch(block, target); + for target in targets { + self.visit_branch(block, *target); } } @@ -483,113 +473,120 @@ macro_rules! make_mir_visitor { TerminatorKind::Unreachable => { } - TerminatorKind::Drop { ref $($mutability)* location, - target, - unwind } => { + TerminatorKind::Drop { + location, + target, + unwind, + } => { self.visit_place( location, PlaceContext::MutatingUse(MutatingUseContext::Drop), source_location ); - self.visit_branch(block, target); + self.visit_branch(block, *target); unwind.map(|t| self.visit_branch(block, t)); } - TerminatorKind::DropAndReplace { ref $($mutability)* location, - ref $($mutability)* value, - target, - unwind } => { + TerminatorKind::DropAndReplace { + location, + value, + target, + unwind, + } => { self.visit_place( location, PlaceContext::MutatingUse(MutatingUseContext::Drop), source_location ); self.visit_operand(value, source_location); - self.visit_branch(block, target); + self.visit_branch(block, *target); unwind.map(|t| self.visit_branch(block, t)); } - TerminatorKind::Call { ref $($mutability)* func, - ref $($mutability)* args, - ref $($mutability)* destination, - cleanup, - from_hir_call: _, } => { + TerminatorKind::Call { + func, + args, + destination, + cleanup, + from_hir_call: _, + } => { self.visit_operand(func, source_location); for arg in args { self.visit_operand(arg, source_location); } - if let Some((ref $($mutability)* destination, target)) = *destination { + if let Some((destination, target)) = destination { self.visit_place( destination, PlaceContext::MutatingUse(MutatingUseContext::Call), source_location ); - self.visit_branch(block, target); + self.visit_branch(block, *target); } cleanup.map(|t| self.visit_branch(block, t)); } - TerminatorKind::Assert { ref $($mutability)* cond, - expected: _, - ref $($mutability)* msg, - target, - cleanup } => { + TerminatorKind::Assert { + cond, + expected: _, + msg, + target, + cleanup, + } => { self.visit_operand(cond, source_location); self.visit_assert_message(msg, source_location); - self.visit_branch(block, target); + self.visit_branch(block, *target); cleanup.map(|t| self.visit_branch(block, t)); } - TerminatorKind::Yield { ref $($mutability)* value, - resume, - drop } => { + TerminatorKind::Yield { + value, + resume, + drop, + } => { self.visit_operand(value, source_location); - self.visit_branch(block, resume); + self.visit_branch(block, *resume); drop.map(|t| self.visit_branch(block, t)); } - TerminatorKind::FalseEdges { real_target, ref imaginary_targets} => { - self.visit_branch(block, real_target); + TerminatorKind::FalseEdges { real_target, imaginary_targets } => { + self.visit_branch(block, *real_target); for target in imaginary_targets { self.visit_branch(block, *target); } } TerminatorKind::FalseUnwind { real_target, unwind } => { - self.visit_branch(block, real_target); + self.visit_branch(block, *real_target); if let Some(unwind) = unwind { - self.visit_branch(block, unwind); + self.visit_branch(block, *unwind); } } } } fn super_assert_message(&mut self, - msg: & $($mutability)* AssertMessage<'tcx>, + msg: & $($mutability)? AssertMessage<'tcx>, location: Location) { use crate::mir::interpret::EvalErrorKind::*; - if let BoundsCheck { - ref $($mutability)* len, - ref $($mutability)* index - } = *msg { + if let BoundsCheck { len, index } = msg { self.visit_operand(len, location); self.visit_operand(index, location); } } fn super_rvalue(&mut self, - rvalue: & $($mutability)* Rvalue<'tcx>, + rvalue: & $($mutability)? Rvalue<'tcx>, location: Location) { - match *rvalue { - Rvalue::Use(ref $($mutability)* operand) => { + match rvalue { + Rvalue::Use(operand) => { self.visit_operand(operand, location); } - Rvalue::Repeat(ref $($mutability)* value, _) => { + Rvalue::Repeat(value, _) => { self.visit_operand(value, location); } - Rvalue::Ref(ref $($mutability)* r, bk, ref $($mutability)* path) => { + Rvalue::Ref(r, bk, path) => { self.visit_region(r, location); let ctx = match bk { BorrowKind::Shared => PlaceContext::NonMutatingUse( @@ -607,7 +604,7 @@ macro_rules! make_mir_visitor { self.visit_place(path, ctx, location); } - Rvalue::Len(ref $($mutability)* path) => { + Rvalue::Len(path) => { self.visit_place( path, PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect), @@ -615,28 +612,22 @@ macro_rules! make_mir_visitor { ); } - Rvalue::Cast(_cast_kind, - ref $($mutability)* operand, - ref $($mutability)* ty) => { + Rvalue::Cast(_cast_kind, operand, ty) => { self.visit_operand(operand, location); self.visit_ty(ty, TyContext::Location(location)); } - Rvalue::BinaryOp(_bin_op, - ref $($mutability)* lhs, - ref $($mutability)* rhs) | - Rvalue::CheckedBinaryOp(_bin_op, - ref $($mutability)* lhs, - ref $($mutability)* rhs) => { + Rvalue::BinaryOp(_bin_op, lhs, rhs) + | Rvalue::CheckedBinaryOp(_bin_op, lhs, rhs) => { self.visit_operand(lhs, location); self.visit_operand(rhs, location); } - Rvalue::UnaryOp(_un_op, ref $($mutability)* op) => { + Rvalue::UnaryOp(_un_op, op) => { self.visit_operand(op, location); } - Rvalue::Discriminant(ref $($mutability)* place) => { + Rvalue::Discriminant(place) => { self.visit_place( place, PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect), @@ -644,34 +635,39 @@ macro_rules! make_mir_visitor { ); } - Rvalue::NullaryOp(_op, ref $($mutability)* ty) => { + Rvalue::NullaryOp(_op, ty) => { self.visit_ty(ty, TyContext::Location(location)); } - Rvalue::Aggregate(ref $($mutability)* kind, - ref $($mutability)* operands) => { - let kind = &$($mutability)* **kind; - match *kind { - AggregateKind::Array(ref $($mutability)* ty) => { + Rvalue::Aggregate(kind, operands) => { + let kind = &$($mutability)? **kind; + match kind { + AggregateKind::Array(ty) => { self.visit_ty(ty, TyContext::Location(location)); } AggregateKind::Tuple => { } - AggregateKind::Adt(_adt_def, - _variant_index, - ref $($mutability)* substs, - _user_substs, - _active_field_index) => { + AggregateKind::Adt( + _adt_def, + _variant_index, + substs, + _user_substs, + _active_field_index + ) => { self.visit_substs(substs, location); } - AggregateKind::Closure(ref $($mutability)* def_id, - ref $($mutability)* closure_substs) => { + AggregateKind::Closure( + def_id, + closure_substs + ) => { self.visit_def_id(def_id, location); self.visit_closure_substs(closure_substs, location); } - AggregateKind::Generator(ref $($mutability)* def_id, - ref $($mutability)* generator_substs, - _movability) => { + AggregateKind::Generator( + def_id, + generator_substs, + _movability, + ) => { self.visit_def_id(def_id, location); self.visit_generator_substs(generator_substs, location); } @@ -685,33 +681,33 @@ macro_rules! make_mir_visitor { } fn super_operand(&mut self, - operand: & $($mutability)* Operand<'tcx>, + operand: & $($mutability)? Operand<'tcx>, location: Location) { - match *operand { - Operand::Copy(ref $($mutability)* place) => { + match operand { + Operand::Copy(place) => { self.visit_place( place, PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy), location ); } - Operand::Move(ref $($mutability)* place) => { + Operand::Move(place) => { self.visit_place( place, PlaceContext::NonMutatingUse(NonMutatingUseContext::Move), location ); } - Operand::Constant(ref $($mutability)* constant) => { + Operand::Constant(constant) => { self.visit_constant(constant, location); } } } fn super_ascribe_user_ty(&mut self, - place: & $($mutability)* Place<'tcx>, - _variance: & $($mutability)* ty::Variance, - user_ty: & $($mutability)* UserTypeProjection<'tcx>, + place: & $($mutability)? Place<'tcx>, + _variance: & $($mutability)? ty::Variance, + user_ty: & $($mutability)? UserTypeProjection<'tcx>, location: Location) { self.visit_place( place, @@ -722,8 +718,8 @@ macro_rules! make_mir_visitor { } fn super_retag(&mut self, - _kind: & $($mutability)* RetagKind, - place: & $($mutability)* Place<'tcx>, + _kind: & $($mutability)? RetagKind, + place: & $($mutability)? Place<'tcx>, location: Location) { self.visit_place( place, @@ -733,45 +729,39 @@ macro_rules! make_mir_visitor { } fn super_place(&mut self, - place: & $($mutability)* Place<'tcx>, + place: & $($mutability)? Place<'tcx>, context: PlaceContext<'tcx>, location: Location) { - match *place { - Place::Local(ref $($mutability)* local) => { + match place { + Place::Local(local) => { self.visit_local(local, context, location); } - Place::Static(ref $($mutability)* static_) => { + Place::Static(static_) => { self.visit_static(static_, context, location); } - Place::Promoted(ref $($mutability)* promoted) => { - self.visit_ty(& $($mutability)* promoted.1, TyContext::Location(location)); + Place::Promoted(promoted) => { + self.visit_ty(& $($mutability)? promoted.1, TyContext::Location(location)); }, - Place::Projection(ref $($mutability)* proj) => { + Place::Projection(proj) => { self.visit_projection(proj, context, location); } } } fn super_static(&mut self, - static_: & $($mutability)* Static<'tcx>, + static_: & $($mutability)? Static<'tcx>, _context: PlaceContext<'tcx>, location: Location) { - let Static { - ref $($mutability)* def_id, - ref $($mutability)* ty, - } = *static_; + let Static { def_id, ty } = static_; self.visit_def_id(def_id, location); self.visit_ty(ty, TyContext::Location(location)); } fn super_projection(&mut self, - proj: & $($mutability)* PlaceProjection<'tcx>, + proj: & $($mutability)? PlaceProjection<'tcx>, context: PlaceContext<'tcx>, location: Location) { - let Projection { - ref $($mutability)* base, - ref $($mutability)* elem, - } = *proj; + let Projection { base, elem } = proj; let context = if context.is_mutating_use() { PlaceContext::MutatingUse(MutatingUseContext::Projection) } else { @@ -782,17 +772,17 @@ macro_rules! make_mir_visitor { } fn super_projection_elem(&mut self, - proj: & $($mutability)* PlaceElem<'tcx>, + proj: & $($mutability)? PlaceElem<'tcx>, location: Location) { - match *proj { + match proj { ProjectionElem::Deref => { } ProjectionElem::Subslice { from: _, to: _ } => { } - ProjectionElem::Field(_field, ref $($mutability)* ty) => { + ProjectionElem::Field(_field, ty) => { self.visit_ty(ty, TyContext::Location(location)); } - ProjectionElem::Index(ref $($mutability)* local) => { + ProjectionElem::Index(local) => { self.visit_local( local, PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy), @@ -810,24 +800,24 @@ macro_rules! make_mir_visitor { fn super_local_decl(&mut self, local: Local, - local_decl: & $($mutability)* LocalDecl<'tcx>) { + local_decl: & $($mutability)? LocalDecl<'tcx>) { let LocalDecl { mutability: _, - ref $($mutability)* ty, - ref $($mutability)* user_ty, + ty, + user_ty, name: _, - ref $($mutability)* source_info, - ref $($mutability)* visibility_scope, + source_info, + visibility_scope, internal: _, is_user_variable: _, is_block_tail: _, - } = *local_decl; + } = local_decl; self.visit_ty(ty, TyContext::LocalDecl { local, source_info: *source_info, }); - for (user_ty, _) in & $($mutability)* user_ty.contents { + for (user_ty, _) in & $($mutability)? user_ty.contents { self.visit_user_type_projection(user_ty); } self.visit_source_info(source_info); @@ -835,7 +825,7 @@ macro_rules! make_mir_visitor { } fn super_source_scope(&mut self, - _scope: & $($mutability)* SourceScope) { + _scope: & $($mutability)? SourceScope) { } fn super_branch(&mut self, @@ -844,14 +834,14 @@ macro_rules! make_mir_visitor { } fn super_constant(&mut self, - constant: & $($mutability)* Constant<'tcx>, + constant: & $($mutability)? Constant<'tcx>, location: Location) { let Constant { - ref $($mutability)* span, - ref $($mutability)* ty, - ref $($mutability)* user_ty, - ref $($mutability)* literal, - } = *constant; + span, + ty, + user_ty, + literal, + } = constant; self.visit_span(span); self.visit_ty(ty, TyContext::Location(location)); @@ -859,17 +849,17 @@ macro_rules! make_mir_visitor { self.visit_const(literal, location); } - fn super_def_id(&mut self, _def_id: & $($mutability)* DefId) { + fn super_def_id(&mut self, _def_id: & $($mutability)? DefId) { } - fn super_span(&mut self, _span: & $($mutability)* Span) { + fn super_span(&mut self, _span: & $($mutability)? Span) { } - fn super_source_info(&mut self, source_info: & $($mutability)* SourceInfo) { + fn super_source_info(&mut self, source_info: & $($mutability)? SourceInfo) { let SourceInfo { - ref $($mutability)* span, - ref $($mutability)* scope, - } = *source_info; + span, + scope, + } = source_info; self.visit_span(span); self.visit_source_scope(scope); @@ -877,49 +867,49 @@ macro_rules! make_mir_visitor { fn super_user_type_projection( &mut self, - _ty: & $($mutability)* UserTypeProjection<'tcx>, + _ty: & $($mutability)? UserTypeProjection<'tcx>, ) { } fn super_user_type_annotation( &mut self, _index: UserTypeAnnotationIndex, - ty: & $($mutability)* CanonicalUserTypeAnnotation<'tcx>, + ty: & $($mutability)? CanonicalUserTypeAnnotation<'tcx>, ) { - self.visit_span(& $($mutability)* ty.span); - self.visit_ty(& $($mutability)* ty.inferred_ty, TyContext::UserTy(ty.span)); + self.visit_span(& $($mutability)? ty.span); + self.visit_ty(& $($mutability)? ty.inferred_ty, TyContext::UserTy(ty.span)); } - fn super_ty(&mut self, _ty: & $($mutability)* Ty<'tcx>) { + fn super_ty(&mut self, _ty: & $($mutability)? Ty<'tcx>) { } - fn super_region(&mut self, _region: & $($mutability)* ty::Region<'tcx>) { + fn super_region(&mut self, _region: & $($mutability)? ty::Region<'tcx>) { } - fn super_const(&mut self, _const: & $($mutability)* &'tcx ty::LazyConst<'tcx>) { + fn super_const(&mut self, _const: & $($mutability)? &'tcx ty::LazyConst<'tcx>) { } - fn super_substs(&mut self, _substs: & $($mutability)* &'tcx Substs<'tcx>) { + fn super_substs(&mut self, _substs: & $($mutability)? &'tcx Substs<'tcx>) { } fn super_generator_substs(&mut self, - _substs: & $($mutability)* GeneratorSubsts<'tcx>) { + _substs: & $($mutability)? GeneratorSubsts<'tcx>) { } fn super_closure_substs(&mut self, - _substs: & $($mutability)* ClosureSubsts<'tcx>) { + _substs: & $($mutability)? ClosureSubsts<'tcx>) { } // Convenience methods - fn visit_location(&mut self, mir: & $($mutability)* Mir<'tcx>, location: Location) { - let basic_block = & $($mutability)* mir[location.block]; + fn visit_location(&mut self, mir: & $($mutability)? Mir<'tcx>, location: Location) { + let basic_block = & $($mutability)? mir[location.block]; if basic_block.statements.len() == location.statement_index { - if let Some(ref $($mutability)* terminator) = basic_block.terminator { + if let Some(ref $($mutability)? terminator) = basic_block.terminator { self.visit_terminator(location.block, terminator, location) } } else { - let statement = & $($mutability)* + let statement = & $($mutability)? basic_block.statements[location.statement_index]; self.visit_statement(location.block, statement, location) } From a01efbcbec2123429a7eaa73ce1c9198007af7cf Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sat, 9 Feb 2019 19:58:41 +0100 Subject: [PATCH 235/278] operand-to-place copies should never be overlapping --- src/librustc_mir/interpret/place.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/librustc_mir/interpret/place.rs b/src/librustc_mir/interpret/place.rs index 9ca7f9d8e27ff..3d6fcae0cab8c 100644 --- a/src/librustc_mir/interpret/place.rs +++ b/src/librustc_mir/interpret/place.rs @@ -823,6 +823,8 @@ where let src = match self.try_read_immediate(src)? { Ok(src_val) => { // Yay, we got a value that we can write directly. + // FIXME: Add a check to make sure that if `src` is indirect, + // it does not overlap with `dest`. return self.write_immediate_no_validate(src_val, dest); } Err(mplace) => mplace, @@ -836,7 +838,8 @@ where self.memory.copy( src_ptr, src_align, dest_ptr, dest_align, - dest.layout.size, false + dest.layout.size, + /*nonoverlapping*/ true, )?; Ok(()) From 80942e95ea42e4ffb40dbdf5315f39775368261d Mon Sep 17 00:00:00 2001 From: Mark Rousskov Date: Sat, 9 Feb 2019 19:42:23 -0700 Subject: [PATCH 236/278] Add EmbeddedBook to test list in bootstrap --- src/bootstrap/builder.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs index 8540d92f74917..f512e1d7a0c62 100644 --- a/src/bootstrap/builder.rs +++ b/src/bootstrap/builder.rs @@ -400,6 +400,7 @@ impl<'a> Builder<'a> { test::TheBook, test::UnstableBook, test::RustcBook, + test::EmbeddedBook, test::Rustfmt, test::Miri, test::Clippy, From 2be0993c4e219994b355a06e82394c966a2cfa5d Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Sun, 10 Feb 2019 16:13:30 +0900 Subject: [PATCH 237/278] Revert removed #![feature(nll)] --- src/libfmt_macros/lib.rs | 1 + src/libgraphviz/lib.rs | 1 + src/libpanic_abort/lib.rs | 1 + src/libproc_macro/lib.rs | 1 + src/libprofiler_builtins/lib.rs | 1 + src/librustc_allocator/lib.rs | 1 + src/librustc_apfloat/lib.rs | 1 + src/librustc_asan/lib.rs | 1 + src/librustc_errors/lib.rs | 1 + src/librustc_llvm/lib.rs | 1 + src/librustc_lsan/lib.rs | 1 + src/librustc_msan/lib.rs | 1 + src/librustc_plugin/lib.rs | 1 + src/librustc_privacy/lib.rs | 1 + src/librustc_resolve/lib.rs | 1 + src/librustc_save_analysis/lib.rs | 1 + src/librustc_tsan/lib.rs | 1 + src/libsyntax/lib.rs | 1 + src/libsyntax_ext/lib.rs | 1 + src/libsyntax_pos/lib.rs | 1 + src/libunwind/lib.rs | 1 + 21 files changed, 21 insertions(+) diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index ea67c01dfc9ea..aacd6cec565a5 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -10,6 +10,7 @@ #![deny(rust_2018_idioms)] +#![feature(nll)] #![feature(rustc_private)] pub use Piece::*; diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 8ce0f755df035..fadcfaec4b268 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -276,6 +276,7 @@ #![deny(rust_2018_idioms)] +#![feature(nll)] #![feature(str_escape)] use LabelText::*; diff --git a/src/libpanic_abort/lib.rs b/src/libpanic_abort/lib.rs index 7c6f36ece3c83..edc97cd28a52a 100644 --- a/src/libpanic_abort/lib.rs +++ b/src/libpanic_abort/lib.rs @@ -14,6 +14,7 @@ #![feature(core_intrinsics)] #![feature(libc)] +#![feature(nll)] #![feature(panic_runtime)] #![feature(staged_api)] #![feature(rustc_attrs)] diff --git a/src/libproc_macro/lib.rs b/src/libproc_macro/lib.rs index 2cdc5a48a5316..09a4a964abf09 100644 --- a/src/libproc_macro/lib.rs +++ b/src/libproc_macro/lib.rs @@ -17,6 +17,7 @@ #![deny(rust_2018_idioms)] +#![feature(nll)] #![feature(staged_api)] #![feature(const_fn)] #![feature(extern_types)] diff --git a/src/libprofiler_builtins/lib.rs b/src/libprofiler_builtins/lib.rs index 9c8d3a13b0812..2ce1a110b44c0 100644 --- a/src/libprofiler_builtins/lib.rs +++ b/src/libprofiler_builtins/lib.rs @@ -5,5 +5,6 @@ reason = "internal implementation detail of rustc right now", issue = "0")] #![allow(unused_features)] +#![feature(nll)] #![feature(staged_api)] #![deny(rust_2018_idioms)] diff --git a/src/librustc_allocator/lib.rs b/src/librustc_allocator/lib.rs index 16b9ccfda8010..9d6e728e13557 100644 --- a/src/librustc_allocator/lib.rs +++ b/src/librustc_allocator/lib.rs @@ -1,3 +1,4 @@ +#![feature(nll)] #![feature(rustc_private)] #![deny(rust_2018_idioms)] diff --git a/src/librustc_apfloat/lib.rs b/src/librustc_apfloat/lib.rs index f79d448edce9f..6653df8ffe92e 100644 --- a/src/librustc_apfloat/lib.rs +++ b/src/librustc_apfloat/lib.rs @@ -34,6 +34,7 @@ #![forbid(unsafe_code)] #![deny(rust_2018_idioms)] +#![feature(nll)] #![feature(try_from)] // See librustc_cratesio_shim/Cargo.toml for a comment explaining this. #[allow(unused_extern_crates)] diff --git a/src/librustc_asan/lib.rs b/src/librustc_asan/lib.rs index 568bb540c4719..3bdb86d313dcb 100644 --- a/src/librustc_asan/lib.rs +++ b/src/librustc_asan/lib.rs @@ -1,4 +1,5 @@ #![sanitizer_runtime] +#![feature(nll)] #![feature(sanitizer_runtime)] #![feature(staged_api)] #![no_std] diff --git a/src/librustc_errors/lib.rs b/src/librustc_errors/lib.rs index ea530fa1bfb73..0fc7b59ff1548 100644 --- a/src/librustc_errors/lib.rs +++ b/src/librustc_errors/lib.rs @@ -4,6 +4,7 @@ #![allow(unused_attributes)] #![feature(range_contains)] #![cfg_attr(unix, feature(libc))] +#![feature(nll)] #![feature(optin_builtin_traits)] #![deny(rust_2018_idioms)] diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs index 3fcb20a29ddc9..292ce8b0a01b0 100644 --- a/src/librustc_llvm/lib.rs +++ b/src/librustc_llvm/lib.rs @@ -1,4 +1,5 @@ #![deny(rust_2018_idioms)] +#![feature(nll)] #![feature(static_nobundle)] #![doc(html_root_url = "https://doc.rust-lang.org/nightly/")] diff --git a/src/librustc_lsan/lib.rs b/src/librustc_lsan/lib.rs index 568bb540c4719..3bdb86d313dcb 100644 --- a/src/librustc_lsan/lib.rs +++ b/src/librustc_lsan/lib.rs @@ -1,4 +1,5 @@ #![sanitizer_runtime] +#![feature(nll)] #![feature(sanitizer_runtime)] #![feature(staged_api)] #![no_std] diff --git a/src/librustc_msan/lib.rs b/src/librustc_msan/lib.rs index 568bb540c4719..3bdb86d313dcb 100644 --- a/src/librustc_msan/lib.rs +++ b/src/librustc_msan/lib.rs @@ -1,4 +1,5 @@ #![sanitizer_runtime] +#![feature(nll)] #![feature(sanitizer_runtime)] #![feature(staged_api)] #![no_std] diff --git a/src/librustc_plugin/lib.rs b/src/librustc_plugin/lib.rs index 32e003ff10747..0ea1634c0b4c5 100644 --- a/src/librustc_plugin/lib.rs +++ b/src/librustc_plugin/lib.rs @@ -52,6 +52,7 @@ #![doc(html_root_url = "https://doc.rust-lang.org/nightly/")] +#![feature(nll)] #![feature(rustc_diagnostic_macros)] #![recursion_limit="256"] diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 14a0922c47740..d31dadd340292 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -2,6 +2,7 @@ #![deny(rust_2018_idioms)] +#![feature(nll)] #![feature(rustc_diagnostic_macros)] #![recursion_limit="256"] diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index ecbfcec3c5eb4..ad73b30ae3fd9 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -2,6 +2,7 @@ #![feature(crate_visibility_modifier)] #![feature(label_break_value)] +#![feature(nll)] #![feature(rustc_diagnostic_macros)] #![feature(slice_sort_by_cached_key)] diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index c4a2ebeba6529..1f7b6d7733327 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -1,5 +1,6 @@ #![doc(html_root_url = "https://doc.rust-lang.org/nightly/")] #![feature(custom_attribute)] +#![feature(nll)] #![deny(rust_2018_idioms)] #![allow(unused_attributes)] diff --git a/src/librustc_tsan/lib.rs b/src/librustc_tsan/lib.rs index 568bb540c4719..3bdb86d313dcb 100644 --- a/src/librustc_tsan/lib.rs +++ b/src/librustc_tsan/lib.rs @@ -1,4 +1,5 @@ #![sanitizer_runtime] +#![feature(nll)] #![feature(sanitizer_runtime)] #![feature(staged_api)] #![no_std] diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 878d06c0f1458..c844f9e2a91ee 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -11,6 +11,7 @@ #![feature(crate_visibility_modifier)] #![feature(label_break_value)] +#![feature(nll)] #![feature(rustc_attrs)] #![feature(rustc_diagnostic_macros)] #![feature(slice_sort_by_cached_key)] diff --git a/src/libsyntax_ext/lib.rs b/src/libsyntax_ext/lib.rs index 670d71fe25bb8..7d7fd03085912 100644 --- a/src/libsyntax_ext/lib.rs +++ b/src/libsyntax_ext/lib.rs @@ -9,6 +9,7 @@ #![feature(proc_macro_internals)] #![feature(proc_macro_span)] #![feature(decl_macro)] +#![feature(nll)] #![feature(str_escape)] #![feature(rustc_diagnostic_macros)] diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs index 70c45f7f9a7a6..dbb4f8f8159dc 100644 --- a/src/libsyntax_pos/lib.rs +++ b/src/libsyntax_pos/lib.rs @@ -11,6 +11,7 @@ #![feature(const_fn)] #![feature(crate_visibility_modifier)] #![feature(custom_attribute)] +#![feature(nll)] #![feature(non_exhaustive)] #![feature(optin_builtin_traits)] #![feature(rustc_attrs)] diff --git a/src/libunwind/lib.rs b/src/libunwind/lib.rs index b9a9929ef8b87..0ccffea317053 100644 --- a/src/libunwind/lib.rs +++ b/src/libunwind/lib.rs @@ -4,6 +4,7 @@ #![deny(rust_2018_idioms)] #![feature(link_cfg)] +#![feature(nll)] #![feature(staged_api)] #![feature(unwind_attributes)] #![feature(static_nobundle)] From 3a3691f1878bf3727585c982526c9db5a79c746c Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 10 Feb 2019 12:58:08 +0100 Subject: [PATCH 238/278] when there are multiple filenames, print what got interpreted as 2nd filename --- src/librustc_driver/lib.rs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index a95ce810ffaeb..fe02dd27072f7 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -839,7 +839,15 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { early_error(sopts.error_format, "no input filename given"); } 1 => panic!("make_input should have provided valid inputs"), - _ => early_error(sopts.error_format, "multiple input filenames provided"), + _ => + early_error( + sopts.error_format, + &format!( + "multiple input filenames provided (first two filenames are `{}` and `{}`)", + matches.free[0], + matches.free[1], + ), + ) } } From adb33008f703320727d5022640e9a09cdc4fa8a6 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 10 Feb 2019 13:05:37 +0100 Subject: [PATCH 239/278] rpath computation: explain why we pop() --- src/librustc_codegen_llvm/back/rpath.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/librustc_codegen_llvm/back/rpath.rs b/src/librustc_codegen_llvm/back/rpath.rs index aeff23dec41bb..a5c828e089f39 100644 --- a/src/librustc_codegen_llvm/back/rpath.rs +++ b/src/librustc_codegen_llvm/back/rpath.rs @@ -101,9 +101,9 @@ fn get_rpath_relative_to_output(config: &mut RPathConfig, lib: &Path) -> String let cwd = env::current_dir().unwrap(); let mut lib = fs::canonicalize(&cwd.join(lib)).unwrap_or_else(|_| cwd.join(lib)); - lib.pop(); + lib.pop(); // strip filename let mut output = cwd.join(&config.out_filename); - output.pop(); + output.pop(); // strip filename let output = fs::canonicalize(&output).unwrap_or(output); let relative = path_relative_from(&lib, &output).unwrap_or_else(|| panic!("couldn't create relative path from {:?} to {:?}", output, lib)); From 55f90c77e8eeb114e1bbbb7d7cc536d050c3786b Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 10 Feb 2019 16:21:47 +0300 Subject: [PATCH 240/278] Fix failing tidy (line endings on Windows) --- src/doc/embedded-book | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/doc/embedded-book b/src/doc/embedded-book index d663113d1d9fb..bd2778f304989 160000 --- a/src/doc/embedded-book +++ b/src/doc/embedded-book @@ -1 +1 @@ -Subproject commit d663113d1d9fbd35f1145c29f6080a6350b7f419 +Subproject commit bd2778f304989ee52be8201504d6ec621dd60ca9 From 74e97f338143c78e3cb511d82fba40c9c96cb6a0 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Tue, 5 Feb 2019 14:27:09 +0100 Subject: [PATCH 241/278] Add trait alias support in rustdoc --- src/librustdoc/clean/mod.rs | 39 +++++++++++++++++++++++++--- src/librustdoc/doctree.rs | 44 +++++++++++++++++++++----------- src/librustdoc/html/item_type.rs | 33 ++++++++++++++---------- src/librustdoc/html/render.rs | 42 ++++++++++++++++++++++-------- src/librustdoc/passes/mod.rs | 1 + src/librustdoc/visit_ast.rs | 15 +++++++++-- src/test/rustdoc/trait_alias.rs | 21 +++++++++++++++ 7 files changed, 149 insertions(+), 46 deletions(-) create mode 100644 src/test/rustdoc/trait_alias.rs diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index bd0525583f2cd..64395da74211f 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -517,6 +517,7 @@ pub enum ItemEnum { StaticItem(Static), ConstantItem(Constant), TraitItem(Trait), + TraitAliasItem(TraitAlias), ImplItem(Impl), /// A method signature only. Used for required methods in traits (ie, /// non-default-methods). @@ -554,6 +555,7 @@ impl ItemEnum { ItemEnum::TyMethodItem(ref i) => &i.generics, ItemEnum::MethodItem(ref i) => &i.generics, ItemEnum::ForeignFunctionItem(ref f) => &f.generics, + ItemEnum::TraitAliasItem(ref ta) => &ta.generics, _ => return None, }) } @@ -603,6 +605,7 @@ impl Clean for doctree::Module { items.extend(self.impls.iter().flat_map(|x| x.clean(cx))); items.extend(self.macros.iter().map(|x| x.clean(cx))); items.extend(self.proc_macros.iter().map(|x| x.clean(cx))); + items.extend(self.trait_aliases.iter().map(|x| x.clean(cx))); // determine if we should display the inner contents or // the outer `mod` item for the source code. @@ -1885,13 +1888,41 @@ impl Clean for doctree::Trait { items: self.items.clean(cx), generics: self.generics.clean(cx), bounds: self.bounds.clean(cx), - is_spotlight: is_spotlight, + is_spotlight, is_auto: self.is_auto.clean(cx), }), } } } +#[derive(Clone, RustcEncodable, RustcDecodable, Debug)] +pub struct TraitAlias { + pub generics: Generics, + pub bounds: Vec, + pub is_spotlight: bool, +} + +impl Clean for doctree::TraitAlias { + fn clean(&self, cx: &DocContext) -> Item { + let attrs = self.attrs.clean(cx); + let is_spotlight = attrs.has_doc_flag("spotlight"); + Item { + name: Some(self.name.clean(cx)), + attrs, + source: self.whence.clean(cx), + def_id: cx.tcx.hir().local_def_id(self.id), + visibility: self.vis.clean(cx), + stability: self.stab.clean(cx), + deprecation: self.depr.clean(cx), + inner: TraitAliasItem(TraitAlias { + generics: self.generics.clean(cx), + bounds: self.bounds.clean(cx), + is_spotlight, + }), + } + } +} + impl Clean for hir::IsAuto { fn clean(&self, _: &DocContext) -> bool { match *self { @@ -2223,6 +2254,7 @@ pub enum TypeKind { Macro, Attr, Derive, + TraitAlias, } pub trait GetDefId { @@ -3819,10 +3851,9 @@ pub fn register_def(cx: &DocContext, def: Def) -> DefId { MacroKind::Derive => (i, TypeKind::Derive), MacroKind::ProcMacroStub => unreachable!(), }, + Def::TraitAlias(i) => (i, TypeKind::TraitAlias), Def::SelfTy(Some(def_id), _) => (def_id, TypeKind::Trait), - Def::SelfTy(_, Some(impl_def_id)) => { - return impl_def_id - } + Def::SelfTy(_, Some(impl_def_id)) => return impl_def_id, _ => return def.def_id() }; if did.is_local() { return did } diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs index cc27da70b16d7..e8458385739df 100644 --- a/src/librustdoc/doctree.rs +++ b/src/librustdoc/doctree.rs @@ -38,6 +38,7 @@ pub struct Module { pub foreigns: Vec, pub macros: Vec, pub proc_macros: Vec, + pub trait_aliases: Vec, pub is_crate: bool, } @@ -53,21 +54,22 @@ impl Module { where_inner: syntax_pos::DUMMY_SP, attrs : hir::HirVec::new(), extern_crates: Vec::new(), - imports : Vec::new(), - structs : Vec::new(), - unions : Vec::new(), - enums : Vec::new(), - fns : Vec::new(), - mods : Vec::new(), - typedefs : Vec::new(), - existentials: Vec::new(), - statics : Vec::new(), - constants : Vec::new(), - traits : Vec::new(), - impls : Vec::new(), - foreigns : Vec::new(), - macros : Vec::new(), - proc_macros: Vec::new(), + imports : Vec::new(), + structs : Vec::new(), + unions : Vec::new(), + enums : Vec::new(), + fns : Vec::new(), + mods : Vec::new(), + typedefs : Vec::new(), + existentials: Vec::new(), + statics : Vec::new(), + constants : Vec::new(), + traits : Vec::new(), + impls : Vec::new(), + foreigns : Vec::new(), + macros : Vec::new(), + proc_macros: Vec::new(), + trait_aliases: Vec::new(), is_crate : false, } } @@ -208,6 +210,18 @@ pub struct Trait { pub depr: Option, } +pub struct TraitAlias { + pub name: Name, + pub generics: hir::Generics, + pub bounds: hir::HirVec, + pub attrs: hir::HirVec, + pub id: ast::NodeId, + pub whence: Span, + pub vis: hir::Visibility, + pub stab: Option, + pub depr: Option, +} + #[derive(Debug)] pub struct Impl { pub unsafety: hir::Unsafety, diff --git a/src/librustdoc/html/item_type.rs b/src/librustdoc/html/item_type.rs index e20d385c487b3..8a3b5484f395d 100644 --- a/src/librustdoc/html/item_type.rs +++ b/src/librustdoc/html/item_type.rs @@ -42,6 +42,7 @@ pub enum ItemType { Existential = 22, ProcAttribute = 23, ProcDerive = 24, + TraitAlias = 25, } @@ -86,6 +87,7 @@ impl<'a> From<&'a clean::Item> for ItemType { clean::AssociatedTypeItem(..) => ItemType::AssociatedType, clean::ForeignTypeItem => ItemType::ForeignType, clean::KeywordItem(..) => ItemType::Keyword, + clean::TraitAliasItem(..) => ItemType::TraitAlias, clean::ProcMacroItem(ref mac) => match mac.kind { MacroKind::Bang => ItemType::Macro, MacroKind::Attr => ItemType::ProcAttribute, @@ -100,20 +102,21 @@ impl<'a> From<&'a clean::Item> for ItemType { impl From for ItemType { fn from(kind: clean::TypeKind) -> ItemType { match kind { - clean::TypeKind::Struct => ItemType::Struct, - clean::TypeKind::Union => ItemType::Union, - clean::TypeKind::Enum => ItemType::Enum, - clean::TypeKind::Function => ItemType::Function, - clean::TypeKind::Trait => ItemType::Trait, - clean::TypeKind::Module => ItemType::Module, - clean::TypeKind::Static => ItemType::Static, - clean::TypeKind::Const => ItemType::Constant, - clean::TypeKind::Variant => ItemType::Variant, - clean::TypeKind::Typedef => ItemType::Typedef, - clean::TypeKind::Foreign => ItemType::ForeignType, - clean::TypeKind::Macro => ItemType::Macro, - clean::TypeKind::Attr => ItemType::ProcAttribute, - clean::TypeKind::Derive => ItemType::ProcDerive, + clean::TypeKind::Struct => ItemType::Struct, + clean::TypeKind::Union => ItemType::Union, + clean::TypeKind::Enum => ItemType::Enum, + clean::TypeKind::Function => ItemType::Function, + clean::TypeKind::Trait => ItemType::Trait, + clean::TypeKind::Module => ItemType::Module, + clean::TypeKind::Static => ItemType::Static, + clean::TypeKind::Const => ItemType::Constant, + clean::TypeKind::Variant => ItemType::Variant, + clean::TypeKind::Typedef => ItemType::Typedef, + clean::TypeKind::Foreign => ItemType::ForeignType, + clean::TypeKind::Macro => ItemType::Macro, + clean::TypeKind::Attr => ItemType::ProcAttribute, + clean::TypeKind::Derive => ItemType::ProcDerive, + clean::TypeKind::TraitAlias => ItemType::TraitAlias, } } } @@ -146,6 +149,7 @@ impl ItemType { ItemType::Existential => "existential", ItemType::ProcAttribute => "attr", ItemType::ProcDerive => "derive", + ItemType::TraitAlias => "traitalias", } } @@ -160,6 +164,7 @@ impl ItemType { ItemType::Primitive | ItemType::AssociatedType | ItemType::Existential | + ItemType::TraitAlias | ItemType::ForeignType => NameSpace::Type, ItemType::ExternCrate | diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index a85ac19286af5..9bcf574651539 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -1836,6 +1836,7 @@ struct AllTypes { keywords: FxHashSet, attributes: FxHashSet, derives: FxHashSet, + trait_aliases: FxHashSet, } impl AllTypes { @@ -1856,6 +1857,7 @@ impl AllTypes { keywords: new_set(100), attributes: new_set(100), derives: new_set(100), + trait_aliases: new_set(100), } } @@ -1879,6 +1881,7 @@ impl AllTypes { ItemType::Constant => self.constants.insert(ItemEntry::new(new_url, name)), ItemType::ProcAttribute => self.attributes.insert(ItemEntry::new(new_url, name)), ItemType::ProcDerive => self.derives.insert(ItemEntry::new(new_url, name)), + ItemType::TraitAlias => self.trait_aliases.insert(ItemEntry::new(new_url, name)), _ => true, }; } @@ -1922,6 +1925,7 @@ impl fmt::Display for AllTypes { print_entries(f, &self.derives, "Derive Macros", "derives")?; print_entries(f, &self.functions, "Functions", "functions")?; print_entries(f, &self.typedefs, "Typedefs", "typedefs")?; + print_entries(f, &self.trait_aliases, "Trait Aliases", "trait-alias")?; print_entries(f, &self.existentials, "Existentials", "existentials")?; print_entries(f, &self.statics, "Statics", "statics")?; print_entries(f, &self.constants, "Constants", "constants") @@ -2419,6 +2423,7 @@ impl<'a> fmt::Display for Item<'a> { clean::ForeignTypeItem => write!(fmt, "Foreign Type ")?, clean::KeywordItem(..) => write!(fmt, "Keyword ")?, clean::ExistentialItem(..) => write!(fmt, "Existential Type ")?, + clean::TraitAliasItem(..) => write!(fmt, "Trait Alias ")?, _ => { // We don't generate pages for any other type. unreachable!(); @@ -2457,6 +2462,7 @@ impl<'a> fmt::Display for Item<'a> { clean::ForeignTypeItem => item_foreign_type(fmt, self.cx, self.item), clean::KeywordItem(ref k) => item_keyword(fmt, self.cx, self.item, k), clean::ExistentialItem(ref e, _) => item_existential(fmt, self.cx, self.item, e), + clean::TraitAliasItem(ref ta) => item_trait_alias(fmt, self.cx, self.item, ta), _ => { // We don't generate pages for any other type. unreachable!(); @@ -3014,23 +3020,17 @@ fn render_impls(cx: &Context, w: &mut fmt::Formatter, Ok(()) } -fn bounds(t_bounds: &[clean::GenericBound]) -> String { +fn bounds(t_bounds: &[clean::GenericBound], trait_alias: bool) -> String { let mut bounds = String::new(); - let mut bounds_plain = String::new(); if !t_bounds.is_empty() { - if !bounds.is_empty() { - bounds.push(' '); - bounds_plain.push(' '); + if !trait_alias { + bounds.push_str(": "); } - bounds.push_str(": "); - bounds_plain.push_str(": "); for (i, p) in t_bounds.iter().enumerate() { if i > 0 { bounds.push_str(" + "); - bounds_plain.push_str(" + "); } bounds.push_str(&(*p).to_string()); - bounds_plain.push_str(&format!("{:#}", *p)); } } bounds @@ -3050,7 +3050,7 @@ fn item_trait( it: &clean::Item, t: &clean::Trait, ) -> fmt::Result { - let bounds = bounds(&t.bounds); + let bounds = bounds(&t.bounds, false); let types = t.items.iter().filter(|m| m.is_associated_type()).collect::>(); let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::>(); let required = t.items.iter().filter(|m| m.is_ty_method()).collect::>(); @@ -4280,7 +4280,26 @@ fn item_existential( it.name.as_ref().unwrap(), t.generics, where_clause = WhereClause { gens: &t.generics, indent: 0, end_newline: true }, - bounds = bounds(&t.bounds))?; + bounds = bounds(&t.bounds, false))?; + + document(w, cx, it)?; + + // Render any items associated directly to this alias, as otherwise they + // won't be visible anywhere in the docs. It would be nice to also show + // associated items from the aliased type (see discussion in #32077), but + // we need #14072 to make sense of the generics. + render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All) +} + +fn item_trait_alias(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item, + t: &clean::TraitAlias) -> fmt::Result { + write!(w, "

    ")?;
+    render_attributes(w, it)?;
+    write!(w, "trait {}{}{} = {};
    ", + it.name.as_ref().unwrap(), + t.generics, + WhereClause { gens: &t.generics, indent: 0, end_newline: true }, + bounds(&t.bounds, true))?; document(w, cx, it)?; @@ -4844,6 +4863,7 @@ fn item_ty_to_strs(ty: &ItemType) -> (&'static str, &'static str) { ItemType::Existential => ("existentials", "Existentials"), ItemType::ProcAttribute => ("attributes", "Attribute Macros"), ItemType::ProcDerive => ("derives", "Derive Macros"), + ItemType::TraitAlias => ("trait-alias", "Trait aliases"), } } diff --git a/src/librustdoc/passes/mod.rs b/src/librustdoc/passes/mod.rs index c9a3a2c003fe0..5f3da4c7b33e0 100644 --- a/src/librustdoc/passes/mod.rs +++ b/src/librustdoc/passes/mod.rs @@ -224,6 +224,7 @@ impl<'a> fold::DocFolder for Stripper<'a> { | clean::ConstantItem(..) | clean::UnionItem(..) | clean::AssociatedConstItem(..) + | clean::TraitAliasItem(..) | clean::ForeignTypeItem => { if i.def_id.is_local() { if !self.access_levels.is_exported(i.def_id) { diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index b8eb777a54ba4..352ff788eedae 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -547,8 +547,19 @@ impl<'a, 'tcx, 'rcx> RustdocVisitor<'a, 'tcx, 'rcx> { }; om.traits.push(t); }, - hir::ItemKind::TraitAlias(..) => { - unimplemented!("trait objects are not yet implemented") + hir::ItemKind::TraitAlias(ref gen, ref b) => { + let t = TraitAlias { + name: ident.name, + generics: gen.clone(), + bounds: b.iter().cloned().collect(), + id: item.id, + attrs: item.attrs.clone(), + whence: item.span, + vis: item.vis.clone(), + stab: self.stability(item.id), + depr: self.deprecation(item.id), + }; + om.trait_aliases.push(t); }, hir::ItemKind::Impl(unsafety, diff --git a/src/test/rustdoc/trait_alias.rs b/src/test/rustdoc/trait_alias.rs new file mode 100644 index 0000000000000..2614eda6cca01 --- /dev/null +++ b/src/test/rustdoc/trait_alias.rs @@ -0,0 +1,21 @@ +#![feature(trait_alias)] + +#![crate_name = "foo"] + +use std::fmt::Debug; + +// @has foo/all.html '//a[@href="traitalias.CopyAlias.html"]' 'CopyAlias' +// @has foo/all.html '//a[@href="traitalias.Alias2.html"]' 'Alias2' +// @has foo/all.html '//a[@href="traitalias.Foo.html"]' 'Foo' + +// @has foo/index.html '//h2[@id="trait-alias"]' 'Trait aliases' +// @has foo/index.html '//a[@class="traitalias"]' 'CopyAlias' +// @has foo/index.html '//a[@class="traitalias"]' 'Alias2' +// @has foo/index.html '//a[@class="traitalias"]' 'Foo' + +// @has foo/traitalias.CopyAlias.html '//section[@id="main"]/pre' 'trait CopyAlias = Copy;' +pub trait CopyAlias = Copy; +// @has foo/traitalias.Alias2.html '//section[@id="main"]/pre' 'trait Alias2 = Copy + Debug;' +pub trait Alias2 = Copy + Debug; +// @has foo/traitalias.Foo.html '//section[@id="main"]/pre' 'trait Foo = Into + Debug;' +pub trait Foo = Into + Debug; From 29354ddc15efb0ae7d6a45ca333b780bbe0ed501 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Thu, 7 Feb 2019 01:02:09 +0100 Subject: [PATCH 242/278] Add style for trait aliases --- src/librustdoc/html/static/themes/dark.css | 2 ++ src/librustdoc/html/static/themes/light.css | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/librustdoc/html/static/themes/dark.css b/src/librustdoc/html/static/themes/dark.css index 6935ecde791f8..333fe76a8a4a9 100644 --- a/src/librustdoc/html/static/themes/dark.css +++ b/src/librustdoc/html/static/themes/dark.css @@ -94,6 +94,7 @@ pre { } .content .highlighted a, .content .highlighted span { color: #eee !important; } .content .highlighted.trait { background-color: #013191; } +.content .highlighted.traitalias { background-color: #013191; } .content .highlighted.mod, .content .highlighted.externcrate { background-color: #afc6e4; } .content .highlighted.mod { background-color: #803a1b; } @@ -128,6 +129,7 @@ pre { .content span.externcrate, .content span.mod, .content a.mod, .block a.current.mod { color: #bda000; } .content span.trait, .content a.trait, .block a.current.trait { color: #b78cf2; } +.content span.traitalias, .content a.traitalias, .block a.current.traitalias { color: #b397da; } .content span.fn, .content a.fn, .block a.current.fn, .content span.method, .content a.method, .block a.current.method, .content span.tymethod, .content a.tymethod, .block a.current.tymethod, diff --git a/src/librustdoc/html/static/themes/light.css b/src/librustdoc/html/static/themes/light.css index 306e8dc15d893..19ae67b29881f 100644 --- a/src/librustdoc/html/static/themes/light.css +++ b/src/librustdoc/html/static/themes/light.css @@ -96,6 +96,7 @@ pre { } .content .highlighted a, .content .highlighted span { color: #000 !important; } .content .highlighted.trait { background-color: #c7b6ff; } +.content .highlighted.traitalias { background-color: #c7b6ff; } .content .highlighted.mod, .content .highlighted.externcrate { background-color: #afc6e4; } .content .highlighted.enum { background-color: #b4d1b9; } @@ -128,6 +129,7 @@ pre { .content span.externcrate, .content span.mod, .content a.mod, .block a.current.mod { color: #4d76ae; } .content span.trait, .content a.trait, .block a.current.trait { color: #7c5af3; } +.content span.traitalias, .content a.traitalias, .block a.current.traitalias { color: #6841f1; } .content span.fn, .content a.fn, .block a.current.fn, .content span.method, .content a.method, .block a.current.method, .content span.tymethod, .content a.tymethod, .block a.current.tymethod, From c20357a62aae335b045f61ba01b4a9a1776db992 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Thu, 7 Feb 2019 01:02:23 +0100 Subject: [PATCH 243/278] Add trait aliases to js types --- src/librustdoc/html/static/main.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js index 877ac9a62bbec..3625848dd85c4 100644 --- a/src/librustdoc/html/static/main.js +++ b/src/librustdoc/html/static/main.js @@ -68,7 +68,8 @@ if (!DOMTokenList.prototype.remove) { "keyword", "existential", "attr", - "derive"]; + "derive", + "traitalias"]; var search_input = document.getElementsByClassName("search-input")[0]; @@ -1786,6 +1787,7 @@ if (!DOMTokenList.prototype.remove) { block("type", "Type Definitions"); block("foreigntype", "Foreign Types"); block("keyword", "Keywords"); + block("traitalias", "Trait Aliases"); } window.initSidebarItems = initSidebarItems; From eaf81c2e3ef174c0e257e010e8ee833772c9ec05 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 10 Feb 2019 15:16:25 +0100 Subject: [PATCH 244/278] miri value visitor: use in macro --- src/librustc_mir/interpret/visitor.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/librustc_mir/interpret/visitor.rs b/src/librustc_mir/interpret/visitor.rs index 930bcb44374aa..4ff5cde08d086 100644 --- a/src/librustc_mir/interpret/visitor.rs +++ b/src/librustc_mir/interpret/visitor.rs @@ -125,14 +125,14 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> Value<'a, 'mir, 'tcx, M> } macro_rules! make_value_visitor { - ($visitor_trait_name:ident, $($mutability:ident)*) => { + ($visitor_trait_name:ident, $($mutability:ident)?) => { // How to traverse a value and what to do when we are at the leaves. pub trait $visitor_trait_name<'a, 'mir, 'tcx: 'mir+'a, M: Machine<'a, 'mir, 'tcx>>: Sized { type V: Value<'a, 'mir, 'tcx, M>; /// The visitor must have an `EvalContext` in it. - fn ecx(&$($mutability)* self) - -> &$($mutability)* EvalContext<'a, 'mir, 'tcx, M>; + fn ecx(&$($mutability)? self) + -> &$($mutability)? EvalContext<'a, 'mir, 'tcx, M>; // Recursive actions, ready to be overloaded. /// Visit the given value, dispatching as appropriate to more specialized visitors. From 4853ce660e38f6dd2e686e2c6292f6e004f51d91 Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 10 Feb 2019 15:27:59 +0100 Subject: [PATCH 245/278] it is okay not to use into_inner --- src/libcore/mem.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index 930fe737a7264..3e081b4f0a46a 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -1147,6 +1147,7 @@ impl MaybeUninit { /// Deprecated alternative to `into_initialized`. Will never get stabilized. /// Exists only to transition stdsimd to `into_initialized`. #[inline(always)] + #[allow(unused)] pub(crate) unsafe fn into_inner(self) -> T { self.into_initialized() } From b1d82ac6ed5f224914c7b89b780663bdfd46eb99 Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Sun, 10 Feb 2019 16:56:21 +0100 Subject: [PATCH 246/278] Remove spotlight for trait aliases and fix nits --- src/librustdoc/clean/mod.rs | 3 --- src/librustdoc/html/render.rs | 4 ++-- src/test/rustdoc/trait_alias.rs | 2 +- 3 files changed, 3 insertions(+), 6 deletions(-) diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 64395da74211f..0e607490b643f 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1899,13 +1899,11 @@ impl Clean for doctree::Trait { pub struct TraitAlias { pub generics: Generics, pub bounds: Vec, - pub is_spotlight: bool, } impl Clean for doctree::TraitAlias { fn clean(&self, cx: &DocContext) -> Item { let attrs = self.attrs.clean(cx); - let is_spotlight = attrs.has_doc_flag("spotlight"); Item { name: Some(self.name.clean(cx)), attrs, @@ -1917,7 +1915,6 @@ impl Clean for doctree::TraitAlias { inner: TraitAliasItem(TraitAlias { generics: self.generics.clean(cx), bounds: self.bounds.clean(cx), - is_spotlight, }), } } diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 9bcf574651539..1bd5e00ec9d8c 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -1925,7 +1925,7 @@ impl fmt::Display for AllTypes { print_entries(f, &self.derives, "Derive Macros", "derives")?; print_entries(f, &self.functions, "Functions", "functions")?; print_entries(f, &self.typedefs, "Typedefs", "typedefs")?; - print_entries(f, &self.trait_aliases, "Trait Aliases", "trait-alias")?; + print_entries(f, &self.trait_aliases, "Trait Aliases", "trait-aliases")?; print_entries(f, &self.existentials, "Existentials", "existentials")?; print_entries(f, &self.statics, "Statics", "statics")?; print_entries(f, &self.constants, "Constants", "constants") @@ -4863,7 +4863,7 @@ fn item_ty_to_strs(ty: &ItemType) -> (&'static str, &'static str) { ItemType::Existential => ("existentials", "Existentials"), ItemType::ProcAttribute => ("attributes", "Attribute Macros"), ItemType::ProcDerive => ("derives", "Derive Macros"), - ItemType::TraitAlias => ("trait-alias", "Trait aliases"), + ItemType::TraitAlias => ("trait-aliases", "Trait aliases"), } } diff --git a/src/test/rustdoc/trait_alias.rs b/src/test/rustdoc/trait_alias.rs index 2614eda6cca01..98b8d879ac078 100644 --- a/src/test/rustdoc/trait_alias.rs +++ b/src/test/rustdoc/trait_alias.rs @@ -8,7 +8,7 @@ use std::fmt::Debug; // @has foo/all.html '//a[@href="traitalias.Alias2.html"]' 'Alias2' // @has foo/all.html '//a[@href="traitalias.Foo.html"]' 'Foo' -// @has foo/index.html '//h2[@id="trait-alias"]' 'Trait aliases' +// @has foo/index.html '//h2[@id="trait-aliases"]' 'Trait aliases' // @has foo/index.html '//a[@class="traitalias"]' 'CopyAlias' // @has foo/index.html '//a[@class="traitalias"]' 'Alias2' // @has foo/index.html '//a[@class="traitalias"]' 'Foo' From 998e58452238056adfdf9c12542dd777a8dd0bb0 Mon Sep 17 00:00:00 2001 From: Pietro Albini Date: Sun, 10 Feb 2019 18:36:00 +0100 Subject: [PATCH 247/278] bump cargo submodule --- src/tools/cargo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/cargo b/src/tools/cargo index 4e74e2fc09085..865cb70106a6b 160000 --- a/src/tools/cargo +++ b/src/tools/cargo @@ -1 +1 @@ -Subproject commit 4e74e2fc0908524d17735c768067117d3e84ee9c +Subproject commit 865cb70106a6b1171a500ff68f93ab52eea56e72 From 4833074a9a47c12bcfeee4435bf981981ede689c Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Sun, 10 Feb 2019 19:08:49 +0100 Subject: [PATCH 248/278] fix SGX build failures --- src/libstd/sys/sgx/ext/arch.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libstd/sys/sgx/ext/arch.rs b/src/libstd/sys/sgx/ext/arch.rs index 3bd87b5d26574..97f7d9181a539 100644 --- a/src/libstd/sys/sgx/ext/arch.rs +++ b/src/libstd/sys/sgx/ext/arch.rs @@ -41,7 +41,7 @@ pub fn egetkey(request: &Align512<[u8; 512]>) -> Result, u32> ); match error { - 0 => Ok(out.into_inner()), + 0 => Ok(out.into_initialized()), err => Err(err), } } @@ -69,6 +69,6 @@ pub fn ereport( "{rdx}"(report.as_mut_ptr()) ); - report.into_inner() + report.into_initialized() } } From c3e182cf43aea2c010a1915eb37293a458df2228 Mon Sep 17 00:00:00 2001 From: Alexander Regueiro Date: Fri, 8 Feb 2019 14:53:55 +0100 Subject: [PATCH 249/278] rustc: doc comments --- src/bootstrap/builder.rs | 10 +- src/bootstrap/cache.rs | 4 +- src/bootstrap/check.rs | 2 +- src/bootstrap/clean.rs | 2 +- src/bootstrap/compile.rs | 8 +- src/bootstrap/dist.rs | 2 +- src/bootstrap/doc.rs | 8 +- src/bootstrap/lib.rs | 18 +- src/bootstrap/test.rs | 16 +- src/bootstrap/tool.rs | 4 +- src/bootstrap/util.rs | 2 +- src/build_helper/lib.rs | 6 +- src/libcore/str/mod.rs | 4 +- src/libcore/str/pattern.rs | 4 +- src/libgraphviz/lib.rs | 4 +- src/libpanic_unwind/dummy.rs | 4 +- src/libpanic_unwind/dwarf/eh.rs | 2 +- src/libpanic_unwind/dwarf/mod.rs | 2 +- src/libpanic_unwind/emcc.rs | 6 +- src/libpanic_unwind/gcc.rs | 10 +- src/librustc/dep_graph/debug.rs | 2 +- src/librustc/dep_graph/dep_node.rs | 6 +- src/librustc/dep_graph/dep_tracking_map.rs | 2 +- src/librustc/dep_graph/graph.rs | 46 +-- src/librustc/hir/check_attr.rs | 10 +- src/librustc/hir/def.rs | 2 +- src/librustc/hir/def_id.rs | 2 +- src/librustc/hir/intravisit.rs | 16 +- src/librustc/hir/lowering.rs | 26 +- src/librustc/hir/map/blocks.rs | 6 +- src/librustc/hir/map/def_collector.rs | 2 +- src/librustc/hir/map/definitions.rs | 52 +-- src/librustc/hir/map/mod.rs | 24 +- src/librustc/hir/mod.rs | 331 +++++++++--------- src/librustc/hir/pat_util.rs | 10 +- src/librustc/infer/at.rs | 24 +- src/librustc/infer/canonical/canonicalizer.rs | 10 +- src/librustc/infer/canonical/mod.rs | 4 +- .../infer/canonical/query_response.rs | 6 +- src/librustc/infer/combine.rs | 10 +- src/librustc/infer/error_reporting/mod.rs | 4 +- .../nice_region_error/different_lifetimes.rs | 2 +- src/librustc/infer/fudge.rs | 4 +- src/librustc/infer/higher_ranked/mod.rs | 2 +- src/librustc/infer/lattice.rs | 4 +- .../infer/lexical_region_resolve/mod.rs | 10 +- src/librustc/infer/mod.rs | 38 +- src/librustc/infer/nll_relate/mod.rs | 16 +- src/librustc/infer/opaque_types/mod.rs | 23 +- src/librustc/infer/outlives/env.rs | 2 +- .../infer/outlives/free_region_map.rs | 2 +- src/librustc/infer/outlives/obligations.rs | 2 +- src/librustc/infer/outlives/verify.rs | 8 +- src/librustc/infer/region_constraints/mod.rs | 80 +++-- src/librustc/infer/type_variable.rs | 8 +- src/librustc/lint/context.rs | 10 +- src/librustc/lint/mod.rs | 18 +- src/librustc/middle/expr_use_visitor.rs | 6 +- src/librustc/middle/free_region.rs | 22 +- src/librustc/middle/liveness.rs | 56 +-- src/librustc/middle/mem_categorization.rs | 16 +- src/librustc/middle/region.rs | 46 +-- src/librustc/middle/resolve_lifetime.rs | 22 +- src/librustc/middle/stability.rs | 4 +- src/librustc/middle/weak_lang_items.rs | 2 +- src/librustc/mir/interpret/allocation.rs | 20 +- src/librustc/mir/interpret/error.rs | 4 +- src/librustc/mir/interpret/mod.rs | 14 +- src/librustc/mir/interpret/value.rs | 15 +- src/librustc/mir/mod.rs | 66 ++-- src/librustc/mir/mono.rs | 2 +- src/librustc/mir/tcx.rs | 2 +- src/librustc/session/config.rs | 10 +- src/librustc/session/mod.rs | 30 +- src/librustc/traits/auto_trait.rs | 2 +- src/librustc/traits/codegen/mod.rs | 4 +- src/librustc/traits/coherence.rs | 10 +- src/librustc/traits/error_reporting.rs | 4 +- src/librustc/traits/fulfill.rs | 6 +- src/librustc/traits/mod.rs | 73 ++-- src/librustc/traits/object_safety.rs | 40 ++- src/librustc/traits/project.rs | 23 +- src/librustc/traits/query/dropck_outlives.rs | 2 +- src/librustc/traits/query/normalize.rs | 2 +- .../traits/query/normalize_erasing_regions.rs | 2 +- src/librustc/traits/query/outlives_bounds.rs | 4 +- .../traits/query/type_op/normalize.rs | 2 +- src/librustc/traits/select.rs | 47 ++- src/librustc/traits/specialize/mod.rs | 8 +- .../traits/specialize/specialization_graph.rs | 4 +- src/librustc/ty/adjustment.rs | 22 +- src/librustc/ty/constness.rs | 2 +- src/librustc/ty/context.rs | 22 +- src/librustc/ty/fold.rs | 46 +-- .../ty/inhabitedness/def_id_forest.rs | 10 +- src/librustc/ty/instance.rs | 12 +- src/librustc/ty/item_path.rs | 12 +- src/librustc/ty/layout.rs | 6 +- src/librustc/ty/mod.rs | 130 +++---- src/librustc/ty/query/job.rs | 19 +- src/librustc/ty/query/mod.rs | 38 +- src/librustc/ty/query/on_disk_cache.rs | 10 +- src/librustc/ty/query/plumbing.rs | 36 +- src/librustc/ty/relate.rs | 2 +- src/librustc/ty/steal.rs | 6 +- src/librustc/ty/sty.rs | 94 ++--- src/librustc/ty/subst.rs | 24 +- src/librustc/ty/trait_def.rs | 6 +- src/librustc/ty/util.rs | 43 +-- src/librustc/ty/wf.rs | 4 +- src/librustc/util/common.rs | 8 +- src/librustc/util/nodemap.rs | 2 +- src/librustc/util/ppaux.rs | 31 +- src/librustc_apfloat/ieee.rs | 20 +- src/librustc_apfloat/lib.rs | 30 +- src/librustc_borrowck/borrowck/check_loans.rs | 2 +- .../borrowck/gather_loans/lifetime.rs | 2 +- .../borrowck/gather_loans/mod.rs | 2 +- src/librustc_borrowck/borrowck/mod.rs | 4 +- src/librustc_borrowck/borrowck/move_data.rs | 8 +- src/librustc_borrowck/dataflow.rs | 2 +- src/librustc_codegen_llvm/abi.rs | 4 +- src/librustc_codegen_llvm/back/archive.rs | 2 +- src/librustc_codegen_llvm/back/link.rs | 2 +- src/librustc_codegen_llvm/back/lto.rs | 2 +- src/librustc_codegen_llvm/back/wasm.rs | 2 +- src/librustc_codegen_llvm/base.rs | 10 +- src/librustc_codegen_llvm/callee.rs | 4 +- src/librustc_codegen_llvm/context.rs | 4 +- .../debuginfo/create_scope_map.rs | 2 +- src/librustc_codegen_llvm/debuginfo/doc.rs | 4 +- src/librustc_codegen_llvm/debuginfo/mod.rs | 2 +- src/librustc_codegen_llvm/debuginfo/utils.rs | 2 +- src/librustc_codegen_llvm/llvm/ffi.rs | 2 +- src/librustc_codegen_llvm/type_of.rs | 2 +- src/librustc_codegen_ssa/back/linker.rs | 4 +- src/librustc_codegen_ssa/back/write.rs | 4 +- src/librustc_codegen_ssa/base.rs | 16 +- src/librustc_codegen_ssa/lib.rs | 4 +- src/librustc_codegen_ssa/mir/block.rs | 2 +- src/librustc_codegen_ssa/mir/mod.rs | 2 +- src/librustc_codegen_ssa/mir/place.rs | 10 +- src/librustc_codegen_ssa/traits/declare.rs | 6 +- src/librustc_codegen_ssa/traits/type_.rs | 4 +- src/librustc_data_structures/base_n.rs | 2 +- src/librustc_data_structures/bit_set.rs | 40 +-- .../graph/implementation/mod.rs | 4 +- src/librustc_data_structures/graph/scc/mod.rs | 2 +- src/librustc_data_structures/indexed_vec.rs | 10 +- .../obligation_forest/graphviz.rs | 4 +- .../obligation_forest/mod.rs | 20 +- .../owning_ref/mod.rs | 14 +- src/librustc_data_structures/sip128.rs | 4 +- src/librustc_data_structures/svh.rs | 2 +- .../transitive_relation.rs | 14 +- src/librustc_data_structures/work_queue.rs | 6 +- src/librustc_driver/driver.rs | 6 +- src/librustc_driver/lib.rs | 8 +- src/librustc_driver/test.rs | 10 +- src/librustc_errors/diagnostic.rs | 2 +- src/librustc_errors/diagnostic_builder.rs | 4 +- src/librustc_errors/emitter.rs | 6 +- src/librustc_errors/lib.rs | 2 +- src/librustc_fs_util/lib.rs | 2 +- src/librustc_incremental/assert_dep_graph.rs | 2 +- .../persist/dirty_clean.rs | 23 +- .../persist/file_format.rs | 6 +- src/librustc_incremental/persist/fs.rs | 4 +- src/librustc_lint/builtin.rs | 29 +- src/librustc_lint/types.rs | 2 +- src/librustc_metadata/creader.rs | 2 +- src/librustc_metadata/cstore.rs | 6 +- src/librustc_metadata/decoder.rs | 2 +- src/librustc_metadata/dynamic_lib.rs | 2 +- src/librustc_metadata/index_builder.rs | 10 +- src/librustc_metadata/locator.rs | 4 +- src/librustc_mir/borrow_check/borrow_set.rs | 12 +- .../borrow_check/error_reporting.rs | 10 +- src/librustc_mir/borrow_check/mod.rs | 30 +- .../borrow_check/mutability_errors.rs | 2 +- .../borrow_check/nll/constraints/graph.rs | 4 +- .../borrow_check/nll/constraints/mod.rs | 4 +- .../borrow_check/nll/explain_borrow/mod.rs | 4 +- src/librustc_mir/borrow_check/nll/facts.rs | 2 +- .../borrow_check/nll/invalidation.rs | 12 +- .../borrow_check/nll/region_infer/dump_mir.rs | 2 +- .../nll/region_infer/error_reporting/mod.rs | 4 +- .../error_reporting/region_name.rs | 16 +- .../borrow_check/nll/region_infer/mod.rs | 30 +- .../borrow_check/nll/region_infer/values.rs | 14 +- .../nll/type_check/free_region_relations.rs | 12 +- .../nll/type_check/liveness/liveness_map.rs | 2 +- .../nll/type_check/liveness/mod.rs | 4 +- .../nll/type_check/liveness/trace.rs | 10 +- .../borrow_check/nll/type_check/mod.rs | 4 +- .../borrow_check/nll/type_check/relate_tys.rs | 2 +- .../borrow_check/nll/universal_regions.rs | 32 +- src/librustc_mir/borrow_check/path_utils.rs | 2 +- src/librustc_mir/borrow_check/place_ext.rs | 2 +- .../borrow_check/places_conflict.rs | 4 +- src/librustc_mir/build/matches/mod.rs | 10 +- src/librustc_mir/build/matches/test.rs | 2 +- src/librustc_mir/build/misc.rs | 2 +- src/librustc_mir/build/mod.rs | 50 +-- src/librustc_mir/build/scope.rs | 6 +- src/librustc_mir/const_eval.rs | 10 +- src/librustc_mir/dataflow/at_location.rs | 4 +- .../dataflow/drop_flag_effects.rs | 4 +- src/librustc_mir/dataflow/graphviz.rs | 4 +- src/librustc_mir/dataflow/impls/mod.rs | 7 - src/librustc_mir/dataflow/mod.rs | 26 +- .../dataflow/move_paths/abs_domain.rs | 10 +- src/librustc_mir/hair/cx/mod.rs | 14 +- src/librustc_mir/hair/mod.rs | 2 +- src/librustc_mir/hair/pattern/_match.rs | 22 +- src/librustc_mir/hair/pattern/check_match.rs | 7 +- src/librustc_mir/hair/pattern/mod.rs | 24 +- src/librustc_mir/interpret/eval_context.rs | 10 +- src/librustc_mir/interpret/intrinsics.rs | 6 +- src/librustc_mir/interpret/machine.rs | 24 +- src/librustc_mir/interpret/memory.rs | 14 +- src/librustc_mir/interpret/operand.rs | 8 +- src/librustc_mir/interpret/place.rs | 18 +- src/librustc_mir/interpret/step.rs | 2 +- src/librustc_mir/interpret/traits.rs | 2 +- src/librustc_mir/interpret/validity.rs | 2 +- src/librustc_mir/interpret/visitor.rs | 22 +- src/librustc_mir/monomorphize/item.rs | 2 +- src/librustc_mir/monomorphize/partitioning.rs | 2 +- src/librustc_mir/shim.rs | 4 +- src/librustc_mir/transform/check_unsafety.rs | 4 +- src/librustc_mir/transform/elaborate_drops.rs | 2 +- src/librustc_mir/transform/erase_regions.rs | 4 +- src/librustc_mir/transform/mod.rs | 2 +- src/librustc_mir/transform/promote_consts.rs | 2 +- src/librustc_mir/transform/qualify_consts.rs | 6 +- .../transform/qualify_min_const_fn.rs | 2 +- .../transform/remove_noop_landing_pads.rs | 2 +- src/librustc_mir/util/alignment.rs | 2 +- src/librustc_mir/util/def_use.rs | 2 +- src/librustc_mir/util/elaborate_drops.rs | 14 +- src/librustc_mir/util/liveness.rs | 29 +- src/librustc_passes/ast_validation.rs | 30 +- src/librustc_passes/rvalue_promotion.rs | 8 +- src/librustc_plugin/build.rs | 2 +- src/librustc_plugin/lib.rs | 2 +- src/librustc_plugin/registry.rs | 2 +- src/librustc_privacy/lib.rs | 8 +- src/librustc_resolve/build_reduced_graph.rs | 6 +- src/librustc_resolve/lib.rs | 96 ++--- src/librustc_resolve/macros.rs | 20 +- src/librustc_resolve/resolve_imports.rs | 8 +- src/librustc_save_analysis/dump_visitor.rs | 8 +- src/librustc_save_analysis/lib.rs | 2 +- src/librustc_target/abi/call/mod.rs | 12 +- src/librustc_target/abi/mod.rs | 22 +- src/librustc_target/lib.rs | 2 +- src/librustc_target/spec/mod.rs | 10 +- src/librustc_traits/chalk_context/mod.rs | 12 +- src/librustc_traits/dropck_outlives.rs | 2 +- src/librustc_typeck/astconv.rs | 14 +- src/librustc_typeck/check/callee.rs | 6 +- src/librustc_typeck/check/cast.rs | 4 +- src/librustc_typeck/check/closure.rs | 4 +- src/librustc_typeck/check/coercion.rs | 22 +- src/librustc_typeck/check/compare_method.rs | 8 +- src/librustc_typeck/check/dropck.rs | 11 +- src/librustc_typeck/check/intrinsic.rs | 2 +- src/librustc_typeck/check/method/mod.rs | 14 +- src/librustc_typeck/check/method/probe.rs | 6 +- src/librustc_typeck/check/method/suggest.rs | 4 +- src/librustc_typeck/check/mod.rs | 54 +-- src/librustc_typeck/check/op.rs | 8 +- src/librustc_typeck/check/regionck.rs | 36 +- src/librustc_typeck/check/wfcheck.rs | 6 +- src/librustc_typeck/check_unused.rs | 2 +- src/librustc_typeck/coherence/mod.rs | 2 +- src/librustc_typeck/coherence/orphan.rs | 2 +- src/librustc_typeck/collect.rs | 24 +- .../constrained_type_params.rs | 8 +- src/librustc_typeck/impl_wf_check.rs | 6 +- src/librustc_typeck/lib.rs | 2 +- .../outlives/implicit_infer.rs | 2 +- src/librustc_typeck/variance/constraints.rs | 2 +- src/librustdoc/clean/cfg.rs | 4 +- src/librustdoc/clean/mod.rs | 10 +- src/librustdoc/clean/simplify.rs | 6 +- src/librustdoc/config.rs | 14 +- src/librustdoc/core.rs | 2 +- src/librustdoc/html/escape.rs | 4 +- src/librustdoc/html/format.rs | 6 +- src/librustdoc/html/highlight.rs | 2 +- src/librustdoc/html/markdown.rs | 10 +- src/librustdoc/html/render.rs | 16 +- src/librustdoc/html/toc.rs | 2 +- src/librustdoc/markdown.rs | 2 +- .../passes/collect_intra_doc_links.rs | 4 +- src/librustdoc/passes/mod.rs | 2 +- src/librustdoc/visit_ast.rs | 2 +- src/libserialize/hex.rs | 2 +- src/libserialize/json.rs | 70 ++-- src/libserialize/serialize.rs | 2 +- src/libsyntax/ast.rs | 29 +- src/libsyntax/attr/builtin.rs | 6 +- src/libsyntax/attr/mod.rs | 6 +- src/libsyntax/config.rs | 8 +- src/libsyntax/diagnostics/metadata.rs | 4 +- src/libsyntax/ext/base.rs | 34 +- src/libsyntax/ext/build.rs | 2 +- src/libsyntax/ext/expand.rs | 2 +- src/libsyntax/ext/tt/macro_parser.rs | 18 +- src/libsyntax/ext/tt/macro_rules.rs | 8 +- src/libsyntax/ext/tt/quoted.rs | 18 +- src/libsyntax/feature_gate.rs | 7 +- src/libsyntax/json.rs | 2 +- src/libsyntax/parse/lexer/comments.rs | 6 +- src/libsyntax/parse/lexer/mod.rs | 12 +- src/libsyntax/parse/mod.rs | 43 ++- src/libsyntax/parse/parser.rs | 319 +++++++++-------- src/libsyntax/parse/token.rs | 20 +- src/libsyntax/print/pp.rs | 4 +- src/libsyntax/ptr.rs | 2 +- src/libsyntax/source_map.rs | 18 +- src/libsyntax/tokenstream.rs | 5 +- src/libsyntax/util/lev_distance.rs | 4 +- src/libsyntax/util/parser.rs | 4 +- src/libsyntax/util/parser_testing.rs | 2 +- src/libsyntax/visit.rs | 6 +- src/libsyntax_ext/deriving/decodable.rs | 2 +- src/libsyntax_ext/deriving/encodable.rs | 4 +- src/libsyntax_ext/deriving/generic/mod.rs | 16 +- src/libsyntax_ext/format.rs | 6 +- src/libsyntax_ext/format_foreign.rs | 2 +- src/libsyntax_pos/analyze_source_file.rs | 4 +- src/libsyntax_pos/hygiene.rs | 4 +- src/libsyntax_pos/lib.rs | 42 +-- src/libsyntax_pos/symbol.rs | 12 +- src/libterm/lib.rs | 12 +- src/libterm/terminfo/mod.rs | 8 +- src/libterm/terminfo/parm.rs | 2 +- src/libterm/terminfo/parser/compiled.rs | 2 +- src/libterm/terminfo/searcher.rs | 2 +- src/libterm/win.rs | 5 +- 343 files changed, 2260 insertions(+), 2241 deletions(-) diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs index f512e1d7a0c62..78ba1d376be79 100644 --- a/src/bootstrap/builder.rs +++ b/src/bootstrap/builder.rs @@ -60,17 +60,17 @@ pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash { /// Run this rule for all hosts without cross compiling. const ONLY_HOSTS: bool = false; - /// Primary function to execute this rule. Can call `builder.ensure(...)` + /// Primary function to execute this rule. Can call `builder.ensure()` /// with other steps to run those. fn run(self, builder: &Builder) -> Self::Output; /// When bootstrap is passed a set of paths, this controls whether this rule /// will execute. However, it does not get called in a "default" context - /// when we are not passed any paths; in that case, make_run is called + /// when we are not passed any paths; in that case, `make_run` is called /// directly. fn should_run(run: ShouldRun) -> ShouldRun; - /// Build up a "root" rule, either as a default rule or from a path passed + /// Builds up a "root" rule, either as a default rule or from a path passed /// to us. /// /// When path is `None`, we are executing in a context where no paths were @@ -648,7 +648,7 @@ impl<'a> Builder<'a> { add_lib_path(vec![self.rustc_libdir(compiler)], cmd); } - /// Get a path to the compiler specified. + /// Gets a path to the compiler specified. pub fn rustc(&self, compiler: Compiler) -> PathBuf { if compiler.is_snapshot(self) { self.initial_rustc.clone() @@ -659,7 +659,7 @@ impl<'a> Builder<'a> { } } - /// Get the paths to all of the compiler's codegen backends. + /// Gets the paths to all of the compiler's codegen backends. fn codegen_backends(&self, compiler: Compiler) -> impl Iterator { fs::read_dir(self.sysroot_codegen_backends(compiler)) .into_iter() diff --git a/src/bootstrap/cache.rs b/src/bootstrap/cache.rs index ea8bc657a57aa..5f84816789a68 100644 --- a/src/bootstrap/cache.rs +++ b/src/bootstrap/cache.rs @@ -227,10 +227,10 @@ lazy_static! { pub static ref INTERNER: Interner = Interner::default(); } -/// This is essentially a HashMap which allows storing any type in its input and +/// This is essentially a `HashMap` which allows storing any type in its input and /// any type in its output. It is a write-once cache; values are never evicted, /// which means that references to the value can safely be returned from the -/// get() method. +/// `get()` method. #[derive(Debug)] pub struct Cache( RefCell String { let mut features = "panic-unwind".to_string(); @@ -521,7 +521,7 @@ impl Build { features } - /// Get the space-separated set of activated features for the compiler. + /// Gets the space-separated set of activated features for the compiler. fn rustc_features(&self) -> String { let mut features = String::new(); if self.config.jemalloc { @@ -609,7 +609,7 @@ impl Build { self.out.join(&*target).join("crate-docs") } - /// Returns true if no custom `llvm-config` is set for the specified target. + /// Returns `true` if no custom `llvm-config` is set for the specified target. /// /// If no custom `llvm-config` was specified then Rust's llvm will be used. fn is_rust_llvm(&self, target: Interned) -> bool { @@ -857,13 +857,13 @@ impl Build { .map(|p| &**p) } - /// Returns true if this is a no-std `target`, if defined + /// Returns `true` if this is a no-std `target`, if defined fn no_std(&self, target: Interned) -> Option { self.config.target_config.get(&target) .map(|t| t.no_std) } - /// Returns whether the target will be tested using the `remote-test-client` + /// Returns `true` if the target will be tested using the `remote-test-client` /// and `remote-test-server` binaries. fn remote_tested(&self, target: Interned) -> bool { self.qemu_rootfs(target).is_some() || target.contains("android") || @@ -1059,7 +1059,7 @@ impl Build { self.rust_info.version(self, channel::CFG_RELEASE_NUM) } - /// Return the full commit hash + /// Returns the full commit hash. fn rust_sha(&self) -> Option<&str> { self.rust_info.sha() } @@ -1079,7 +1079,7 @@ impl Build { panic!("failed to find version in {}'s Cargo.toml", package) } - /// Returns whether unstable features should be enabled for the compiler + /// Returns `true` if unstable features should be enabled for the compiler /// we're building. fn unstable_features(&self) -> bool { match &self.config.channel[..] { @@ -1327,7 +1327,7 @@ impl<'a> Compiler { self } - /// Returns whether this is a snapshot compiler for `build`'s configuration + /// Returns `true` if this is a snapshot compiler for `build`'s configuration pub fn is_snapshot(&self, build: &Build) -> bool { self.stage == 0 && self.host == build.build } diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs index bb00f6f625130..a882550f734f4 100644 --- a/src/bootstrap/test.rs +++ b/src/bootstrap/test.rs @@ -30,9 +30,9 @@ const ADB_TEST_DIR: &str = "/data/tmp/work"; /// The two modes of the test runner; tests or benchmarks. #[derive(Debug, PartialEq, Eq, Hash, Copy, Clone, PartialOrd, Ord)] pub enum TestKind { - /// Run `cargo test` + /// Run `cargo test`. Test, - /// Run `cargo bench` + /// Run `cargo bench`. Bench, } @@ -1288,7 +1288,7 @@ impl Step for DocTest { run.never() } - /// Run `rustdoc --test` for all documentation in `src/doc`. + /// Runs `rustdoc --test` for all documentation in `src/doc`. /// /// This will run all tests in our markdown documentation (e.g., the book) /// located in `src/doc`. The `rustdoc` that's run is the one that sits next to @@ -1408,7 +1408,7 @@ impl Step for ErrorIndex { }); } - /// Run the error index generator tool to execute the tests located in the error + /// Runs the error index generator tool to execute the tests located in the error /// index. /// /// The `error_index_generator` tool lives in `src/tools` and is used to @@ -1614,7 +1614,7 @@ impl Step for Crate { } } - /// Run all unit tests plus documentation tests for a given crate defined + /// Runs all unit tests plus documentation tests for a given crate defined /// by a `Cargo.toml` (single manifest) /// /// This is what runs tests for crates like the standard library, compiler, etc. @@ -1833,7 +1833,7 @@ fn envify(s: &str) -> String { /// the standard library and such to the emulator ahead of time. This step /// represents this and is a dependency of all test suites. /// -/// Most of the time this is a noop. For some steps such as shipping data to +/// Most of the time this is a no-op. For some steps such as shipping data to /// QEMU we have to build our own tools so we've got conditional dependencies /// on those programs as well. Note that the remote test client is built for /// the build target (us) and the server is built for the target. @@ -1904,7 +1904,7 @@ impl Step for Distcheck { run.builder.ensure(Distcheck); } - /// Run "distcheck", a 'make check' from a tarball + /// Runs "distcheck", a 'make check' from a tarball fn run(self, builder: &Builder) { builder.info("Distcheck"); let dir = builder.out.join("tmp").join("distcheck"); @@ -1965,7 +1965,7 @@ impl Step for Bootstrap { const DEFAULT: bool = true; const ONLY_HOSTS: bool = true; - /// Test the build system itself + /// Tests the build system itself. fn run(self, builder: &Builder) { let mut cmd = Command::new(&builder.initial_cargo); cmd.arg("test") diff --git a/src/bootstrap/tool.rs b/src/bootstrap/tool.rs index cd3afc59e560c..c09e9332895d8 100644 --- a/src/bootstrap/tool.rs +++ b/src/bootstrap/tool.rs @@ -40,7 +40,7 @@ impl Step for ToolBuild { run.never() } - /// Build a tool in `src/tools` + /// Builds a tool in `src/tools` /// /// This will build the specified tool with the specified `host` compiler in /// `stage` into the normal cargo output directory. @@ -621,7 +621,7 @@ tool_extended!((self, builder), ); impl<'a> Builder<'a> { - /// Get a `Command` which is ready to run `tool` in `stage` built for + /// Gets a `Command` which is ready to run `tool` in `stage` built for /// `host`. pub fn tool_cmd(&self, tool: Tool) -> Command { let mut cmd = Command::new(self.tool_exe(tool)); diff --git a/src/bootstrap/util.rs b/src/bootstrap/util.rs index 37c6c040da8e8..29aa98971fb56 100644 --- a/src/bootstrap/util.rs +++ b/src/bootstrap/util.rs @@ -33,7 +33,7 @@ pub fn exe(name: &str, target: &str) -> String { } } -/// Returns whether the file name given looks like a dynamic library. +/// Returns `true` if the file name given looks like a dynamic library. pub fn is_dylib(name: &str) -> bool { name.ends_with(".dylib") || name.ends_with(".so") || name.ends_with(".dll") } diff --git a/src/build_helper/lib.rs b/src/build_helper/lib.rs index 93aa91768121c..bd99dc118e66a 100644 --- a/src/build_helper/lib.rs +++ b/src/build_helper/lib.rs @@ -163,7 +163,7 @@ pub fn mtime(path: &Path) -> SystemTime { .unwrap_or(UNIX_EPOCH) } -/// Returns whether `dst` is up to date given that the file or files in `src` +/// Returns `true` if `dst` is up to date given that the file or files in `src` /// are used to generate it. /// /// Uses last-modified time checks to verify this. @@ -190,12 +190,12 @@ pub struct NativeLibBoilerplate { } impl NativeLibBoilerplate { - /// On OSX we don't want to ship the exact filename that compiler-rt builds. + /// On macOS we don't want to ship the exact filename that compiler-rt builds. /// This conflicts with the system and ours is likely a wildly different /// version, so they can't be substituted. /// /// As a result, we rename it here but we need to also use - /// `install_name_tool` on OSX to rename the commands listed inside of it to + /// `install_name_tool` on macOS to rename the commands listed inside of it to /// ensure it's linked against correctly. pub fn fixup_sanitizer_lib_name(&self, sanitizer_name: &str) { if env::var("TARGET").unwrap() != "x86_64-apple-darwin" { diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index e9190cc3ddf1b..81c351be30502 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -1,6 +1,6 @@ -//! String manipulation +//! String manipulation. //! -//! For more details, see std::str +//! For more details, see the `std::str` module. #![stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libcore/str/pattern.rs b/src/libcore/str/pattern.rs index 55a7ba181e527..e5a75cdbbcce0 100644 --- a/src/libcore/str/pattern.rs +++ b/src/libcore/str/pattern.rs @@ -1,7 +1,7 @@ //! The string Pattern API. //! -//! For more details, see the traits `Pattern`, `Searcher`, -//! `ReverseSearcher` and `DoubleEndedSearcher`. +//! For more details, see the traits [`Pattern`], [`Searcher`], +//! [`ReverseSearcher`], and [`DoubleEndedSearcher`]. #![unstable(feature = "pattern", reason = "API not fully fleshed out and ready to be stabilized", diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 8ce0f755df035..a445e70ca995a 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -392,7 +392,7 @@ impl<'a> Id<'a> { /// digit (i.e., the regular expression `[a-zA-Z_][a-zA-Z_0-9]*`). /// /// (Note: this format is a strict subset of the `ID` format - /// defined by the DOT language. This function may change in the + /// defined by the DOT language. This function may change in the /// future to accept a broader subset, or the entirety, of DOT's /// `ID` format.) /// @@ -529,7 +529,7 @@ impl<'a> LabelText<'a> { } /// Decomposes content into string suitable for making EscStr that - /// yields same content as self. The result obeys the law + /// yields same content as self. The result obeys the law /// render(`lt`) == render(`EscStr(lt.pre_escaped_content())`) for /// all `lt: LabelText`. fn pre_escaped_content(self) -> Cow<'a, str> { diff --git a/src/libpanic_unwind/dummy.rs b/src/libpanic_unwind/dummy.rs index b052f76e2a3a8..3a00d6376658c 100644 --- a/src/libpanic_unwind/dummy.rs +++ b/src/libpanic_unwind/dummy.rs @@ -1,6 +1,6 @@ -//! Unwinding for wasm32 +//! Unwinding for *wasm32* target. //! -//! Right now we don't support this, so this is just stubs +//! Right now we don't support this, so this is just stubs. use alloc::boxed::Box; use core::any::Any; diff --git a/src/libpanic_unwind/dwarf/eh.rs b/src/libpanic_unwind/dwarf/eh.rs index ce7fab8584a28..ce24406b55642 100644 --- a/src/libpanic_unwind/dwarf/eh.rs +++ b/src/libpanic_unwind/dwarf/eh.rs @@ -6,7 +6,7 @@ //! http://www.airs.com/blog/archives/464 //! //! A reference implementation may be found in the GCC source tree -//! (/libgcc/unwind-c.c as of this writing) +//! (`/libgcc/unwind-c.c` as of this writing). #![allow(non_upper_case_globals)] #![allow(unused)] diff --git a/src/libpanic_unwind/dwarf/mod.rs b/src/libpanic_unwind/dwarf/mod.rs index eb5fb81f61b83..0360696426dc9 100644 --- a/src/libpanic_unwind/dwarf/mod.rs +++ b/src/libpanic_unwind/dwarf/mod.rs @@ -1,5 +1,5 @@ //! Utilities for parsing DWARF-encoded data streams. -//! See http://www.dwarfstd.org, +//! See , //! DWARF-4 standard, Section 7 - "Data Representation" // This module is used only by x86_64-pc-windows-gnu for now, but we diff --git a/src/libpanic_unwind/emcc.rs b/src/libpanic_unwind/emcc.rs index 45c9244a46fcd..1f5ccfb0f1210 100644 --- a/src/libpanic_unwind/emcc.rs +++ b/src/libpanic_unwind/emcc.rs @@ -1,9 +1,9 @@ -//! Unwinding for emscripten +//! Unwinding for *emscripten* target. //! //! Whereas Rust's usual unwinding implementation for Unix platforms -//! calls into the libunwind APIs directly, on emscripten we instead +//! calls into the libunwind APIs directly, on Emscripten we instead //! call into the C++ unwinding APIs. This is just an expedience since -//! emscripten's runtime always implements those APIs and does not +//! Emscripten's runtime always implements those APIs and does not //! implement libunwind. #![allow(private_no_mangle_fns)] diff --git a/src/libpanic_unwind/gcc.rs b/src/libpanic_unwind/gcc.rs index 065403aba1b98..607fe28e3f28d 100644 --- a/src/libpanic_unwind/gcc.rs +++ b/src/libpanic_unwind/gcc.rs @@ -1,4 +1,4 @@ -//! Implementation of panics backed by libgcc/libunwind (in some form) +//! Implementation of panics backed by libgcc/libunwind (in some form). //! //! For background on exception handling and stack unwinding please see //! "Exception Handling in LLVM" (llvm.org/docs/ExceptionHandling.html) and @@ -23,14 +23,14 @@ //! //! In the search phase, the job of a personality routine is to examine //! exception object being thrown, and to decide whether it should be caught at -//! that stack frame. Once the handler frame has been identified, cleanup phase +//! that stack frame. Once the handler frame has been identified, cleanup phase //! begins. //! //! In the cleanup phase, the unwinder invokes each personality routine again. //! This time it decides which (if any) cleanup code needs to be run for -//! the current stack frame. If so, the control is transferred to a special +//! the current stack frame. If so, the control is transferred to a special //! branch in the function body, the "landing pad", which invokes destructors, -//! frees memory, etc. At the end of the landing pad, control is transferred +//! frees memory, etc. At the end of the landing pad, control is transferred //! back to the unwinder and unwinding resumes. //! //! Once stack has been unwound down to the handler frame level, unwinding stops @@ -39,7 +39,7 @@ //! ## `eh_personality` and `eh_unwind_resume` //! //! These language items are used by the compiler when generating unwind info. -//! The first one is the personality routine described above. The second one +//! The first one is the personality routine described above. The second one //! allows compilation target to customize the process of resuming unwind at the //! end of the landing pads. `eh_unwind_resume` is used only if //! `custom_unwind_resume` flag in the target options is set. diff --git a/src/librustc/dep_graph/debug.rs b/src/librustc/dep_graph/debug.rs index a9ad22c5e913e..f18ee3dced72d 100644 --- a/src/librustc/dep_graph/debug.rs +++ b/src/librustc/dep_graph/debug.rs @@ -22,7 +22,7 @@ impl DepNodeFilter { } } - /// True if all nodes always pass the filter. + /// Returns `true` if all nodes always pass the filter. pub fn accepts_all(&self) -> bool { self.text.is_empty() } diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs index 58087b76266b5..796739c872174 100644 --- a/src/librustc/dep_graph/dep_node.rs +++ b/src/librustc/dep_graph/dep_node.rs @@ -302,7 +302,7 @@ macro_rules! define_dep_nodes { } } - /// Create a new, parameterless DepNode. This method will assert + /// Creates a new, parameterless DepNode. This method will assert /// that the DepNode corresponding to the given DepKind actually /// does not require any parameters. #[inline(always)] @@ -314,7 +314,7 @@ macro_rules! define_dep_nodes { } } - /// Extract the DefId corresponding to this DepNode. This will work + /// Extracts the DefId corresponding to this DepNode. This will work /// if two conditions are met: /// /// 1. The Fingerprint of the DepNode actually is a DefPathHash, and @@ -798,7 +798,7 @@ impl<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> DepNodeParams<'a, 'gcx, 'tcx> for HirId { } /// A "work product" corresponds to a `.o` (or other) file that we -/// save in between runs. These ids do not have a DefId but rather +/// save in between runs. These IDs do not have a `DefId` but rather /// some independent path or string that persists between runs without /// the need to be mapped or unmapped. (This ensures we can serialize /// them even in the absence of a tcx.) diff --git a/src/librustc/dep_graph/dep_tracking_map.rs b/src/librustc/dep_graph/dep_tracking_map.rs index a296a3379c2ac..94b832bea628e 100644 --- a/src/librustc/dep_graph/dep_tracking_map.rs +++ b/src/librustc/dep_graph/dep_tracking_map.rs @@ -43,7 +43,7 @@ impl MemoizationMap for RefCell> { /// /// Here, `[op]` represents whatever nodes `op` reads in the /// course of execution; `Map(key)` represents the node for this - /// map; and `CurrentTask` represents the current task when + /// map, and `CurrentTask` represents the current task when /// `memoize` is invoked. /// /// **Important:** when `op` is invoked, the current task will be diff --git a/src/librustc/dep_graph/graph.rs b/src/librustc/dep_graph/graph.rs index e8c1cd36064e1..59ec459de9641 100644 --- a/src/librustc/dep_graph/graph.rs +++ b/src/librustc/dep_graph/graph.rs @@ -61,13 +61,13 @@ struct DepGraphData { colors: DepNodeColorMap, - /// A set of loaded diagnostics which has been emitted. + /// A set of loaded diagnostics that have been emitted. emitted_diagnostics: Mutex>, /// Used to wait for diagnostics to be emitted. emitted_diagnostics_cond_var: Condvar, - /// When we load, there may be `.o` files, cached mir, or other such + /// When we load, there may be `.o` files, cached MIR, or other such /// things available to us. If we find that they are not dirty, we /// load the path to the file storing those work-products here into /// this map. We can later look for and extract that data. @@ -115,7 +115,7 @@ impl DepGraph { } } - /// True if we are actually building the full dep-graph. + /// Returns `true` if we are actually building the full dep-graph, and `false` otherwise. #[inline] pub fn is_fully_enabled(&self) -> bool { self.data.is_some() @@ -320,8 +320,8 @@ impl DepGraph { } } - /// Execute something within an "anonymous" task, that is, a task the - /// DepNode of which is determined by the list of inputs it read from. + /// Executes something within an "anonymous" task, that is, a task the + /// `DepNode` of which is determined by the list of inputs it read from. pub fn with_anon_task(&self, dep_kind: DepKind, op: OP) -> (R, DepNodeIndex) where OP: FnOnce() -> R { @@ -356,8 +356,8 @@ impl DepGraph { } } - /// Execute something within an "eval-always" task which is a task - // that runs whenever anything changes. + /// Executes something within an "eval-always" task which is a task + /// that runs whenever anything changes. pub fn with_eval_always_task<'a, C, A, R>( &self, key: DepNode, @@ -438,7 +438,7 @@ impl DepGraph { self.data.as_ref().unwrap().previous.node_to_index(dep_node) } - /// Check whether a previous work product exists for `v` and, if + /// Checks whether a previous work product exists for `v` and, if /// so, return the path that leads to it. Used to skip doing work. pub fn previous_work_product(&self, v: &WorkProductId) -> Option { self.data @@ -589,7 +589,7 @@ impl DepGraph { } } - /// Try to mark a dep-node which existed in the previous compilation session as green + /// Try to mark a dep-node which existed in the previous compilation session as green. fn try_mark_previous_green<'tcx>( &self, tcx: TyCtxt<'_, 'tcx, 'tcx>, @@ -773,8 +773,8 @@ impl DepGraph { Some(dep_node_index) } - /// Atomically emits some loaded diagnotics assuming that this only gets called with - /// did_allocation set to true on one thread + /// Atomically emits some loaded diagnotics, assuming that this only gets called with + /// `did_allocation` set to `true` on a single thread. #[cold] #[inline(never)] fn emit_diagnostics<'tcx>( @@ -913,7 +913,7 @@ impl DepGraph { #[derive(Clone, Debug, RustcEncodable, RustcDecodable)] pub struct WorkProduct { pub cgu_name: String, - /// Saved files associated with this CGU + /// Saved files associated with this CGU. pub saved_files: Vec<(WorkProductFileKind, String)>, } @@ -937,17 +937,17 @@ pub(super) struct CurrentDepGraph { #[allow(dead_code)] forbidden_edge: Option, - // Anonymous DepNodes are nodes the ID of which we compute from the list of - // their edges. This has the beneficial side-effect that multiple anonymous - // nodes can be coalesced into one without changing the semantics of the - // dependency graph. However, the merging of nodes can lead to a subtle - // problem during red-green marking: The color of an anonymous node from - // the current session might "shadow" the color of the node with the same - // ID from the previous session. In order to side-step this problem, we make - // sure that anon-node IDs allocated in different sessions don't overlap. - // This is implemented by mixing a session-key into the ID fingerprint of - // each anon node. The session-key is just a random number generated when - // the DepGraph is created. + /// Anonymous `DepNode`s are nodes whose IDs we compute from the list of + /// their edges. This has the beneficial side-effect that multiple anonymous + /// nodes can be coalesced into one without changing the semantics of the + /// dependency graph. However, the merging of nodes can lead to a subtle + /// problem during red-green marking: The color of an anonymous node from + /// the current session might "shadow" the color of the node with the same + /// ID from the previous session. In order to side-step this problem, we make + /// sure that anonymous `NodeId`s allocated in different sessions don't overlap. + /// This is implemented by mixing a session-key into the ID fingerprint of + /// each anon node. The session-key is just a random number generated when + /// the `DepGraph` is created. anon_id_seed: Fingerprint, total_read_count: u64, diff --git a/src/librustc/hir/check_attr.rs b/src/librustc/hir/check_attr.rs index ba340ad251f2a..ddc1eebe645ae 100644 --- a/src/librustc/hir/check_attr.rs +++ b/src/librustc/hir/check_attr.rs @@ -91,7 +91,7 @@ struct CheckAttrVisitor<'a, 'tcx: 'a> { } impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> { - /// Check any attribute. + /// Checks any attribute. fn check_attributes(&self, item: &hir::Item, target: Target) { if target == Target::Fn || target == Target::Const { self.tcx.codegen_fn_attrs(self.tcx.hir().local_def_id(item.id)); @@ -115,7 +115,7 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> { self.check_used(item, target); } - /// Check if an `#[inline]` is applied to a function or a closure. + /// Checks if an `#[inline]` is applied to a function or a closure. fn check_inline(&self, attr: &hir::Attribute, span: &Span, target: Target) { if target != Target::Fn && target != Target::Closure { struct_span_err!(self.tcx.sess, @@ -127,7 +127,7 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> { } } - /// Check if the `#[non_exhaustive]` attribute on an `item` is valid. + /// Checks if the `#[non_exhaustive]` attribute on an `item` is valid. fn check_non_exhaustive(&self, attr: &hir::Attribute, item: &hir::Item, target: Target) { match target { Target::Struct | Target::Enum => { /* Valid */ }, @@ -143,7 +143,7 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> { } } - /// Check if the `#[marker]` attribute on an `item` is valid. + /// Checks if the `#[marker]` attribute on an `item` is valid. fn check_marker(&self, attr: &hir::Attribute, item: &hir::Item, target: Target) { match target { Target::Trait => { /* Valid */ }, @@ -157,7 +157,7 @@ impl<'a, 'tcx> CheckAttrVisitor<'a, 'tcx> { } } - /// Check if the `#[repr]` attributes on `item` are valid. + /// Checks if the `#[repr]` attributes on `item` are valid. fn check_repr(&self, item: &hir::Item, target: Target) { // Extract the names of all repr hints, e.g., [foo, bar, align] for: // ``` diff --git a/src/librustc/hir/def.rs b/src/librustc/hir/def.rs index 15efa7650293c..b15bea017762e 100644 --- a/src/librustc/hir/def.rs +++ b/src/librustc/hir/def.rs @@ -182,7 +182,7 @@ impl ::std::ops::IndexMut for PerNS { } impl PerNS> { - /// Returns whether all the items in this collection are `None`. + /// Returns `true` if all the items in this collection are `None`. pub fn is_empty(&self) -> bool { self.type_ns.is_none() && self.value_ns.is_none() && self.macro_ns.is_none() } diff --git a/src/librustc/hir/def_id.rs b/src/librustc/hir/def_id.rs index e06f09e21cbf3..ed1c15a73c260 100644 --- a/src/librustc/hir/def_id.rs +++ b/src/librustc/hir/def_id.rs @@ -229,7 +229,7 @@ impl fmt::Debug for DefId { } impl DefId { - /// Make a local `DefId` with the given index. + /// Makes a local `DefId` from the given `DefIndex`. #[inline] pub fn local(index: DefIndex) -> DefId { DefId { krate: LOCAL_CRATE, index: index } diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index 86c3fb9e4fcd7..9436c600c9fd3 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -4,7 +4,7 @@ //! `super::itemlikevisit::ItemLikeVisitor` trait.** //! //! If you have decided to use this visitor, here are some general -//! notes on how to do it: +//! notes on how to do so: //! //! Each overridden visit method has full control over what //! happens with its node, it can do its own traversal of the node's children, @@ -86,7 +86,7 @@ pub enum NestedVisitorMap<'this, 'tcx: 'this> { /// using this setting. OnlyBodies(&'this Map<'tcx>), - /// Visit all nested things, including item-likes. + /// Visits all nested things, including item-likes. /// /// **This is an unusual choice.** It is used when you want to /// process everything within their lexical context. Typically you @@ -96,7 +96,7 @@ pub enum NestedVisitorMap<'this, 'tcx: 'this> { impl<'this, 'tcx> NestedVisitorMap<'this, 'tcx> { /// Returns the map to use for an "intra item-like" thing (if any). - /// e.g., function body. + /// E.g., function body. pub fn intra(self) -> Option<&'this Map<'tcx>> { match self { NestedVisitorMap::None => None, @@ -106,7 +106,7 @@ impl<'this, 'tcx> NestedVisitorMap<'this, 'tcx> { } /// Returns the map to use for an "item-like" thing (if any). - /// e.g., item, impl-item. + /// E.g., item, impl-item. pub fn inter(self) -> Option<&'this Map<'tcx>> { match self { NestedVisitorMap::None => None, @@ -117,7 +117,7 @@ impl<'this, 'tcx> NestedVisitorMap<'this, 'tcx> { } /// Each method of the Visitor trait is a hook to be potentially -/// overridden. Each method's default implementation recursively visits +/// overridden. Each method's default implementation recursively visits /// the substructure of the input via the corresponding `walk` method; /// e.g., the `visit_mod` method by default calls `intravisit::walk_mod`. /// @@ -129,7 +129,7 @@ impl<'this, 'tcx> NestedVisitorMap<'this, 'tcx> { /// on `visit_nested_item` for details on how to visit nested items. /// /// If you want to ensure that your code handles every variant -/// explicitly, you need to override each method. (And you also need +/// explicitly, you need to override each method. (And you also need /// to monitor future changes to `Visitor` in case a new method with a /// new default implementation gets introduced.) pub trait Visitor<'v> : Sized { @@ -203,7 +203,7 @@ pub trait Visitor<'v> : Sized { } } - /// Visit the top-level item and (optionally) nested items / impl items. See + /// Visits the top-level item and (optionally) nested items / impl items. See /// `visit_nested_item` for details. fn visit_item(&mut self, i: &'v Item) { walk_item(self, i) @@ -214,7 +214,7 @@ pub trait Visitor<'v> : Sized { } /// When invoking `visit_all_item_likes()`, you need to supply an - /// item-like visitor. This method converts a "intra-visit" + /// item-like visitor. This method converts a "intra-visit" /// visitor into an item-like visitor that walks the entire tree. /// If you use this, you probably don't want to process the /// contents of nested item-like things, since the outer loop will diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 3de41b1665d6d..8ce6d14012223 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -3,24 +3,24 @@ //! Since the AST and HIR are fairly similar, this is mostly a simple procedure, //! much like a fold. Where lowering involves a bit more work things get more //! interesting and there are some invariants you should know about. These mostly -//! concern spans and ids. +//! concern spans and IDs. //! //! Spans are assigned to AST nodes during parsing and then are modified during //! expansion to indicate the origin of a node and the process it went through -//! being expanded. Ids are assigned to AST nodes just before lowering. +//! being expanded. IDs are assigned to AST nodes just before lowering. //! -//! For the simpler lowering steps, ids and spans should be preserved. Unlike +//! For the simpler lowering steps, IDs and spans should be preserved. Unlike //! expansion we do not preserve the process of lowering in the spans, so spans //! should not be modified here. When creating a new node (as opposed to -//! 'folding' an existing one), then you create a new id using `next_id()`. +//! 'folding' an existing one), then you create a new ID using `next_id()`. //! -//! You must ensure that ids are unique. That means that you should only use the -//! id from an AST node in a single HIR node (you can assume that AST node ids -//! are unique). Every new node must have a unique id. Avoid cloning HIR nodes. -//! If you do, you must then set the new node's id to a fresh one. +//! You must ensure that IDs are unique. That means that you should only use the +//! ID from an AST node in a single HIR node (you can assume that AST node IDs +//! are unique). Every new node must have a unique ID. Avoid cloning HIR nodes. +//! If you do, you must then set the new node's ID to a fresh one. //! //! Spans are used for error messages and for tools to map semantics back to -//! source code. It is therefore not as important with spans as ids to be strict +//! source code. It is therefore not as important with spans as IDs to be strict //! about use (you can't break the compiler by screwing up a span). Obviously, a //! HIR node can only have a single span. But multiple nodes can have the same //! span and spans don't need to be kept in order, etc. Where code is preserved @@ -144,7 +144,7 @@ pub trait Resolver { is_value: bool, ) -> hir::Path; - /// Obtain the resolution for a node-id. + /// Obtain the resolution for a `NodeId`. fn get_resolution(&mut self, id: NodeId) -> Option; /// Obtain the possible resolutions for the given `use` statement. @@ -273,10 +273,10 @@ enum ParenthesizedGenericArgs { } /// What to do when we encounter an **anonymous** lifetime -/// reference. Anonymous lifetime references come in two flavors. You +/// reference. Anonymous lifetime references come in two flavors. You /// have implicit, or fully elided, references to lifetimes, like the /// one in `&T` or `Ref`, and you have `'_` lifetimes, like `&'_ T` -/// or `Ref<'_, T>`. These often behave the same, but not always: +/// or `Ref<'_, T>`. These often behave the same, but not always: /// /// - certain usages of implicit references are deprecated, like /// `Ref`, and we sometimes just give hard errors in those cases @@ -3287,7 +3287,7 @@ impl<'a> LoweringContext<'a> { /// Paths like the visibility path in `pub(super) use foo::{bar, baz}` are repeated /// many times in the HIR tree; for each occurrence, we need to assign distinct - /// node-ids. (See e.g., #56128.) + /// `NodeId`s. (See, e.g., #56128.) fn renumber_segment_ids(&mut self, path: &P) -> P { debug!("renumber_segment_ids(path = {:?})", path); let mut path = path.clone(); diff --git a/src/librustc/hir/map/blocks.rs b/src/librustc/hir/map/blocks.rs index d5fb578d8d492..6919628c76755 100644 --- a/src/librustc/hir/map/blocks.rs +++ b/src/librustc/hir/map/blocks.rs @@ -1,9 +1,9 @@ //! This module provides a simplified abstraction for working with -//! code blocks identified by their integer node-id. In particular, +//! code blocks identified by their integer `NodeId`. In particular, //! it captures a common set of attributes that all "function-like -//! things" (represented by `FnLike` instances) share. For example, +//! things" (represented by `FnLike` instances) share. For example, //! all `FnLike` instances have a type signature (be it explicit or -//! inferred). And all `FnLike` instances have a body, i.e., the code +//! inferred). And all `FnLike` instances have a body, i.e., the code //! that is run when the function-like thing it represents is invoked. //! //! With the above abstraction in place, one can treat the program diff --git a/src/librustc/hir/map/def_collector.rs b/src/librustc/hir/map/def_collector.rs index 02fb503e752b5..8fe10a85ef380 100644 --- a/src/librustc/hir/map/def_collector.rs +++ b/src/librustc/hir/map/def_collector.rs @@ -12,7 +12,7 @@ use syntax_pos::Span; use crate::hir::map::{ITEM_LIKE_SPACE, REGULAR_SPACE}; -/// Creates def ids for nodes in the AST. +/// Creates `DefId`s for nodes in the AST. pub struct DefCollector<'a> { definitions: &'a mut Definitions, parent_def: Option, diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs index 84e9cde6df160..f454d691d4188 100644 --- a/src/librustc/hir/map/definitions.rs +++ b/src/librustc/hir/map/definitions.rs @@ -1,5 +1,5 @@ -//! For each definition, we track the following data. A definition -//! here is defined somewhat circularly as "something with a def-id", +//! For each definition, we track the following data. A definition +//! here is defined somewhat circularly as "something with a `DefId`", //! but it generally corresponds to things like structs, enums, etc. //! There are also some rather random cases (like const initializer //! expressions) that are mostly just leftovers. @@ -163,10 +163,10 @@ pub struct Definitions { /// any) with a `DisambiguatedDefPathData`. #[derive(Clone, PartialEq, Debug, Hash, RustcEncodable, RustcDecodable)] pub struct DefKey { - /// Parent path. + /// The parent path. pub parent: Option, - /// Identifier of this node. + /// The identifier of this node. pub disambiguated_data: DisambiguatedDefPathData, } @@ -207,12 +207,12 @@ impl DefKey { } } -/// Pair of `DefPathData` and an integer disambiguator. The integer is +/// A pair of `DefPathData` and an integer disambiguator. The integer is /// normally 0, but in the event that there are multiple defs with the /// same `parent` and `data`, we use this field to disambiguate /// between them. This introduces some artificial ordering dependency /// but means that if you have (e.g.) two impls for the same type in -/// the same module, they do get distinct def-ids. +/// the same module, they do get distinct `DefId`s. #[derive(Clone, PartialEq, Debug, Hash, RustcEncodable, RustcDecodable)] pub struct DisambiguatedDefPathData { pub data: DefPathData, @@ -221,10 +221,10 @@ pub struct DisambiguatedDefPathData { #[derive(Clone, Debug, Hash, RustcEncodable, RustcDecodable)] pub struct DefPath { - /// the path leading from the crate root to the item + /// The path leading from the crate root to the item. pub data: Vec, - /// what krate root is this path relative to? + /// The crate root this path is relative to. pub krate: CrateNum, } @@ -260,9 +260,9 @@ impl DefPath { DefPath { data: data, krate: krate } } - /// Returns a string representation of the DefPath without + /// Returns a string representation of the `DefPath` without /// the crate-prefix. This method is useful if you don't have - /// a TyCtxt available. + /// a `TyCtxt` available. pub fn to_string_no_crate(&self) -> String { let mut s = String::with_capacity(self.data.len() * 16); @@ -277,7 +277,7 @@ impl DefPath { s } - /// Return filename friendly string of the DefPah with the + /// Returns a filename-friendly string for the `DefPath`, with the /// crate-prefix. pub fn to_string_friendly(&self, crate_imported_name: F) -> String where F: FnOnce(CrateNum) -> Symbol @@ -302,9 +302,9 @@ impl DefPath { s } - /// Return filename friendly string of the DefPah without + /// Returns a filename-friendly string of the `DefPath`, without /// the crate-prefix. This method is useful if you don't have - /// a TyCtxt available. + /// a `TyCtxt` available. pub fn to_filename_friendly_no_crate(&self) -> String { let mut s = String::with_capacity(self.data.len() * 16); @@ -394,18 +394,18 @@ impl Borrow for DefPathHash { } impl Definitions { - /// Create new empty definition map. + /// Creates new empty definition map. /// - /// The DefIndex returned from a new Definitions are as follows: - /// 1. At DefIndexAddressSpace::Low, + /// The `DefIndex` returned from a new `Definitions` are as follows: + /// 1. At `DefIndexAddressSpace::Low`, /// CRATE_ROOT has index 0:0, and then new indexes are allocated in /// ascending order. - /// 2. At DefIndexAddressSpace::High, - /// the first FIRST_FREE_HIGH_DEF_INDEX indexes are reserved for - /// internal use, then 1:FIRST_FREE_HIGH_DEF_INDEX are allocated in + /// 2. At `DefIndexAddressSpace::High`, + /// the first `FIRST_FREE_HIGH_DEF_INDEX` indexes are reserved for + /// internal use, then `1:FIRST_FREE_HIGH_DEF_INDEX` are allocated in /// ascending order. - /// - /// FIXME: there is probably a better place to put this comment. + // + // FIXME: there is probably a better place to put this comment. pub fn new() -> Self { Self::default() } @@ -414,7 +414,7 @@ impl Definitions { &self.table } - /// Get the number of definitions. + /// Gets the number of definitions. pub fn def_index_counts_lo_hi(&self) -> (usize, usize) { (self.table.index_to_key[DefIndexAddressSpace::Low.index()].len(), self.table.index_to_key[DefIndexAddressSpace::High.index()].len()) @@ -497,8 +497,8 @@ impl Definitions { self.node_to_hir_id[node_id] } - /// Retrieve the span of the given `DefId` if `DefId` is in the local crate, the span exists and - /// it's not DUMMY_SP + /// Retrieves the span of the given `DefId` if `DefId` is in the local crate, the span exists + /// and it's not `DUMMY_SP`. #[inline] pub fn opt_span(&self, def_id: DefId) -> Option { if def_id.krate == LOCAL_CRATE { @@ -508,7 +508,7 @@ impl Definitions { } } - /// Add a definition with a parent definition. + /// Adds a root definition (no parent). pub fn create_root_def(&mut self, crate_name: &str, crate_disambiguator: CrateDisambiguator) @@ -606,7 +606,7 @@ impl Definitions { index } - /// Initialize the ast::NodeId to HirId mapping once it has been generated during + /// Initialize the `ast::NodeId` to `HirId` mapping once it has been generated during /// AST to HIR lowering. pub fn init_node_id_to_hir_id_mapping(&mut self, mapping: IndexVec) { diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 955f834e40398..bf89eada4a57f 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -36,7 +36,7 @@ mod hir_id_validator; pub const ITEM_LIKE_SPACE: DefIndexAddressSpace = DefIndexAddressSpace::Low; pub const REGULAR_SPACE: DefIndexAddressSpace = DefIndexAddressSpace::High; -/// Represents an entry and its parent NodeId. +/// Represents an entry and its parent `NodeId`. #[derive(Copy, Clone, Debug)] pub struct Entry<'hir> { parent: NodeId, @@ -162,8 +162,7 @@ impl Forest { } } -/// Represents a mapping from Node IDs to AST elements and their parent -/// Node IDs +/// Represents a mapping from `NodeId`s to AST elements and their parent `NodeId`s. #[derive(Clone)] pub struct Map<'hir> { /// The backing storage for all the AST nodes. @@ -473,7 +472,7 @@ impl<'hir> Map<'hir> { self.local_def_id(self.body_owner(id)) } - /// Given a node id, returns the `BodyId` associated with it, + /// Given a `NodeId`, returns the `BodyId` associated with it, /// if the node is a body owner, otherwise returns `None`. pub fn maybe_body_owned_by(&self, id: NodeId) -> Option { if let Some(entry) = self.find_entry(id) { @@ -558,7 +557,7 @@ impl<'hir> Map<'hir> { self.trait_auto_impl(trait_did).is_some() } - /// Get the attributes on the krate. This is preferable to + /// Gets the attributes on the crate. This is preferable to /// invoking `krate.attrs` because it registers a tighter /// dep-graph access. pub fn krate_attrs(&self) -> &'hir [ast::Attribute] { @@ -653,8 +652,7 @@ impl<'hir> Map<'hir> { self.get_generics(id).map(|generics| generics.span).filter(|sp| *sp != DUMMY_SP) } - /// Retrieve the Node corresponding to `id`, returning None if - /// cannot be found. + /// Retrieves the `Node` corresponding to `id`, returning `None` if cannot be found. pub fn find(&self, id: NodeId) -> Option> { let result = self.find_entry(id).and_then(|entry| { if let Node::Crate = entry.node { @@ -683,8 +681,8 @@ impl<'hir> Map<'hir> { /// returns the enclosing item. Note that this might not be the actual parent /// node in the AST - some kinds of nodes are not in the map and these will /// never appear as the parent_node. So you can always walk the `parent_nodes` - /// from a node to the root of the ast (unless you get the same id back here - /// that can happen if the id is not in the map itself or is just weird). + /// from a node to the root of the ast (unless you get the same ID back here + /// that can happen if the ID is not in the map itself or is just weird). pub fn get_parent_node(&self, id: NodeId) -> NodeId { if self.dep_graph.is_fully_enabled() { let hir_id_owner = self.node_to_hir_id(id).owner; @@ -725,7 +723,7 @@ impl<'hir> Map<'hir> { /// If there is some error when walking the parents (e.g., a node does not /// have a parent in the map or a node can't be found), then we return the - /// last good node id we found. Note that reaching the crate root (`id == 0`), + /// last good `NodeId` we found. Note that reaching the crate root (`id == 0`), /// is not an error, since items in the crate module have the crate root as /// parent. fn walk_parent_nodes(&self, @@ -761,7 +759,7 @@ impl<'hir> Map<'hir> { } } - /// Retrieve the `NodeId` for `id`'s enclosing method, unless there's a + /// Retrieves the `NodeId` for `id`'s enclosing method, unless there's a /// `while` or `loop` before reaching it, as block tail returns are not /// available in them. /// @@ -809,7 +807,7 @@ impl<'hir> Map<'hir> { self.walk_parent_nodes(id, match_fn, match_non_returning_block).ok() } - /// Retrieve the `NodeId` for `id`'s parent item, or `id` itself if no + /// Retrieves the `NodeId` for `id`'s parent item, or `id` itself if no /// parent item is in this map. The "parent item" is the closest parent node /// in the HIR which is recorded by the map and is an item, either an item /// in a module, trait, or impl. @@ -1122,7 +1120,7 @@ pub struct NodesMatchingSuffix<'a, 'hir:'a> { } impl<'a, 'hir> NodesMatchingSuffix<'a, 'hir> { - /// Returns true only if some suffix of the module path for parent + /// Returns `true` only if some suffix of the module path for parent /// matches `self.in_which`. /// /// In other words: let `[x_0,x_1,...,x_k]` be `self.in_which`; diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index 3e7dd1432e1e3..d9759da9dfca8 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -62,14 +62,14 @@ pub mod map; pub mod pat_util; pub mod print; -/// A HirId uniquely identifies a node in the HIR of the current crate. It is -/// composed of the `owner`, which is the DefIndex of the directly enclosing -/// hir::Item, hir::TraitItem, or hir::ImplItem (i.e., the closest "item-like"), +/// Uniquely identifies a node in the HIR of the current crate. It is +/// composed of the `owner`, which is the `DefIndex` of the directly enclosing +/// `hir::Item`, `hir::TraitItem`, or `hir::ImplItem` (i.e., the closest "item-like"), /// and the `local_id` which is unique within the given owner. /// /// This two-level structure makes for more stable values: One can move an item /// around within the source code, or add or remove stuff before it, without -/// the local_id part of the HirId changing, which is a very useful property in +/// the `local_id` part of the `HirId` changing, which is a very useful property in /// incremental compilation where we have to persist things through changes to /// the code base. #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] @@ -130,7 +130,7 @@ mod item_local_id_inner { pub use self::item_local_id_inner::ItemLocalId; -/// The `HirId` corresponding to CRATE_NODE_ID and CRATE_DEF_INDEX +/// The `HirId` corresponding to `CRATE_NODE_ID` and `CRATE_DEF_INDEX`. pub const CRATE_HIR_ID: HirId = HirId { owner: CRATE_DEF_INDEX, local_id: ItemLocalId::from_u32_const(0) @@ -149,8 +149,8 @@ pub struct Lifetime { pub hir_id: HirId, pub span: Span, - /// Either "'a", referring to a named lifetime definition, - /// or "" (aka keywords::Invalid), for elision placeholders. + /// Either "`'a`", referring to a named lifetime definition, + /// or "``" (i.e., `keywords::Invalid`), for elision placeholders. /// /// HIR lowering inserts these placeholders in type paths that /// refer to type definitions needing lifetime parameters, @@ -163,8 +163,9 @@ pub enum ParamName { /// Some user-given name like `T` or `'x`. Plain(Ident), - /// Synthetic name generated when user elided a lifetime in an impl header, - /// e.g., the lifetimes in cases like these: + /// Synthetic name generated when user elided a lifetime in an impl header. + /// + /// E.g., the lifetimes in cases like these: /// /// impl Foo for &u32 /// impl Foo<'_> for u32 @@ -180,7 +181,7 @@ pub enum ParamName { /// Indicates an illegal name was given and an error has been /// repored (so we should squelch other derived errors). Occurs - /// when e.g., `'_` is used in the wrong place. + /// when, e.g., `'_` is used in the wrong place. Error, } @@ -205,17 +206,17 @@ pub enum LifetimeName { /// User-given names or fresh (synthetic) names. Param(ParamName), - /// User typed nothing. e.g., the lifetime in `&u32`. + /// User wrote nothing (e.g., the lifetime in `&u32`). Implicit, /// Indicates an error during lowering (usually `'_` in wrong place) /// that was already reported. Error, - /// User typed `'_`. + /// User wrote specifies `'_`. Underscore, - /// User wrote `'static` + /// User wrote `'static`. Static, } @@ -280,7 +281,7 @@ impl Lifetime { } } -/// A "Path" is essentially Rust's notion of a name; for instance: +/// A `Path` is essentially Rust's notion of a name; for instance, /// `std::cmp::PartialEq`. It's represented as a sequence of identifiers, /// along with a bunch of supporting information. #[derive(Clone, RustcEncodable, RustcDecodable)] @@ -340,7 +341,7 @@ pub struct PathSegment { } impl PathSegment { - /// Convert an identifier to the corresponding segment. + /// Converts an identifier to the corresponding segment. pub fn from_ident(ident: Ident) -> PathSegment { PathSegment { ident, @@ -597,14 +598,14 @@ impl Generics { } } -/// Synthetic Type Parameters are converted to an other form during lowering, this allows -/// to track the original form they had. Useful for error messages. +/// Synthetic type parameters are converted to another form during lowering; this allows +/// us to track the original form they had, and is useful for error messages. #[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum SyntheticTyParamKind { ImplTrait } -/// A `where` clause in a definition +/// A where-clause in a definition. #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereClause { pub id: NodeId, @@ -624,7 +625,7 @@ impl WhereClause { } } -/// A single predicate in a `where` clause +/// A single predicate in a where-clause. #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum WherePredicate { /// A type binding (e.g., `for<'c> Foo: Send + Clone + 'c`). @@ -645,19 +646,19 @@ impl WherePredicate { } } -/// A type bound, eg `for<'c> Foo: Send+Clone+'c` +/// A type bound (e.g., `for<'c> Foo: Send + Clone + 'c`). #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereBoundPredicate { pub span: Span, - /// Any generics from a `for` binding + /// Any generics from a `for` binding. pub bound_generic_params: HirVec, - /// The type being bounded + /// The type being bounded. pub bounded_ty: P, - /// Trait and lifetime bounds (`Clone+Send+'static`) + /// Trait and lifetime bounds (e.g., `Clone + Send + 'static`). pub bounds: GenericBounds, } -/// A lifetime predicate, e.g., `'a: 'b+'c` +/// A lifetime predicate (e.g., `'a: 'b + 'c`). #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereRegionPredicate { pub span: Span, @@ -665,7 +666,7 @@ pub struct WhereRegionPredicate { pub bounds: GenericBounds, } -/// An equality predicate (unsupported), e.g., `T=int` +/// An equality predicate (e.g., `T = int`); currently unsupported. #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct WhereEqPredicate { pub id: NodeId, @@ -759,7 +760,7 @@ impl Crate { } } - /// A parallel version of visit_all_item_likes + /// A parallel version of `visit_all_item_likes`. pub fn par_visit_all_item_likes<'hir, V>(&'hir self, visitor: &V) where V: itemlikevisit::ParItemLikeVisitor<'hir> + Sync + Send { @@ -800,14 +801,14 @@ pub struct MacroDef { #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Block { - /// Statements in a block + /// Statements in a block. pub stmts: HirVec, /// An expression at the end of the block - /// without a semicolon, if any + /// without a semicolon, if any. pub expr: Option>, pub id: NodeId, pub hir_id: HirId, - /// Distinguishes between `unsafe { ... }` and `{ ... }` + /// Distinguishes between `unsafe { ... }` and `{ ... }`. pub rules: BlockCheckMode, pub span: Span, /// If true, then there may exist `break 'a` values that aim to @@ -874,18 +875,18 @@ impl Pat { } } -/// A single field in a struct pattern +/// A single field in a struct pattern. /// /// Patterns like the fields of Foo `{ x, ref y, ref mut z }` /// are treated the same as` x: x, y: ref y, z: ref mut z`, -/// except is_shorthand is true +/// except `is_shorthand` is true. #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct FieldPat { pub id: NodeId, pub hir_id: HirId, - /// The identifier for the field + /// The identifier for the field. pub ident: Ident, - /// The pattern the field is destructured to + /// The pattern the field is destructured to. pub pat: P, pub is_shorthand: bool, } @@ -922,41 +923,41 @@ pub enum RangeEnd { #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum PatKind { - /// Represents a wildcard pattern (`_`) + /// Represents a wildcard pattern (i.e., `_`). Wild, /// A fresh binding `ref mut binding @ OPT_SUBPATTERN`. /// The `NodeId` is the canonical ID for the variable being bound, - /// e.g., in `Ok(x) | Err(x)`, both `x` use the same canonical ID, + /// (e.g., in `Ok(x) | Err(x)`, both `x` use the same canonical ID), /// which is the pattern ID of the first `x`. Binding(BindingAnnotation, NodeId, HirId, Ident, Option>), - /// A struct or struct variant pattern, e.g., `Variant {x, y, ..}`. + /// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`). /// The `bool` is `true` in the presence of a `..`. Struct(QPath, HirVec>, bool), /// A tuple struct/variant pattern `Variant(x, y, .., z)`. /// If the `..` pattern fragment is present, then `Option` denotes its position. - /// 0 <= position <= subpats.len() + /// `0 <= position <= subpats.len()` TupleStruct(QPath, HirVec>, Option), /// A path pattern for an unit struct/variant or a (maybe-associated) constant. Path(QPath), - /// A tuple pattern `(a, b)`. + /// A tuple pattern (e.g., `(a, b)`). /// If the `..` pattern fragment is present, then `Option` denotes its position. - /// 0 <= position <= subpats.len() + /// `0 <= position <= subpats.len()` Tuple(HirVec>, Option), - /// A `box` pattern + /// A `box` pattern. Box(P), - /// A reference pattern, e.g., `&mut (a, b)` + /// A reference pattern (e.g., `&mut (a, b)`). Ref(P, Mutability), - /// A literal + /// A literal. Lit(P), - /// A range pattern, e.g., `1...2` or `1..2` + /// A range pattern (e.g., `1...2` or `1..2`). Range(P, P, RangeEnd), /// `[a, b, ..i, y, z]` is represented as: - /// `PatKind::Slice(box [a, b], Some(i), box [y, z])` + /// `PatKind::Slice(box [a, b], Some(i), box [y, z])`. Slice(HirVec>, Option>, HirVec>), } @@ -967,7 +968,7 @@ pub enum Mutability { } impl Mutability { - /// Return MutMutable only if both arguments are mutable. + /// Returns `MutMutable` only if both arguments are mutable. pub fn and(self, other: Self) -> Self { match self { MutMutable => other, @@ -978,41 +979,41 @@ impl Mutability { #[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy, Hash)] pub enum BinOpKind { - /// The `+` operator (addition) + /// The `+` operator (addition). Add, - /// The `-` operator (subtraction) + /// The `-` operator (subtraction). Sub, - /// The `*` operator (multiplication) + /// The `*` operator (multiplication). Mul, - /// The `/` operator (division) + /// The `/` operator (division). Div, - /// The `%` operator (modulus) + /// The `%` operator (modulus). Rem, - /// The `&&` operator (logical and) + /// The `&&` operator (logical and). And, - /// The `||` operator (logical or) + /// The `||` operator (logical or). Or, - /// The `^` operator (bitwise xor) + /// The `^` operator (bitwise xor). BitXor, - /// The `&` operator (bitwise and) + /// The `&` operator (bitwise and). BitAnd, - /// The `|` operator (bitwise or) + /// The `|` operator (bitwise or). BitOr, - /// The `<<` operator (shift left) + /// The `<<` operator (shift left). Shl, - /// The `>>` operator (shift right) + /// The `>>` operator (shift right). Shr, - /// The `==` operator (equality) + /// The `==` operator (equality). Eq, - /// The `<` operator (less than) + /// The `<` operator (less than). Lt, - /// The `<=` operator (less than or equal to) + /// The `<=` operator (less than or equal to). Le, - /// The `!=` operator (not equal to) + /// The `!=` operator (not equal to). Ne, - /// The `>=` operator (greater than or equal to) + /// The `>=` operator (greater than or equal to). Ge, - /// The `>` operator (greater than) + /// The `>` operator (greater than). Gt, } @@ -1077,7 +1078,7 @@ impl BinOpKind { } } - /// Returns `true` if the binary operator takes its arguments by value + /// Returns `true` if the binary operator takes its arguments by value. pub fn is_by_value(self) -> bool { !self.is_comparison() } @@ -1112,11 +1113,11 @@ pub type BinOp = Spanned; #[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, Debug, Copy, Hash)] pub enum UnOp { - /// The `*` operator for dereferencing + /// The `*` operator (deferencing). UnDeref, - /// The `!` operator for logical inversion + /// The `!` operator (logical negation). UnNot, - /// The `-` operator for negation + /// The `-` operator (negation). UnNeg, } @@ -1129,7 +1130,7 @@ impl UnOp { } } - /// Returns `true` if the unary operator takes its argument by value + /// Returns `true` if the unary operator takes its argument by value. pub fn is_by_value(self) -> bool { match self { UnNeg | UnNot => true, @@ -1138,7 +1139,7 @@ impl UnOp { } } -/// A statement +/// A statement. #[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Stmt { pub id: NodeId, @@ -1156,15 +1157,15 @@ impl fmt::Debug for Stmt { #[derive(Clone, RustcEncodable, RustcDecodable)] pub enum StmtKind { - /// A local (let) binding: + /// A local (`let`) binding. Local(P), - /// An item binding: + /// An item binding. Item(P), - /// Expr without trailing semi-colon (must have unit type): + /// An expression without a trailing semi-colon (must have unit type). Expr(P), - /// Expr with trailing semi-colon (may have any type): + /// An expression with a trailing semi-colon (may have any type). Semi(P), } @@ -1179,12 +1180,12 @@ impl StmtKind { } } -/// Local represents a `let` statement, e.g., `let : = ;` +/// Represents a `let` statement (i.e., `let : = ;`). #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Local { pub pat: P, pub ty: Option>, - /// Initializer expression to set the value, if any + /// Initializer expression to set the value, if any. pub init: Option>, pub id: NodeId, pub hir_id: HirId, @@ -1193,7 +1194,7 @@ pub struct Local { pub source: LocalSource, } -/// represents one arm of a 'match' +/// Represents a single arm of a `match` expression. #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Arm { pub attrs: HirVec, @@ -1419,16 +1420,16 @@ impl fmt::Debug for Expr { pub enum ExprKind { /// A `box x` expression. Box(P), - /// An array (`[a, b, c, d]`) + /// An array (e.g., `[a, b, c, d]`). Array(HirVec), - /// A function call + /// A function call. /// /// The first field resolves to the function itself (usually an `ExprKind::Path`), /// and the second field is the list of arguments. /// This also represents calling the constructor of /// tuple-like ADTs such as tuple structs and enum variants. Call(P, HirVec), - /// A method call (`x.foo::<'static, Bar, Baz>(a, b, c, d)`) + /// A method call (e.g., `x.foo::<'static, Bar, Baz>(a, b, c, d)`). /// /// The `PathSegment`/`Span` represent the method name and its generic arguments /// (within the angle brackets). @@ -1438,63 +1439,64 @@ pub enum ExprKind { /// Thus, `x.foo::(a, b, c, d)` is represented as /// `ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, [x, a, b, c, d])`. MethodCall(PathSegment, Span, HirVec), - /// A tuple (`(a, b, c ,d)`) + /// A tuple (e.g., `(a, b, c ,d)`). Tup(HirVec), - /// A binary operation (For example: `a + b`, `a * b`) + /// A binary operation (e.g., `a + b`, `a * b`). Binary(BinOp, P, P), - /// A unary operation (For example: `!x`, `*x`) + /// A unary operation (e.g., `!x`, `*x`). Unary(UnOp, P), - /// A literal (For example: `1`, `"foo"`) + /// A literal (e.g., `1`, `"foo"`). Lit(Lit), - /// A cast (`foo as f64`) + /// A cast (e.g., `foo as f64`). Cast(P, P), + /// A type reference (e.g., `Foo`). Type(P, P), - /// An `if` block, with an optional else block + /// An `if` block, with an optional else block. /// - /// `if expr { expr } else { expr }` + /// I.e., `if { } else { }`. If(P, P, Option>), /// A while loop, with an optional label /// - /// `'label: while expr { block }` + /// I.e., `'label: while expr { }`. While(P, P, Option    ::new` and /// so forth. #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] @@ -1053,7 +1053,7 @@ pub struct GlobalCtxt<'tcx> { } impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { - /// Get the global TyCtxt. + /// Gets the global `TyCtxt`. #[inline] pub fn global_tcx(self) -> TyCtxt<'gcx, 'gcx, 'gcx> { TyCtxt { @@ -1153,12 +1153,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { value.lift_to_tcx(self.global_tcx()) } - /// Returns true if self is the same as self.global_tcx(). + /// Returns `true` if self is the same as self.global_tcx(). fn is_global(self) -> bool { ptr::eq(self.interners, &self.global_interners) } - /// Create a type context and call the closure with a `TyCtxt` reference + /// Creates a type context and call the closure with a `TyCtxt` reference /// to the context. The closure enforces that the type context and any interned /// value (types, substs, etc.) can only be used while `ty::tls` has a valid /// reference to the context, to allow formatting values that need it. @@ -1353,7 +1353,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - /// Convert a `DefId` into its fully expanded `DefPath` (every + /// Converts a `DefId` into its fully expanded `DefPath` (every /// `DefId` is really just an interned def-path). /// /// Note that if `id` is not local to this crate, the result will diff --git a/src/librustc/ty/fold.rs b/src/librustc/ty/fold.rs index 306c69666e596..7aa1694db800a 100644 --- a/src/librustc/ty/fold.rs +++ b/src/librustc/ty/fold.rs @@ -4,7 +4,7 @@ //! instance of a "folder" (a type which implements `TypeFolder`). Then //! the setup is intended to be: //! -//! T.fold_with(F) --calls--> F.fold_T(T) --calls--> T.super_fold_with(F) +//! T.fold_with(F) --calls--> F.fold_T(T) --calls--> T.super_fold_with(F) //! //! This way, when you define a new folder F, you can override //! `fold_T()` to customize the behavior, and invoke `T.super_fold_with()` @@ -25,9 +25,11 @@ //! proper thing. //! //! A `TypeFoldable` T can also be visited by a `TypeVisitor` V using similar setup: -//! T.visit_with(V) --calls--> V.visit_T(T) --calls--> T.super_visit_with(V). -//! These methods return true to indicate that the visitor has found what it is looking for -//! and does not need to visit anything else. +//! +//! T.visit_with(V) --calls--> V.visit_T(T) --calls--> T.super_visit_with(V). +//! +//! These methods return true to indicate that the visitor has found what it is +//! looking for, and does not need to visit anything else. use crate::hir::def_id::DefId; use crate::ty::{self, Binder, Ty, TyCtxt, TypeFlags}; @@ -52,7 +54,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone { self.super_visit_with(visitor) } - /// True if `self` has any late-bound regions that are either + /// Returns `true` if `self` has any late-bound regions that are either /// bound by `binder` or bound by some binder outside of `binder`. /// If `binder` is `ty::INNERMOST`, this indicates whether /// there are any late-bound regions that appear free. @@ -60,7 +62,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone { self.visit_with(&mut HasEscapingVarsVisitor { outer_index: binder }) } - /// True if this `self` has any regions that escape `binder` (and + /// Returns `true` if this `self` has any regions that escape `binder` (and /// hence are not bound by it). fn has_vars_bound_above(&self, binder: ty::DebruijnIndex) -> bool { self.has_vars_bound_at_or_above(binder.shifted_in(1)) @@ -141,7 +143,7 @@ pub trait TypeFoldable<'tcx>: fmt::Debug + Clone { } } -/// The TypeFolder trait defines the actual *folding*. There is a +/// The `TypeFolder` trait defines the actual *folding*. There is a /// method defined for every foldable type. Each of these has a /// default implementation that does an "identity" fold. Within each /// identity fold, it should invoke `foo.fold_with(self)` to fold each @@ -262,7 +264,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { }); } - /// True if `callback` returns true for every region appearing free in `value`. + /// Returns `true` if `callback` returns true for every region appearing free in `value`. pub fn all_free_regions_meet( self, value: &impl TypeFoldable<'tcx>, @@ -271,7 +273,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { !self.any_free_region_meets(value, |r| !callback(r)) } - /// True if `callback` returns true for some region appearing free in `value`. + /// Returns `true` if `callback` returns true for some region appearing free in `value`. pub fn any_free_region_meets( self, value: &impl TypeFoldable<'tcx>, @@ -292,8 +294,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { /// ^ ^ ^ ^ /// | | | | here, would be shifted in 1 /// | | | here, would be shifted in 2 - /// | | here, would be INNERMOST shifted in by 1 - /// | here, initially, binder would be INNERMOST + /// | | here, would be `INNERMOST` shifted in by 1 + /// | here, initially, binder would be `INNERMOST` /// ``` /// /// You see that, initially, *any* bound value is free, @@ -496,12 +498,12 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for BoundVarReplacer<'a, 'gcx, 'tcx> } impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { - /// Replace all regions bound by the given `Binder` with the + /// Replaces all regions bound by the given `Binder` with the /// results returned by the closure; the closure is expected to /// return a free region (relative to this binder), and hence the /// binder is removed in the return type. The closure is invoked /// once for each unique `BoundRegion`; multiple references to the - /// same `BoundRegion` will reuse the previous result. A map is + /// same `BoundRegion` will reuse the previous result. A map is /// returned at the end with each bound region and the free region /// that replaced it. /// @@ -520,7 +522,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { self.replace_escaping_bound_vars(value.skip_binder(), fld_r, fld_t) } - /// Replace all escaping bound vars. The `fld_r` closure replaces escaping + /// Replaces all escaping bound vars. The `fld_r` closure replaces escaping /// bound regions while the `fld_t` closure replaces escaping bound types. pub fn replace_escaping_bound_vars( self, @@ -554,7 +556,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - /// Replace all types or regions bound by the given `Binder`. The `fld_r` + /// Replaces all types or regions bound by the given `Binder`. The `fld_r` /// closure replaces bound regions while the `fld_t` closure replaces bound /// types. pub fn replace_bound_vars( @@ -570,7 +572,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { self.replace_escaping_bound_vars(value.skip_binder(), fld_r, fld_t) } - /// Replace any late-bound regions bound in `value` with + /// Replaces any late-bound regions bound in `value` with /// free variants attached to `all_outlive_scope`. pub fn liberate_late_bound_regions( &self, @@ -640,7 +642,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { collector.regions } - /// Replace any late-bound regions bound in `value` with `'erased`. Useful in codegen but also + /// Replaces any late-bound regions bound in `value` with `'erased`. Useful in codegen but also /// method lookup and a few other places where precise region relationships are not required. pub fn erase_late_bound_regions(self, value: &Binder) -> T where T : TypeFoldable<'tcx> @@ -648,13 +650,13 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { self.replace_late_bound_regions(value, |_| self.types.re_erased).0 } - /// Rewrite any late-bound regions so that they are anonymous. Region numbers are + /// Rewrite any late-bound regions so that they are anonymous. Region numbers are /// assigned starting at 1 and increasing monotonically in the order traversed /// by the fold operation. /// /// The chief purpose of this function is to canonicalize regions so that two /// `FnSig`s or `TraitRef`s which are equivalent up to region naming will become - /// structurally identical. For example, `for<'a, 'b> fn(&'a isize, &'b isize)` and + /// structurally identical. For example, `for<'a, 'b> fn(&'a isize, &'b isize)` and /// `for<'a, 'b> fn(&'b isize, &'a isize)` will become identical after anonymization. pub fn anonymize_late_bound_regions(self, sig: &Binder) -> Binder where T : TypeFoldable<'tcx>, @@ -818,7 +820,7 @@ pub fn shift_out_vars<'a, 'gcx, 'tcx, T>( /// scope to which it is attached, etc. An escaping var represents /// a bound var for which this processing has not yet been done. struct HasEscapingVarsVisitor { - /// Anything bound by `outer_index` or "above" is escaping + /// Anything bound by `outer_index` or "above" is escaping. outer_index: ty::DebruijnIndex, } @@ -881,10 +883,10 @@ struct LateBoundRegionsCollector { current_index: ty::DebruijnIndex, regions: FxHashSet, - /// If true, we only want regions that are known to be + /// `true` if we only want regions that are known to be /// "constrained" when you equate this type with another type. In /// particular, if you have e.g., `&'a u32` and `&'b u32`, equating - /// them constraints `'a == 'b`. But if you have `<&'a u32 as + /// them constraints `'a == 'b`. But if you have `<&'a u32 as /// Trait>::Foo` and `<&'b u32 as Trait>::Foo`, normalizing those /// types may mean that `'a` and `'b` don't appear in the results, /// so they are not considered *constrained*. diff --git a/src/librustc/ty/inhabitedness/def_id_forest.rs b/src/librustc/ty/inhabitedness/def_id_forest.rs index 73b7d74d9dafe..3b393c3ca15bb 100644 --- a/src/librustc/ty/inhabitedness/def_id_forest.rs +++ b/src/librustc/ty/inhabitedness/def_id_forest.rs @@ -22,14 +22,14 @@ pub struct DefIdForest { } impl<'a, 'gcx, 'tcx> DefIdForest { - /// Create an empty forest. + /// Creates an empty forest. pub fn empty() -> DefIdForest { DefIdForest { root_ids: SmallVec::new(), } } - /// Create a forest consisting of a single tree representing the entire + /// Creates a forest consisting of a single tree representing the entire /// crate. #[inline] pub fn full(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> DefIdForest { @@ -37,7 +37,7 @@ impl<'a, 'gcx, 'tcx> DefIdForest { DefIdForest::from_id(crate_id) } - /// Create a forest containing a DefId and all its descendants. + /// Creates a forest containing a DefId and all its descendants. pub fn from_id(id: DefId) -> DefIdForest { let mut root_ids = SmallVec::new(); root_ids.push(id); @@ -46,12 +46,12 @@ impl<'a, 'gcx, 'tcx> DefIdForest { } } - /// Test whether the forest is empty. + /// Tests whether the forest is empty. pub fn is_empty(&self) -> bool { self.root_ids.is_empty() } - /// Test whether the forest contains a given DefId. + /// Tests whether the forest contains a given DefId. pub fn contains(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, id: DefId) -> bool diff --git a/src/librustc/ty/instance.rs b/src/librustc/ty/instance.rs index e4fe93d5deaea..5fc22e3c02b60 100644 --- a/src/librustc/ty/instance.rs +++ b/src/librustc/ty/instance.rs @@ -22,17 +22,17 @@ pub enum InstanceDef<'tcx> { /// `::method` where `method` receives unsizeable `self: Self`. VtableShim(DefId), - /// \::call_* - /// def-id is FnTrait::call_* + /// `::call_*` + /// `DefId` is `FnTrait::call_*` FnPtrShim(DefId, Ty<'tcx>), - /// ::fn + /// `::fn` Virtual(DefId, usize), - /// <[mut closure] as FnOnce>::call_once + /// `<[mut closure] as FnOnce>::call_once` ClosureOnceShim { call_once: DefId }, - /// drop_in_place::; None for empty drop glue. + /// `drop_in_place::; None` for empty drop glue. DropGlue(DefId, Option>), ///`::clone` shim. @@ -220,7 +220,7 @@ impl<'a, 'b, 'tcx> Instance<'tcx> { self.def.def_id() } - /// Resolve a (def_id, substs) pair to an (optional) instance -- most commonly, + /// Resolves a `(def_id, substs)` pair to an (optional) instance -- most commonly, /// this is used to find the precise code that will run for a trait method invocation, /// if known. /// diff --git a/src/librustc/ty/item_path.rs b/src/librustc/ty/item_path.rs index 3f49c1b27ce5f..5dc31caf295af 100644 --- a/src/librustc/ty/item_path.rs +++ b/src/librustc/ty/item_path.rs @@ -43,7 +43,7 @@ pub fn with_forced_impl_filename_line R, R>(f: F) -> R { }) } -/// Add the `crate::` prefix to paths where appropriate. +/// Adds the `crate::` prefix to paths where appropriate. pub fn with_crate_prefix R, R>(f: F) -> R { SHOULD_PREFIX_WITH_CRATE.with(|flag| { let old = flag.get(); @@ -55,7 +55,7 @@ pub fn with_crate_prefix R, R>(f: F) -> R { } impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { - /// Returns a string identifying this def-id. This string is + /// Returns a string identifying this `DefId`. This string is /// suitable for user output. It is relative to the current crate /// root, unless with_forced_absolute_paths was used. pub fn item_path_str(self, def_id: DefId) -> String { @@ -468,7 +468,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { buffer.push(&format!("", span_str)); } - /// Returns the def-id of `def_id`'s parent in the def tree. If + /// Returns the `DefId` of `def_id`'s parent in the def tree. If /// this returns `None`, then `def_id` represents a crate root or /// inlined root. pub fn parent_def_id(self, def_id: DefId) -> Option { @@ -478,9 +478,9 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } /// As a heuristic, when we see an impl, if we see that the -/// 'self-type' is a type defined in the same module as the impl, +/// 'self type' is a type defined in the same module as the impl, /// we can omit including the path to the impl itself. This -/// function tries to find a "characteristic def-id" for a +/// function tries to find a "characteristic `DefId`" for a /// type. It's just a heuristic so it makes some questionable /// decisions and we may want to adjust it later. pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option { @@ -535,7 +535,7 @@ pub trait ItemPathBuffer { #[derive(Debug)] pub enum RootMode { - /// Try to make a path relative to the local crate. In + /// Try to make a path relative to the local crate. In /// particular, local paths have no prefix, and if the path comes /// from an extern crate, start with the path to the `extern /// crate` declaration. diff --git a/src/librustc/ty/layout.rs b/src/librustc/ty/layout.rs index 8401d0861cad2..6c507c0015d7b 100644 --- a/src/librustc/ty/layout.rs +++ b/src/librustc/ty/layout.rs @@ -46,7 +46,7 @@ impl IntegerExt for Integer { } } - /// Get the Integer type from an attr::IntType. + /// Gets the Integer type from an attr::IntType. fn from_attr(cx: &C, ity: attr::IntType) -> Integer { let dl = cx.data_layout(); @@ -62,7 +62,7 @@ impl IntegerExt for Integer { } } - /// Find the appropriate Integer type and signedness for the given + /// Finds the appropriate Integer type and signedness for the given /// signed discriminant range and #[repr] attribute. /// N.B.: u128 values above i128::MAX will be treated as signed, but /// that shouldn't affect anything, other than maybe debuginfo. @@ -1686,7 +1686,7 @@ impl<'a, 'tcx, C> TyLayoutMethods<'tcx, C> for Ty<'tcx> tcx.types.re_static, tcx.mk_array(tcx.types.usize, 3), ) - /* FIXME use actual fn pointers + /* FIXME: use actual fn pointers Warning: naively computing the number of entries in the vtable by counting the methods on the trait + methods on all parent traits does not work, because some methods can diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 1f08d930fbda5..70f72acad1fb6 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -135,8 +135,8 @@ pub enum AssociatedItemContainer { } impl AssociatedItemContainer { - /// Asserts that this is the def-id of an associated item declared - /// in a trait, and returns the trait def-id. + /// Asserts that this is the `DefId` of an associated item declared + /// in a trait, and returns the trait `DefId`. pub fn assert_trait(&self) -> DefId { match *self { TraitContainer(id) => id, @@ -154,7 +154,7 @@ impl AssociatedItemContainer { /// The "header" of an impl is everything outside the body: a Self type, a trait /// ref (in the case of a trait impl), and a set of predicates (from the -/// bounds/where clauses). +/// bounds / where-clauses). #[derive(Clone, PartialEq, Eq, Hash, Debug)] pub struct ImplHeader<'tcx> { pub impl_def_id: DefId, @@ -328,7 +328,7 @@ pub enum Variance { /// item. pub struct CrateVariancesMap { /// For each item with generics, maps to a vector of the variance - /// of its generics. If an item has no generics, it will have no + /// of its generics. If an item has no generics, it will have no /// entry. pub variances: FxHashMap>>, @@ -338,7 +338,7 @@ pub struct CrateVariancesMap { impl Variance { /// `a.xform(b)` combines the variance of a context with the - /// variance of a type with the following meaning. If we are in a + /// variance of a type with the following meaning. If we are in a /// context with variance `a`, and we encounter a type argument in /// a position with variance `b`, then `a.xform(b)` is the new /// variance with which the argument appears. @@ -362,10 +362,10 @@ impl Variance { /// The ambient variance is covariant. A `fn` type is /// contravariant with respect to its parameters, so the variance /// within which both pointer types appear is - /// `Covariant.xform(Contravariant)`, or `Contravariant`. `*const + /// `Covariant.xform(Contravariant)`, or `Contravariant`. `*const /// T` is covariant with respect to `T`, so the variance within /// which the first `Vec` appears is - /// `Contravariant.xform(Covariant)` or `Contravariant`. The same + /// `Contravariant.xform(Covariant)` or `Contravariant`. The same /// is true for its `i32` argument. In the `*mut T` case, the /// variance of `Vec` is `Contravariant.xform(Invariant)`, /// and hence the outermost type is `Invariant` with respect to @@ -489,12 +489,12 @@ pub struct TyS<'tcx> { /// So, for a type without any late-bound things, like `u32`, this /// will be *innermost*, because that is the innermost binder that /// captures nothing. But for a type `&'D u32`, where `'D` is a - /// late-bound region with debruijn index `D`, this would be `D + 1` + /// late-bound region with De Bruijn index `D`, this would be `D + 1` /// -- the binder itself does not capture `D`, but `D` is captured /// by an inner binder. /// /// We call this concept an "exclusive" binder `D` because all - /// debruijn indices within the type are contained within `0..D` + /// De Bruijn indices within the type are contained within `0..D` /// (exclusive). outer_exclusive_binder: ty::DebruijnIndex, } @@ -720,9 +720,9 @@ pub struct UpvarPath { pub hir_id: hir::HirId, } -/// Upvars do not get their own node-id. Instead, we use the pair of -/// the original var id (that is, the root variable that is referenced -/// by the upvar) and the id of the closure expression. +/// Upvars do not get their own `NodeId`. Instead, we use the pair of +/// the original var ID (that is, the root variable that is referenced +/// by the upvar) and the ID of the closure expression. #[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] pub struct UpvarId { pub var_path: UpvarPath, @@ -734,7 +734,7 @@ pub enum BorrowKind { /// Data must be immutable and is aliasable. ImmBorrow, - /// Data must be immutable but not aliasable. This kind of borrow + /// Data must be immutable but not aliasable. This kind of borrow /// cannot currently be expressed by the user and is used only in /// implicit closure bindings. It is needed when the closure /// is borrowing or mutating a mutable referent, e.g.: @@ -1096,7 +1096,7 @@ impl<'a, 'gcx, 'tcx> Predicate<'tcx> { /// Performs a substitution suitable for going from a /// poly-trait-ref to supertraits that must hold if that /// poly-trait-ref holds. This is slightly different from a normal - /// substitution in terms of what happens with bound regions. See + /// substitution in terms of what happens with bound regions. See /// lengthy comment below for details. pub fn subst_supertrait(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, trait_ref: &ty::PolyTraitRef<'tcx>) @@ -1235,7 +1235,7 @@ pub type PolySubtypePredicate<'tcx> = ty::Binder>; /// This kind of predicate has no *direct* correspondent in the /// syntax, but it roughly corresponds to the syntactic forms: /// -/// 1. `T: TraitRef<..., Item=Type>` +/// 1. `T: TraitRef<..., Item = Type>` /// 2. `>::Item == Type` (NYI) /// /// In particular, form #1 is "desugared" to the combination of a @@ -1456,8 +1456,8 @@ impl<'tcx> Predicate<'tcx> { } /// Represents the bounds declared on a particular set of type -/// parameters. Should eventually be generalized into a flag list of -/// where clauses. You can obtain a `InstantiatedPredicates` list from a +/// parameters. Should eventually be generalized into a flag list of +/// where-clauses. You can obtain a `InstantiatedPredicates` list from a /// `GenericPredicates` by using the `instantiate` method. Note that this method /// reflects an important semantic invariant of `InstantiatedPredicates`: while /// the `GenericPredicates` are expressed in terms of the bound type @@ -1471,7 +1471,7 @@ impl<'tcx> Predicate<'tcx> { /// struct Foo> { ... } /// /// Here, the `GenericPredicates` for `Foo` would contain a list of bounds like -/// `[[], [U:Bar]]`. Now if there were some particular reference +/// `[[], [U:Bar]]`. Now if there were some particular reference /// like `Foo`, then the `InstantiatedPredicates` would be `[[], /// [usize:Bar]]`. #[derive(Clone)] @@ -1537,7 +1537,7 @@ impl UniverseIndex { /// Returns the "next" universe index in order -- this new index /// is considered to extend all previous universes. This - /// corresponds to entering a `forall` quantifier. So, for + /// corresponds to entering a `forall` quantifier. So, for /// example, suppose we have this type in universe `U`: /// /// ``` @@ -1619,7 +1619,7 @@ pub struct ParamEnv<'tcx> { impl<'tcx> ParamEnv<'tcx> { /// Construct a trait environment suitable for contexts where - /// there are no where clauses in scope. Hidden types (like `impl + /// there are no where-clauses in scope. Hidden types (like `impl /// Trait`) are left hidden, so this is suitable for ordinary /// type-checking. #[inline] @@ -1627,12 +1627,12 @@ impl<'tcx> ParamEnv<'tcx> { Self::new(List::empty(), Reveal::UserFacing, None) } - /// Construct a trait environment with no where clauses in scope + /// Construct a trait environment with no where-clauses in scope /// where the values of all `impl Trait` and other hidden types /// are revealed. This is suitable for monomorphized, post-typeck /// environments like codegen or doing optimizations. /// - /// N.B. If you want to have predicates in scope, use `ParamEnv::new`, + /// N.B., if you want to have predicates in scope, use `ParamEnv::new`, /// or invoke `param_env.with_reveal_all()`. #[inline] pub fn reveal_all() -> Self { @@ -1651,7 +1651,7 @@ impl<'tcx> ParamEnv<'tcx> { /// Returns a new parameter environment with the same clauses, but /// which "reveals" the true results of projections in all cases - /// (even for associated types that are specializable). This is + /// (even for associated types that are specializable). This is /// the desired behavior during codegen and certain other special /// contexts; normally though we want to use `Reveal::UserFacing`, /// which is the default. @@ -1736,7 +1736,7 @@ impl<'a, 'gcx, T> HashStable> for ParamEnvAnd<'gcx, T> #[derive(Copy, Clone, Debug)] pub struct Destructor { - /// The def-id of the destructor method + /// The `DefId` of the destructor method pub did: DefId, } @@ -1781,20 +1781,21 @@ pub struct VariantDef { } impl<'a, 'gcx, 'tcx> VariantDef { - /// Create a new `VariantDef`. + /// Creates a new `VariantDef`. /// - /// - `did` is the DefId used for the variant - for tuple-structs, it is the constructor DefId, - /// and for everything else, it is the variant DefId. + /// - `did` is the `DefId` used for the variant. + /// This is the constructor `DefId` for tuple stucts, and the variant `DefId` for everything + /// else. /// - `attribute_def_id` is the DefId that has the variant's attributes. - /// this is the struct DefId for structs, and the variant DefId for variants. + /// This is the struct `DefId` for structs, and the variant `DefId` for variants. /// - /// Note that we *could* use the constructor DefId, because the constructor attributes + /// Note that we *could* use the constructor `DefId`, because the constructor attributes /// redirect to the base attributes, but compiling a small crate requires - /// loading the AdtDefs for all the structs in the universe (e.g., coherence for any + /// loading the `AdtDef`s for all the structs in the universe (e.g., coherence for any /// built-in trait), and we do not want to load attributes twice. /// /// If someone speeds up attribute loading to not be a performance concern, they can - /// remove this hack and use the constructor DefId everywhere. + /// remove this hack and use the constructor `DefId` everywhere. pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>, did: DefId, ident: Ident, @@ -2049,13 +2050,13 @@ impl ReprOptions { } /// Returns `true` if this `#[repr()]` should inhibit struct field reordering - /// optimizations, such as with repr(C), repr(packed(1)), or repr(). + /// optimizations, such as with `repr(C)`, `repr(packed(1))`, or `repr()`. pub fn inhibit_struct_field_reordering_opt(&self) -> bool { self.flags.intersects(ReprFlags::IS_UNOPTIMISABLE) || self.pack == 1 || self.int.is_some() } - /// Returns true if this `#[repr()]` should inhibit union abi optimisations + /// Returns `true` if this `#[repr()]` should inhibit union ABI optimisations. pub fn inhibit_union_abi_opt(&self) -> bool { self.c() } @@ -2170,14 +2171,14 @@ impl<'a, 'gcx, 'tcx> AdtDef { self.flags.contains(AdtFlags::HAS_CTOR) } - /// Returns whether this type is `#[fundamental]` for the purposes + /// Returns `true` if this type is `#[fundamental]` for the purposes /// of coherence checking. #[inline] pub fn is_fundamental(&self) -> bool { self.flags.contains(AdtFlags::IS_FUNDAMENTAL) } - /// Returns `true` if this is PhantomData. + /// Returns `true` if this is `PhantomData`. #[inline] pub fn is_phantom_data(&self) -> bool { self.flags.contains(AdtFlags::IS_PHANTOM_DATA) @@ -2199,7 +2200,7 @@ impl<'a, 'gcx, 'tcx> AdtDef { self.flags.contains(AdtFlags::IS_BOX) } - /// Returns whether this type has a destructor. + /// Returns `true` if this type has a destructor. pub fn has_dtor(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> bool { self.destructor(tcx).is_some() } @@ -2320,7 +2321,7 @@ impl<'a, 'gcx, 'tcx> AdtDef { }) } - /// Compute the discriminant value used by a specific variant. + /// Computes the discriminant value used by a specific variant. /// Unlike `discriminants`, this is (amortized) constant-time, /// only doing at most one query for evaluating an explicit /// discriminant (the last one before the requested variant), @@ -2336,9 +2337,9 @@ impl<'a, 'gcx, 'tcx> AdtDef { explicit_value.checked_add(tcx, offset as u128).0 } - /// Yields a DefId for the discriminant and an offset to add to it + /// Yields a `DefId` for the discriminant and an offset to add to it /// Alternatively, if there is no explicit discriminant, returns the - /// inferred discriminant directly + /// inferred discriminant directly. pub fn discriminant_def_for_variant( &self, variant_index: VariantIdx, @@ -2368,15 +2369,15 @@ impl<'a, 'gcx, 'tcx> AdtDef { } /// Returns a list of types such that `Self: Sized` if and only - /// if that type is Sized, or `TyErr` if this type is recursive. + /// if that type is `Sized`, or `TyErr` if this type is recursive. /// - /// Oddly enough, checking that the sized-constraint is Sized is + /// Oddly enough, checking that the sized-constraint is `Sized` is /// actually more expressive than checking all members: - /// the Sized trait is inductive, so an associated type that references - /// Self would prevent its containing ADT from being Sized. + /// the `Sized` trait is inductive, so an associated type that references + /// `Self` would prevent its containing ADT from being `Sized`. /// /// Due to normalization being eager, this applies even if - /// the associated type is behind a pointer, e.g., issue #31299. + /// the associated type is behind a pointer (e.g., issue #31299). pub fn sized_constraint(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> &'tcx [Ty<'tcx>] { match tcx.try_adt_sized_constraint(DUMMY_SP, self.did) { Ok(tys) => tys, @@ -2480,7 +2481,7 @@ impl<'a, 'gcx, 'tcx> FieldDef { } } -/// Represents the various closure traits in the Rust language. This +/// Represents the various closure traits in the language. This /// will determine the type of the environment (`self`, in the /// desugaring) argument that the closure expects. /// @@ -2552,7 +2553,7 @@ impl<'tcx> TyS<'tcx> { TypeWalker::new(self) } - /// Iterator that walks the immediate children of `self`. Hence + /// Iterator that walks the immediate children of `self`. Hence /// `Foo, u32>` yields the sequence `[Bar, u32]` /// (but not `i32`, like `walk`). pub fn walk_shallow(&'tcx self) -> smallvec::IntoIter> { @@ -2560,7 +2561,7 @@ impl<'tcx> TyS<'tcx> { } /// Walks `ty` and any types appearing within `ty`, invoking the - /// callback `f` on each type. If the callback returns false, then the + /// callback `f` on each type. If the callback returns `false`, then the /// children of the current type are ignored. /// /// Note: prefer `ty.walk()` where possible. @@ -2670,7 +2671,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { self.typeck_tables_of(self.hir().body_owner_def_id(body)) } - /// Returns an iterator of the def-ids for all body-owners in this + /// Returns an iterator of the `DefId`s for all body-owners in this /// crate. If you would prefer to iterate over the bodies /// themselves, you can do `self.hir().krate().body_ids.iter()`. pub fn body_owners( @@ -2917,7 +2918,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - /// Return the possibly-auto-generated MIR of a (DefId, Subst) pair. + /// Returns the possibly-auto-generated MIR of a `(DefId, Subst)` pair. pub fn instance_mir(self, instance: ty::InstanceDef<'gcx>) -> &'gcx Mir<'gcx> { @@ -2937,7 +2938,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - /// Get the attributes of a definition. + /// Gets the attributes of a definition. pub fn get_attrs(self, did: DefId) -> Attributes<'gcx> { if let Some(id) = self.hir().as_local_hir_id(did) { Attributes::Borrowed(self.hir().attrs_by_hir_id(id)) @@ -2946,7 +2947,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - /// Determine whether an item is annotated with an attribute. + /// Determines whether an item is annotated with an attribute. pub fn has_attr(self, did: DefId, attr: &str) -> bool { attr::contains_name(&self.get_attrs(did), attr) } @@ -2960,14 +2961,14 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { self.optimized_mir(def_id).generator_layout.as_ref().unwrap() } - /// Given the def-id of an impl, return the def_id of the trait it implements. - /// If it implements no trait, return `None`. + /// Given the `DefId` of an impl, returns the `DefId` of the trait it implements. + /// If it implements no trait, returns `None`. pub fn trait_id_of_impl(self, def_id: DefId) -> Option { self.impl_trait_ref(def_id).map(|tr| tr.def_id) } - /// If the given defid describes a method belonging to an impl, return the - /// def-id of the impl that the method belongs to. Otherwise, return `None`. + /// If the given defid describes a method belonging to an impl, returns the + /// `DefId` of the impl that the method belongs to; otherwise, returns `None`. pub fn impl_of_method(self, def_id: DefId) -> Option { let item = if def_id.krate != LOCAL_CRATE { if let Some(Def::Method(_)) = self.describe_def(def_id) { @@ -2998,9 +2999,9 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - // Hygienically compare a use-site name (`use_name`) for a field or an associated item with its - // supposed definition name (`def_name`). The method also needs `DefId` of the supposed - // definition's parent/scope to perform comparison. + /// Hygienically compares a use-site name (`use_name`) for a field or an associated item with + /// its supposed definition name (`def_name`). The method also needs `DefId` of the supposed + /// definition's parent/scope to perform comparison. pub fn hygienic_eq(self, use_name: Ident, def_name: Ident, def_parent_def_id: DefId) -> bool { self.adjust_ident(use_name, def_parent_def_id, DUMMY_NODE_ID).0 == def_name.modern() } @@ -3082,7 +3083,7 @@ fn associated_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Asso parent_item.node) } -/// Calculates the Sized-constraint. +/// Calculates the `Sized` constraint. /// /// In fact, there are only a few options for the types in the constraint: /// - an obviously-unsized type @@ -3135,9 +3136,9 @@ fn def_span<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Span { tcx.hir().span_if_local(def_id).unwrap() } -/// If the given def ID describes an item belonging to a trait, -/// return the ID of the trait that the trait item belongs to. -/// Otherwise, return `None`. +/// If the given `DefId` describes an item belonging to a trait, +/// returns the `DefId` of the trait that the trait item belongs to; +/// otherwise, returns `None`. fn trait_of_item<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Option { tcx.opt_associated_item(def_id) .and_then(|associated_item| { @@ -3232,10 +3233,9 @@ fn instance_def_size_estimate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } } -/// If `def_id` is an issue 33140 hack impl, return its self type. Otherwise -/// return None. +/// If `def_id` is an issue 33140 hack impl, returns its self type; otherwise, returns `None`. /// -/// See ImplOverlapKind::Issue33140 for more details. +/// See [`ImplOverlapKind::Issue33140`] for more details. fn issue33140_self_ty<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Option> diff --git a/src/librustc/ty/query/job.rs b/src/librustc/ty/query/job.rs index 0793366e6d479..16b4af535943b 100644 --- a/src/librustc/ty/query/job.rs +++ b/src/librustc/ty/query/job.rs @@ -31,37 +31,38 @@ use { rustc_data_structures::stable_hasher::{StableHasherResult, StableHasher, HashStable}, }; -/// Indicates the state of a query for a given key in a query map +/// Indicates the state of a query for a given key in a query map. pub(super) enum QueryResult<'tcx> { - /// An already executing query. The query job can be used to await for its completion + /// An already executing query. The query job can be used to await for its completion. Started(Lrc>), - /// The query panicked. Queries trying to wait on this will raise a fatal error / silently panic + /// The query panicked. Queries trying to wait on this will raise a fatal error or + /// silently panic. Poisoned, } -/// A span and a query key +/// Represents a span and a query key. #[derive(Clone, Debug)] pub struct QueryInfo<'tcx> { - /// The span for a reason this query was required + /// The span corresponding to the reason for which this query was required. pub span: Span, pub query: Query<'tcx>, } -/// A object representing an active query job. +/// Representss an object representing an active query job. pub struct QueryJob<'tcx> { pub info: QueryInfo<'tcx>, /// The parent query job which created this job and is implicitly waiting on it. pub parent: Option>>, - /// The latch which is used to wait on this job + /// The latch that is used to wait on this job. #[cfg(parallel_compiler)] latch: QueryLatch<'tcx>, } impl<'tcx> QueryJob<'tcx> { - /// Creates a new query job + /// Creates a new query job. pub fn new(info: QueryInfo<'tcx>, parent: Option>>) -> Self { QueryJob { info, @@ -230,7 +231,7 @@ impl<'tcx> QueryLatch<'tcx> { } } - /// Remove a single waiter from the list of waiters. + /// Removes a single waiter from the list of waiters. /// This is used to break query cycles. fn extract_waiter( &self, diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs index d002b99f385a3..67a5c7d6c9a64 100644 --- a/src/librustc/ty/query/mod.rs +++ b/src/librustc/ty/query/mod.rs @@ -102,12 +102,12 @@ define_queries! { <'tcx> /// Records the type of every item. [] fn type_of: TypeOfItem(DefId) -> Ty<'tcx>, - /// Maps from the def-id of an item (trait/struct/enum/fn) to its + /// Maps from the `DefId` of an item (trait/struct/enum/fn) to its /// associated generics. [] fn generics_of: GenericsOfItem(DefId) -> &'tcx ty::Generics, - /// Maps from the def-id of an item (trait/struct/enum/fn) to the - /// predicates (where clauses) that must be proven true in order + /// Maps from the `DefId` of an item (trait/struct/enum/fn) to the + /// predicates (where-clauses) that must be proven true in order /// to reference it. This is almost always the "predicates query" /// that you want. /// @@ -123,8 +123,8 @@ define_queries! { <'tcx> /// user.) [] fn predicates_of: PredicatesOfItem(DefId) -> Lrc>, - /// Maps from the def-id of an item (trait/struct/enum/fn) to the - /// predicates (where clauses) directly defined on it. This is + /// Maps from the `DefId` of an item (trait/struct/enum/fn) to the + /// predicates (where-clauses) directly defined on it. This is /// equal to the `explicit_predicates_of` predicates plus the /// `inferred_outlives_of` predicates. [] fn predicates_defined_on: PredicatesDefinedOnItem(DefId) @@ -138,7 +138,7 @@ define_queries! { <'tcx> /// Foo<'a, T> { x: &'a T }`, this would return `T: 'a`). [] fn inferred_outlives_of: InferredOutlivesOf(DefId) -> Lrc>>, - /// Maps from the def-id of a trait to the list of + /// Maps from the `DefId` of a trait to the list of /// super-predicates. This is a subset of the full list of /// predicates. We store these in a separate map because we must /// evaluate them even during type conversion, often before the @@ -216,7 +216,7 @@ define_queries! { <'tcx> }, Codegen { - /// Set of all the def-ids in this crate that have MIR associated with + /// Set of all the `DefId`s in this crate that have MIR associated with /// them. This includes all the body owners, but also things like struct /// constructors. [] fn mir_keys: mir_keys(CrateNum) -> Lrc, @@ -226,11 +226,11 @@ define_queries! { <'tcx> /// the value isn't known except to the pass itself. [] fn mir_const_qualif: MirConstQualif(DefId) -> (u8, Lrc>), - /// Fetch the MIR for a given def-id right after it's built - this includes + /// Fetch the MIR for a given `DefId` right after it's built - this includes /// unreachable code. [] fn mir_built: MirBuilt(DefId) -> &'tcx Steal>, - /// Fetch the MIR for a given def-id up till the point where it is + /// Fetch the MIR for a given `DefId` up till the point where it is /// ready for const evaluation. /// /// See the README for the `mir` module for details. @@ -244,7 +244,7 @@ define_queries! { <'tcx> }, TypeChecking { - /// The result of unsafety-checking this def-id. + /// The result of unsafety-checking this `DefId`. [] fn unsafety_check_result: UnsafetyCheckResult(DefId) -> mir::UnsafetyCheckResult, /// HACK: when evaluated, this reports a "unsafe derive on repr(packed)" error @@ -307,13 +307,13 @@ define_queries! { <'tcx> TypeChecking { /// Gets a complete map from all types to their inherent impls. /// Not meant to be used directly outside of coherence. - /// (Defined only for LOCAL_CRATE) + /// (Defined only for `LOCAL_CRATE`.) [] fn crate_inherent_impls: crate_inherent_impls_dep_node(CrateNum) -> Lrc, - /// Checks all types in the krate for overlap in their inherent impls. Reports errors. + /// Checks all types in the crate for overlap in their inherent impls. Reports errors. /// Not meant to be used directly outside of coherence. - /// (Defined only for LOCAL_CRATE) + /// (Defined only for `LOCAL_CRATE`.) [] fn crate_inherent_impls_overlap_check: inherent_impls_overlap_check_dep_node(CrateNum) -> (), }, @@ -321,9 +321,9 @@ define_queries! { <'tcx> Other { /// Evaluate a constant without running sanity checks /// - /// DO NOT USE THIS outside const eval. Const eval uses this to break query cycles during - /// validation. Please add a comment to every use site explaining why using `const_eval` - /// isn't sufficient + /// **Do not use this** outside const eval. Const eval uses this to break query cycles + /// during validation. Please add a comment to every use site explaining why using + /// `const_eval` isn't sufficient [] fn const_eval_raw: const_eval_raw_dep_node(ty::ParamEnvAnd<'tcx, GlobalId<'tcx>>) -> ConstEvalRawResult<'tcx>, @@ -344,7 +344,7 @@ define_queries! { <'tcx> Other { [] fn reachable_set: reachability_dep_node(CrateNum) -> ReachableSet, - /// Per-body `region::ScopeTree`. The `DefId` should be the owner-def-id for the body; + /// Per-body `region::ScopeTree`. The `DefId` should be the owner `DefId` for the body; /// in the case of closures, this will be redirected to the enclosing function. [] fn region_scope_tree: RegionScopeTree(DefId) -> Lrc, @@ -398,7 +398,7 @@ define_queries! { <'tcx> -> Lrc, [] fn is_object_safe: ObjectSafety(DefId) -> bool, - /// Get the ParameterEnvironment for a given item; this environment + /// Gets the ParameterEnvironment for a given item; this environment /// will be in "user-facing" mode, meaning that it is suitabe for /// type-checking etc, and it does not normalize specializable /// associated types. This is almost always what you want, @@ -485,7 +485,7 @@ define_queries! { <'tcx> [] fn foreign_modules: ForeignModules(CrateNum) -> Lrc>, - /// Identifies the entry-point (e.g. the `main` function) for a given + /// Identifies the entry-point (e.g., the `main` function) for a given /// crate, returning `None` if there is no entry point (such as for library crates). [] fn entry_fn: EntryFn(CrateNum) -> Option<(DefId, EntryFnType)>, [] fn plugin_registrar_fn: PluginRegistrarFn(CrateNum) -> Option, diff --git a/src/librustc/ty/query/on_disk_cache.rs b/src/librustc/ty/query/on_disk_cache.rs index 9c9bc0f6aa11c..f948abc7f6fd3 100644 --- a/src/librustc/ty/query/on_disk_cache.rs +++ b/src/librustc/ty/query/on_disk_cache.rs @@ -103,7 +103,7 @@ impl AbsoluteBytePos { } impl<'sess> OnDiskCache<'sess> { - /// Create a new OnDiskCache instance from the serialized data in `data`. + /// Creates a new OnDiskCache instance from the serialized data in `data`. pub fn new(sess: &'sess Session, data: Vec, start_pos: usize) -> OnDiskCache<'sess> { debug_assert!(sess.opts.incremental.is_some()); @@ -325,7 +325,7 @@ impl<'sess> OnDiskCache<'sess> { }) } - /// Load a diagnostic emitted during the previous compilation session. + /// Loads a diagnostic emitted during the previous compilation session. pub fn load_diagnostics<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, dep_node_index: SerializedDepNodeIndex) @@ -339,7 +339,7 @@ impl<'sess> OnDiskCache<'sess> { diagnostics.unwrap_or_default() } - /// Store a diagnostic emitted during the current compilation session. + /// Stores a diagnostic emitted during the current compilation session. /// Anything stored like this will be available via `load_diagnostics` in /// the next compilation session. #[inline(never)] @@ -353,7 +353,7 @@ impl<'sess> OnDiskCache<'sess> { } /// Returns the cached query result if there is something in the cache for - /// the given SerializedDepNodeIndex. Otherwise returns None. + /// the given `SerializedDepNodeIndex`; otherwise returns `None`. pub fn try_load_query_result<'tcx, T>(&self, tcx: TyCtxt<'_, 'tcx, 'tcx>, dep_node_index: SerializedDepNodeIndex) @@ -366,7 +366,7 @@ impl<'sess> OnDiskCache<'sess> { "query result") } - /// Store a diagnostic emitted during computation of an anonymous query. + /// Stores a diagnostic emitted during computation of an anonymous query. /// Since many anonymous queries can share the same `DepNode`, we aggregate /// them -- as opposed to regular queries where we assume that there is a /// 1:1 relationship between query-key and `DepNode`. diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs index f63fbd79825db..9b2a70a6a6d20 100644 --- a/src/librustc/ty/query/plumbing.rs +++ b/src/librustc/ty/query/plumbing.rs @@ -1,6 +1,6 @@ -//! The implementation of the query system itself. Defines the macros -//! that generate the actual methods on tcx which find and execute the -//! provider, manage the caches, and so forth. +//! The implementation of the query system itself. This defines the macros that +//! generate the actual methods on tcx which find and execute the provider, +//! manage the caches, and so forth. use crate::dep_graph::{DepNodeIndex, DepNode, DepKind, SerializedDepNodeIndex}; use crate::errors::DiagnosticBuilder; @@ -1017,8 +1017,8 @@ macro_rules! define_queries_inner { } impl<'a, $tcx, 'lcx> TyCtxt<'a, $tcx, 'lcx> { - /// Return a transparent wrapper for `TyCtxt` which ensures queries - /// are executed instead of returing their result + /// Returns a transparent wrapper for `TyCtxt`, which ensures queries + /// are executed instead of just returing their results. #[inline(always)] pub fn ensure(self) -> TyCtxtEnsure<'a, $tcx, 'lcx> { TyCtxtEnsure { @@ -1026,7 +1026,7 @@ macro_rules! define_queries_inner { } } - /// Return a transparent wrapper for `TyCtxt` which uses + /// Returns a transparent wrapper for `TyCtxt` which uses /// `span` as the location of queries performed through it. #[inline(always)] pub fn at(self, span: Span) -> TyCtxtAt<'a, $tcx, 'lcx> { @@ -1067,7 +1067,7 @@ macro_rules! define_queries_struct { (tcx: $tcx:tt, input: ($(([$($modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => { pub struct Queries<$tcx> { - /// This provides access to the incr. comp. on-disk cache for query results. + /// This provides access to the incrimental comilation on-disk cache for query results. /// Do not access this directly. It is only meant to be used by /// `DepGraph::try_mark_green()` and the query infrastructure. pub(crate) on_disk_cache: OnDiskCache<'tcx>, @@ -1123,22 +1123,22 @@ macro_rules! define_provider_struct { /// /// Now, if force_from_dep_node() would always fail, it would be pretty useless. /// Fortunately, we can use some contextual information that will allow us to -/// reconstruct query-keys for certain kinds of DepNodes. In particular, we -/// enforce by construction that the GUID/fingerprint of certain DepNodes is a -/// valid DefPathHash. Since we also always build a huge table that maps every -/// DefPathHash in the current codebase to the corresponding DefId, we have +/// reconstruct query-keys for certain kinds of `DepNode`s. In particular, we +/// enforce by construction that the GUID/fingerprint of certain `DepNode`s is a +/// valid `DefPathHash`. Since we also always build a huge table that maps every +/// `DefPathHash` in the current codebase to the corresponding `DefId`, we have /// everything we need to re-run the query. /// /// Take the `mir_validated` query as an example. Like many other queries, it -/// just has a single parameter: the DefId of the item it will compute the -/// validated MIR for. Now, when we call `force_from_dep_node()` on a dep-node -/// with kind `MirValidated`, we know that the GUID/fingerprint of the dep-node -/// is actually a DefPathHash, and can therefore just look up the corresponding -/// DefId in `tcx.def_path_hash_to_def_id`. +/// just has a single parameter: the `DefId` of the item it will compute the +/// validated MIR for. Now, when we call `force_from_dep_node()` on a `DepNode` +/// with kind `MirValidated`, we know that the GUID/fingerprint of the `DepNode` +/// is actually a `DefPathHash`, and can therefore just look up the corresponding +/// `DefId` in `tcx.def_path_hash_to_def_id`. /// /// When you implement a new query, it will likely have a corresponding new -/// DepKind, and you'll have to support it here in `force_from_dep_node()`. As -/// a rule of thumb, if your query takes a DefId or DefIndex as sole parameter, +/// `DepKind`, and you'll have to support it here in `force_from_dep_node()`. As +/// a rule of thumb, if your query takes a `DefId` or `DefIndex` as sole parameter, /// then `force_from_dep_node()` should not fail for it. Otherwise, you can just /// add it to the "We don't have enough information to reconstruct..." group in /// the match below. diff --git a/src/librustc/ty/relate.rs b/src/librustc/ty/relate.rs index 3dbd0dc1d97f7..db248072d9b50 100644 --- a/src/librustc/ty/relate.rs +++ b/src/librustc/ty/relate.rs @@ -30,7 +30,7 @@ pub trait TypeRelation<'a, 'gcx: 'a+'tcx, 'tcx: 'a> : Sized { /// Returns a static string we can use for printouts. fn tag(&self) -> &'static str; - /// Returns true if the value `a` is the "expected" type in the + /// Returns `true` if the value `a` is the "expected" type in the /// relation. Just affects error messages. fn a_is_expected(&self) -> bool; diff --git a/src/librustc/ty/steal.rs b/src/librustc/ty/steal.rs index 336a4c3bf2279..a8f9301ba51c9 100644 --- a/src/librustc/ty/steal.rs +++ b/src/librustc/ty/steal.rs @@ -12,14 +12,14 @@ use rustc_data_structures::sync::{RwLock, ReadGuard, MappedReadGuard}; /// Steal>` (to be very specific). Now we can read from this /// as much as we want (using `borrow()`), but you can also /// `steal()`. Once you steal, any further attempt to read will panic. -/// Therefore we know that -- assuming no ICE -- nobody is observing +/// Therefore, we know that -- assuming no ICE -- nobody is observing /// the fact that the MIR was updated. /// /// Obviously, whenever you have a query that yields a `Steal` value, /// you must treat it with caution, and make sure that you know that /// -- once the value is stolen -- it will never be read from again. -/// -/// FIXME(#41710) -- what is the best way to model linear queries? +// +// FIXME(#41710): what is the best way to model linear queries? pub struct Steal { value: RwLock> } diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index d4c18c64c9951..66efd2aea155a 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -47,7 +47,7 @@ pub enum BoundRegion { /// Named region parameters for functions (a in &'a T) /// - /// The def-id is needed to distinguish free regions in + /// The `DefId` is needed to distinguish free regions in /// the event of shadowing. BrNamed(DefId, InternedString), @@ -87,7 +87,7 @@ pub enum TyKind<'tcx> { Bool, /// The primitive character type; holds a Unicode scalar value - /// (a non-surrogate code point). Written as `char`. + /// (a non-surrogate code point). Written as `char`. Char, /// A primitive signed integer type. For example, `i32`. @@ -116,7 +116,7 @@ pub enum TyKind<'tcx> { /// An array with the given length. Written as `[T; n]`. Array(Ty<'tcx>, &'tcx ty::LazyConst<'tcx>), - /// The pointee of an array slice. Written as `[T]`. + /// The pointee of an array slice. Written as `[T]`. Slice(Ty<'tcx>), /// A raw pointer. Written as `*mut T` or `*const T` @@ -138,7 +138,7 @@ pub enum TyKind<'tcx> { /// ``` FnDef(DefId, &'tcx Substs<'tcx>), - /// A pointer to a function. Written as `fn() -> i32`. + /// A pointer to a function. Written as `fn() -> i32`. /// /// For example the type of `bar` here: /// @@ -166,10 +166,10 @@ pub enum TyKind<'tcx> { /// The never type `!` Never, - /// A tuple type. For example, `(i32, bool)`. + /// A tuple type. For example, `(i32, bool)`. Tuple(&'tcx List>), - /// The projection of an associated type. For example, + /// The projection of an associated type. For example, /// `>::N`. Projection(ProjectionTy<'tcx>), @@ -278,7 +278,7 @@ static_assert!(MEM_SIZE_OF_TY_KIND: ::std::mem::size_of::>() == 24); /// /// All right, you say, but why include the type parameters from the /// original function then? The answer is that codegen may need them -/// when monomorphizing, and they may not appear in the upvars. A +/// when monomorphizing, and they may not appear in the upvars. A /// closure could capture no variables but still make use of some /// in-scope type parameter with a bound (e.g., if our example above /// had an extra `U: Default`, and the closure called `U::default()`). @@ -295,9 +295,9 @@ static_assert!(MEM_SIZE_OF_TY_KIND: ::std::mem::size_of::>() == 24); /// ## Generators /// /// Perhaps surprisingly, `ClosureSubsts` are also used for -/// generators. In that case, what is written above is only half-true +/// generators. In that case, what is written above is only half-true /// -- the set of type parameters is similar, but the role of CK and -/// CS are different. CK represents the "yield type" and CS +/// CS are different. CK represents the "yield type" and CS /// represents the "return type" of the generator. /// /// It'd be nice to split this struct into ClosureSubsts and @@ -442,17 +442,17 @@ impl<'tcx> GeneratorSubsts<'tcx> { self.split(def_id, tcx).return_ty } - /// Return the "generator signature", which consists of its yield + /// Returns the "generator signature", which consists of its yield /// and return types. /// - /// NB. Some bits of the code prefers to see this wrapped in a + /// N.B., some bits of the code prefers to see this wrapped in a /// binder, but it never contains bound regions. Probably this /// function should be removed. pub fn poly_sig(self, def_id: DefId, tcx: TyCtxt<'_, '_, '_>) -> PolyGenSig<'tcx> { ty::Binder::dummy(self.sig(def_id, tcx)) } - /// Return the "generator signature", which consists of its yield + /// Returns the "generator signature", which consists of its yield /// and return types. pub fn sig(self, def_id: DefId, tcx: TyCtxt<'_, '_, '_>) -> GenSig<'tcx> { ty::GenSig { @@ -520,11 +520,11 @@ impl<'tcx> UpvarSubsts<'tcx> { #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Hash, RustcEncodable, RustcDecodable)] pub enum ExistentialPredicate<'tcx> { - /// e.g., Iterator + /// E.g., `Iterator`. Trait(ExistentialTraitRef<'tcx>), - /// e.g., Iterator::Item = T + /// E.g., `Iterator::Item = T`. Projection(ExistentialProjection<'tcx>), - /// e.g., Send + /// E.g., `Send`. AutoTrait(DefId), } @@ -655,12 +655,12 @@ impl<'tcx> Binder<&'tcx List>> { } /// A complete reference to a trait. These take numerous guises in syntax, -/// but perhaps the most recognizable form is in a where clause: +/// but perhaps the most recognizable form is in a where-clause: /// /// T: Foo /// -/// This would be represented by a trait-reference where the def-id is the -/// def-id for the trait `Foo` and the substs define `T` as parameter 0, +/// This would be represented by a trait-reference where the `DefId` is the +/// `DefId` for the trait `Foo` and the substs define `T` as parameter 0, /// and `U` as parameter 1. /// /// Trait references also appear in object types like `Foo`, but in @@ -766,9 +766,9 @@ impl<'a, 'gcx, 'tcx> ExistentialTraitRef<'tcx> { } } - /// Object types don't have a self-type specified. Therefore, when + /// Object types don't have a self type specified. Therefore, when /// we convert the principal trait-ref into a normal trait-ref, - /// you must give *some* self-type. A common choice is `mk_err()` + /// you must give *some* self type. A common choice is `mk_err()` /// or some placeholder type. pub fn with_self_ty(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, self_ty: Ty<'tcx>) -> ty::TraitRef<'tcx> { @@ -789,9 +789,9 @@ impl<'tcx> PolyExistentialTraitRef<'tcx> { self.skip_binder().def_id } - /// Object types don't have a self-type specified. Therefore, when + /// Object types don't have a self type specified. Therefore, when /// we convert the principal trait-ref into a normal trait-ref, - /// you must give *some* self-type. A common choice is `mk_err()` + /// you must give *some* self type. A common choice is `mk_err()` /// or some placeholder type. pub fn with_self_ty(&self, tcx: TyCtxt<'_, '_, 'tcx>, self_ty: Ty<'tcx>) @@ -829,7 +829,7 @@ impl Binder { /// Skips the binder and returns the "bound" value. This is a /// risky thing to do because it's easy to get confused about - /// debruijn indices and the like. It is usually better to + /// De Bruijn indices and the like. It is usually better to /// discharge the binder using `no_bound_vars` or /// `replace_late_bound_regions` or something like /// that. `skip_binder` is only valid when you are either @@ -840,7 +840,7 @@ impl Binder { /// /// Some examples where `skip_binder` is reasonable: /// - /// - extracting the def-id from a PolyTraitRef; + /// - extracting the `DefId` from a PolyTraitRef; /// - comparing the self type of a PolyTraitRef to see if it is equal to /// a type parameter `X`, since the type `X` does not reference any regions pub fn skip_binder(&self) -> &T { @@ -884,8 +884,8 @@ impl Binder { } /// Given two things that have the same binder level, - /// and an operation that wraps on their contents, execute the operation - /// and then wrap its result. + /// and an operation that wraps on their contents, executes the operation + /// and then wraps its result. /// /// `f` should consider bound regions at depth 1 to be free, and /// anything it produces with bound regions at depth 1 will be @@ -896,7 +896,7 @@ impl Binder { Binder(f(self.0, u.0)) } - /// Split the contents into two things that share the same binder + /// Splits the contents into two things that share the same binder /// level as the original, returning two distinct binders. /// /// `f` should consider bound regions at depth 1 to be free, and @@ -1118,14 +1118,14 @@ pub type Region<'tcx> = &'tcx RegionKind; /// ## Bound Regions /// /// These are regions that are stored behind a binder and must be substituted -/// with some concrete region before being used. There are 2 kind of -/// bound regions: early-bound, which are bound in an item's Generics, -/// and are substituted by a Substs, and late-bound, which are part of -/// higher-ranked types (e.g., `for<'a> fn(&'a ())`) and are substituted by +/// with some concrete region before being used. There are two kind of +/// bound regions: early-bound, which are bound in an item's `Generics`, +/// and are substituted by a `Substs`, and late-bound, which are part of +/// higher-ranked types (e.g., `for<'a> fn(&'a ())`), and are substituted by /// the likes of `liberate_late_bound_regions`. The distinction exists /// because higher-ranked lifetimes aren't supported in all places. See [1][2]. /// -/// Unlike Param-s, bound regions are not supposed to exist "in the wild" +/// Unlike `Param`s, bound regions are not supposed to exist "in the wild" /// outside their binder, e.g., in types passed to type inference, and /// should first be substituted (by placeholder regions, free regions, /// or region variables). @@ -1141,7 +1141,7 @@ pub type Region<'tcx> = &'tcx RegionKind; /// To do this, we replace the bound regions with placeholder markers, /// which don't satisfy any relation not explicitly provided. /// -/// There are 2 kinds of placeholder regions in rustc: `ReFree` and +/// There are two kinds of placeholder regions in rustc: `ReFree` and /// `RePlaceholder`. When checking an item's body, `ReFree` is supposed /// to be used. These also support explicit bounds: both the internally-stored /// *scope*, which the region is assumed to outlive, as well as other @@ -1189,7 +1189,7 @@ pub enum RegionKind { /// Static data that has an "infinite" lifetime. Top in the region lattice. ReStatic, - /// A region variable. Should not exist after typeck. + /// A region variable. Should not exist after typeck. ReVar(RegionVid), /// A placeholder region - basically the higher-ranked version of ReFree. @@ -1346,11 +1346,11 @@ impl<'a, 'tcx, 'gcx> PolyExistentialProjection<'tcx> { impl DebruijnIndex { /// Returns the resulting index when this value is moved into - /// `amount` number of new binders. So e.g., if you had + /// `amount` number of new binders. So, e.g., if you had /// /// for<'a> fn(&'a x) /// - /// and you wanted to change to + /// and you wanted to change it to /// /// for<'a> fn(for<'b> fn(&'a x)) /// @@ -1378,7 +1378,7 @@ impl DebruijnIndex { *self = self.shifted_out(amount); } - /// Adjusts any Debruijn Indices so as to make `to_binder` the + /// Adjusts any De Bruijn indices so as to make `to_binder` the /// innermost binder. That is, if we have something bound at `to_binder`, /// it will now be bound at INNERMOST. This is an appropriate thing to do /// when moving a region out from inside binders: @@ -1388,12 +1388,12 @@ impl DebruijnIndex { /// // Binder: D3 D2 D1 ^^ /// ``` /// - /// Here, the region `'a` would have the debruijn index D3, + /// Here, the region `'a` would have the De Bruijn index D3, /// because it is the bound 3 binders out. However, if we wanted /// to refer to that region `'a` in the second argument (the `_`), /// those two binders would not be in scope. In that case, we /// might invoke `shift_out_to_binder(D3)`. This would adjust the - /// debruijn index of `'a` to D1 (the innermost binder). + /// De Bruijn index of `'a` to D1 (the innermost binder). /// /// If we invoke `shift_out_to_binder` and the region is in fact /// bound by one of the binders we are shifting out of, that is an @@ -1444,7 +1444,7 @@ impl RegionKind { } } - /// Adjusts any Debruijn Indices so as to make `to_binder` the + /// Adjusts any De Bruijn indices so as to make `to_binder` the /// innermost binder. That is, if we have something bound at `to_binder`, /// it will now be bound at INNERMOST. This is an appropriate thing to do /// when moving a region out from inside binders: @@ -1454,12 +1454,12 @@ impl RegionKind { /// // Binder: D3 D2 D1 ^^ /// ``` /// - /// Here, the region `'a` would have the debruijn index D3, + /// Here, the region `'a` would have the De Bruijn index D3, /// because it is the bound 3 binders out. However, if we wanted /// to refer to that region `'a` in the second argument (the `_`), /// those two binders would not be in scope. In that case, we /// might invoke `shift_out_to_binder(D3)`. This would adjust the - /// debruijn index of `'a` to D1 (the innermost binder). + /// De Bruijn index of `'a` to D1 (the innermost binder). /// /// If we invoke `shift_out_to_binder` and the region is in fact /// bound by one of the binders we are shifting out of, that is an @@ -1528,7 +1528,7 @@ impl RegionKind { flags } - /// Given an early-bound or free region, returns the def-id where it was bound. + /// Given an early-bound or free region, returns the `DefId` where it was bound. /// For example, consider the regions in this snippet of code: /// /// ``` @@ -1543,10 +1543,10 @@ impl RegionKind { /// } /// ``` /// - /// Here, `free_region_binding_scope('a)` would return the def-id + /// Here, `free_region_binding_scope('a)` would return the `DefId` /// of the impl, and for all the other highlighted regions, it - /// would return the def-id of the function. In other cases (not shown), this - /// function might return the def-id of a closure. + /// would return the `DefId` of the function. In other cases (not shown), this + /// function might return the `DefId` of a closure. pub fn free_region_binding_scope(&self, tcx: TyCtxt<'_, '_, '_>) -> DefId { match self { ty::ReEarlyBound(br) => { @@ -1772,7 +1772,7 @@ impl<'a, 'gcx, 'tcx> TyS<'tcx> { } } - /// Returns true if this type is a floating point type and false otherwise. + /// Returns `true` if this type is a floating point type. pub fn is_floating_point(&self) -> bool { match self.sty { Float(_) | diff --git a/src/librustc/ty/subst.rs b/src/librustc/ty/subst.rs index d7c322d0f8402..7559ea90b1782 100644 --- a/src/librustc/ty/subst.rs +++ b/src/librustc/ty/subst.rs @@ -171,7 +171,7 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> { /// Creates a `Substs` that maps each generic parameter to a higher-ranked /// var bound at index `0`. For types, we use a `BoundVar` index equal to /// the type parameter index. For regions, we use the `BoundRegion::BrNamed` - /// variant (which has a def-id). + /// variant (which has a `DefId`). pub fn bound_vars_for_item( tcx: TyCtxt<'a, 'gcx, 'tcx>, def_id: DefId @@ -492,7 +492,7 @@ impl<'a, 'gcx, 'tcx> SubstFolder<'a, 'gcx, 'tcx> { self.shift_vars_through_binders(ty) } - /// It is sometimes necessary to adjust the debruijn indices during substitution. This occurs + /// It is sometimes necessary to adjust the De Bruijn indices during substitution. This occurs /// when we are substituting a type with escaping bound vars into a context where we have /// passed through binders. That's quite a mouthful. Let's see an example: /// @@ -511,9 +511,9 @@ impl<'a, 'gcx, 'tcx> SubstFolder<'a, 'gcx, 'tcx> { /// /// Here the `'a` lifetime is bound in the outer function, but appears as an argument of the /// inner one. Therefore, that appearance will have a DebruijnIndex of 2, because we must skip - /// over the inner binder (remember that we count Debruijn indices from 1). However, in the + /// over the inner binder (remember that we count De Bruijn indices from 1). However, in the /// definition of `MetaFunc`, the binder is not visible, so the type `&'a int` will have a - /// debruijn index of 1. It's only during the substitution that we can see we must increase the + /// De Bruijn index of 1. It's only during the substitution that we can see we must increase the /// depth by 1 to account for the binder that we passed through. /// /// As a second example, consider this twist: @@ -532,7 +532,7 @@ impl<'a, 'gcx, 'tcx> SubstFolder<'a, 'gcx, 'tcx> { /// DebruijnIndex of 2 /// /// As indicated in the diagram, here the same type `&'a int` is substituted once, but in the - /// first case we do not increase the Debruijn index and in the second case we do. The reason + /// first case we do not increase the De Bruijn index and in the second case we do. The reason /// is that only in the second case have we passed through a fn binder. fn shift_vars_through_binders(&self, ty: Ty<'tcx>) -> Ty<'tcx> { debug!("shift_vars(ty={:?}, binders_passed={:?}, has_escaping_bound_vars={:?})", @@ -565,7 +565,7 @@ pub struct UserSubsts<'tcx> { /// The substitutions for the item as given by the user. pub substs: &'tcx Substs<'tcx>, - /// The self-type, in the case of a `::Item` path (when applied + /// The self type, in the case of a `::Item` path (when applied /// to an inherent impl). See `UserSelfTy` below. pub user_self_ty: Option>, } @@ -585,8 +585,8 @@ BraceStructLiftImpl! { } } -/// Specifies the user-given self-type. In the case of a path that -/// refers to a member in an inherent impl, this self-type is +/// Specifies the user-given self type. In the case of a path that +/// refers to a member in an inherent impl, this self type is /// sometimes needed to constrain the type parameters on the impl. For /// example, in this code: /// @@ -596,11 +596,11 @@ BraceStructLiftImpl! { /// ``` /// /// when you then have a path like `>::method`, -/// this struct would carry the def-id of the impl along with the -/// self-type `Foo`. Then we can instantiate the parameters of +/// this struct would carry the `DefId` of the impl along with the +/// self type `Foo`. Then we can instantiate the parameters of /// the impl (with the substs from `UserSubsts`) and apply those to -/// the self-type, giving `Foo`. Finally, we unify that with -/// the self-type here, which contains `?A` to be `&'static u32` +/// the self type, giving `Foo`. Finally, we unify that with +/// the self type here, which contains `?A` to be `&'static u32` #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)] pub struct UserSelfTy<'tcx> { pub impl_def_id: DefId, diff --git a/src/librustc/ty/trait_def.rs b/src/librustc/ty/trait_def.rs index 5429a2504b97b..9ce8bf2e60a31 100644 --- a/src/librustc/ty/trait_def.rs +++ b/src/librustc/ty/trait_def.rs @@ -39,7 +39,7 @@ pub struct TraitDef { #[derive(Default)] pub struct TraitImpls { blanket_impls: Vec, - /// Impls indexed by their simplified self-type, for fast lookup. + /// Impls indexed by their simplified self type, for fast lookup. non_blanket_impls: FxHashMap>, } @@ -84,7 +84,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } /// Iterate over every impl that could possibly match the - /// self-type `self_ty`. + /// self type `self_ty`. pub fn for_each_relevant_impl(self, def_id: DefId, self_ty: Ty<'tcx>, @@ -134,7 +134,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - /// Return a vector containing all impls + /// Returns a vector containing all impls pub fn all_impls(self, def_id: DefId) -> Vec { let impls = self.trait_impls_of(def_id); diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs index 61544932b4329..0578162f84d02 100644 --- a/src/librustc/ty/util.rs +++ b/src/librustc/ty/util.rs @@ -1,4 +1,4 @@ -//! misc. type-system utilities too small to deserve their own file +//! Miscellaneous type-system utilities that are too small to deserve their own modules. use crate::hir::def::Def; use crate::hir::def_id::DefId; @@ -23,7 +23,7 @@ use syntax_pos::{Span, DUMMY_SP}; #[derive(Copy, Clone, Debug)] pub struct Discr<'tcx> { - /// bit representation of the discriminant, so `-128i8` is `0xFF_u128` + /// Bit representation of the discriminant (e.g., `-128i8` is `0xFF_u128`). pub val: u128, pub ty: Ty<'tcx> } @@ -46,7 +46,7 @@ impl<'tcx> fmt::Display for Discr<'tcx> { } impl<'tcx> Discr<'tcx> { - /// Adds 1 to the value and wraps around if the maximum for the type is reached + /// Adds `1` to the value and wraps around if the maximum for the type is reached. pub fn wrap_incr<'a, 'gcx>(self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Self { self.checked_add(tcx, 1).0 } @@ -342,9 +342,9 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { /// /// Requires that trait definitions have been processed so that we can /// elaborate predicates and walk supertraits. - /// - /// FIXME callers may only have a &[Predicate], not a Vec, so that's - /// what this code should accept. + // + // FIXME: callers may only have a `&[Predicate]`, not a `Vec`, so that's + // what this code should accept. pub fn required_region_bounds(self, erased_self_ty: Ty<'tcx>, predicates: Vec>) @@ -417,7 +417,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { Some(ty::Destructor { did: dtor_did? }) } - /// Return the set of types that are required to be alive in + /// Returns the set of types that are required to be alive in /// order to run the destructor of `def` (see RFCs 769 and /// 1238). /// @@ -507,17 +507,17 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { result } - /// True if `def_id` refers to a closure (e.g., `|x| x * 2`). Note - /// that closures have a def-id, but the closure *expression* also + /// Returns `true` if `def_id` refers to a closure (e.g., `|x| x * 2`). Note + /// that closures have a `DefId`, but the closure *expression* also /// has a `HirId` that is located within the context where the /// closure appears (and, sadly, a corresponding `NodeId`, since /// those are not yet phased out). The parent of the closure's - /// def-id will also be the context where it appears. + /// `DefId` will also be the context where it appears. pub fn is_closure(self, def_id: DefId) -> bool { self.def_key(def_id).disambiguated_data.data == DefPathData::ClosureExpr } - /// True if `def_id` refers to a trait (i.e., `trait Foo { ... }`). + /// Returns `true` if `def_id` refers to a trait (i.e., `trait Foo { ... }`). pub fn is_trait(self, def_id: DefId) -> bool { if let DefPathData::Trait(_) = self.def_key(def_id).disambiguated_data.data { true @@ -526,7 +526,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - /// True if `def_id` refers to a trait alias (i.e., `trait Foo = ...;`). + /// Returns `true` if `def_id` refers to a trait alias (i.e., `trait Foo = ...;`), + /// and `false` otherwise. pub fn is_trait_alias(self, def_id: DefId) -> bool { if let DefPathData::TraitAlias(_) = self.def_key(def_id).disambiguated_data.data { true @@ -535,17 +536,17 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - /// True if this def-id refers to the implicit constructor for - /// a tuple struct like `struct Foo(u32)`. + /// Returns `true` if this `DefId` refers to the implicit constructor for + /// a tuple struct like `struct Foo(u32)`, and `false` otherwise. pub fn is_struct_constructor(self, def_id: DefId) -> bool { self.def_key(def_id).disambiguated_data.data == DefPathData::StructCtor } /// Given the `DefId` of a fn or closure, returns the `DefId` of /// the innermost fn item that the closure is contained within. - /// This is a significant def-id because, when we do + /// This is a significant `DefId` because, when we do /// type-checking, we type-check this fn item and all of its - /// (transitive) closures together. Therefore, when we fetch the + /// (transitive) closures together. Therefore, when we fetch the /// `typeck_tables_of` the closure, for example, we really wind up /// fetching the `typeck_tables_of` the enclosing fn item. pub fn closure_base_def_id(self, def_id: DefId) -> DefId { @@ -558,10 +559,10 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { def_id } - /// Given the def-id and substs a closure, creates the type of + /// Given the `DefId` and substs a closure, creates the type of /// `self` argument that the closure expects. For example, for a /// `Fn` closure, this would return a reference type `&T` where - /// `T=closure_ty`. + /// `T = closure_ty`. /// /// Returns `None` if this closure's kind has not yet been inferred. /// This should only be possible during type checking. @@ -585,7 +586,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { Some(ty::Binder::bind(env_ty)) } - /// Given the def-id of some item that has no type parameters, make + /// Given the `DefId` of some item that has no type parameters, make /// a suitable "empty substs" for it. pub fn empty_substs_for_def_id(self, item_def_id: DefId) -> &'tcx Substs<'tcx> { Substs::for_item(self, item_def_id, |param, _| { @@ -598,7 +599,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { }) } - /// Return whether the node pointed to by def_id is a static item, and its mutability + /// Returns `true` if the node pointed to by `def_id` is a static item, and its mutability. pub fn is_static(&self, def_id: DefId) -> Option { if let Some(node) = self.hir().get_if_local(def_id) { match node { @@ -730,7 +731,7 @@ impl<'a, 'tcx> ty::TyS<'tcx> { /// Checks whether values of this type `T` implement the `Freeze` /// trait -- frozen types are those that do not contain a - /// `UnsafeCell` anywhere. This is a language concept used to + /// `UnsafeCell` anywhere. This is a language concept used to /// distinguish "true immutability", which is relevant to /// optimization as well as the rules around static values. Note /// that the `Freeze` trait is not exposed to end users and is diff --git a/src/librustc/ty/wf.rs b/src/librustc/ty/wf.rs index 2aae953c1c40a..ffb5471e34fbf 100644 --- a/src/librustc/ty/wf.rs +++ b/src/librustc/ty/wf.rs @@ -227,7 +227,7 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> { } } - /// Push new obligations into `out`. Returns true if it was able + /// Pushes new obligations into `out`. Returns `true` if it was able /// to generate all the predicates needed to validate that `ty0` /// is WF. Returns false if `ty0` is an unresolved type variable, /// in which case we are not able to simplify at all. @@ -502,7 +502,7 @@ impl<'a, 'gcx, 'tcx> WfPredicates<'a, 'gcx, 'tcx> { } } -/// Given an object type like `SomeTrait+Send`, computes the lifetime +/// Given an object type like `SomeTrait + Send`, computes the lifetime /// bounds that must hold on the elided self type. These are derived /// from the declarations of `SomeTrait`, `Send`, and friends -- if /// they declare `trait SomeTrait : 'static`, for example, then diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs index f6743ed75d92e..dd635e5c946f0 100644 --- a/src/librustc/util/common.rs +++ b/src/librustc/util/common.rs @@ -63,11 +63,11 @@ pub fn install_panic_hook() { /// Parameters to the `Dump` variant of type `ProfileQueriesMsg`. #[derive(Clone,Debug)] pub struct ProfQDumpParams { - /// A base path for the files we will dump + /// A base path for the files we will dump. pub path:String, - /// To ensure that the compiler waits for us to finish our dumps + /// To ensure that the compiler waits for us to finish our dumps. pub ack:Sender<()>, - /// toggle dumping a log file with every `ProfileQueriesMsg` + /// Toggle dumping a log file with every `ProfileQueriesMsg`. pub dump_profq_msg_log:bool, } @@ -131,7 +131,7 @@ pub fn time_depth() -> usize { TIME_DEPTH.with(|slot| slot.get()) } -/// Set the current depth of `time()` calls. The idea is to call +/// Sets the current depth of `time()` calls. The idea is to call /// `set_time_depth()` with the result from `time_depth()` in the /// parent thread. pub fn set_time_depth(depth: usize) { diff --git a/src/librustc/util/nodemap.rs b/src/librustc/util/nodemap.rs index 6969b2f872ade..63c7b76d1b6a5 100644 --- a/src/librustc/util/nodemap.rs +++ b/src/librustc/util/nodemap.rs @@ -1,4 +1,4 @@ -//! An efficient hash map for node IDs +//! An efficient hash map for `NodeId`s. use crate::hir::def_id::DefId; use crate::hir::{HirId, ItemLocalId}; diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs index 4945bf8364877..1cb9f47bb31f1 100644 --- a/src/librustc/util/ppaux.rs +++ b/src/librustc/util/ppaux.rs @@ -23,18 +23,18 @@ use crate::hir; /// The "region highlights" are used to control region printing during /// specific error messages. When a "region highlight" is enabled, it /// gives an alternate way to print specific regions. For now, we -/// always print those regions using a number, so something like `'0`. +/// always print those regions using a number, so something like "`'0`". /// /// Regions not selected by the region highlight mode are presently /// unaffected. #[derive(Copy, Clone, Default)] pub struct RegionHighlightMode { - /// If enabled, when we see the selected region, use `"'N"` + /// If enabled, when we see the selected region, use "`'N`" /// instead of the ordinary behavior. highlight_regions: [Option<(ty::RegionKind, usize)>; 3], /// If enabled, when printing a "free region" that originated from - /// the given `ty::BoundRegion`, print it as `'1`. Free regions that would ordinarily + /// the given `ty::BoundRegion`, print it as "`'1`". Free regions that would ordinarily /// have names print as normal. /// /// This is used when you have a signature like `fn foo(x: &u32, @@ -51,12 +51,12 @@ thread_local! { } impl RegionHighlightMode { - /// Read and return current region highlight settings (accesses thread-local state).a + /// Reads and returns the current region highlight settings (accesses thread-local state). pub fn get() -> Self { REGION_HIGHLIGHT_MODE.with(|c| c.get()) } - /// Internal helper to update current settings during the execution of `op`. + // Internal helper to update current settings during the execution of `op`. fn set( old_mode: Self, new_mode: Self, @@ -70,8 +70,8 @@ impl RegionHighlightMode { }) } - /// If `region` and `number` are both `Some`, invoke - /// `highlighting_region`. Otherwise, just invoke `op` directly. + /// If `region` and `number` are both `Some`, invokes + /// `highlighting_region`; otherwise, just invokes `op` directly. pub fn maybe_highlighting_region( region: Option>, number: Option, @@ -86,8 +86,8 @@ impl RegionHighlightMode { op() } - /// During the execution of `op`, highlight the region inference - /// vairable `vid` as `'N`. We can only highlight one region vid + /// During the execution of `op`, highlights the region inference + /// variable `vid` as `'N`. We can only highlight one region `vid` /// at a time. pub fn highlighting_region( region: ty::Region<'_>, @@ -109,7 +109,7 @@ impl RegionHighlightMode { Self::set(old_mode, new_mode, op) } - /// Convenience wrapper for `highlighting_region` + /// Convenience wrapper for `highlighting_region`. pub fn highlighting_region_vid( vid: ty::RegionVid, number: usize, @@ -118,7 +118,7 @@ impl RegionHighlightMode { Self::highlighting_region(&ty::ReVar(vid), number, op) } - /// Returns true if any placeholders are highlighted. + /// Returns `true` if any placeholders are highlighted, and `false` otherwise. fn any_region_vids_highlighted(&self) -> bool { Self::get() .highlight_regions @@ -129,8 +129,7 @@ impl RegionHighlightMode { }) } - /// Returns `Some(n)` with the number to use for the given region, - /// if any. + /// Returns `Some(n)` with the number to use for the given region, if any. fn region_highlighted(&self, region: ty::Region<'_>) -> Option { Self::get() .highlight_regions @@ -143,7 +142,7 @@ impl RegionHighlightMode { } /// During the execution of `op`, highlight the given bound - /// region. We can only highlight one bound region at a time. See + /// region. We can only highlight one bound region at a time. See /// the field `highlight_bound_region` for more detailed notes. pub fn highlighting_bound_region( br: ty::BoundRegion, @@ -162,7 +161,7 @@ impl RegionHighlightMode { ) } - /// Returns true if any placeholders are highlighted. + /// Returns `true` if any placeholders are highlighted, and `false` otherwise. pub fn any_placeholders_highlighted(&self) -> bool { Self::get() .highlight_regions @@ -173,7 +172,7 @@ impl RegionHighlightMode { }) } - /// Returns `Some(N)` if the placeholder `p` is highlighted to print as `'N`. + /// Returns `Some(N)` if the placeholder `p` is highlighted to print as "`'N`". pub fn placeholder_highlight(&self, p: ty::PlaceholderRegion) -> Option { self.region_highlighted(&ty::RePlaceholder(p)) } diff --git a/src/librustc_apfloat/ieee.rs b/src/librustc_apfloat/ieee.rs index 58066a9cada47..9f68d770b9e87 100644 --- a/src/librustc_apfloat/ieee.rs +++ b/src/librustc_apfloat/ieee.rs @@ -186,7 +186,7 @@ impl Semantics for X87DoubleExtendedS { /// exponent = all 1's, integer bit 0, significand 0 ("pseudoinfinity") /// exponent = all 1's, integer bit 0, significand nonzero ("pseudoNaN") /// exponent = 0, integer bit 1 ("pseudodenormal") - /// exponent!=0 nor all 1's, integer bit 0 ("unnormal") + /// exponent != 0 nor all 1's, integer bit 0 ("unnormal") /// At the moment, the first two are treated as NaNs, the second two as Normal. fn from_bits(bits: u128) -> IeeeFloat { let sign = bits & (1 << (Self::BITS - 1)); @@ -1549,11 +1549,11 @@ impl IeeeFloat { } } - /// Returns TRUE if, when truncating the current number, with BIT the + /// Returns `true` if, when truncating the current number, with `bit` the /// new LSB, with the given lost fraction and rounding mode, the result /// would need to be rounded away from zero (i.e., by increasing the - /// signficand). This routine must work for Category::Zero of both signs, and - /// Category::Normal numbers. + /// signficand). This routine must work for `Category::Zero` of both signs, and + /// `Category::Normal` numbers. fn round_away_from_zero(&self, round: Round, loss: Loss, bit: usize) -> bool { // NaNs and infinities should not have lost fractions. assert!(self.is_finite_non_zero() || self.is_zero()); @@ -2257,7 +2257,7 @@ impl Loss { more_significant } - /// Return the fraction lost were a bignum truncated losing the least + /// Returns the fraction lost were a bignum truncated losing the least /// significant `bits` bits. fn through_truncation(limbs: &[Limb], bits: usize) -> Loss { if bits == 0 { @@ -2320,12 +2320,12 @@ mod sig { Ordering::Equal } - /// Extract the given bit. + /// Extracts the given bit. pub(super) fn get_bit(limbs: &[Limb], bit: usize) -> bool { limbs[bit / LIMB_BITS] & (1 << (bit % LIMB_BITS)) != 0 } - /// Set the given bit. + /// Sets the given bit. pub(super) fn set_bit(limbs: &mut [Limb], bit: usize) { limbs[bit / LIMB_BITS] |= 1 << (bit % LIMB_BITS); } @@ -2335,7 +2335,7 @@ mod sig { limbs[bit / LIMB_BITS] &= !(1 << (bit % LIMB_BITS)); } - /// Shift `dst` left `bits` bits, subtract `bits` from its exponent. + /// Shifts `dst` left `bits` bits, subtract `bits` from its exponent. pub(super) fn shift_left(dst: &mut [Limb], exp: &mut ExpInt, bits: usize) { if bits > 0 { // Our exponent should not underflow. @@ -2367,7 +2367,7 @@ mod sig { } } - /// Shift `dst` right `bits` bits noting lost fraction. + /// Shifts `dst` right `bits` bits noting lost fraction. pub(super) fn shift_right(dst: &mut [Limb], exp: &mut ExpInt, bits: usize) -> Loss { let loss = Loss::through_truncation(dst, bits); @@ -2403,7 +2403,7 @@ mod sig { loss } - /// Copy the bit vector of width `src_bits` from `src`, starting at bit SRC_LSB, + /// Copies the bit vector of width `src_bits` from `src`, starting at bit SRC_LSB, /// to `dst`, such that the bit SRC_LSB becomes the least significant bit of `dst`. /// All high bits above `src_bits` in `dst` are zero-filled. pub(super) fn extract(dst: &mut [Limb], src: &[Limb], src_bits: usize, src_lsb: usize) { diff --git a/src/librustc_apfloat/lib.rs b/src/librustc_apfloat/lib.rs index f79d448edce9f..18fd06960ead9 100644 --- a/src/librustc_apfloat/lib.rs +++ b/src/librustc_apfloat/lib.rs @@ -374,7 +374,7 @@ pub trait Float fn from_str_r(s: &str, round: Round) -> Result, ParseError>; fn to_bits(self) -> u128; - /// Convert a floating point number to an integer according to the + /// Converts a floating point number to an integer according to the /// rounding mode. In case of an invalid operation exception, /// deterministic values are returned, namely zero for NaNs and the /// minimal or maximal value respectively for underflow or overflow. @@ -387,7 +387,7 @@ pub trait Float /// /// The *is_exact output tells whether the result is exact, in the sense /// that converting it back to the original floating point type produces - /// the original value. This is almost equivalent to result==Status::OK, + /// the original value. This is almost equivalent to `result == Status::OK`, /// except for negative zeroes. fn to_i128_r(self, width: usize, round: Round, is_exact: &mut bool) -> StatusAnd { let status; @@ -457,13 +457,13 @@ pub trait Float } } - /// IEEE-754R isSignMinus: Returns true if and only if the current value is + /// IEEE-754R isSignMinus: Returns whether the current value is /// negative. /// /// This applies to zeros and NaNs as well. fn is_negative(self) -> bool; - /// IEEE-754R isNormal: Returns true if and only if the current value is normal. + /// IEEE-754R isNormal: Returns whether the current value is normal. /// /// This implies that the current value of the float is not zero, subnormal, /// infinite, or NaN following the definition of normality from IEEE-754R. @@ -471,7 +471,7 @@ pub trait Float !self.is_denormal() && self.is_finite_non_zero() } - /// Returns true if and only if the current value is zero, subnormal, or + /// Returns `true` if the current value is zero, subnormal, or /// normal. /// /// This means that the value is not infinite or NaN. @@ -479,26 +479,26 @@ pub trait Float !self.is_nan() && !self.is_infinite() } - /// Returns true if and only if the float is plus or minus zero. + /// Returns `true` if the float is plus or minus zero. fn is_zero(self) -> bool { self.category() == Category::Zero } - /// IEEE-754R isSubnormal(): Returns true if and only if the float is a + /// IEEE-754R isSubnormal(): Returns whether the float is a /// denormal. fn is_denormal(self) -> bool; - /// IEEE-754R isInfinite(): Returns true if and only if the float is infinity. + /// IEEE-754R isInfinite(): Returns whether the float is infinity. fn is_infinite(self) -> bool { self.category() == Category::Infinity } - /// Returns true if and only if the float is a quiet or signaling NaN. + /// Returns `true` if the float is a quiet or signaling NaN. fn is_nan(self) -> bool { self.category() == Category::NaN } - /// Returns true if and only if the float is a signaling NaN. + /// Returns `true` if the float is a signaling NaN. fn is_signaling(self) -> bool; // Simple Queries @@ -517,19 +517,19 @@ pub trait Float self.is_zero() && self.is_negative() } - /// Returns true if and only if the number has the smallest possible non-zero + /// Returns `true` if the number has the smallest possible non-zero /// magnitude in the current semantics. fn is_smallest(self) -> bool { Self::SMALLEST.copy_sign(self).bitwise_eq(self) } - /// Returns true if and only if the number has the largest possible finite + /// Returns `true` if the number has the largest possible finite /// magnitude in the current semantics. fn is_largest(self) -> bool { Self::largest().copy_sign(self).bitwise_eq(self) } - /// Returns true if and only if the number is an exact integer. + /// Returns `true` if the number is an exact integer. fn is_integer(self) -> bool { // This could be made more efficient; I'm going for obviously correct. if !self.is_finite() { @@ -571,11 +571,11 @@ pub trait Float } pub trait FloatConvert: Float { - /// Convert a value of one floating point type to another. + /// Converts a value of one floating point type to another. /// The return value corresponds to the IEEE754 exceptions. *loses_info /// records whether the transformation lost information, i.e., whether /// converting the result back to the original type will produce the - /// original value (this is almost the same as return value==Status::OK, + /// original value (this is almost the same as return `value == Status::OK`, /// but there are edge cases where this is not so). fn convert_r(self, round: Round, loses_info: &mut bool) -> StatusAnd; fn convert(self, loses_info: &mut bool) -> StatusAnd { diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index f675c8d38a676..b528967dd65ff 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -239,7 +239,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { { //! Iterates over each loan that has been issued //! on entrance to `node`, regardless of whether it is - //! actually *in scope* at that point. Sometimes loans + //! actually *in scope* at that point. Sometimes loans //! are issued for future scopes and thus they may have been //! *issued* but not yet be in effect. diff --git a/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs b/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs index 11597455bca8f..ae1d49afd4931 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/lifetime.rs @@ -53,7 +53,7 @@ struct GuaranteeLifetimeContext<'a, 'tcx: 'a> { impl<'a, 'tcx> GuaranteeLifetimeContext<'a, 'tcx> { fn check(&self, cmt: &mc::cmt_<'tcx>, discr_scope: Option) -> R { //! Main routine. Walks down `cmt` until we find the - //! "guarantor". Reports an error if `self.loan_region` is + //! "guarantor". Reports an error if `self.loan_region` is //! larger than scope of `cmt`. debug!("guarantee_lifetime.check(cmt={:?}, loan_region={:?})", cmt, diff --git a/src/librustc_borrowck/borrowck/gather_loans/mod.rs b/src/librustc_borrowck/borrowck/gather_loans/mod.rs index c21a43bc68333..1971c6663120b 100644 --- a/src/librustc_borrowck/borrowck/gather_loans/mod.rs +++ b/src/librustc_borrowck/borrowck/gather_loans/mod.rs @@ -285,7 +285,7 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> { } /// Guarantees that `addr_of(cmt)` will be valid for the duration of `static_scope_r`, or - /// reports an error. This may entail taking out loans, which will be added to the + /// reports an error. This may entail taking out loans, which will be added to the /// `req_loan_map`. fn guarantee_valid(&mut self, borrow_id: hir::ItemLocalId, diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index 4ced72cd279b2..85c4ca7bd379e 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -296,11 +296,11 @@ pub struct Loan<'tcx> { /// gen_scope indicates where loan is introduced. Typically the /// loan is introduced at the point of the borrow, but in some /// cases, notably method arguments, the loan may be introduced - /// only later, once it comes into scope. See also + /// only later, once it comes into scope. See also /// `GatherLoanCtxt::compute_gen_scope`. gen_scope: region::Scope, - /// kill_scope indicates when the loan goes out of scope. This is + /// kill_scope indicates when the loan goes out of scope. This is /// either when the lifetime expires or when the local variable /// which roots the loan-path goes out of scope, whichever happens /// faster. See also `GatherLoanCtxt::compute_kill_scope`. diff --git a/src/librustc_borrowck/borrowck/move_data.rs b/src/librustc_borrowck/borrowck/move_data.rs index a206c37e97b09..325d3559f0ab6 100644 --- a/src/librustc_borrowck/borrowck/move_data.rs +++ b/src/librustc_borrowck/borrowck/move_data.rs @@ -114,7 +114,7 @@ pub struct Move { /// Path being moved. pub path: MovePathIndex, - /// id of node that is doing the move. + /// ID of node that is doing the move. pub id: hir::ItemLocalId, /// Kind of move, for error messages. @@ -129,7 +129,7 @@ pub struct Assignment { /// Path being assigned. pub path: MovePathIndex, - /// id where assignment occurs + /// ID where assignment occurs pub id: hir::ItemLocalId, /// span of node where assignment occurs @@ -168,8 +168,8 @@ fn loan_path_is_precise(loan_path: &LoanPath<'_>) -> bool { } impl<'a, 'tcx> MoveData<'tcx> { - /// return true if there are no trackable assignments or moves - /// in this move data - that means that there is nothing that + /// Returns `true` if there are no trackable assignments or moves + /// in this move data -- that means that there is nothing that /// could cause a borrow error. pub fn is_empty(&self) -> bool { self.moves.borrow().is_empty() && diff --git a/src/librustc_borrowck/dataflow.rs b/src/librustc_borrowck/dataflow.rs index 90f33ede62c21..de2a3c4cb22a8 100644 --- a/src/librustc_borrowck/dataflow.rs +++ b/src/librustc_borrowck/dataflow.rs @@ -178,7 +178,7 @@ fn build_local_id_to_index(body: Option<&hir::Body>, return index; - /// Add mappings from the ast nodes for the formal bindings to + /// Adds mappings from the ast nodes for the formal bindings to /// the entry-node in the graph. fn add_entries_from_fn_body(index: &mut FxHashMap>, body: &hir::Body, diff --git a/src/librustc_codegen_llvm/abi.rs b/src/librustc_codegen_llvm/abi.rs index 258d839d32e82..f7d2699a27e3f 100644 --- a/src/librustc_codegen_llvm/abi.rs +++ b/src/librustc_codegen_llvm/abi.rs @@ -174,13 +174,13 @@ pub trait ArgTypeExt<'ll, 'tcx> { } impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> { - /// Get the LLVM type for a place of the original Rust type of + /// Gets the LLVM type for a place of the original Rust type of /// this argument/return, i.e., the result of `type_of::type_of`. fn memory_ty(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type { self.layout.llvm_type(cx) } - /// Store a direct/indirect value described by this ArgType into a + /// Stores a direct/indirect value described by this ArgType into a /// place for the original Rust type of this argument/return. /// Can be used for both storing formal arguments into Rust variables /// or results of call/invoke instructions into their destinations. diff --git a/src/librustc_codegen_llvm/back/archive.rs b/src/librustc_codegen_llvm/back/archive.rs index 1cf150dad6025..e02f7df2efcc9 100644 --- a/src/librustc_codegen_llvm/back/archive.rs +++ b/src/librustc_codegen_llvm/back/archive.rs @@ -51,7 +51,7 @@ fn is_relevant_child(c: &Child) -> bool { } impl<'a> ArchiveBuilder<'a> { - /// Create a new static archive, ready for modifying the archive specified + /// Creates a new static archive, ready for modifying the archive specified /// by `config`. pub fn new(config: ArchiveConfig<'a>) -> ArchiveBuilder<'a> { ArchiveBuilder { diff --git a/src/librustc_codegen_llvm/back/link.rs b/src/librustc_codegen_llvm/back/link.rs index fc744201a332c..725009e1377af 100644 --- a/src/librustc_codegen_llvm/back/link.rs +++ b/src/librustc_codegen_llvm/back/link.rs @@ -42,7 +42,7 @@ pub use rustc_codegen_utils::link::{find_crate_name, filename_for_input, default out_filename, check_file_is_writeable}; -/// Perform the linkage portion of the compilation phase. This will generate all +/// Performs the linkage portion of the compilation phase. This will generate all /// of the requested outputs for this compilation session. pub(crate) fn link_binary(sess: &Session, codegen_results: &CodegenResults, diff --git a/src/librustc_codegen_llvm/back/lto.rs b/src/librustc_codegen_llvm/back/lto.rs index 3e51078dc6436..be7733bf554bb 100644 --- a/src/librustc_codegen_llvm/back/lto.rs +++ b/src/librustc_codegen_llvm/back/lto.rs @@ -791,7 +791,7 @@ impl ThinLTOImports { self.imports.get(llvm_module_name).map(|v| &v[..]).unwrap_or(&[]) } - /// Load the ThinLTO import map from ThinLTOData. + /// Loads the ThinLTO import map from ThinLTOData. unsafe fn from_thin_lto_data(data: *const llvm::ThinLTOData) -> ThinLTOImports { unsafe extern "C" fn imported_module_callback(payload: *mut libc::c_void, importing_module_name: *const libc::c_char, diff --git a/src/librustc_codegen_llvm/back/wasm.rs b/src/librustc_codegen_llvm/back/wasm.rs index 3501123a37f51..b403660fa512d 100644 --- a/src/librustc_codegen_llvm/back/wasm.rs +++ b/src/librustc_codegen_llvm/back/wasm.rs @@ -112,7 +112,7 @@ pub fn rewrite_imports(path: &Path, import_map: &FxHashMap) { } } -/// Add or augment the existing `producers` section to encode information about +/// Adds or augment the existing `producers` section to encode information about /// the Rust compiler used to produce the wasm file. pub fn add_producer_section( path: &Path, diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs index d9f44ca6e45a3..70986a4e17941 100644 --- a/src/librustc_codegen_llvm/base.rs +++ b/src/librustc_codegen_llvm/base.rs @@ -7,11 +7,11 @@ //! //! Hopefully useful general knowledge about codegen: //! -//! * There's no way to find out the Ty type of a Value. Doing so -//! would be "trying to get the eggs out of an omelette" (credit: -//! pcwalton). You can, instead, find out its llvm::Type by calling val_ty, -//! but one llvm::Type corresponds to many `Ty`s; for instance, tup(int, int, -//! int) and rec(x=int, y=int, z=int) will have the same llvm::Type. +//! * There's no way to find out the `Ty` type of a Value. Doing so +//! would be "trying to get the eggs out of an omelette" (credit: +//! pcwalton). You can, instead, find out its `llvm::Type` by calling `val_ty`, +//! but one `llvm::Type` corresponds to many `Ty`s; for instance, `tup(int, int, +//! int)` and `rec(x=int, y=int, z=int)` will have the same `llvm::Type`. use super::ModuleLlvm; use rustc_codegen_ssa::{ModuleCodegen, ModuleKind}; diff --git a/src/librustc_codegen_llvm/callee.rs b/src/librustc_codegen_llvm/callee.rs index 0d9d6aa5aa20f..9426328da327d 100644 --- a/src/librustc_codegen_llvm/callee.rs +++ b/src/librustc_codegen_llvm/callee.rs @@ -1,6 +1,6 @@ //! Handles codegen of callees as well as other call-related -//! things. Callees are a superset of normal rust values and sometimes -//! have different representations. In particular, top-level fn items +//! things. Callees are a superset of normal rust values and sometimes +//! have different representations. In particular, top-level fn items //! and methods are represented as just a fn ptr and not a full //! closure. diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs index f679558844198..a4b976dfbd9ba 100644 --- a/src/librustc_codegen_llvm/context.rs +++ b/src/librustc_codegen_llvm/context.rs @@ -75,7 +75,7 @@ pub struct CodegenCx<'ll, 'tcx: 'll> { pub statics_to_rauw: RefCell>, /// Statics that will be placed in the llvm.used variable - /// See http://llvm.org/docs/LangRef.html#the-llvm-used-global-variable for details + /// See for details pub used_statics: RefCell>, pub lltypes: RefCell, Option), &'ll Type>>, @@ -807,7 +807,7 @@ impl CodegenCx<'b, 'tcx> { } impl<'b, 'tcx> CodegenCx<'b, 'tcx> { - /// Generate a new symbol name with the given prefix. This symbol name must + /// Generates a new symbol name with the given prefix. This symbol name must /// only be used for definitions with `internal` or `private` linkage. pub fn generate_local_symbol_name(&self, prefix: &str) -> String { let idx = self.local_gen_sym_counter.get(); diff --git a/src/librustc_codegen_llvm/debuginfo/create_scope_map.rs b/src/librustc_codegen_llvm/debuginfo/create_scope_map.rs index dbd821865f95f..791526c98c85c 100644 --- a/src/librustc_codegen_llvm/debuginfo/create_scope_map.rs +++ b/src/librustc_codegen_llvm/debuginfo/create_scope_map.rs @@ -16,7 +16,7 @@ use rustc_data_structures::indexed_vec::{Idx, IndexVec}; use syntax_pos::BytePos; -/// Produce DIScope DIEs for each MIR Scope which has variables defined in it. +/// Produces DIScope DIEs for each MIR Scope which has variables defined in it. /// If debuginfo is disabled, the returned vector is empty. pub fn create_mir_scopes( cx: &CodegenCx<'ll, '_>, diff --git a/src/librustc_codegen_llvm/debuginfo/doc.rs b/src/librustc_codegen_llvm/debuginfo/doc.rs index a4acc58eca953..cf18b995b61da 100644 --- a/src/librustc_codegen_llvm/debuginfo/doc.rs +++ b/src/librustc_codegen_llvm/debuginfo/doc.rs @@ -160,7 +160,7 @@ //! //! This algorithm also provides a stable ID for types that are defined in one //! crate but instantiated from metadata within another crate. We just have to -//! take care to always map crate and node IDs back to the original crate +//! take care to always map crate and `NodeId`s back to the original crate //! context. //! //! As a side-effect these unique type IDs also help to solve a problem arising @@ -170,7 +170,7 @@ //! with different concrete substitutions for `'a`, and thus there will be N //! `Ty` instances for the type `Struct<'a>` even though it is not generic //! otherwise. Unfortunately this means that we cannot use `ty::type_id()` as -//! cheap identifier for type metadata---we have done this in the past, but it +//! cheap identifier for type metadata -- we have done this in the past, but it //! led to unnecessary metadata duplication in the best case and LLVM //! assertions in the worst. However, the unique type ID as described above //! *can* be used as identifier. Since it is comparatively expensive to diff --git a/src/librustc_codegen_llvm/debuginfo/mod.rs b/src/librustc_codegen_llvm/debuginfo/mod.rs index 113b9958c7f8c..625f6cd45fb3e 100644 --- a/src/librustc_codegen_llvm/debuginfo/mod.rs +++ b/src/librustc_codegen_llvm/debuginfo/mod.rs @@ -102,7 +102,7 @@ impl<'a, 'tcx> CrateDebugContext<'a, 'tcx> { } } -/// Create any deferred debug metadata nodes +/// Creates any deferred debug metadata nodes pub fn finalize(cx: &CodegenCx) { if cx.dbg_cx.is_none() { return; diff --git a/src/librustc_codegen_llvm/debuginfo/utils.rs b/src/librustc_codegen_llvm/debuginfo/utils.rs index 8b85df79d0484..f2d92eefad3e3 100644 --- a/src/librustc_codegen_llvm/debuginfo/utils.rs +++ b/src/librustc_codegen_llvm/debuginfo/utils.rs @@ -36,7 +36,7 @@ pub fn create_DIArray( }; } -/// Return syntax_pos::Loc corresponding to the beginning of the span +/// Returns syntax_pos::Loc corresponding to the beginning of the span pub fn span_start(cx: &CodegenCx, span: Span) -> syntax_pos::Loc { cx.sess().source_map().lookup_char_pos(span.lo()) } diff --git a/src/librustc_codegen_llvm/llvm/ffi.rs b/src/librustc_codegen_llvm/llvm/ffi.rs index 58bdfc47fcaed..3232f4e8f51ac 100644 --- a/src/librustc_codegen_llvm/llvm/ffi.rs +++ b/src/librustc_codegen_llvm/llvm/ffi.rs @@ -1337,7 +1337,7 @@ extern "C" { pub fn LLVMGetSections(ObjFile: &'a ObjectFile) -> &'a mut SectionIterator<'a>; /// Destroys a section iterator. pub fn LLVMDisposeSectionIterator(SI: &'a mut SectionIterator<'a>); - /// Returns true if the section iterator is at the end of the section + /// Returns `true` if the section iterator is at the end of the section /// list: pub fn LLVMIsSectionIteratorAtEnd(ObjFile: &'a ObjectFile, SI: &SectionIterator<'a>) -> Bool; /// Moves the section iterator to point to the next section. diff --git a/src/librustc_codegen_llvm/type_of.rs b/src/librustc_codegen_llvm/type_of.rs index afaeb352cd992..39f48b266c219 100644 --- a/src/librustc_codegen_llvm/type_of.rs +++ b/src/librustc_codegen_llvm/type_of.rs @@ -226,7 +226,7 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyLayout<'tcx> { } } - /// Get the LLVM type corresponding to a Rust type, i.e., `rustc::ty::Ty`. + /// Gets the LLVM type corresponding to a Rust type, i.e., `rustc::ty::Ty`. /// The pointee type of the pointer in `PlaceRef` is always this type. /// For sized types, it is also the right LLVM type for an `alloca` /// containing a value of that type, and most immediates (except `bool`). diff --git a/src/librustc_codegen_ssa/back/linker.rs b/src/librustc_codegen_ssa/back/linker.rs index 249715a7b6e26..3cbe3793f10cf 100644 --- a/src/librustc_codegen_ssa/back/linker.rs +++ b/src/librustc_codegen_ssa/back/linker.rs @@ -91,7 +91,7 @@ impl LinkerInfo { } } -/// Linker abstraction used by back::link to build up the command to invoke a +/// Linker abstraction used by `back::link` to build up the command to invoke a /// linker. /// /// This trait is the total list of requirements needed by `back::link` and @@ -145,7 +145,7 @@ pub struct GccLinker<'a> { impl<'a> GccLinker<'a> { /// Argument that must be passed *directly* to the linker /// - /// These arguments need to be prepended with '-Wl,' when a gcc-style linker is used + /// These arguments need to be prepended with `-Wl`, when a GCC-style linker is used. fn linker_arg(&mut self, arg: S) -> &mut Self where S: AsRef { diff --git a/src/librustc_codegen_ssa/back/write.rs b/src/librustc_codegen_ssa/back/write.rs index 67d4d408babfa..8f8095a96ee72 100644 --- a/src/librustc_codegen_ssa/back/write.rs +++ b/src/librustc_codegen_ssa/back/write.rs @@ -663,7 +663,7 @@ pub enum WorkItem { /// Copy the post-LTO artifacts from the incremental cache to the output /// directory. CopyPostLtoArtifacts(CachedModuleCodegen), - /// Perform (Thin)LTO on the given module. + /// Performs (Thin)LTO on the given module. LTO(lto::LtoModuleCodegen), } @@ -1798,7 +1798,7 @@ impl OngoingCodegen { drop(self.coordinator_send.send(Box::new(Message::CodegenComplete::))); } - /// Consume this context indicating that codegen was entirely aborted, and + /// Consumes this context indicating that codegen was entirely aborted, and /// we need to exit as quickly as possible. /// /// This method blocks the current thread until all worker threads have diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs index 84e55ce0f22c6..ecac82db94798 100644 --- a/src/librustc_codegen_ssa/base.rs +++ b/src/librustc_codegen_ssa/base.rs @@ -7,11 +7,11 @@ //! //! Hopefully useful general knowledge about codegen: //! -//! * There's no way to find out the Ty type of a Value. Doing so -//! would be "trying to get the eggs out of an omelette" (credit: -//! pcwalton). You can, instead, find out its llvm::Type by calling val_ty, -//! but one llvm::Type corresponds to many `Ty`s; for instance, tup(int, int, -//! int) and rec(x=int, y=int, z=int) will have the same llvm::Type. +//! * There's no way to find out the `Ty` type of a Value. Doing so +//! would be "trying to get the eggs out of an omelette" (credit: +//! pcwalton). You can, instead, find out its `llvm::Type` by calling `val_ty`, +//! but one `llvm::Type` corresponds to many `Ty`s; for instance, `tup(int, int, +//! int)` and `rec(x=int, y=int, z=int)` will have the same `llvm::Type`. use {ModuleCodegen, ModuleKind, CachedModuleCodegen}; @@ -156,7 +156,7 @@ pub fn compare_simd_types<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>( bx.sext(cmp, ret_ty) } -/// Retrieve the information we are losing (making dynamic) in an unsizing +/// Retrieves the information we are losing (making dynamic) in an unsizing /// adjustment. /// /// The `old_info` argument is a bit funny. It is intended for use @@ -347,7 +347,7 @@ fn cast_shift_rhs<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>( } } -/// Returns whether this session's target will use SEH-based unwinding. +/// Returns `true` if this session's target will use SEH-based unwinding. /// /// This is only true for MSVC targets, and even then the 64-bit MSVC target /// currently uses SEH-ish unwinding with DWARF info tables to the side (same as @@ -436,7 +436,7 @@ pub fn codegen_instance<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>( mir::codegen_mir::(cx, lldecl, &mir, instance, sig); } -/// Create the `main` function which will initialize the rust runtime and call +/// Creates the `main` function which will initialize the rust runtime and call /// users main function. pub fn maybe_create_entry_wrapper<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>( cx: &'a Bx::CodegenCx diff --git a/src/librustc_codegen_ssa/lib.rs b/src/librustc_codegen_ssa/lib.rs index 58b3f0434a623..1a911d94b1bd7 100644 --- a/src/librustc_codegen_ssa/lib.rs +++ b/src/librustc_codegen_ssa/lib.rs @@ -68,7 +68,7 @@ pub mod back; pub struct ModuleCodegen { /// The name of the module. When the crate may be saved between /// compilations, incremental compilation requires that name be - /// unique amongst **all** crates. Therefore, it should contain + /// unique amongst **all** crates. Therefore, it should contain /// something unique to this crate (e.g., a module path) as well /// as the crate name and disambiguator. /// We currently generate these names via CodegenUnit::build_cgu_name(). @@ -141,7 +141,7 @@ bitflags! { } } -/// Misc info we load from metadata to persist beyond the tcx +/// Misc info we load from metadata to persist beyond the tcx. pub struct CrateInfo { pub panic_runtime: Option, pub compiler_builtins: Option, diff --git a/src/librustc_codegen_ssa/mir/block.rs b/src/librustc_codegen_ssa/mir/block.rs index aa82c853257a3..be2db47a53387 100644 --- a/src/librustc_codegen_ssa/mir/block.rs +++ b/src/librustc_codegen_ssa/mir/block.rs @@ -884,7 +884,7 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> { } } - /// Return the landingpad wrapper around the given basic block + /// Returns the landing-pad wrapper around the given basic block. /// /// No-op in MSVC SEH scheme. fn landing_pad_to( diff --git a/src/librustc_codegen_ssa/mir/mod.rs b/src/librustc_codegen_ssa/mir/mod.rs index c7e2131eed5da..32c3408f1cb82 100644 --- a/src/librustc_codegen_ssa/mir/mod.rs +++ b/src/librustc_codegen_ssa/mir/mod.rs @@ -422,7 +422,7 @@ fn create_funclets<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>( }).unzip() } -/// Produce, for each argument, a `Value` pointing at the +/// Produces, for each argument, a `Value` pointing at the /// argument's value. As arguments are places, these are always /// indirect. fn arg_local_refs<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>( diff --git a/src/librustc_codegen_ssa/mir/place.rs b/src/librustc_codegen_ssa/mir/place.rs index 596f97a038892..efededb06dd7d 100644 --- a/src/librustc_codegen_ssa/mir/place.rs +++ b/src/librustc_codegen_ssa/mir/place.rs @@ -13,16 +13,16 @@ use super::operand::OperandValue; #[derive(Copy, Clone, Debug)] pub struct PlaceRef<'tcx, V> { - /// Pointer to the contents of the place + /// Pointer to the contents of the place. pub llval: V, - /// This place's extra data if it is unsized, or null + /// This place's extra data if it is unsized, or null. pub llextra: Option, - /// Monomorphized type of this place, including variant information + /// Monomorphized type of this place, including variant information. pub layout: TyLayout<'tcx>, - /// What alignment we know for this place + /// What alignment we know for this place. pub align: Align, } @@ -277,7 +277,7 @@ impl<'a, 'tcx: 'a, V: CodegenObject> PlaceRef<'tcx, V> { } } - /// Set the discriminant for a new value of the given case of the given + /// Sets the discriminant for a new value of the given case of the given /// representation. pub fn codegen_set_discr>( &self, diff --git a/src/librustc_codegen_ssa/traits/declare.rs b/src/librustc_codegen_ssa/traits/declare.rs index 3cd3c4e48b998..6a400a7d7a45d 100644 --- a/src/librustc_codegen_ssa/traits/declare.rs +++ b/src/librustc_codegen_ssa/traits/declare.rs @@ -29,7 +29,7 @@ pub trait DeclareMethods<'tcx>: BackendTypes { /// Declare a global with an intention to define it. /// /// Use this function when you intend to define a global. This function will - /// return None if the name already has a definition associated with it. In that + /// return `None` if the name already has a definition associated with it. In that /// case an error should be reported to the user, because it usually happens due /// to user’s fault (e.g., misuse of #[no_mangle] or #[export_name] attributes). fn define_global(&self, name: &str, ty: Self::Type) -> Option; @@ -53,10 +53,10 @@ pub trait DeclareMethods<'tcx>: BackendTypes { /// can happen with #[no_mangle] or #[export_name], for example. fn define_internal_fn(&self, name: &str, fn_sig: ty::PolyFnSig<'tcx>) -> Self::Value; - /// Get declared value by name. + /// Gets declared value by name. fn get_declared_value(&self, name: &str) -> Option; - /// Get defined or externally defined (AvailableExternally linkage) value by + /// Gets defined or externally defined (AvailableExternally linkage) value by /// name. fn get_defined_value(&self, name: &str) -> Option; } diff --git a/src/librustc_codegen_ssa/traits/type_.rs b/src/librustc_codegen_ssa/traits/type_.rs index 2ec0c8e5a75cc..2c990ed89c98e 100644 --- a/src/librustc_codegen_ssa/traits/type_.rs +++ b/src/librustc_codegen_ssa/traits/type_.rs @@ -39,13 +39,13 @@ pub trait BaseTypeMethods<'tcx>: Backend<'tcx> { fn type_ptr_to(&self, ty: Self::Type) -> Self::Type; fn element_type(&self, ty: Self::Type) -> Self::Type; - /// Return the number of elements in `self` if it is a LLVM vector type. + /// Returns the number of elements in `self` if it is a LLVM vector type. fn vector_length(&self, ty: Self::Type) -> usize; fn func_params_types(&self, ty: Self::Type) -> Vec; fn float_width(&self, ty: Self::Type) -> usize; - /// Retrieve the bit width of the integer type `self`. + /// Retrieves the bit width of the integer type `self`. fn int_width(&self, ty: Self::Type) -> u64; fn val_ty(&self, v: Self::Value) -> Self::Type; diff --git a/src/librustc_data_structures/base_n.rs b/src/librustc_data_structures/base_n.rs index c9c1933f25b2b..f1bd3f03aef8d 100644 --- a/src/librustc_data_structures/base_n.rs +++ b/src/librustc_data_structures/base_n.rs @@ -1,4 +1,4 @@ -/// Convert unsigned integers into a string representation with some base. +/// Converts unsigned integers into a string representation with some base. /// Bases up to and including 36 can be used for case-insensitive things. use std::str; diff --git a/src/librustc_data_structures/bit_set.rs b/src/librustc_data_structures/bit_set.rs index 05d2185ae69b4..ff7964646d608 100644 --- a/src/librustc_data_structures/bit_set.rs +++ b/src/librustc_data_structures/bit_set.rs @@ -27,7 +27,7 @@ pub struct BitSet { } impl BitSet { - /// Create a new, empty bitset with a given `domain_size`. + /// Creates a new, empty bitset with a given `domain_size`. #[inline] pub fn new_empty(domain_size: usize) -> BitSet { let num_words = num_words(domain_size); @@ -38,7 +38,7 @@ impl BitSet { } } - /// Create a new, filled bitset with a given `domain_size`. + /// Creates a new, filled bitset with a given `domain_size`. #[inline] pub fn new_filled(domain_size: usize) -> BitSet { let num_words = num_words(domain_size); @@ -51,7 +51,7 @@ impl BitSet { result } - /// Get the domain size. + /// Gets the domain size. pub fn domain_size(&self) -> usize { self.domain_size } @@ -85,7 +85,7 @@ impl BitSet { self.words.iter().map(|e| e.count_ones() as usize).sum() } - /// True if `self` contains `elem`. + /// Returns `true` if `self` contains `elem`. #[inline] pub fn contains(&self, elem: T) -> bool { assert!(elem.index() < self.domain_size); @@ -106,7 +106,7 @@ impl BitSet { self.words.iter().all(|a| *a == 0) } - /// Insert `elem`. Returns true if the set has changed. + /// Insert `elem`. Returns whether the set has changed. #[inline] pub fn insert(&mut self, elem: T) -> bool { assert!(elem.index() < self.domain_size); @@ -126,7 +126,7 @@ impl BitSet { self.clear_excess_bits(); } - /// Returns true if the set has changed. + /// Returns `true` if the set has changed. #[inline] pub fn remove(&mut self, elem: T) -> bool { assert!(elem.index() < self.domain_size); @@ -138,26 +138,26 @@ impl BitSet { new_word != word } - /// Set `self = self | other` and return true if `self` changed + /// Sets `self = self | other` and returns `true` if `self` changed /// (i.e., if new bits were added). pub fn union(&mut self, other: &impl UnionIntoBitSet) -> bool { other.union_into(self) } - /// Set `self = self - other` and return true if `self` changed. + /// Sets `self = self - other` and returns `true` if `self` changed. /// (i.e., if any bits were removed). pub fn subtract(&mut self, other: &impl SubtractFromBitSet) -> bool { other.subtract_from(self) } - /// Set `self = self & other` and return true if `self` changed. + /// Sets `self = self & other` and return `true` if `self` changed. /// (i.e., if any bits were removed). pub fn intersect(&mut self, other: &BitSet) -> bool { assert_eq!(self.domain_size, other.domain_size); bitwise(&mut self.words, &other.words, |a, b| { a & b }) } - /// Get a slice of the underlying words. + /// Gets a slice of the underlying words. pub fn words(&self) -> &[Word] { &self.words } @@ -611,7 +611,7 @@ impl GrowableBitSet { GrowableBitSet { bit_set: BitSet::new_empty(bits) } } - /// Returns true if the set has changed. + /// Returns `true` if the set has changed. #[inline] pub fn insert(&mut self, elem: T) -> bool { self.ensure(elem.index() + 1); @@ -645,7 +645,7 @@ pub struct BitMatrix { } impl BitMatrix { - /// Create a new `rows x columns` matrix, initially empty. + /// Creates a new `rows x columns` matrix, initially empty. pub fn new(num_rows: usize, num_columns: usize) -> BitMatrix { // For every element, we need one bit for every other // element. Round up to an even number of words. @@ -668,7 +668,7 @@ impl BitMatrix { /// Sets the cell at `(row, column)` to true. Put another way, insert /// `column` to the bitset for `row`. /// - /// Returns true if this changed the matrix, and false otherwise. + /// Returns `true` if this changed the matrix. pub fn insert(&mut self, row: R, column: C) -> bool { assert!(row.index() < self.num_rows && column.index() < self.num_columns); let (start, _) = self.range(row); @@ -691,7 +691,7 @@ impl BitMatrix { (self.words[start + word_index] & mask) != 0 } - /// Returns those indices that are true in rows `a` and `b`. This + /// Returns those indices that are true in rows `a` and `b`. This /// is an O(n) operation where `n` is the number of elements /// (somewhat independent from the actual size of the /// intersection, in particular). @@ -715,8 +715,8 @@ impl BitMatrix { result } - /// Add the bits from row `read` to the bits from row `write`, - /// return true if anything changed. + /// Adds the bits from row `read` to the bits from row `write`, and + /// returns `true` if anything changed. /// /// This is used when computing transitive reachability because if /// you have an edge `write -> read`, because in that case @@ -772,7 +772,7 @@ where } impl SparseBitMatrix { - /// Create a new empty sparse bit matrix with no rows or columns. + /// Creates a new empty sparse bit matrix with no rows or columns. pub fn new(num_columns: usize) -> Self { Self { num_columns, @@ -793,7 +793,7 @@ impl SparseBitMatrix { /// Sets the cell at `(row, column)` to true. Put another way, insert /// `column` to the bitset for `row`. /// - /// Returns true if this changed the matrix, and false otherwise. + /// Returns `true` if this changed the matrix. pub fn insert(&mut self, row: R, column: C) -> bool { self.ensure_row(row).insert(column) } @@ -806,8 +806,8 @@ impl SparseBitMatrix { self.row(row).map_or(false, |r| r.contains(column)) } - /// Add the bits from row `read` to the bits from row `write`, - /// return true if anything changed. + /// Adds the bits from row `read` to the bits from row `write`, and + /// returns `true` if anything changed. /// /// This is used when computing transitive reachability because if /// you have an edge `write -> read`, because in that case diff --git a/src/librustc_data_structures/graph/implementation/mod.rs b/src/librustc_data_structures/graph/implementation/mod.rs index a8b734094064a..de4b1bcd0c2a1 100644 --- a/src/librustc_data_structures/graph/implementation/mod.rs +++ b/src/librustc_data_structures/graph/implementation/mod.rs @@ -14,7 +14,7 @@ //! stored. The edges are stored in a central array, but they are also //! threaded onto two linked lists for each node, one for incoming edges //! and one for outgoing edges. Note that every edge is a member of some -//! incoming list and some outgoing list. Basically you can load the +//! incoming list and some outgoing list. Basically you can load the //! first index of the linked list from the node data structures (the //! field `first_edge`) and then, for each edge, load the next index from //! the field `next_edge`). Each of those fields is an array that should @@ -79,7 +79,7 @@ pub const OUTGOING: Direction = Direction { repr: 0 }; pub const INCOMING: Direction = Direction { repr: 1 }; impl NodeIndex { - /// Returns unique id (unique with respect to the graph holding associated node). + /// Returns unique ID (unique with respect to the graph holding associated node). pub fn node_id(self) -> usize { self.0 } diff --git a/src/librustc_data_structures/graph/scc/mod.rs b/src/librustc_data_structures/graph/scc/mod.rs index e3264fda2629c..24c5448639e7d 100644 --- a/src/librustc_data_structures/graph/scc/mod.rs +++ b/src/librustc_data_structures/graph/scc/mod.rs @@ -200,7 +200,7 @@ where } } - /// Visit a node during the DFS. We first examine its current + /// Visits a node during the DFS. We first examine its current /// state -- if it is not yet visited (`NotVisited`), we can push /// it onto the stack and start walking its successors. /// diff --git a/src/librustc_data_structures/indexed_vec.rs b/src/librustc_data_structures/indexed_vec.rs index 516ea7fb7d946..09aec50e4bb11 100644 --- a/src/librustc_data_structures/indexed_vec.rs +++ b/src/librustc_data_structures/indexed_vec.rs @@ -12,7 +12,7 @@ use rustc_serialize as serialize; /// Represents some newtyped `usize` wrapper. /// -/// (purpose: avoid mixing indexes for different bitvector domains.) +/// Purpose: avoid mixing indexes for different bitvector domains. pub trait Idx: Copy + 'static + Ord + Debug + Hash { fn new(idx: usize) -> Self; @@ -144,19 +144,19 @@ macro_rules! newtype_index { unsafe { $type { private: value } } } - /// Extract value of this index as an integer. + /// Extracts the value of this index as an integer. #[inline] $v fn index(self) -> usize { self.as_usize() } - /// Extract value of this index as a usize. + /// Extracts the value of this index as a `u32`. #[inline] $v fn as_u32(self) -> u32 { self.private } - /// Extract value of this index as a u32. + /// Extracts the value of this index as a `usize`. #[inline] $v fn as_usize(self) -> usize { self.as_u32() as usize @@ -641,7 +641,7 @@ impl IndexVec { self.raw.get_mut(index.index()) } - /// Return mutable references to two distinct elements, a and b. Panics if a == b. + /// Returns mutable references to two distinct elements, a and b. Panics if a == b. #[inline] pub fn pick2_mut(&mut self, a: I, b: I) -> (&mut T, &mut T) { let (ai, bi) = (a.index(), b.index()); diff --git a/src/librustc_data_structures/obligation_forest/graphviz.rs b/src/librustc_data_structures/obligation_forest/graphviz.rs index 72551b42324d0..a0363e165e049 100644 --- a/src/librustc_data_structures/obligation_forest/graphviz.rs +++ b/src/librustc_data_structures/obligation_forest/graphviz.rs @@ -7,8 +7,8 @@ use std::sync::atomic::AtomicUsize; use std::sync::atomic::Ordering; impl ObligationForest { - /// Create a graphviz representation of the obligation forest. Given a directory this will - /// create files with name of the format `_.gv`. The counter is + /// Creates a graphviz representation of the obligation forest. Given a directory this will + /// create files with name of the format `_.gv`. The counter is /// global and is maintained internally. /// /// Calling this will do nothing unless the environment variable diff --git a/src/librustc_data_structures/obligation_forest/mod.rs b/src/librustc_data_structures/obligation_forest/mod.rs index 546bb64168e14..4490e5f86d2bd 100644 --- a/src/librustc_data_structures/obligation_forest/mod.rs +++ b/src/librustc_data_structures/obligation_forest/mod.rs @@ -64,7 +64,7 @@ //! #### Snapshots //! //! The `ObligationForest` supports a limited form of snapshots; see -//! `start_snapshot`; `commit_snapshot`; and `rollback_snapshot`. In +//! `start_snapshot`, `commit_snapshot`, and `rollback_snapshot`. In //! particular, you can use a snapshot to roll back new root //! obligations. However, it is an error to attempt to //! `process_obligations` during a snapshot. @@ -72,7 +72,7 @@ //! ### Implementation details //! //! For the most part, comments specific to the implementation are in the -//! code. This file only contains a very high-level overview. Basically, +//! code. This file only contains a very high-level overview. Basically, //! the forest is stored in a vector. Each element of the vector is a node //! in some tree. Each node in the vector has the index of an (optional) //! parent and (for convenience) its root (which may be itself). It also @@ -163,7 +163,7 @@ pub struct ObligationForest { obligation_tree_id_generator: ObligationTreeIdGenerator, - /// Per tree error cache. This is used to deduplicate errors, + /// Per tree error cache. This is used to deduplicate errors, /// which is necessary to avoid trait resolution overflow in /// some cases. /// @@ -268,13 +268,13 @@ impl ObligationForest { } } - /// Return the total number of nodes in the forest that have not + /// Returns the total number of nodes in the forest that have not /// yet been fully resolved. pub fn len(&self) -> usize { self.nodes.len() } - /// Registers an obligation + /// Registers an obligation. /// /// This CAN be done in a snapshot pub fn register_obligation(&mut self, obligation: O) { @@ -341,7 +341,7 @@ impl ObligationForest { } } - /// Convert all remaining obligations to the given error. + /// Converts all remaining obligations to the given error. /// /// This cannot be done during a snapshot. pub fn to_errors(&mut self, error: E) -> Vec> { @@ -380,10 +380,10 @@ impl ObligationForest { .insert(node.obligation.as_predicate().clone()); } - /// Perform a pass through the obligation list. This must + /// Performs a pass through the obligation list. This must /// be called in a loop until `outcome.stalled` is false. /// - /// This CANNOT be unrolled (presently, at least). + /// This _cannot_ be unrolled (presently, at least). pub fn process_obligations

    (&mut self, processor: &mut P, do_completed: DoCompleted) -> Outcome where P: ObligationProcessor @@ -461,7 +461,7 @@ impl ObligationForest { } } - /// Mark all NodeState::Success nodes as NodeState::Done and + /// Mark all `NodeState::Success` nodes as `NodeState::Done` and /// report all cycles between them. This should be called /// after `mark_as_waiting` marks all nodes with pending /// subobligations as NodeState::Waiting. @@ -566,7 +566,7 @@ impl ObligationForest { } } - /// Marks all nodes that depend on a pending node as NodeState::Waiting. + /// Marks all nodes that depend on a pending node as `NodeState::Waiting`. fn mark_as_waiting(&self) { for node in &self.nodes { if node.state.get() == NodeState::Waiting { diff --git a/src/librustc_data_structures/owning_ref/mod.rs b/src/librustc_data_structures/owning_ref/mod.rs index 30e510cc5b055..236559dcd7c10 100644 --- a/src/librustc_data_structures/owning_ref/mod.rs +++ b/src/librustc_data_structures/owning_ref/mod.rs @@ -286,7 +286,7 @@ impl Erased for T {} pub unsafe trait IntoErased<'a> { /// Owner with the dereference type substituted to `Erased`. type Erased; - /// Perform the type erasure. + /// Performs the type erasure. fn into_erased(self) -> Self::Erased; } @@ -296,7 +296,7 @@ pub unsafe trait IntoErased<'a> { pub unsafe trait IntoErasedSend<'a> { /// Owner with the dereference type substituted to `Erased + Send`. type Erased: Send; - /// Perform the type erasure. + /// Performs the type erasure. fn into_erased_send(self) -> Self::Erased; } @@ -306,7 +306,7 @@ pub unsafe trait IntoErasedSend<'a> { pub unsafe trait IntoErasedSendSync<'a> { /// Owner with the dereference type substituted to `Erased + Send + Sync`. type Erased: Send + Sync; - /// Perform the type erasure. + /// Performs the type erasure. fn into_erased_send_sync(self) -> Self::Erased; } @@ -844,7 +844,7 @@ pub trait ToHandleMut { impl OwningHandle where O: StableAddress, O::Target: ToHandle, H: Deref, { - /// Create a new `OwningHandle` for a type that implements `ToHandle`. For types + /// Creates a new `OwningHandle` for a type that implements `ToHandle`. For types /// that don't implement `ToHandle`, callers may invoke `new_with_fn`, which accepts /// a callback to perform the conversion. pub fn new(o: O) -> Self { @@ -855,7 +855,7 @@ impl OwningHandle impl OwningHandle where O: StableAddress, O::Target: ToHandleMut, H: DerefMut, { - /// Create a new mutable `OwningHandle` for a type that implements `ToHandleMut`. + /// Creates a new mutable `OwningHandle` for a type that implements `ToHandleMut`. pub fn new_mut(o: O) -> Self { OwningHandle::new_with_fn(o, |x| unsafe { O::Target::to_handle_mut(x) }) } @@ -864,7 +864,7 @@ impl OwningHandle impl OwningHandle where O: StableAddress, H: Deref, { - /// Create a new OwningHandle. The provided callback will be invoked with + /// Creates a new OwningHandle. The provided callback will be invoked with /// a pointer to the object owned by `o`, and the returned value is stored /// as the object to which this `OwningHandle` will forward `Deref` and /// `DerefMut`. @@ -882,7 +882,7 @@ impl OwningHandle } } - /// Create a new OwningHandle. The provided callback will be invoked with + /// Creates a new OwningHandle. The provided callback will be invoked with /// a pointer to the object owned by `o`, and the returned value is stored /// as the object to which this `OwningHandle` will forward `Deref` and /// `DerefMut`. diff --git a/src/librustc_data_structures/sip128.rs b/src/librustc_data_structures/sip128.rs index 9ec9a39840032..06f157f972932 100644 --- a/src/librustc_data_structures/sip128.rs +++ b/src/librustc_data_structures/sip128.rs @@ -44,7 +44,7 @@ macro_rules! compress { }); } -/// Load an integer of the desired type from a byte stream, in LE order. Uses +/// Loads an integer of the desired type from a byte stream, in LE order. Uses /// `copy_nonoverlapping` to let the compiler generate the most efficient way /// to load it from a possibly unaligned address. /// @@ -61,7 +61,7 @@ macro_rules! load_int_le { }); } -/// Load an u64 using up to 7 bytes of a byte slice. +/// Loads an u64 using up to 7 bytes of a byte slice. /// /// Unsafe because: unchecked indexing at start..start+len #[inline] diff --git a/src/librustc_data_structures/svh.rs b/src/librustc_data_structures/svh.rs index 3757f921098f2..df4f61768375e 100644 --- a/src/librustc_data_structures/svh.rs +++ b/src/librustc_data_structures/svh.rs @@ -17,7 +17,7 @@ pub struct Svh { } impl Svh { - /// Create a new `Svh` given the hash. If you actually want to + /// Creates a new `Svh` given the hash. If you actually want to /// compute the SVH from some HIR, you want the `calculate_svh` /// function found in `librustc_incremental`. pub fn new(hash: u64) -> Svh { diff --git a/src/librustc_data_structures/transitive_relation.rs b/src/librustc_data_structures/transitive_relation.rs index 39aed9833607f..0974607fabea8 100644 --- a/src/librustc_data_structures/transitive_relation.rs +++ b/src/librustc_data_structures/transitive_relation.rs @@ -82,7 +82,7 @@ impl TransitiveRelation { } /// Applies the (partial) function to each edge and returns a new - /// relation. If `f` returns `None` for any end-point, returns + /// relation. If `f` returns `None` for any end-point, returns /// `None`. pub fn maybe_map(&self, mut f: F) -> Option> where F: FnMut(&T) -> Option, @@ -111,7 +111,7 @@ impl TransitiveRelation { } } - /// Check whether `a < target` (transitively) + /// Checks whether `a < target` (transitively) pub fn contains(&self, a: &T, b: &T) -> bool { match (self.index(a), self.index(b)) { (Some(a), Some(b)) => self.with_closure(|closure| closure.contains(a.0, b.0)), @@ -122,7 +122,7 @@ impl TransitiveRelation { /// Thinking of `x R y` as an edge `x -> y` in a graph, this /// returns all things reachable from `a`. /// - /// Really this probably ought to be `impl Iterator`, but + /// Really this probably ought to be `impl Iterator`, but /// I'm too lazy to make that work, and -- given the caching /// strategy -- it'd be a touch tricky anyhow. pub fn reachable_from(&self, a: &T) -> Vec<&T> { @@ -152,20 +152,20 @@ impl TransitiveRelation { /// the query is `postdom_upper_bound(a, b)`: /// /// ```text - /// // returns Some(x), which is also LUB + /// // Returns Some(x), which is also LUB. /// a -> a1 -> x /// ^ /// | /// b -> b1 ---+ /// - /// // returns Some(x), which is not LUB (there is none) - /// // diagonal edges run left-to-right + /// // Returns `Some(x)`, which is not LUB (there is none) + /// // diagonal edges run left-to-right. /// a -> a1 -> x /// \/ ^ /// /\ | /// b -> b1 ---+ /// - /// // returns None + /// // Returns `None`. /// a -> a1 /// b -> b1 /// ``` diff --git a/src/librustc_data_structures/work_queue.rs b/src/librustc_data_structures/work_queue.rs index 06418b1051ac3..193025aafad20 100644 --- a/src/librustc_data_structures/work_queue.rs +++ b/src/librustc_data_structures/work_queue.rs @@ -14,7 +14,7 @@ pub struct WorkQueue { } impl WorkQueue { - /// Create a new work queue with all the elements from (0..len). + /// Creates a new work queue with all the elements from (0..len). #[inline] pub fn with_all(len: usize) -> Self { WorkQueue { @@ -23,7 +23,7 @@ impl WorkQueue { } } - /// Create a new work queue that starts empty, where elements range from (0..len). + /// Creates a new work queue that starts empty, where elements range from (0..len). #[inline] pub fn with_none(len: usize) -> Self { WorkQueue { @@ -54,7 +54,7 @@ impl WorkQueue { } } - /// True if nothing is enqueued. + /// Returns `true` if nothing is enqueued. #[inline] pub fn is_empty(&self) -> bool { self.deque.is_empty() diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 6a23cadf87795..09804a706ec98 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -711,7 +711,7 @@ pub struct InnerExpansionResult<'a> { pub hir_forest: hir_map::Forest, } -/// Run the "early phases" of the compiler: initial `cfg` processing, +/// Runs the "early phases" of the compiler: initial `cfg` processing, /// loading compiler plugins (including those from `addl_plugins`), /// syntax expansion, secondary `cfg` expansion, synthesis of a test /// harness if one is to be provided, injection of a dependency on the @@ -1167,7 +1167,7 @@ pub fn default_provide_extern(providers: &mut ty::query::Providers) { cstore::provide_extern(providers); } -/// Run the resolution, typechecking, region checking and other +/// Runs the resolution, typec-hecking, region checking and other /// miscellaneous analysis passes on the crate. Return various /// structures carrying the results of the analysis. pub fn phase_3_run_analysis_passes<'tcx, F, R>( @@ -1334,7 +1334,7 @@ where ) } -/// Run the codegen backend, after which the AST and analysis can +/// Runs the codegen backend, after which the AST and analysis can /// be discarded. pub fn phase_4_codegen<'a, 'tcx>( codegen_backend: &dyn CodegenBackend, diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index b356ae38e24ca..2d894bd65b286 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -114,7 +114,7 @@ pub mod target_features { use rustc::session::Session; use rustc_codegen_utils::codegen_backend::CodegenBackend; - /// Add `target_feature = "..."` cfgs for a variety of platform + /// Adds `target_feature = "..."` cfgs for a variety of platform /// specific features (SSE, NEON etc.). /// /// This is performed by checking whether a whitelisted set of @@ -1316,7 +1316,7 @@ fn print_flag_list(cmdline_opt: &str, /// Process command line options. Emits messages as appropriate. If compilation /// should continue, returns a getopts::Matches object parsed from args, -/// otherwise returns None. +/// otherwise returns `None`. /// /// The compiler's handling of options is a little complicated as it ties into /// our stability story, and it's even *more* complicated by historical @@ -1480,7 +1480,7 @@ pub fn in_rustc_thread(f: F) -> Result> in_named_rustc_thread("rustc".to_string(), f) } -/// Get a list of extra command-line flags provided by the user, as strings. +/// Gets a list of extra command-line flags provided by the user, as strings. /// /// This function is used during ICEs to show more information useful for /// debugging, since some ICEs only happens with non-default compiler flags @@ -1545,7 +1545,7 @@ impl Display for CompilationFailure { } } -/// Run a procedure which will detect panics in the compiler and print nicer +/// Runs a procedure which will detect panics in the compiler and print nicer /// error messages rather than just failing the test. /// /// The diagnostic emitter yielded to the procedure should be used for reporting diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index afcf08632a4f0..2ec755bd62691 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -1,4 +1,4 @@ -//! # Standalone Tests for the Inference Module +//! Standalone tests for the inference module. use driver; use errors; @@ -508,8 +508,8 @@ fn subst_ty_renumber_bound() { }) } -/// Test substituting a bound region into a function, which introduces another level of binding. -/// This requires adjusting the Debruijn index. +/// Tests substituting a bound region into a function, which introduces another level of binding. +/// This requires adjusting the De Bruijn index. #[test] fn subst_ty_renumber_some_bounds() { test_env(EMPTY_SOURCE_STR, errors(&[]), |env| { @@ -544,7 +544,7 @@ fn subst_ty_renumber_some_bounds() { }) } -/// Test that we correctly compute whether a type has escaping regions or not. +/// Tests that we correctly compute whether a type has escaping regions or not. #[test] fn escaping() { test_env(EMPTY_SOURCE_STR, errors(&[]), |mut env| { @@ -571,7 +571,7 @@ fn escaping() { }) } -/// Test applying a substitution where the value being substituted for an early-bound region is a +/// Tests applying a substitution where the value being substituted for an early-bound region is a /// late-bound region. #[test] fn subst_region_renumber_region() { diff --git a/src/librustc_errors/diagnostic.rs b/src/librustc_errors/diagnostic.rs index aefe296ad0fa7..2c410f69bfc66 100644 --- a/src/librustc_errors/diagnostic.rs +++ b/src/librustc_errors/diagnostic.rs @@ -118,7 +118,7 @@ impl Diagnostic { self.level == Level::Cancelled } - /// Add a span/label to be included in the resulting snippet. + /// Adds a span/label to be included in the resulting snippet. /// This is pushed onto the `MultiSpan` that was created when the /// diagnostic was first built. If you don't call this function at /// all, and you just supplied a `Span` to create the diagnostic, diff --git a/src/librustc_errors/diagnostic_builder.rs b/src/librustc_errors/diagnostic_builder.rs index fd4ea7f2d823f..9d5e8d10b1772 100644 --- a/src/librustc_errors/diagnostic_builder.rs +++ b/src/librustc_errors/diagnostic_builder.rs @@ -26,7 +26,7 @@ pub struct DiagnosticBuilder<'a> { /// In general, the `DiagnosticBuilder` uses deref to allow access to /// the fields and methods of the embedded `diagnostic` in a -/// transparent way. *However,* many of the methods are intended to +/// transparent way. *However,* many of the methods are intended to /// be used in a chained way, and hence ought to return `self`. In /// that case, we can't just naively forward to the method on the /// `diagnostic`, because the return type would be a `&Diagnostic` @@ -150,7 +150,7 @@ impl<'a> DiagnosticBuilder<'a> { self.cancel(); } - /// Add a span/label to be included in the resulting snippet. + /// Adds a span/label to be included in the resulting snippet. /// This is pushed onto the `MultiSpan` that was created when the /// diagnostic was first built. If you don't call this function at /// all, and you just supplied a `Span` to create the diagnostic, diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs index 2821201173ea0..1c0c9d137e40f 100644 --- a/src/librustc_errors/emitter.rs +++ b/src/librustc_errors/emitter.rs @@ -22,7 +22,7 @@ pub trait Emitter { /// Emit a structured diagnostic. fn emit(&mut self, db: &DiagnosticBuilder<'_>); - /// Check if should show explanations about "rustc --explain" + /// Checks if should show explanations about "rustc --explain" fn should_show_explain(&self) -> bool { true } @@ -868,7 +868,7 @@ impl EmitterWriter { } } - /// Add a left margin to every line but the first, given a padding length and the label being + /// Adds a left margin to every line but the first, given a padding length and the label being /// displayed, keeping the provided highlighting. fn msg_to_buffer(&self, buffer: &mut StyledBuffer, @@ -895,7 +895,7 @@ impl EmitterWriter { // `max_line_num_len` let padding = " ".repeat(padding + label.len() + 5); - /// Return whether `style`, or the override if present and the style is `NoStyle`. + /// Returns `true` if `style`, or the override if present and the style is `NoStyle`. fn style_or_override(style: Style, override_style: Option

    (self, predicate: P) -> TakeWhile where From 652f2c753aed97261f5d988f0a2b50aa6508964c Mon Sep 17 00:00:00 2001 From: ishitatsuyuki Date: Mon, 4 Feb 2019 19:26:46 +0900 Subject: [PATCH 058/278] Add test --- src/test/ui/stability-in-private-module.rs | 4 ++++ src/test/ui/stability-in-private-module.stderr | 9 +++++++++ 2 files changed, 13 insertions(+) create mode 100644 src/test/ui/stability-in-private-module.rs create mode 100644 src/test/ui/stability-in-private-module.stderr diff --git a/src/test/ui/stability-in-private-module.rs b/src/test/ui/stability-in-private-module.rs new file mode 100644 index 0000000000000..f12e9198b0d7c --- /dev/null +++ b/src/test/ui/stability-in-private-module.rs @@ -0,0 +1,4 @@ +fn main() { + let _ = std::thread::thread_info::current_thread(); + //~^ERROR module `thread_info` is private +} diff --git a/src/test/ui/stability-in-private-module.stderr b/src/test/ui/stability-in-private-module.stderr new file mode 100644 index 0000000000000..c3edd62a15eda --- /dev/null +++ b/src/test/ui/stability-in-private-module.stderr @@ -0,0 +1,9 @@ +error[E0603]: module `thread_info` is private + --> $DIR/stability-in-private-module.rs:2:26 + | +LL | let _ = std::thread::thread_info::current_thread(); + | ^^^^^^^^^^^ + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0603`. From 82df9d7434c949b4357fb4c80c36961404226f93 Mon Sep 17 00:00:00 2001 From: Jethro Beekman Date: Mon, 4 Feb 2019 16:02:54 +0530 Subject: [PATCH 059/278] Remove stray FIXME --- src/libstd/sys/sgx/rwlock.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/libstd/sys/sgx/rwlock.rs b/src/libstd/sys/sgx/rwlock.rs index 43ceae7d33b8d..33163a556c16d 100644 --- a/src/libstd/sys/sgx/rwlock.rs +++ b/src/libstd/sys/sgx/rwlock.rs @@ -19,9 +19,6 @@ unsafe fn rw_lock_size_assert(r: RWLock) { mem::transmute::(r); } -//unsafe impl Send for RWLock {} -//unsafe impl Sync for RWLock {} // FIXME - impl RWLock { pub const fn new() -> RWLock { RWLock { From 4633cca157d9730d75e3fc6144ae952b76f5559f Mon Sep 17 00:00:00 2001 From: James Munns Date: Mon, 4 Feb 2019 11:34:50 +0100 Subject: [PATCH 060/278] Update embedded book dependency --- src/doc/embedded-book | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/doc/embedded-book b/src/doc/embedded-book index 36bc507044a95..d663113d1d9fb 160000 --- a/src/doc/embedded-book +++ b/src/doc/embedded-book @@ -1 +1 @@ -Subproject commit 36bc507044a9596df426e67e2e1685a3ed6e3c60 +Subproject commit d663113d1d9fbd35f1145c29f6080a6350b7f419 From c40fa3271a939ee34662482052be64929978ca6a Mon Sep 17 00:00:00 2001 From: Guillaume Gomez Date: Mon, 4 Feb 2019 12:38:26 +0100 Subject: [PATCH 061/278] sort elements in the sidebar --- src/librustdoc/html/render.rs | 156 ++++++++++++++++++---------------- 1 file changed, 84 insertions(+), 72 deletions(-) diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 86fb51419c270..c4c3b635b59e0 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -4470,15 +4470,17 @@ fn sidebar_assoc_items(it: &clean::Item) -> String { { let used_links_bor = Rc::new(RefCell::new(&mut used_links)); - let ret = v.iter() - .filter(|i| i.inner_impl().trait_.is_none()) - .flat_map(move |i| get_methods(i.inner_impl(), - false, - &mut used_links_bor.borrow_mut())) - .collect::(); + let mut ret = v.iter() + .filter(|i| i.inner_impl().trait_.is_none()) + .flat_map(move |i| get_methods(i.inner_impl(), + false, + &mut used_links_bor.borrow_mut())) + .collect::>(); + // We want links' order to be reproducible so we don't use unstable sort. + ret.sort(); if !ret.is_empty() { out.push_str(&format!("Methods\ -