diff --git a/Cargo.lock b/Cargo.lock index 313fef1c086a8..108c2fbd8f503 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -277,7 +277,7 @@ dependencies = [ "crypto-hash", "curl", "curl-sys", - "env_logger 0.6.0", + "env_logger", "failure", "filetime", "flate2", @@ -507,7 +507,7 @@ name = "compiletest" version = "0.0.0" dependencies = [ "diff", - "env_logger 0.5.13", + "env_logger", "getopts", "lazy_static 1.3.0", "libc", @@ -909,21 +909,9 @@ dependencies = [ [[package]] name = "env_logger" -version = "0.5.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15b0a4d2e39f8420210be8b27eeda28029729e2fd4291019455016c348240c38" -dependencies = [ - "atty", - "humantime", - "log", - "termcolor", -] - -[[package]] -name = "env_logger" -version = "0.6.0" +version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "afb070faf94c85d17d50ca44f6ad076bce18ae92f0037d350947240a36e9d42e" +checksum = "aafcde04e90a5226a6443b7aabdb016ba2f8307c847d524724bd9b346dd1a2d3" dependencies = [ "atty", "humantime", @@ -1774,7 +1762,7 @@ dependencies = [ "chrono", "clap", "elasticlunr-rs", - "env_logger 0.6.0", + "env_logger", "error-chain", "handlebars", "itertools 0.8.0", @@ -1799,7 +1787,7 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "77d1f0ba4d1e6b86fa18e8853d026d7d76a97eb7eb5eb052ed80901e43b7fc10" dependencies = [ - "env_logger 0.6.0", + "env_logger", "failure", "log", "mdbook", @@ -1992,7 +1980,7 @@ dependencies = [ "colored", "compiletest_rs", "directories", - "env_logger 0.6.0", + "env_logger", "getrandom", "hex", "log", @@ -2363,7 +2351,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "df8b3f4e0475def7d9c2e5de8e5a1306949849761e107b360d03e98eafaffd61" dependencies = [ "chrono", - "env_logger 0.6.0", + "env_logger", "log", ] @@ -2440,7 +2428,7 @@ dependencies = [ "bitflags", "clap", "derive_more", - "env_logger 0.6.0", + "env_logger", "humantime", "lazy_static 1.3.0", "log", @@ -2734,7 +2722,7 @@ dependencies = [ "clippy_lints", "crossbeam-channel", "difference", - "env_logger 0.6.0", + "env_logger", "failure", "futures", "heck", @@ -3129,11 +3117,7 @@ dependencies = [ name = "rustc_codegen_llvm" version = "0.0.0" dependencies = [ - "cc", - "memmap", - "num_cpus", "rustc_llvm", - "tempfile", ] [[package]] @@ -3203,7 +3187,7 @@ dependencies = [ name = "rustc_driver" version = "0.0.0" dependencies = [ - "env_logger 0.5.13", + "env_logger", "graphviz", "log", "rustc", @@ -3590,7 +3574,7 @@ dependencies = [ "derive-new", "diff", "dirs", - "env_logger 0.6.0", + "env_logger", "failure", "getopts", "ignore", diff --git a/src/bootstrap/bin/rustc.rs b/src/bootstrap/bin/rustc.rs index 8cb48df14bfef..84415baa3a140 100644 --- a/src/bootstrap/bin/rustc.rs +++ b/src/bootstrap/bin/rustc.rs @@ -119,17 +119,18 @@ fn main() { cmd.arg(format!("-Cdebuginfo={}", debuginfo_level)); } - if env::var_os("RUSTC_DENY_WARNINGS").is_some() && - env::var_os("RUSTC_EXTERNAL_TOOL").is_none() { + if env::var_os("RUSTC_EXTERNAL_TOOL").is_none() { // When extending this list, add the new lints to the RUSTFLAGS of the // build_bootstrap function of src/bootstrap/bootstrap.py as well as // some code doesn't go through this `rustc` wrapper. - cmd.arg("-Dwarnings"); - cmd.arg("-Drust_2018_idioms"); - cmd.arg("-Dunused_lifetimes"); + cmd.arg("-Wrust_2018_idioms"); + cmd.arg("-Wunused_lifetimes"); if use_internal_lints(crate_name) { cmd.arg("-Zunstable-options"); - cmd.arg("-Drustc::internal"); + cmd.arg("-Wrustc::internal"); + } + if env::var_os("RUSTC_DENY_WARNINGS").is_some() { + cmd.arg("-Dwarnings"); } } diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py index 179cd488be732..e0e4c076071b6 100644 --- a/src/bootstrap/bootstrap.py +++ b/src/bootstrap/bootstrap.py @@ -631,8 +631,9 @@ def build_bootstrap(self): target_linker = self.get_toml("linker", build_section) if target_linker is not None: env["RUSTFLAGS"] += "-C linker=" + target_linker + " " + env["RUSTFLAGS"] += " -Wrust_2018_idioms -Wunused_lifetimes " if self.get_toml("deny-warnings", "rust") != "false": - env["RUSTFLAGS"] += "-Dwarnings -Drust_2018_idioms -Dunused_lifetimes " + env["RUSTFLAGS"] += "-Dwarnings " env["PATH"] = os.path.join(self.bin_root(), "bin") + \ os.pathsep + env["PATH"] diff --git a/src/bootstrap/flags.rs b/src/bootstrap/flags.rs index 828865f10ffba..d9580b598155e 100644 --- a/src/bootstrap/flags.rs +++ b/src/bootstrap/flags.rs @@ -36,7 +36,7 @@ pub struct Flags { // This overrides the deny-warnings configuation option, // which passes -Dwarnings to the compiler invocations. // - // true => deny, false => allow + // true => deny, false => warn pub deny_warnings: Option, } @@ -556,10 +556,10 @@ fn split(s: &[String]) -> Vec { fn parse_deny_warnings(matches: &getopts::Matches) -> Option { match matches.opt_str("warnings").as_ref().map(|v| v.as_str()) { Some("deny") => Some(true), - Some("allow") => Some(false), + Some("warn") => Some(false), Some(value) => { eprintln!( - r#"invalid value for --warnings: {:?}, expected "allow" or "deny""#, + r#"invalid value for --warnings: {:?}, expected "warn" or "deny""#, value, ); process::exit(1); diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs index 97b28ed9e96c8..00d87f3841cff 100644 --- a/src/bootstrap/test.rs +++ b/src/bootstrap/test.rs @@ -1327,7 +1327,10 @@ impl Step for Compiletest { cmd.env("RUSTC_PROFILER_SUPPORT", "1"); } - cmd.env("RUST_TEST_TMPDIR", builder.out.join("tmp")); + let tmp = builder.out.join("tmp"); + std::fs::create_dir_all(&tmp).unwrap(); + cmd.env("RUST_TEST_TMPDIR", tmp); + cmd.arg("--adb-path").arg("adb"); cmd.arg("--adb-test-dir").arg(ADB_TEST_DIR); diff --git a/src/librustc/arena.rs b/src/librustc/arena.rs index b3a561ef74be7..d4fc1b12830a1 100644 --- a/src/librustc/arena.rs +++ b/src/librustc/arena.rs @@ -187,7 +187,7 @@ impl ArenaAllocatable for T {} unsafe trait ArenaField<'tcx>: Sized { /// Returns a specific arena to allocate from. - /// If None is returned, the DropArena will be used. + /// If `None` is returned, the `DropArena` will be used. fn arena<'a>(arena: &'a Arena<'tcx>) -> Option<&'a TypedArena>; } diff --git a/src/librustc/error_codes.rs b/src/librustc/error_codes.rs index 937a9ea6c1bd4..eee33846139e6 100644 --- a/src/librustc/error_codes.rs +++ b/src/librustc/error_codes.rs @@ -1,7 +1,8 @@ // 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. -register_long_diagnostics! { +// 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. +syntax::register_diagnostics! { E0038: r##" Trait objects like `Box` can only be constructed when certain requirements are satisfied by the trait in question. @@ -2183,11 +2184,7 @@ Examples of erroneous code: static X: u32 = 42; ``` "##, - -} - - -register_diagnostics! { +; // E0006, // merged with E0005 // E0101, // replaced with E0282 // E0102, // replaced with E0282 @@ -2206,7 +2203,8 @@ register_diagnostics! { // E0305, // expected constant E0311, // thing may not live long enough E0312, // lifetime of reference outlives lifetime of borrowed content - E0313, // lifetime of borrowed pointer outlives lifetime of captured variable + E0313, // lifetime of borrowed pointer outlives lifetime of captured + // variable E0314, // closure outlives stack frame E0315, // cannot invoke closure outside of its lifetime E0316, // nested quantification of lifetimes @@ -2223,12 +2221,13 @@ register_diagnostics! { E0483, // lifetime of operand does not outlive the operation E0484, // reference is not valid at the time of borrow E0485, // automatically reference is not valid at the time of borrow - E0486, // type of expression contains references that are not valid during... + E0486, // type of expression contains references that are not valid during.. E0487, // unsafe use of destructor: destructor might be called while... E0488, // lifetime of variable does not enclose its declaration E0489, // type/lifetime parameter not in scope here E0490, // a value of type `..` is borrowed for too long - E0495, // cannot infer an appropriate lifetime due to conflicting requirements + E0495, // cannot infer an appropriate lifetime due to conflicting + // requirements E0566, // conflicting representation hints E0623, // lifetime mismatch where both parameters are anonymous regions E0628, // generators cannot have explicit parameters @@ -2239,7 +2238,8 @@ register_diagnostics! { E0688, // in-band lifetimes cannot be mixed with explicit lifetime binders E0697, // closures cannot be static E0707, // multiple elided lifetimes used in arguments of `async fn` - E0708, // `async` non-`move` closures with parameters are not currently supported + E0708, // `async` non-`move` closures with parameters are not currently + // supported E0709, // multiple different lifetimes used in arguments of `async fn` E0710, // an unknown tool name found in scoped lint E0711, // a feature has been declared with conflicting stability attributes diff --git a/src/librustc/hir/check_attr.rs b/src/librustc/hir/check_attr.rs index eae956c978a8e..1df09429e519f 100644 --- a/src/librustc/hir/check_attr.rs +++ b/src/librustc/hir/check_attr.rs @@ -4,13 +4,12 @@ //! conflicts between multiple such attributes attached to the same //! item. - -use crate::ty::TyCtxt; -use crate::ty::query::Providers; - use crate::hir; use crate::hir::def_id::DefId; use crate::hir::intravisit::{self, Visitor, NestedVisitorMap}; +use crate::ty::TyCtxt; +use crate::ty::query::Providers; + use std::fmt::{self, Display}; use syntax::symbol::sym; use syntax_pos::Span; diff --git a/src/librustc/hir/def.rs b/src/librustc/hir/def.rs index f83fbcdc263b0..f7d31ca06ee56 100644 --- a/src/librustc/hir/def.rs +++ b/src/librustc/hir/def.rs @@ -1,15 +1,17 @@ +use self::Namespace::*; + use crate::hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE}; +use crate::hir; +use crate::ty; use crate::util::nodemap::DefIdMap; + use syntax::ast; use syntax::ext::base::MacroKind; use syntax::ast::NodeId; use syntax_pos::Span; use rustc_macros::HashStable; -use crate::hir; -use crate::ty; -use std::fmt::Debug; -use self::Namespace::*; +use std::fmt::Debug; /// Encodes if a `DefKind::Ctor` is the constructor of an enum variant or a struct. #[derive(Clone, Copy, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, HashStable)] @@ -115,7 +117,7 @@ impl DefKind { } } - /// An English article for the def. + /// Gets an English article for the definition. pub fn article(&self) -> &'static str { match *self { DefKind::AssocTy @@ -134,18 +136,22 @@ pub enum Res { Def(DefKind, DefId), // Type namespace + PrimTy(hir::PrimTy), SelfTy(Option /* trait */, Option /* impl */), ToolMod, // e.g., `rustfmt` in `#[rustfmt::skip]` // Value namespace + SelfCtor(DefId /* impl */), // `DefId` refers to the impl Local(Id), // Macro namespace + NonMacroAttr(NonMacroAttrKind), // e.g., `#[inline]` or `#[rustfmt::skip]` // All namespaces + Err, } @@ -330,7 +336,7 @@ impl NonMacroAttrKind { } impl Res { - /// Return the `DefId` of this `Def` if it has an id, else panic. + /// Return the `DefId` of this `Def` if it has an ID, else panic. pub fn def_id(&self) -> DefId where Id: Debug, @@ -340,7 +346,7 @@ impl Res { }) } - /// Return `Some(..)` with the `DefId` of this `Res` if it has a id, else `None`. + /// Return `Some(..)` with the `DefId` of this `Res` if it has a ID, else `None`. pub fn opt_def_id(&self) -> Option { match *self { Res::Def(_, id) => Some(id), @@ -379,7 +385,7 @@ impl Res { } } - /// An English article for the res. + /// Gets an English article for the `Res`. pub fn article(&self) -> &'static str { match *self { Res::Def(kind, _) => kind.article(), diff --git a/src/librustc/hir/def_id.rs b/src/librustc/hir/def_id.rs index c91ad7858d0bb..d0bdc14913183 100644 --- a/src/librustc/hir/def_id.rs +++ b/src/librustc/hir/def_id.rs @@ -11,7 +11,7 @@ newtype_index! { #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub enum CrateNum { - /// A special CrateNum that we use for the tcx.rcache when decoding from + /// A special `CrateNum` that we use for the `tcx.rcache` when decoding from /// the incr. comp. cache. ReservedForIncrCompCache, Index(CrateId), @@ -26,11 +26,10 @@ impl ::std::fmt::Debug for CrateNum { } } -/// Item definitions in the currently-compiled crate would have the CrateNum -/// LOCAL_CRATE in their DefId. +/// Item definitions in the currently-compiled crate would have the `CrateNum` +/// `LOCAL_CRATE` in their `DefId`. pub const LOCAL_CRATE: CrateNum = CrateNum::Index(CrateId::from_u32_const(0)); - impl Idx for CrateNum { #[inline] fn new(value: usize) -> Self { diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs index bbde3510e29f9..1f125de967216 100644 --- a/src/librustc/hir/intravisit.rs +++ b/src/librustc/hir/intravisit.rs @@ -31,11 +31,13 @@ //! This order consistency is required in a few places in rustc, for //! example generator inference, and possibly also HIR borrowck. -use syntax::ast::{Ident, Name, Attribute}; -use syntax_pos::Span; +use super::itemlikevisit::DeepVisitor; + use crate::hir::*; use crate::hir::map::Map; -use super::itemlikevisit::DeepVisitor; + +use syntax::ast::{Ident, Name, Attribute}; +use syntax_pos::Span; #[derive(Copy, Clone)] pub enum FnKind<'a> { @@ -139,7 +141,7 @@ impl<'this, 'tcx> NestedVisitorMap<'this, 'tcx> { /// 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 { +pub trait Visitor<'v>: Sized { /////////////////////////////////////////////////////////////////////////// // Nested items. @@ -162,8 +164,8 @@ pub trait Visitor<'v> : Sized { fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'v>; /// Invoked when a nested item is encountered. By default does - /// nothing unless you override `nested_visit_map` to return - /// `Some(_)`, in which case it will walk the item. **You probably + /// nothing unless you override `nested_visit_map` to return other than + /// `None`, in which case it will walk the item. **You probably /// don't want to override this method** -- instead, override /// `nested_visit_map` or use the "shallow" or "deep" visit /// patterns described on `itemlikevisit::ItemLikeVisitor`. The only @@ -201,8 +203,8 @@ pub trait Visitor<'v> : Sized { /// Invoked to visit the body of a function, method or closure. Like /// visit_nested_item, does nothing by default unless you override - /// `nested_visit_map` to return `Some(_)`, in which case it will walk the - /// body. + /// `nested_visit_map` to return other htan `None`, in which case it will walk + /// the body. fn visit_nested_body(&mut self, id: BodyId) { let opt_body = self.nested_visit_map().intra().map(|map| map.body(id)); if let Some(body) = opt_body { @@ -603,7 +605,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) { visitor.visit_lifetime(lifetime); visitor.visit_ty(&mutable_type.ty) } - TyKind::Never => {}, + TyKind::Never => {} TyKind::Tup(ref tuple_element_types) => { walk_list!(visitor, visit_ty, tuple_element_types); } diff --git a/src/librustc/hir/itemlikevisit.rs b/src/librustc/hir/itemlikevisit.rs index 35b181245837f..39dd46c2d2903 100644 --- a/src/librustc/hir/itemlikevisit.rs +++ b/src/librustc/hir/itemlikevisit.rs @@ -1,7 +1,7 @@ use super::{Item, ImplItem, TraitItem}; use super::intravisit::Visitor; -/// The "item-like visitor" visitor defines only the top-level methods +/// The "item-like visitor" defines only the top-level methods /// that can be invoked by `Crate::visit_all_item_likes()`. Whether /// this trait is the right one to implement will depend on the /// overall pattern you need. Here are the three available patterns, @@ -18,11 +18,11 @@ use super::intravisit::Visitor; /// an item, but don't care about how item-like things are nested /// within one another. /// - Example: Examine each expression to look for its type and do some check or other. -/// - How: Implement `intravisit::Visitor` and use -/// `tcx.hir().krate().visit_all_item_likes(visitor.as_deep_visitor())`. Within -/// your `intravisit::Visitor` impl, implement methods like -/// `visit_expr()`; don't forget to invoke -/// `intravisit::walk_visit_expr()` to keep walking the subparts. +/// - How: Implement `intravisit::Visitor` and override the `nested_visit_map()` method +/// to return `NestedVisitorMap::OnlyBodies` and use +/// `tcx.hir().krate().visit_all_item_likes(&mut visitor.as_deep_visitor())`. Within +/// your `intravisit::Visitor` impl, implement methods like `visit_expr()` (don't forget +/// to invoke `intravisit::walk_expr()` to keep walking the subparts). /// - Pro: Visitor methods for any kind of HIR node, not just item-like things. /// - Pro: Integrates well into dependency tracking. /// - Con: Don't get information about nesting between items @@ -30,10 +30,9 @@ use super::intravisit::Visitor; /// item-like things. /// - Example: Lifetime resolution, which wants to bring lifetimes declared on the /// impl into scope while visiting the impl-items, and then back out again. -/// - How: Implement `intravisit::Visitor` and override the -/// `nested_visit_map()` methods to return -/// `NestedVisitorMap::All`. Walk your crate with -/// `intravisit::walk_crate()` invoked on `tcx.hir().krate()`. +/// - How: Implement `intravisit::Visitor` and override the `nested_visit_map()` method +/// to return `NestedVisitorMap::All`. Walk your crate with `intravisit::walk_crate()` +/// invoked on `tcx.hir().krate()`. /// - Pro: Visitor methods for any kind of HIR node, not just item-like things. /// - Pro: Preserves nesting information /// - Con: Does not integrate well into dependency tracking. @@ -79,7 +78,7 @@ impl<'v, 'hir, V> ItemLikeVisitor<'hir> for DeepVisitor<'v, V> } } -/// A parallel variant of ItemLikeVisitor +/// A parallel variant of `ItemLikeVisitor`. pub trait ParItemLikeVisitor<'hir> { fn visit_item(&self, item: &'hir Item); fn visit_trait_item(&self, trait_item: &'hir TraitItem); diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 190b50b10b281..b50cfa00f09ef 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -79,7 +79,7 @@ const HIR_ID_COUNTER_LOCKED: u32 = 0xFFFFFFFF; pub struct LoweringContext<'a> { crate_root: Option, - /// Used to assign ids to HIR nodes that do not directly correspond to an AST node. + /// Used to assign IDs to HIR nodes that do not directly correspond to AST nodes. sess: &'a Session, cstore: &'a dyn CrateStore, @@ -126,7 +126,7 @@ pub struct LoweringContext<'a> { /// lifetime definitions in the corresponding impl or function generics. lifetimes_to_define: Vec<(Span, ParamName)>, - /// Whether or not in-band lifetimes are being collected. This is used to + /// `true` if in-band lifetimes are being collected. This is used to /// indicate whether or not we're in a place where new lifetimes will result /// in in-band lifetime definitions, such a function or an impl header, /// including implicit lifetimes from `impl_header_lifetime_elision`. @@ -154,13 +154,13 @@ pub struct LoweringContext<'a> { } pub trait Resolver { - /// Obtain resolution for a `NodeId` with a single resolution. + /// Obtains resolution for a `NodeId` with a single resolution. fn get_partial_res(&mut self, id: NodeId) -> Option; - /// Obtain per-namespace resolutions for `use` statement with the given `NoedId`. + /// Obtains per-namespace resolutions for `use` statement with the given `NodeId`. fn get_import_res(&mut self, id: NodeId) -> PerNS>>; - /// Obtain resolution for a label with the given `NodeId`. + /// Obtains resolution for a label with the given `NodeId`. fn get_label_res(&mut self, id: NodeId) -> Option; /// We must keep the set of definitions up to date as we add nodes that weren't in the AST. @@ -699,7 +699,7 @@ impl<'a> LoweringContext<'a> { fn lower_res(&mut self, res: Res) -> Res { res.map_id(|id| { self.lower_node_id_generic(id, |_| { - panic!("expected node_id to be lowered already for res {:#?}", res) + panic!("expected `NodeId` to be lowered already for res {:#?}", res); }) }) } @@ -1364,7 +1364,7 @@ impl<'a> LoweringContext<'a> { } } } - TyKind::Mac(_) => bug!("`TyMac` should have been expanded by now."), + TyKind::Mac(_) => bug!("`TyMac` should have been expanded by now"), TyKind::CVarArgs => { // Create the implicit lifetime of the "spoofed" `VaListImpl`. let span = self.sess.source_map().next_point(t.span.shrink_to_lo()); @@ -2999,7 +2999,7 @@ impl<'a> LoweringContext<'a> { } StmtKind::Expr(ref e) => hir::StmtKind::Expr(P(self.lower_expr(e))), StmtKind::Semi(ref e) => hir::StmtKind::Semi(P(self.lower_expr(e))), - StmtKind::Mac(..) => panic!("Shouldn't exist here"), + StmtKind::Mac(..) => panic!("shouldn't exist here"), }; smallvec![hir::Stmt { hir_id: self.lower_node_id(s.id), @@ -3187,7 +3187,7 @@ impl<'a> LoweringContext<'a> { hir::Path { span, - res: res.map_id(|_| panic!("unexpected node_id")), + res: res.map_id(|_| panic!("unexpected `NodeId`")), segments: segments.into(), } } diff --git a/src/librustc/hir/lowering/item.rs b/src/librustc/hir/lowering/item.rs index 4e432f4981d23..5f82e42abb308 100644 --- a/src/librustc/hir/lowering/item.rs +++ b/src/librustc/hir/lowering/item.rs @@ -718,7 +718,7 @@ impl LoweringContext<'_> { AnonymousLifetimeMode::PassThrough, |this, _| { ( - // Disallow impl Trait in foreign items + // Disallow `impl Trait` in foreign items. this.lower_fn_decl(fdec, None, false, None), this.lower_fn_params_to_names(fdec), ) @@ -732,7 +732,7 @@ impl LoweringContext<'_> { self.lower_ty(t, ImplTraitContext::disallowed()), self.lower_mutability(m)) } ForeignItemKind::Ty => hir::ForeignItemKind::Type, - ForeignItemKind::Macro(_) => panic!("shouldn't exist here"), + ForeignItemKind::Macro(_) => panic!("macro shouldn't exist here"), }, vis: self.lower_visibility(&i.vis, None), span: i.span, diff --git a/src/librustc/hir/map/collector.rs b/src/librustc/hir/map/collector.rs index b8bd1d73fc28b..4179cf2ff807f 100644 --- a/src/librustc/hir/map/collector.rs +++ b/src/librustc/hir/map/collector.rs @@ -340,7 +340,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> { /// their outer items. fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'hir> { - panic!("visit_nested_xxx must be manually implemented in this visitor") + panic!("`visit_nested_xxx` must be manually implemented in this visitor"); } fn visit_nested_item(&mut self, item: ItemId) { diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs index 6dc3c7038f569..651fe8449ac93 100644 --- a/src/librustc/hir/map/definitions.rs +++ b/src/librustc/hir/map/definitions.rs @@ -7,10 +7,12 @@ use crate::hir; use crate::hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE, CRATE_DEF_INDEX}; use crate::ich::Fingerprint; +use crate::session::CrateDisambiguator; +use crate::util::nodemap::NodeMap; + use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::indexed_vec::{IndexVec}; use rustc_data_structures::stable_hasher::StableHasher; -use crate::session::CrateDisambiguator; use std::borrow::Borrow; use std::fmt::Write; use std::hash::Hash; @@ -18,12 +20,11 @@ use syntax::ast; use syntax::ext::hygiene::ExpnId; use syntax::symbol::{Symbol, sym, InternedString}; use syntax_pos::{Span, DUMMY_SP}; -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 -/// stores the DefIndex of its parent. -/// There is one DefPathTable for each crate. +/// The `DefPathTable` maps `DefIndex`es to `DefKey`s and vice versa. +/// Internally the `DefPathTable` holds a tree of `DefKey`s, where each `DefKey` +/// stores the `DefIndex` of its parent. +/// There is one `DefPathTable` for each crate. #[derive(Clone, Default, RustcDecodable, RustcEncodable)] pub struct DefPathTable { index_to_key: Vec, @@ -121,7 +122,7 @@ impl DefKey { fn compute_stable_hash(&self, parent_hash: DefPathHash) -> DefPathHash { let mut hasher = StableHasher::new(); - // We hash a 0u8 here to disambiguate between regular DefPath hashes, + // We hash a `0u8` here to disambiguate between regular `DefPath` hashes, // and the special "root_parent" below. 0u8.hash(&mut hasher); parent_hash.hash(&mut hasher); @@ -145,8 +146,7 @@ impl DefKey { crate_disambiguator: CrateDisambiguator) -> DefPathHash { let mut hasher = StableHasher::new(); - // Disambiguate this from a regular DefPath hash, - // see compute_stable_hash() above. + // Disambiguate this from a regular `DefPath` hash; see `compute_stable_hash()` above. 1u8.hash(&mut hasher); crate_name.hash(&mut hasher); crate_disambiguator.hash(&mut hasher); @@ -155,10 +155,10 @@ impl DefKey { } /// A pair of `DefPathData` and an integer disambiguator. The integer is -/// normally 0, but in the event that there are multiple defs with the +/// 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 +/// but means that if you have, e.g., two impls for the same type in /// the same module, they do get distinct `DefId`s. #[derive(Clone, PartialEq, Debug, Hash, RustcEncodable, RustcDecodable)] pub struct DisambiguatedDefPathData { @@ -277,29 +277,34 @@ impl DefPath { pub enum DefPathData { // Root: these should only be used for the root nodes, because // they are treated specially by the `def_path` function. - /// The crate root (marker) + + /// The crate root (marker). CrateRoot, - // Catch-all for random DefId things like `DUMMY_NODE_ID` + // Catch-all for random `DefId` things like `DUMMY_NODE_ID`. Misc, + // Different kinds of items and item-like things: - /// An impl + + /// An impl. Impl, - /// Something in the type NS + /// Something in the type namespace. TypeNs(InternedString), - /// Something in the value NS + /// Something in the value namespace. ValueNs(InternedString), - /// Something in the macro NS + /// Something in the macro namespace. MacroNs(InternedString), - /// Something in the lifetime NS + /// Something in the lifetime namespace. LifetimeNs(InternedString), - /// A closure expression + /// A closure expression. ClosureExpr, - // Subportions of items - /// Implicit ctor for a unit or tuple-like struct or enum variant. + + // Subportions of items: + + /// Implicit constructor for a unit or tuple-like struct or enum variant. Ctor, - /// A constant expression (see {ast,hir}::AnonConst). + /// A constant expression (see `{ast,hir}::AnonConst`). AnonConst, - /// An `impl Trait` type node + /// An `impl Trait` type node. ImplTrait, /// Identifies a piece of crate metadata that is global to a whole crate /// (as opposed to just one item). `GlobalMetaData` components are only @@ -435,7 +440,7 @@ impl Definitions { self.node_to_def_index.insert(ast::CRATE_NODE_ID, root_index); self.set_invocation_parent(ExpnId::root(), root_index); - // Allocate some other DefIndices that always must exist. + // Allocate some other `DefIndex`es that always must exist. GlobalMetaDataKind::allocate_def_indices(self); root_index @@ -458,7 +463,7 @@ impl Definitions { data, self.table.def_key(self.node_to_def_index[&node_id])); - // The root node must be created with create_root_def() + // The root node must be created with `create_root_def()`. assert!(data != DefPathData::CrateRoot); // Find the next free disambiguator for this key. @@ -486,9 +491,9 @@ impl Definitions { assert_eq!(index.index(), self.def_index_to_node.len()); self.def_index_to_node.push(node_id); - // Some things for which we allocate DefIndices don't correspond to - // anything in the AST, so they don't have a NodeId. For these cases - // we don't need a mapping from NodeId to DefIndex. + // Some things for which we allocate `DefIndex`es don't correspond to + // anything in the AST, so they don't have a `NodeId`. For these cases + // we don't need a mapping from `NodeId` to `DefIndex`. 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); @@ -498,7 +503,7 @@ impl Definitions { self.expansions_that_defined.insert(index, expn_id); } - // The span is added if it isn't dummy + // The span is added if it isn't dummy. if !span.is_dummy() { self.def_index_to_span.insert(index, span); } @@ -506,12 +511,12 @@ impl Definitions { index } - /// Initialize the `ast::NodeId` to `HirId` mapping once it has been generated during + /// Initializes 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) { assert!(self.node_to_hir_id.is_empty(), - "Trying initialize NodeId -> HirId mapping twice"); + "trying to initialize `NodeId` -> `HirId` mapping twice"); self.node_to_hir_id = mapping; } @@ -533,7 +538,7 @@ impl Definitions { pub fn set_invocation_parent(&mut self, invoc_id: ExpnId, parent: DefIndex) { let old_parent = self.invocation_parents.insert(invoc_id, parent); - assert!(old_parent.is_none(), "parent def-index is reset for an invocation"); + assert!(old_parent.is_none(), "parent `DefIndex` is reset for an invocation"); } } @@ -585,9 +590,9 @@ impl DefPathData { } } -// We define the GlobalMetaDataKind enum with this macro because we want to +// We define the `GlobalMetaDataKind` enum with this macro because we want to // make sure that we exhaustively iterate over all variants when registering -// the corresponding DefIndices in the DefTable. +// the corresponding `DefIndex`es in the `DefTable`. macro_rules! define_global_metadata_kind { (pub enum GlobalMetaDataKind { $($variant:ident),* @@ -609,7 +614,7 @@ macro_rules! define_global_metadata_kind { DUMMY_SP ); - // Make sure calling def_index does not crash. + // Make sure calling `def_index` does not crash. instance.def_index(&definitions.table); })* } @@ -623,7 +628,7 @@ macro_rules! define_global_metadata_kind { } }; - // These DefKeys are all right after the root, + // These `DefKey`s are all right after the root, // so a linear search is fine. let index = def_path_table.index_to_key .iter() diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index eb8be6e6e3cbc..5cec8a593f12a 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -5,10 +5,15 @@ pub use self::definitions::{ }; use crate::dep_graph::{DepGraph, DepNode, DepKind, DepNodeIndex}; - +use crate::hir::*; +use crate::hir::DefKind; use crate::hir::def_id::{CRATE_DEF_INDEX, DefId, LocalDefId}; - +use crate::hir::itemlikevisit::ItemLikeVisitor; +use crate::hir::print::Nested; use crate::middle::cstore::CrateStoreDyn; +use crate::ty::query::Providers; +use crate::util::nodemap::FxHashMap; +use crate::util::common::time; use rustc_target::spec::abi::Abi; use rustc_data_structures::svh::Svh; @@ -18,15 +23,7 @@ use syntax::source_map::Spanned; use syntax::ext::base::MacroKind; use syntax_pos::{Span, DUMMY_SP}; -use crate::hir::*; -use crate::hir::DefKind; -use crate::hir::itemlikevisit::ItemLikeVisitor; -use crate::hir::print::Nested; -use crate::util::nodemap::FxHashMap; -use crate::util::common::time; - use std::result::Result::Err; -use crate::ty::query::Providers; pub mod blocks; mod collector; @@ -627,7 +624,7 @@ impl<'hir> Map<'hir> { .unwrap_or(hir_id) } - /// Check if the node is an argument. An argument is a local variable whose + /// Checks 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: HirId) -> bool { match self.find(id) { @@ -733,7 +730,7 @@ impl<'hir> Map<'hir> { /// ``` /// fn foo(x: usize) -> bool { /// if x == 1 { - /// true // `get_return_block` gets passed the `id` corresponding + /// true // If `get_return_block` gets passed the `id` corresponding /// } else { // to this, it will return `foo`'s `HirId`. /// false /// } @@ -743,7 +740,7 @@ impl<'hir> Map<'hir> { /// ``` /// fn foo(x: usize) -> bool { /// loop { - /// true // `get_return_block` gets passed the `id` corresponding + /// true // If `get_return_block` gets passed the `id` corresponding /// } // to this, it will return `None`. /// false /// } @@ -994,9 +991,9 @@ impl<'hir> Map<'hir> { self.map.iter().enumerate().filter_map(|(i, local_map)| { local_map.as_ref().map(|m| (i, m)) }).flat_map(move |(array_index, local_map)| { - // Iterate over each valid entry in the local map + // Iterate over each valid entry in the local map. local_map.iter_enumerated().filter_map(move |(i, entry)| entry.map(move |_| { - // Reconstruct the HirId based on the 3 indices we used to find it + // Reconstruct the `HirId` based on the 3 indices we used to find it. HirId { owner: DefIndex::from(array_index), local_id: i, @@ -1207,7 +1204,7 @@ pub fn map_crate<'hir>(sess: &crate::session::Session, definitions, }; - time(sess, "validate hir map", || { + time(sess, "validate HIR map", || { hir_id_validator::check_crate(&map); }); @@ -1247,9 +1244,9 @@ impl<'a> print::State<'a> { Node::Pat(a) => self.print_pat(&a), Node::Arm(a) => self.print_arm(&a), Node::Block(a) => { - // containing cbox, will be closed by print-block at } + // Containing cbox, will be closed by print-block at `}`. self.cbox(print::INDENT_UNIT); - // head-ibox, will be closed by print-block after { + // Head-ibox, will be closed by print-block after `{`. self.ibox(0); self.print_block(&a) } @@ -1257,8 +1254,8 @@ impl<'a> print::State<'a> { Node::Visibility(a) => self.print_visibility(&a), Node::GenericParam(_) => bug!("cannot print Node::GenericParam"), Node::Field(_) => bug!("cannot print StructField"), - // these cases do not carry enough information in the - // hir_map to reconstruct their full structure for pretty + // These cases do not carry enough information in the + // `hir_map` to reconstruct their full structure for pretty // printing. Node::Ctor(..) => bug!("cannot print isolated Ctor"), Node::Local(a) => self.print_local_decl(&a), @@ -1273,8 +1270,8 @@ fn hir_id_to_string(map: &Map<'_>, id: HirId, include_id: bool) -> String { let id_str = if include_id { &id_str[..] } else { "" }; 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. + // This functionality is used for debugging, try to use `TyCtxt` to get + // the user-friendly path, otherwise fall back to stringifying `DefPath`. crate::ty::tls::with_opt(|tcx| { if let Some(tcx) = tcx { let def_id = map.local_def_id(id); diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs index d2c45a5af8598..f5e644625729b 100644 --- a/src/librustc/hir/mod.rs +++ b/src/librustc/hir/mod.rs @@ -13,26 +13,24 @@ pub use self::UnsafeSource::*; use crate::hir::def::{Res, DefKind}; use crate::hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX}; use crate::hir::ptr::P; -use crate::util::nodemap::{NodeMap, FxHashSet}; use crate::mir::mono::Linkage; +use crate::ty::AdtKind; +use crate::ty::query::Providers; +use crate::util::nodemap::{NodeMap, FxHashSet}; use errors::FatalError; use syntax_pos::{Span, DUMMY_SP, symbol::InternedString, MultiSpan}; use syntax::source_map::Spanned; -use rustc_target::spec::abi::Abi; use syntax::ast::{self, CrateSugar, Ident, Name, NodeId, AsmDialect}; use syntax::ast::{Attribute, Label, LitKind, StrStyle, FloatTy, IntTy, UintTy}; use syntax::attr::{InlineAttr, OptimizeAttr}; use syntax::symbol::{Symbol, kw}; use syntax::tokenstream::TokenStream; use syntax::util::parser::ExprPrecedence; -use crate::ty::AdtKind; -use crate::ty::query::Providers; - +use rustc_target::spec::abi::Abi; use rustc_data_structures::sync::{par_for_each_in, Send, Sync}; use rustc_data_structures::thin_vec::ThinVec; use rustc_macros::HashStable; - use rustc_serialize::{self, Encoder, Encodable, Decoder, Decodable}; use std::collections::{BTreeSet, BTreeMap}; use std::fmt; @@ -99,7 +97,8 @@ impl rustc_serialize::UseSpecializedEncodable for HirId { } = *self; owner.encode(s)?; - local_id.encode(s) + local_id.encode(s)?; + Ok(()) } } @@ -121,7 +120,7 @@ impl fmt::Display for HirId { } } -// Hack to ensure that we don't try to access the private parts of `ItemLocalId` in this module +// Hack to ensure that we don't try to access the private parts of `ItemLocalId` in this module. mod item_local_id_inner { use rustc_data_structures::indexed_vec::Idx; use rustc_macros::HashStable; @@ -746,7 +745,7 @@ pub struct Crate { // Attributes from non-exported macros, kept only for collecting the library feature list. pub non_exported_macro_attrs: HirVec, - // N.B., we use a BTreeMap here so that `visit_all_items` iterates + // N.B., we use a `BTreeMap` here so that `visit_all_items` iterates // over the ids in increasing order. In principle it should not // matter what order we visit things in, but in *practice* it // does, because it can affect the order in which errors are @@ -1403,13 +1402,13 @@ pub struct AnonConst { pub body: BodyId, } -/// An expression +/// An expression. #[derive(RustcEncodable, RustcDecodable)] pub struct Expr { - pub span: Span, + pub hir_id: HirId, pub node: ExprKind, pub attrs: ThinVec, - pub hir_id: HirId, + pub span: Span, } // `Expr` is used a lot. Make sure it doesn't unintentionally get bigger. @@ -2422,37 +2421,37 @@ pub enum ItemKind { /// /// or just /// - /// `use foo::bar::baz;` (with `as baz` implicitly on the right) + /// `use foo::bar::baz;` (with `as baz` implicitly on the right). Use(P, UseKind), - /// A `static` item + /// A `static` item. Static(P, Mutability, BodyId), - /// A `const` item + /// A `const` item. Const(P, BodyId), - /// A function declaration + /// A function declaration. Fn(P, FnHeader, Generics, BodyId), - /// A module + /// A module. Mod(Mod), - /// An external module + /// An external module. ForeignMod(ForeignMod), - /// Module-level inline assembly (from global_asm!) + /// Module-level inline assembly (from `global_asm!`). GlobalAsm(P), - /// A type alias, e.g., `type Foo = Bar` + /// A type alias, e.g., `type Foo = Bar`. TyAlias(P, Generics), - /// An opaque `impl Trait` type alias, e.g., `type Foo = impl Bar;` + /// An opaque `impl Trait` type alias, e.g., `type Foo = impl Bar;`. OpaqueTy(OpaqueTy), - /// An enum definition, e.g., `enum Foo {C, D}` + /// An enum definition, e.g., `enum Foo {C, D}`. Enum(EnumDef, Generics), - /// A struct definition, e.g., `struct Foo {x: A}` + /// A struct definition, e.g., `struct Foo {x: A}`. Struct(VariantData, Generics), - /// A union definition, e.g., `union Foo {x: A, y: B}` + /// A union definition, e.g., `union Foo {x: A, y: B}`. Union(VariantData, Generics), - /// A trait definition + /// A trait definition. Trait(IsAuto, Unsafety, Generics, GenericBounds, HirVec), - /// A trait alias + /// A trait alias. TraitAlias(Generics, GenericBounds), - /// An implementation, eg `impl Trait for Foo { .. }` + /// An implementation, e.g., `impl Trait for Foo { .. }`. Impl(Unsafety, ImplPolarity, Defaultness, diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs index 21cc72efee4a3..cfbfb5eceb550 100644 --- a/src/librustc/hir/print.rs +++ b/src/librustc/hir/print.rs @@ -1293,11 +1293,11 @@ impl<'a> State<'a> { self.print_closure_params(&decl, body); self.s.space(); - // this is a bare expression + // This is a bare expression. self.ann.nested(self, Nested::Body(body)); self.end(); // need to close a box - // a box will be closed by print_expr, but we didn't want an overall + // A box will be closed by `print_expr`, but we didn't want an overall // wrapper so we closed the corresponding opening. so create an // empty box to satisfy the close. self.ibox(0); @@ -1307,9 +1307,9 @@ impl<'a> State<'a> { self.print_ident(label.ident); self.word_space(":"); } - // containing cbox, will be closed by print-block at } + // containing cbox, will be closed by print-block at `}` self.cbox(INDENT_UNIT); - // head-box, will be closed by print-block after { + // head-box, will be closed by print-block after `{` self.ibox(0); self.print_block(&blk); } @@ -1759,7 +1759,7 @@ impl<'a> State<'a> { self.word_space(","); } if let PatKind::Wild = p.node { - // Print nothing + // Print nothing. } else { self.print_pat(&p); } @@ -1891,7 +1891,7 @@ impl<'a> State<'a> { i += 1; if let hir::TyKind::Infer = ty.node { - // Print nothing + // Print nothing. } else { s.s.word(":"); s.s.space(); @@ -2221,7 +2221,6 @@ impl<'a> State<'a> { } } -// Dup'ed from parse::classify, but adapted for the HIR. /// Does this expression require a semicolon to be treated /// as a statement? The negation of this: 'can this expression /// be used as a statement without a semicolon' -- is used @@ -2229,6 +2228,8 @@ impl<'a> State<'a> { /// if true {...} else {...} /// |x| 5 /// isn't parsed as (if true {...} else {...} | x) | 5 +// +// Duplicated from `parse::classify`, but adapted for the HIR. fn expr_requires_semi_to_be_stmt(e: &hir::Expr) -> bool { match e.node { hir::ExprKind::Match(..) | @@ -2238,7 +2239,7 @@ fn expr_requires_semi_to_be_stmt(e: &hir::Expr) -> bool { } } -/// this statement requires a semicolon after it. +/// This statement requires a semicolon after it. /// note that in one case (stmt_semi), we've already /// seen the semicolon, and thus don't need another. fn stmt_ends_with_semi(stmt: &hir::StmtKind) -> bool { @@ -2277,7 +2278,7 @@ fn bin_op_to_assoc_op(op: hir::BinOpKind) -> AssocOp { } } -/// Expressions that syntactically contain an "exterior" struct literal i.e., not surrounded by any +/// Expressions that syntactically contain an "exterior" struct literal, i.e., not surrounded by any /// parens or other delimiters, e.g., `X { y: 1 }`, `X { y: 1 }.method()`, `foo == X { y: 1 }` and /// `X { y: 1 } == foo` all do, but `(X { y: 1 }) == foo` does not. fn contains_exterior_struct_lit(value: &hir::Expr) -> bool { @@ -2287,7 +2288,7 @@ fn contains_exterior_struct_lit(value: &hir::Expr) -> bool { hir::ExprKind::Assign(ref lhs, ref rhs) | hir::ExprKind::AssignOp(_, ref lhs, ref rhs) | hir::ExprKind::Binary(_, ref lhs, ref rhs) => { - // X { y: 1 } + X { y: 2 } + // `X { y: 1 } + X { y: 2 }` contains_exterior_struct_lit(&lhs) || contains_exterior_struct_lit(&rhs) } hir::ExprKind::Unary(_, ref x) | @@ -2295,12 +2296,12 @@ fn contains_exterior_struct_lit(value: &hir::Expr) -> bool { hir::ExprKind::Type(ref x, _) | hir::ExprKind::Field(ref x, _) | hir::ExprKind::Index(ref x, _) => { - // &X { y: 1 }, X { y: 1 }.y + // `&X { y: 1 }, X { y: 1 }.y` contains_exterior_struct_lit(&x) } hir::ExprKind::MethodCall(.., ref exprs) => { - // X { y: 1 }.bar(...) + // `X { y: 1 }.bar(...)` contains_exterior_struct_lit(&exprs[0]) } diff --git a/src/librustc/ich/hcx.rs b/src/librustc/ich/hcx.rs index e77faea1e4c58..182a9ade8c36e 100644 --- a/src/librustc/ich/hcx.rs +++ b/src/librustc/ich/hcx.rs @@ -12,7 +12,6 @@ use std::hash as std_hash; use std::cell::RefCell; use syntax::ast; - use syntax::source_map::SourceMap; use syntax::ext::hygiene::SyntaxContext; use syntax::symbol::Symbol; @@ -20,9 +19,9 @@ use syntax::tokenstream::DelimSpan; use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::hygiene; -use rustc_data_structures::stable_hasher::{HashStable, - StableHasher, StableHasherResult, - ToStableHashKey}; +use rustc_data_structures::stable_hasher::{ + HashStable, StableHasher, StableHasherResult, ToStableHashKey, +}; use rustc_data_structures::fx::{FxHashSet, FxHashMap}; use smallvec::SmallVec; @@ -32,9 +31,9 @@ fn compute_ignored_attr_names() -> FxHashSet { } /// This is the context state available during incr. comp. hashing. It contains -/// enough information to transform DefIds and HirIds into stable DefPaths (i.e. -/// a reference to the TyCtxt) and it holds a few caches for speeding up various -/// things (e.g., each DefId/DefPath is only hashed once). +/// enough information to transform `DefId`s and `HirId`s into stable `DefPath`s (i.e., +/// a reference to the `TyCtxt`) and it holds a few caches for speeding up various +/// things (e.g., each `DefId`/`DefPath` is only hashed once). #[derive(Clone)] pub struct StableHashingContext<'a> { sess: &'a Session, @@ -46,7 +45,7 @@ pub struct StableHashingContext<'a> { node_id_hashing_mode: NodeIdHashingMode, // Very often, we are hashing something that does not need the - // CachingSourceMapView, so we initialize it lazily. + // `CachingSourceMapView`, so we initialize it lazily. raw_source_map: &'a SourceMap, caching_source_map: Option>, } @@ -57,24 +56,24 @@ pub enum NodeIdHashingMode { HashDefPath, } -/// The BodyResolver allows to map a BodyId to the corresponding hir::Body. -/// We could also just store a plain reference to the hir::Crate but we want +/// The `BodyResolver` allows mapping a `BodyId` to the corresponding `hir::Body`. +/// We could also just store a plain reference to the `hir::Crate` but we want /// to avoid that the crate is used to get untracked access to all of the HIR. #[derive(Clone, Copy)] struct BodyResolver<'tcx>(&'tcx hir::Crate); impl<'tcx> BodyResolver<'tcx> { - // Return a reference to the hir::Body with the given BodyId. - // DOES NOT DO ANY TRACKING, use carefully. + /// Returns a reference to the `hir::Body` with the given `BodyId`. + /// **Does not do any tracking**; use carefully. fn body(self, id: hir::BodyId) -> &'tcx hir::Body { self.0.body(id) } } impl<'a> StableHashingContext<'a> { - // The `krate` here is only used for mapping BodyIds to Bodies. - // Don't use it for anything else or you'll run the risk of - // leaking data out of the tracking system. + /// The `krate` here is only used for mapping `BodyId`s to `Body`s. + /// Don't use it for anything else or you'll run the risk of + /// leaking data out of the tracking system. #[inline] pub fn new(sess: &'a Session, krate: &'a hir::Crate, @@ -217,9 +216,7 @@ impl<'a> StableHashingContextProvider<'a> for StableHashingContext<'a> { } } -impl<'a> crate::dep_graph::DepGraphSafe for StableHashingContext<'a> { -} - +impl<'a> crate::dep_graph::DepGraphSafe for StableHashingContext<'a> {} impl<'a> HashStable> for hir::BodyId { fn hash_stable(&self, @@ -292,16 +289,15 @@ impl<'a> ToStableHashKey> for ast::NodeId { } impl<'a> HashStable> for Span { - - // Hash a span in a stable way. We can't directly hash the span's BytePos - // fields (that would be similar to hashing pointers, since those are just - // offsets into the SourceMap). Instead, we hash the (file name, line, column) - // triple, which stays the same even if the containing SourceFile has moved - // within the SourceMap. - // Also note that we are hashing byte offsets for the column, not unicode - // codepoint offsets. For the purpose of the hash that's sufficient. - // Also, hashing filenames is expensive so we avoid doing it twice when the - // span starts and ends in the same file, which is almost always the case. + /// Hashes a span in a stable way. We can't directly hash the span's `BytePos` + /// fields (that would be similar to hashing pointers, since those are just + /// offsets into the `SourceMap`). Instead, we hash the (file name, line, column) + /// triple, which stays the same even if the containing `SourceFile` has moved + /// within the `SourceMap`. + /// Also note that we are hashing byte offsets for the column, not unicode + /// codepoint offsets. For the purpose of the hash that's sufficient. + /// Also, hashing filenames is expensive so we avoid doing it twice when the + /// span starts and ends in the same file, which is almost always the case. fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { @@ -340,7 +336,7 @@ impl<'a> HashStable> for Span { } std_hash::Hash::hash(&TAG_VALID_SPAN, hasher); - // We truncate the stable_id hash and line and col numbers. The chances + // We truncate the stable ID hash and line and column numbers. The chances // of causing a collision this way should be minimal. std_hash::Hash::hash(&(file_lo.name_hash as u64), hasher); diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index fb981d961129f..6e6492d0426f2 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -5,8 +5,10 @@ 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 rustc_data_structures::stable_hasher::{ + HashStable, ToStableHashKey, StableHasher, StableHasherResult, +}; use smallvec::SmallVec; use std::mem; use syntax::ast; @@ -82,9 +84,9 @@ for hir::ItemLocalId { } } -// The following implementations of HashStable for ItemId, TraitItemId, and -// ImplItemId deserve special attention. Normally we do not hash NodeIds within -// the HIR, since they just signify a HIR nodes own path. But ItemId et al +// The following implementations of HashStable for `ItemId`, `TraitItemId`, and +// `ImplItemId` deserve special attention. Normally we do not hash `NodeId`s within +// the HIR, since they just signify a HIR nodes own path. But `ItemId` et al // are used when another item in the HIR is *referenced* and we certainly // want to pick up on a reference changing its target, so we hash the NodeIds // in "DefPath Mode". @@ -131,7 +133,6 @@ impl<'a> HashStable> for hir::ImplItemId { } } - impl_stable_hash_for!(struct ast::Label { ident }); @@ -241,7 +242,7 @@ impl<'a> HashStable> for hir::ImplItem { } } -impl_stable_hash_for!(enum ::syntax::ast::CrateSugar { +impl_stable_hash_for!(enum ast::CrateSugar { JustCrate, PubCrate, }); @@ -365,8 +366,7 @@ impl<'a> HashStable> for hir::def_id::DefIndex { } } -impl<'a> ToStableHashKey> -for hir::def_id::DefIndex { +impl<'a> ToStableHashKey> for hir::def_id::DefIndex { type KeyType = DefPathHash; #[inline] diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs index be7669fcad875..f230c53728748 100644 --- a/src/librustc/ich/impls_ty.rs +++ b/src/librustc/ich/impls_ty.rs @@ -204,7 +204,7 @@ impl<'a> HashStable> for ty::TyVid { fn hash_stable(&self, _hcx: &mut StableHashingContext<'a>, _hasher: &mut StableHasher) { - // TyVid values are confined to an inference context and hence + // `TyVid` values are confined to an inference context and hence // should not be hashed. bug!("ty::TyKind::hash_stable() - can't hash a TyVid {:?}.", *self) } @@ -214,7 +214,7 @@ impl<'a> HashStable> for ty::IntVid { fn hash_stable(&self, _hcx: &mut StableHashingContext<'a>, _hasher: &mut StableHasher) { - // IntVid values are confined to an inference context and hence + // `IntVid` values are confined to an inference context and hence // should not be hashed. bug!("ty::TyKind::hash_stable() - can't hash an IntVid {:?}.", *self) } @@ -224,7 +224,7 @@ impl<'a> HashStable> for ty::FloatVid { fn hash_stable(&self, _hcx: &mut StableHashingContext<'a>, _hasher: &mut StableHasher) { - // FloatVid values are confined to an inference context and hence + // `FloatVid` values are confined to an inference context and hence // should not be hashed. bug!("ty::TyKind::hash_stable() - can't hash a FloatVid {:?}.", *self) } diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs index cc28567e2fc9e..8638f42976f04 100644 --- a/src/librustc/infer/mod.rs +++ b/src/librustc/infer/mod.rs @@ -1321,13 +1321,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { T: TypeFoldable<'tcx>, { if !value.needs_infer() { - return value.clone(); // avoid duplicated subst-folding + return value.clone(); // Avoid duplicated subst-folding. } let mut r = resolve::OpportunisticVarResolver::new(self); value.fold_with(&mut r) } - /// Returns first unresolved variable contained in `T`. In the + /// Returns the first unresolved variable contained in `T`. In the /// process of visiting `T`, this will resolve (where possible) /// type variables in `T`, but it never constructs the final, /// resolved type, so it's more efficient than @@ -1462,7 +1462,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { let copy_def_id = self.tcx.require_lang_item(lang_items::CopyTraitLangItem, None); - // this can get called from typeck (by euv), and moves_by_default + // This can get called from typeck (by euv), and `moves_by_default` // rightly refuses to work with inference variables, but // moves_by_default has a cache, which we want to use in other // cases. @@ -1482,7 +1482,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { closure_kind_ty.to_opt_closure_kind() } - /// Obtain the signature of a closure. For closures, unlike + /// Obtains the signature of a closure. For closures, unlike /// `tcx.fn_sig(def_id)`, this method will work during the /// type-checking of the enclosing function and return the closure /// signature in its partially inferred state. diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index bf4330a29a7df..63ef82a7401a3 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -45,7 +45,6 @@ #![feature(non_exhaustive)] #![feature(optin_builtin_traits)] #![feature(range_is_empty)] -#![feature(rustc_diagnostic_macros)] #![feature(slice_patterns)] #![feature(specialization)] #![feature(unboxed_closures)] @@ -88,8 +87,6 @@ mod tests; #[macro_use] mod macros; -// N.B., this module needs to be declared first so diagnostics are -// registered before they are used. pub mod error_codes; #[macro_use] @@ -142,6 +139,3 @@ pub mod util { // Allows macros to refer to this crate as `::rustc` extern crate self as rustc; - -// Build the diagnostics array at the end so that the metadata includes error use sites. -__build_diagnostic_array! { librustc, DIAGNOSTICS } diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index 77df93080cd16..c658120b95df3 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -16,32 +16,32 @@ use self::TargetLint::*; -use std::slice; -use rustc_data_structures::sync::{ReadGuard, Lock, ParallelIterator, join, par_iter}; +use crate::hir; +use crate::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; +use crate::hir::intravisit as hir_visit; +use crate::hir::intravisit::Visitor; +use crate::hir::map::{definitions::DisambiguatedDefPathData, DefPathData}; use crate::lint::{EarlyLintPass, LateLintPass, 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 rustc_serialize::{Decoder, Decodable, Encoder, Encodable}; use crate::session::{config, early_error, Session}; use crate::ty::{self, print::Printer, subst::Kind, TyCtxt, Ty}; use crate::ty::layout::{LayoutError, LayoutOf, TyLayout}; use crate::util::nodemap::FxHashMap; use crate::util::common::time; +use errors::DiagnosticBuilder; +use std::slice; use std::default::Default as StdDefault; +use rustc_data_structures::sync::{ReadGuard, Lock, ParallelIterator, join, par_iter}; +use rustc_serialize::{Decoder, Decodable, Encoder, Encodable}; use syntax::ast; use syntax::edition; -use syntax_pos::{MultiSpan, Span, symbol::Symbol}; -use errors::DiagnosticBuilder; -use crate::hir; -use crate::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; -use crate::hir::intravisit as hir_visit; -use crate::hir::intravisit::Visitor; -use crate::hir::map::{definitions::DisambiguatedDefPathData, DefPathData}; use syntax::util::lev_distance::find_best_match_for_name; use syntax::visit as ast_visit; +use syntax_pos::{MultiSpan, Span, symbol::Symbol}; /// Information about the registered lints. /// diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index e33f8e27871b2..5b490b701267d 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -875,12 +875,12 @@ pub fn in_external_macro(sess: &Session, span: Span) -> bool { ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) => true, // well, it's "external" ExpnKind::Macro(MacroKind::Bang, _) => { if expn_data.def_site.is_dummy() { - // dummy span for the def_site means it's an external macro + // Dummy span for the `def_site` means it's an external macro. return true; } match sess.source_map().span_to_snippet(expn_data.def_site) { Ok(code) => !code.starts_with("macro_rules"), - // no snippet = external macro or compiler-builtin expansion + // No snippet means external macro or compiler-builtin expansion. Err(_) => true, } } @@ -888,7 +888,7 @@ pub fn in_external_macro(sess: &Session, span: Span) -> bool { } } -/// Returns whether `span` originates in a derive macro's expansion +/// Returns `true` if `span` originates in a derive-macro's expansion. pub fn in_derive_expansion(span: Span) -> bool { if let ExpnKind::Macro(MacroKind::Derive, _) = span.ctxt().outer_expn_data().kind { return true; diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs index 53c099c0b4339..93bb301f0951a 100644 --- a/src/librustc/middle/entry.rs +++ b/src/librustc/middle/entry.rs @@ -16,17 +16,17 @@ struct EntryContext<'a, 'tcx> { map: &'a hir_map::Map<'tcx>, - // The top-level function called 'main' + /// The top-level function called 'main'. main_fn: Option<(HirId, Span)>, - // The function that has attribute named 'main' + /// The function that has attribute named 'main'. attr_main_fn: Option<(HirId, Span)>, - // The function that has the attribute 'start' on it + /// The function that has the attribute 'start' on it. start_fn: Option<(HirId, Span)>, - // The functions that one might think are 'main' but aren't, e.g. - // main functions not defined at the top level. For diagnostics. + /// The functions that one might think are 'main' but aren't, e.g. + /// main functions not defined at the top level. For diagnostics. non_main_fns: Vec<(HirId, Span)> , } @@ -39,11 +39,11 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for EntryContext<'a, 'tcx> { } fn visit_trait_item(&mut self, _trait_item: &'tcx TraitItem) { - // entry fn is never a trait item + // Entry fn is never a trait item. } fn visit_impl_item(&mut self, _impl_item: &'tcx ImplItem) { - // entry fn is never an impl item + // Entry fn is never a trait item. } } @@ -54,7 +54,7 @@ fn entry_fn(tcx: TyCtxt<'_>, cnum: CrateNum) -> Option<(DefId, EntryFnType)> { *ty == config::CrateType::Executable }); if !any_exe { - // No need to find a main function + // No need to find a main function. return None; } @@ -148,7 +148,7 @@ fn configure_main(tcx: TyCtxt<'_>, visitor: &EntryContext<'_, '_>) -> Option<(De } else if let Some((hir_id, _)) = visitor.main_fn { Some((tcx.hir().local_def_id(hir_id), EntryFnType::Main)) } else { - // No main function + // There is no main function. let mut err = struct_err!(tcx.sess, E0601, "`main` function not found in crate `{}`", tcx.crate_name(LOCAL_CRATE)); if !visitor.non_main_fns.is_empty() { diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 222c2a405d65b..de6dadabcbf56 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -596,7 +596,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> { } hir::StmtKind::Item(_) => { - // we don't visit nested items in this visitor, + // We don't visit nested items in this visitor, // only the fn body we were given. } diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 6b04600eb75f8..6dfd7a7f94378 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -3,10 +3,8 @@ //! Language items are items that represent concepts intrinsic to the language //! itself. Examples are: //! -//! * Traits that specify "kinds"; e.g., "Sync", "Send". -//! -//! * Traits that represent operators; e.g., "Add", "Sub", "Index". -//! +//! * Traits that specify "kinds"; e.g., `Sync`, `Send`. +//! * Traits that represent operators; e.g., `Add`, `Sub`, `Index`. //! * Functions called by the compiler itself. pub use self::LangItem::*; @@ -151,11 +149,11 @@ impl ItemLikeVisitor<'v> for LanguageItemCollector<'tcx> { } fn visit_trait_item(&mut self, _trait_item: &hir::TraitItem) { - // at present, lang items are always items, not trait items + // At present, lang items are always items, not trait items. } fn visit_impl_item(&mut self, _impl_item: &hir::ImplItem) { - // at present, lang items are always items, not impl items + // At present, lang items are always items, not impl items. } } @@ -204,7 +202,7 @@ impl LanguageItemCollector<'tcx> { } } -/// Extract the first `lang = "$name"` out of a list of attributes. +/// Extracts the first `lang = "$name"` out of a list of attributes. /// The attributes `#[panic_handler]` and `#[alloc_error_handler]` /// are also extracted out when found. pub fn extract(attrs: &[ast::Attribute]) -> Option<(Symbol, Span)> { @@ -216,7 +214,7 @@ pub fn extract(attrs: &[ast::Attribute]) -> Option<(Symbol, Span)> { })) } -/// Traverse and collect all the lang items in all crates. +/// Traverses and collects all the lang items in all crates. pub fn collect<'tcx>(tcx: TyCtxt<'tcx>) -> LanguageItems { // Initialize the collector. let mut collector = LanguageItemCollector::new(tcx); @@ -367,7 +365,7 @@ language_item_table! { MaybeUninitLangItem, "maybe_uninit", maybe_uninit, Target::Union; - // Align offset for stride != 1, must not panic. + // Align offset for stride != 1; must not panic. AlignOffsetLangItem, "align_offset", align_offset_fn, Target::Fn; TerminationTraitLangItem, "termination", termination, Target::Trait; @@ -378,7 +376,7 @@ language_item_table! { impl<'tcx> TyCtxt<'tcx> { /// Returns the `DefId` for a given `LangItem`. - /// If not found, fatally abort compilation. + /// If not found, fatally aborts compilation. pub fn require_lang_item(&self, lang_item: LangItem, span: Option) -> DefId { self.lang_items().require(lang_item).unwrap_or_else(|msg| { if let Some(span) = span { diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs index 28aa86ef9afb2..b9d8a4ec68fad 100644 --- a/src/librustc/middle/region.rs +++ b/src/librustc/middle/region.rs @@ -6,29 +6,27 @@ //! //! [rustc guide]: https://rust-lang.github.io/rustc-guide/mir/borrowck.html +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 crate::ich::{StableHashingContext, NodeIdHashingMode}; use crate::util::nodemap::{FxHashMap, FxHashSet}; -use crate::ty; +use crate::ty::{self, DefIdTree, TyCtxt}; +use crate::ty::query::Providers; -use std::mem; -use std::fmt; +use rustc_data_structures::indexed_vec::Idx; +use rustc_data_structures::stable_hasher::{HashStable, StableHasher, StableHasherResult}; use rustc_macros::HashStable; use syntax::source_map; use syntax_pos::{Span, DUMMY_SP}; -use crate::ty::{DefIdTree, 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}; +use std::fmt; +use std::mem; -/// Scope represents a statically-describable scope that can be -/// used to bound the lifetime/region for values. +/// Represents a statically-describable scope that can be used to +/// bound the lifetime/region for values. /// /// `Node(node_id)`: Any AST node that has any scope at all has the /// `Node(node_id)` scope. Other variants represent special cases not @@ -225,7 +223,7 @@ pub struct ScopeTree { /// have lifetime parameters free in this body. root_parent: Option, - /// `parent_map` maps from a scope ID to the enclosing scope id; + /// Maps from a scope ID to the enclosing scope id; /// this is usually corresponding to the lexical nesting, though /// in the case of closures the parent scope is the innermost /// conditional expression or repeating block. (Note that the @@ -233,17 +231,17 @@ pub struct ScopeTree { /// the closure itself.) parent_map: FxHashMap, - /// `var_map` maps from a variable or binding ID to the block in - /// which that variable is declared. + /// Maps from a variable or binding ID to the block in which that + /// variable is declared. var_map: FxHashMap, - /// maps from a `NodeId` to the associated destruction scope (if any) + /// Maps from a `NodeId` to the associated destruction scope (if any). destruction_scopes: FxHashMap, - /// `rvalue_scopes` includes entries for those expressions whose cleanup scope is - /// larger than the default. The map goes from the expression id - /// to the cleanup scope id. For rvalues not present in this - /// table, the appropriate cleanup scope is the innermost + /// `rvalue_scopes` includes entries for those expressions whose + /// cleanup scope is larger than the default. The map goes from the + /// expression ID to the cleanup scope id. For rvalues not present in + /// this table, the appropriate cleanup scope is the innermost /// enclosing statement, conditional expression, or repeating /// block (see `terminating_scopes`). /// In constants, None is used to indicate that certain expressions @@ -318,7 +316,7 @@ pub struct ScopeTree { /// 4. By `2.` and `3.`, `D` is *statically* storage-dead at `U`, /// QED. /// - /// I don't think this property relies on `3.` in an essential way - it + /// This property ought to not on (3) in an essential way -- it /// is probably still correct even if we have "unrestricted" terminating /// scopes. However, why use the complicated proof when a simple one /// works? @@ -341,20 +339,20 @@ pub struct ScopeTree { #[derive(Debug, Copy, Clone, RustcEncodable, RustcDecodable, HashStable)] pub struct YieldData { - /// `Span` of the yield. + /// The `Span` of the yield. pub span: Span, - /// The number of expressions and patterns appearing before the `yield` in the body + 1. + /// The number of expressions and patterns appearing before the `yield` in the body plus one. pub expr_and_pat_count: usize, pub source: hir::YieldSource, } #[derive(Debug, Copy, Clone)] pub struct Context { - /// the root of the current region tree. This is typically the id + /// The root of the current region tree. This is typically the id /// of the innermost fn body. Each fn forms its own disjoint tree /// in the region hierarchy. These fn bodies are themselves /// arranged into a tree. See the "Modeling closures" section of - /// the README in infer::region_constraints for more + /// the README in `infer::region_constraints` for more /// details. root_id: Option, @@ -369,15 +367,15 @@ pub struct Context { struct RegionResolutionVisitor<'tcx> { tcx: TyCtxt<'tcx>, - // The number of expressions and patterns visited in the current body + // The number of expressions and patterns visited in the current body. expr_and_pat_count: usize, // When this is `true`, we record the `Scopes` we encounter // when processing a Yield expression. This allows us to fix // up their indices. pessimistic_yield: bool, - // Stores scopes when pessimistic_yield is true. + // Stores scopes when `pessimistic_yield` is `true`. fixup_scopes: Vec, - // Generated scope tree: + // The generated scope tree. scope_tree: ScopeTree, cx: Context, @@ -411,7 +409,7 @@ struct ExprLocatorVisitor { expr_and_pat_count: usize, } -// This visitor has to have the same visit_expr calls as RegionResolutionVisitor +// This visitor has to have the same `visit_expr` calls as `RegionResolutionVisitor` // since `expr_count` is compared against the results there. impl<'tcx> Visitor<'tcx> for ExprLocatorVisitor { fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { @@ -456,7 +454,7 @@ impl<'tcx> ScopeTree { assert!(prev.is_none()); } - // record the destruction scopes for later so we can query them + // Record the destruction scopes for later so we can query them. if let ScopeData::Destruction = child.data { self.destruction_scopes.insert(child.item_local_id(), child); } @@ -478,7 +476,7 @@ impl<'tcx> ScopeTree { self.destruction_scopes.get(&n).cloned() } - /// Records that `sub_closure` is defined within `sup_closure`. These ids + /// Records that `sub_closure` is defined within `sup_closure`. These IDs /// should be the ID of the block that is the fn body, which is /// also the root of the region hierarchy for that fn. fn record_closure_parent(&mut self, @@ -505,14 +503,14 @@ impl<'tcx> ScopeTree { self.rvalue_scopes.insert(var, lifetime); } + /// Returns the narrowest scope that encloses `id`, if any. pub fn opt_encl_scope(&self, id: Scope) -> Option { - //! Returns the narrowest scope that encloses `id`, if any. self.parent_map.get(&id).cloned().map(|(p, _)| p) } + /// Returns the narrowest scope that encloses `id`, if any. #[allow(dead_code)] // used in cfg pub fn encl_scope(&self, id: Scope) -> Scope { - //! Returns the narrowest scope that encloses `id`, if any. self.opt_encl_scope(id).unwrap() } @@ -522,16 +520,15 @@ impl<'tcx> ScopeTree { bug!("no enclosing scope for id {:?}", var_id)) } + /// Returns the scope when the temp created by `expr_id` will be cleaned up. pub fn temporary_scope(&self, expr_id: hir::ItemLocalId) -> Option { - //! Returns the scope when temp created by expr_id will be cleaned up - - // check for a designated rvalue scope + // Check for a designated rvalue scope. if let Some(&s) = self.rvalue_scopes.get(&expr_id) { debug!("temporary_scope({:?}) = {:?} [custom]", expr_id, s); return s; } - // else, locate the innermost terminating scope + // Otherwise, locate the innermost terminating scope // if there's one. Static items, for instance, won't // have an enclosing scope, hence no scope will be // returned. @@ -552,9 +549,8 @@ impl<'tcx> ScopeTree { return None; } + /// Returns the lifetime of the variable `id`. pub fn var_region(&self, id: hir::ItemLocalId) -> ty::RegionKind { - //! Returns the lifetime of the variable `id`. - let scope = ty::ReScope(self.var_scope(id)); debug!("var_region({:?}) = {:?}", id, scope); scope @@ -589,7 +585,7 @@ impl<'tcx> ScopeTree { return true; } - /// Returns the ID of the innermost containing body + /// Returns the ID of the innermost containing body. pub fn containing_body(&self, mut scope: Scope) -> Option { loop { if let ScopeData::CallSite = scope.data { diff --git a/src/librustc/mir/cache.rs b/src/librustc/mir/cache.rs index 3d33e249536c7..1f604877841a7 100644 --- a/src/librustc/mir/cache.rs +++ b/src/librustc/mir/cache.rs @@ -27,7 +27,7 @@ impl<'a> HashStable> for Cache { fn hash_stable(&self, _: &mut StableHashingContext<'a>, _: &mut StableHasher) { - // do nothing + // Do nothing. } } diff --git a/src/librustc/mir/interpret/allocation.rs b/src/librustc/mir/interpret/allocation.rs index 13552a61acb0e..755cda792ba79 100644 --- a/src/librustc/mir/interpret/allocation.rs +++ b/src/librustc/mir/interpret/allocation.rs @@ -4,16 +4,17 @@ use super::{ Pointer, InterpResult, AllocId, ScalarMaybeUndef, write_target_uint, read_target_uint, Scalar, }; +use crate::mir; use crate::ty::layout::{Size, Align}; + +use rustc_data_structures::sorted_map::SortedMap; +use rustc_target::abi::HasDataLayout; use syntax::ast::Mutability; use std::iter; -use crate::mir; use std::ops::{Range, Deref, DerefMut}; -use rustc_data_structures::sorted_map::SortedMap; -use rustc_target::abi::HasDataLayout; use std::borrow::Cow; -// NOTE: When adding new fields, make sure to adjust the Snapshot impl in +// NOTE: When adding new fields, make sure to adjust the `Snapshot` impl in // `src/librustc_mir/interpret/snapshot.rs`. #[derive( Clone, @@ -27,7 +28,7 @@ use std::borrow::Cow; RustcDecodable, HashStable, )] -pub struct Allocation { +pub struct Allocation { /// The actual bytes of the allocation. /// Note that the bytes of a pointer represent the offset of the pointer. bytes: Vec, @@ -42,7 +43,7 @@ pub struct Allocation { pub size: Size, /// The alignment of the allocation to detect unaligned reads. pub align: Align, - /// Whether the allocation is mutable. + /// `true` if the allocation is mutable. /// Also used by codegen to determine if a static should be put into mutable memory, /// which happens for `static mut` and `static` with interior mutability. pub mutability: Mutability, @@ -50,7 +51,6 @@ pub struct Allocation { pub extra: Extra, } - pub trait AllocationExtra: ::std::fmt::Debug + Clone { // There is no constructor in here because the constructor's type depends // on `MemoryKind`, and making things sufficiently generic leads to painful @@ -92,7 +92,7 @@ pub trait AllocationExtra: ::std::fmt::Debug + Clone { } } -// For Tag=() and no extra state, we have is a trivial implementation. +// For `Tag = ()` and no extra state, we have a trivial implementation. impl AllocationExtra<()> for () { } // The constructors are all without extra; the extra gets added by a machine hook later. @@ -185,7 +185,7 @@ impl Allocation { impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx Allocation {} -/// Byte accessors +/// Byte accessors. impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { /// Just a small local helper function to avoid a bit of code repetition. /// Returns the range of this allocation that was meant. @@ -195,7 +195,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { offset: Size, size: Size ) -> Range { - let end = offset + size; // this does overflow checking + let end = offset + size; // This does overflow checking. assert_eq!( end.bytes() as usize as u64, end.bytes(), "cannot handle this access on this host architecture" @@ -232,7 +232,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { self.check_defined(ptr, size)?; self.check_relocations(cx, ptr, size)?; } else { - // We still don't want relocations on the *edges* + // We still don't want relocations on the *edges*. self.check_relocation_edges(cx, ptr, size)?; } @@ -241,7 +241,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { Ok(&self.bytes[range]) } - /// Check that these bytes are initialized and not pointer bytes, and then return them + /// Checks that these bytes are initialized and not pointer bytes, and then return them /// as a slice. /// /// It is the caller's responsibility to check bounds and alignment beforehand. @@ -293,7 +293,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { } } -/// Reading and writing +/// Reading and writing. impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { /// Reads bytes until a `0` is encountered. Will error if the end of the allocation is reached /// before a `0` is found. @@ -329,9 +329,9 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { allow_ptr_and_undef: bool, ) -> InterpResult<'tcx> { - // Check bounds and relocations on the edges + // Check bounds and relocations on the edges. self.get_bytes_with_undef_and_ptr(cx, ptr, size)?; - // Check undef and ptr + // Check undef and ptr. if !allow_ptr_and_undef { self.check_defined(ptr, size)?; self.check_relocations(cx, ptr, size)?; @@ -372,12 +372,12 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { Ok(()) } - /// Read a *non-ZST* scalar + /// Reads a *non-ZST* scalar. /// - /// zsts can't be read out of two reasons: - /// * byteorder cannot work with zero element buffers - /// * in order to obtain a `Pointer` we need to check for ZSTness anyway due to integer pointers - /// being valid for ZSTs + /// ZSTs can't be read for two reasons: + /// * byte-order cannot work with zero-element buffers; + /// * in order to obtain a `Pointer`, we need to check for ZSTness anyway due to integer + /// pointers being valid for ZSTs. /// /// It is the caller's responsibility to check bounds and alignment beforehand. pub fn read_scalar( @@ -387,20 +387,20 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { size: Size ) -> InterpResult<'tcx, ScalarMaybeUndef> { - // get_bytes_unchecked tests relocation edges + // `get_bytes_unchecked` tests relocation edges. let bytes = self.get_bytes_with_undef_and_ptr(cx, ptr, size)?; // Undef check happens *after* we established that the alignment is correct. - // We must not return Ok() for unaligned pointers! + // We must not return `Ok()` for unaligned pointers! if self.check_defined(ptr, size).is_err() { - // this inflates undefined bytes to the entire scalar, even if only a few - // bytes are undefined + // This inflates undefined bytes to the entire scalar, even if only a few + // bytes are undefined. return Ok(ScalarMaybeUndef::Undef); } - // Now we do the actual reading + // Now we do the actual reading. let bits = read_target_uint(cx.data_layout().endian, bytes).unwrap(); - // See if we got a pointer + // See if we got a pointer. if size != cx.data_layout().pointer_size { - // *Now* better make sure that the inside also is free of relocations. + // *Now*, we better make sure that the inside is free of relocations too. self.check_relocations(cx, ptr, size)?; } else { match self.relocations.get(&ptr.offset) { @@ -415,7 +415,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { Ok(ScalarMaybeUndef::Scalar(Scalar::from_uint(bits, size))) } - /// Read a pointer-sized scalar. + /// Reads a pointer-sized scalar. /// /// It is the caller's responsibility to check bounds and alignment beforehand. pub fn read_ptr_sized( @@ -427,12 +427,12 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { self.read_scalar(cx, ptr, cx.data_layout().pointer_size) } - /// Write a *non-ZST* scalar + /// Writes a *non-ZST* scalar. /// - /// zsts can't be read out of two reasons: - /// * byteorder cannot work with zero element buffers - /// * in oder to obtain a `Pointer` we need to check for ZSTness anyway due to integer pointers - /// being valid for ZSTs + /// ZSTs can't be read for two reasons: + /// * byte-order cannot work with zero-element buffers; + /// * in order to obtain a `Pointer`, we need to check for ZSTness anyway due to integer + /// pointers being valid for ZSTs. /// /// It is the caller's responsibility to check bounds and alignment beforehand. pub fn write_scalar( @@ -460,7 +460,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { let dst = self.get_bytes_mut(cx, ptr, type_size)?; write_target_uint(endian, dst, bytes).unwrap(); - // See if we have to also write a relocation + // See if we have to also write a relocation. match val { Scalar::Ptr(val) => { self.relocations.insert( @@ -474,7 +474,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { Ok(()) } - /// Write a pointer-sized scalar. + /// Writes a pointer-sized scalar. /// /// It is the caller's responsibility to check bounds and alignment beforehand. pub fn write_ptr_sized( @@ -489,9 +489,9 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra> Allocation { } } -/// Relocations +/// Relocations. impl<'tcx, Tag: Copy, Extra> Allocation { - /// Returns all relocations overlapping with the given ptr-offset pair. + /// Returns all relocations overlapping with the given pointer-offset pair. pub fn get_relocations( &self, cx: &impl HasDataLayout, @@ -501,7 +501,7 @@ impl<'tcx, Tag: Copy, Extra> Allocation { // We have to go back `pointer_size - 1` bytes, as that one would still overlap with // the beginning of this range. let start = ptr.offset.bytes().saturating_sub(cx.data_layout().pointer_size.bytes() - 1); - let end = ptr.offset + size; // this does overflow checking + let end = ptr.offset + size; // This does overflow checking. self.relocations.range(Size::from_bytes(start)..end) } @@ -561,7 +561,7 @@ impl<'tcx, Tag: Copy, Extra> Allocation { Ok(()) } - /// Error if there are relocations overlapping with the edges of the + /// Errors if there are relocations overlapping with the edges of the /// given memory range. #[inline] fn check_relocation_edges( @@ -577,7 +577,7 @@ impl<'tcx, Tag: Copy, Extra> Allocation { } -/// Undefined bytes +/// Undefined bytes. impl<'tcx, Tag, Extra> Allocation { /// Checks that a range of bytes is defined. If not, returns the `ReadUndefBytes` /// error which will report the first byte which is undefined. @@ -618,7 +618,7 @@ pub struct AllocationDefinedness { /// Transferring the definedness mask to other allocations. impl Allocation { - /// Creates a run-length encoding of the undef_mask. + /// Creates a run-length encoding of the undef mask. pub fn compress_undef_range( &self, src: Pointer, @@ -631,10 +631,10 @@ impl Allocation { // Therefor we precompute a compressed version of the undef mask of the source value and // then write it back `repeat` times without computing any more information from the source. - // a precomputed cache for ranges of defined/undefined bits + // A precomputed cache for ranges of defined/undefined bits // 0000010010001110 will become - // [5, 1, 2, 1, 3, 3, 1] - // where each element toggles the state + // `[5, 1, 2, 1, 3, 3, 1]`, + // where each element toggles the state. let mut ranges = smallvec::SmallVec::<[u64; 1]>::new(); let initial = self.undef_mask.get(src.offset); @@ -642,7 +642,7 @@ impl Allocation { let mut cur = initial; for i in 1..size.bytes() { - // FIXME: optimize to bitshift the current undef block's bits and read the top bit + // FIXME: optimize to bitshift the current undef block's bits and read the top bit. if self.undef_mask.get(src.offset + Size::from_bytes(i)) == cur { cur_len += 1; } else { @@ -657,7 +657,7 @@ impl Allocation { AllocationDefinedness { ranges, initial, } } - /// Apply multiple instances of the run-length encoding to the undef_mask. + /// Applies multiple instances of the run-length encoding to the undef mask. pub fn mark_compressed_undef_range( &mut self, defined: &AllocationDefinedness, @@ -665,7 +665,7 @@ impl Allocation { size: Size, repeat: u64, ) { - // an optimization where we can just overwrite an entire range of definedness bits if + // An optimization where we can just overwrite an entire range of definedness bits if // they are going to be uniformly `1` or `0`. if defined.ranges.len() <= 1 { self.undef_mask.set_range_inbounds( @@ -694,9 +694,9 @@ impl Allocation { } } -/// Relocations +/// Relocations. #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, RustcEncodable, RustcDecodable)] -pub struct Relocations(SortedMap); +pub struct Relocations(SortedMap); impl Relocations { pub fn new() -> Self { @@ -766,7 +766,7 @@ impl Allocation { } } - /// Apply a relocation copy. + /// Applies a relocation copy. /// The affected range, as defined in the parameters to `prepare_relocation_copy` is expected /// to be clear of relocations. pub fn mark_relocation_range( @@ -838,8 +838,8 @@ impl UndefMask { let (blocka, bita) = bit_index(start); let (blockb, bitb) = bit_index(end); if blocka == blockb { - // first set all bits but the first `bita` - // then unset the last `64 - bitb` bits + // First set all bits except the first `bita`, + // then unset the last `64 - bitb` bits. let range = if bitb == 0 { u64::max_value() << bita } else { @@ -854,24 +854,24 @@ impl UndefMask { } // across block boundaries if new_state { - // set bita..64 to 1 + // Set `bita..64` to `1`. self.blocks[blocka] |= u64::max_value() << bita; - // set 0..bitb to 1 + // Set `0..bitb` to `1`. if bitb != 0 { self.blocks[blockb] |= u64::max_value() >> (64 - bitb); } - // fill in all the other blocks (much faster than one bit at a time) + // Fill in all the other blocks (much faster than one bit at a time). for block in (blocka + 1) .. blockb { self.blocks[block] = u64::max_value(); } } else { - // set bita..64 to 0 + // Set `bita..64` to `0`. self.blocks[blocka] &= !(u64::max_value() << bita); - // set 0..bitb to 0 + // Set `0..bitb` to `0`. if bitb != 0 { self.blocks[blockb] &= !(u64::max_value() >> (64 - bitb)); } - // fill in all the other blocks (much faster than one bit at a time) + // Fill in all the other blocks (much faster than one bit at a time). for block in (blocka + 1) .. blockb { self.blocks[block] = 0; } @@ -908,7 +908,7 @@ impl UndefMask { let additional_blocks = amount.bytes() / Self::BLOCK_SIZE + 1; assert_eq!(additional_blocks as usize as u64, additional_blocks); self.blocks.extend( - // FIXME(oli-obk): optimize this by repeating `new_state as Block` + // FIXME(oli-obk): optimize this by repeating `new_state as Block`. iter::repeat(0).take(additional_blocks as usize), ); } diff --git a/src/librustc/mir/interpret/error.rs b/src/librustc/mir/interpret/error.rs index 589a021241d94..09c822f7508a0 100644 --- a/src/librustc/mir/interpret/error.rs +++ b/src/librustc/mir/interpret/error.rs @@ -1,23 +1,21 @@ -use std::{fmt, env}; +use super::{RawConst, Pointer, CheckInAllocMsg, ScalarMaybeUndef}; use crate::hir; 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 rustc_macros::HashStable; - -use super::{RawConst, Pointer, CheckInAllocMsg, ScalarMaybeUndef}; +use crate::ty::query::TyCtxtAt; use backtrace::Backtrace; - -use crate::ty::query::TyCtxtAt; use errors::DiagnosticBuilder; - +use rustc_macros::HashStable; +use rustc_target::spec::abi::Abi; use syntax_pos::{Pos, Span}; use syntax::symbol::Symbol; +use std::{fmt, env}; + #[derive(Debug, Copy, Clone, PartialEq, Eq, HashStable, RustcEncodable, RustcDecodable)] pub enum ErrorHandled { /// Already reported a lint or an error for this evaluation. @@ -582,7 +580,7 @@ pub type InterpResult<'tcx, T = ()> = Result>; impl fmt::Display for InterpError<'_> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - // Forward `Display` to `Debug` + // Forward `Display` to `Debug`. write!(f, "{:?}", self) } } diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs index 1ec95c29a4a6f..23433c2e8834d 100644 --- a/src/librustc/mir/interpret/mod.rs +++ b/src/librustc/mir/interpret/mod.rs @@ -1,4 +1,4 @@ -//! An interpreter for MIR used in CTFE and by miri +//! An interpreter for MIR used in CTFE and by miri. #[macro_export] macro_rules! err_unsup { @@ -107,21 +107,21 @@ pub use self::allocation::{Allocation, AllocationExtra, Relocations, UndefMask}; pub use self::pointer::{Pointer, PointerArithmetic, CheckInAllocMsg}; -use std::fmt; use crate::mir; use crate::hir::def_id::DefId; use crate::ty::{self, TyCtxt, Instance, subst::UnpackedKind}; +use crate::ty::codec::TyDecoder; use crate::ty::layout::{self, Size}; use std::io; +use std::fmt; +use std::num::NonZeroU32; +use std::sync::atomic::{AtomicU32, Ordering}; use rustc_serialize::{Encoder, Decodable, Encodable}; use rustc_data_structures::fx::FxHashMap; -use rustc_data_structures::sync::{Lock as Mutex, HashMapExt}; +use rustc_data_structures::sync::{Lock, HashMapExt}; use rustc_data_structures::tiny_list::TinyList; use rustc_macros::HashStable; use byteorder::{WriteBytesExt, ReadBytesExt, LittleEndian, BigEndian}; -use crate::ty::codec::TyDecoder; -use std::sync::atomic::{AtomicU32, Ordering}; -use std::num::NonZeroU32; /// Uniquely identifies a specific constant or static. #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, RustcEncodable, RustcDecodable, HashStable)] @@ -152,8 +152,8 @@ pub fn specialized_encode_alloc_id<'tcx, E: Encoder>( tcx: TyCtxt<'tcx>, alloc_id: AllocId, ) -> Result<(), E::Error> { - let alloc: GlobalAlloc<'tcx> = - tcx.alloc_map.lock().get(alloc_id).expect("no value for AllocId"); + let alloc: GlobalAlloc<'tcx> = tcx.alloc_map.lock().get(alloc_id) + .expect("no value for given alloc ID"); match alloc { GlobalAlloc::Memory(alloc) => { trace!("encoding {:?} with {:#?}", alloc_id, alloc); @@ -166,8 +166,8 @@ pub fn specialized_encode_alloc_id<'tcx, E: Encoder>( fn_instance.encode(encoder)?; } GlobalAlloc::Static(did) => { - // referring to statics doesn't need to know about their allocations, - // just about its DefId + // References to statics doesn't need to know about their allocations, + // just about its `DefId`. AllocDiscriminant::Static.encode(encoder)?; did.encode(encoder)?; } @@ -187,19 +187,18 @@ enum State { } pub struct AllocDecodingState { - // For each AllocId we keep track of which decoding state it's currently in. - decoding_state: Vec>, + // For each `AllocId`, we keep track of which decoding state it's currently in. + decoding_state: Vec>, // The offsets of each allocation in the data stream. data_offsets: Vec, } impl AllocDecodingState { - pub fn new_decoding_session(&self) -> AllocDecodingSession<'_> { static DECODER_SESSION_ID: AtomicU32 = AtomicU32::new(0); let counter = DECODER_SESSION_ID.fetch_add(1, Ordering::SeqCst); - // Make sure this is never zero + // Make sure this is never zero. let session_id = DecodingSessionId::new((counter & 0x7FFFFFFF) + 1).unwrap(); AllocDecodingSession { @@ -208,10 +207,10 @@ impl AllocDecodingState { } } - pub fn new(data_offsets: Vec) -> AllocDecodingState { - let decoding_state = vec![Mutex::new(State::Empty); data_offsets.len()]; + pub fn new(data_offsets: Vec) -> Self { + let decoding_state = vec![Lock::new(State::Empty); data_offsets.len()]; - AllocDecodingState { + Self { decoding_state, data_offsets, } @@ -225,23 +224,23 @@ pub struct AllocDecodingSession<'s> { } impl<'s> AllocDecodingSession<'s> { - // Decodes an AllocId in a thread-safe way. + /// Decodes an `AllocId` in a thread-safe way. pub fn decode_alloc_id(&self, decoder: &mut D) -> Result where D: TyDecoder<'tcx>, { - // Read the index of the allocation + // Read the index of the allocation. let idx = decoder.read_u32()? as usize; let pos = self.state.data_offsets[idx] as usize; - // Decode the AllocDiscriminant now so that we know if we have to reserve an - // AllocId. + // Decode the `AllocDiscriminant` now so that we know if we have to reserve an + // `AllocId`. let (alloc_kind, pos) = decoder.with_position(pos, |decoder| { let alloc_kind = AllocDiscriminant::decode(decoder)?; Ok((alloc_kind, decoder.position())) })?; - // Check the decoding state, see if it's already decoded or if we should + // Check the decoding state to see if it's already decoded or if we should // decode it here. let alloc_id = { let mut entry = self.state.decoding_state[idx].lock(); @@ -251,11 +250,11 @@ impl<'s> AllocDecodingSession<'s> { return Ok(alloc_id); } ref mut entry @ State::Empty => { - // We are allowed to decode + // We are allowed to decode. match alloc_kind { AllocDiscriminant::Alloc => { // If this is an allocation, we need to reserve an - // AllocId so we can decode cyclic graphs. + // `AllocId` so we can decode cyclic graphs. let alloc_id = decoder.tcx().alloc_map.lock().reserve(); *entry = State::InProgress( TinyList::new_single(self.session_id), @@ -263,8 +262,8 @@ impl<'s> AllocDecodingSession<'s> { Some(alloc_id) }, AllocDiscriminant::Fn | AllocDiscriminant::Static => { - // Fns and statics cannot be cyclic and their AllocId - // is determined later by interning + // Fns and statics cannot be cyclic, and their `AllocId` + // is determined later by interning. *entry = State::InProgressNonAlloc( TinyList::new_single(self.session_id)); None @@ -273,9 +272,9 @@ impl<'s> AllocDecodingSession<'s> { } State::InProgressNonAlloc(ref mut sessions) => { if sessions.contains(&self.session_id) { - bug!("This should be unreachable") + bug!("this should be unreachable"); } else { - // Start decoding concurrently + // Start decoding concurrently. sessions.insert(self.session_id); None } @@ -285,7 +284,7 @@ impl<'s> AllocDecodingSession<'s> { // Don't recurse. return Ok(alloc_id) } else { - // Start decoding concurrently + // Start decoding concurrently. sessions.insert(self.session_id); Some(alloc_id) } @@ -293,20 +292,20 @@ impl<'s> AllocDecodingSession<'s> { } }; - // Now decode the actual data + // Now decode the actual data. let alloc_id = decoder.with_position(pos, |decoder| { match alloc_kind { AllocDiscriminant::Alloc => { - let allocation = <&'tcx Allocation as Decodable>::decode(decoder)?; - // We already have a reserved AllocId. + let alloc = <&'tcx Allocation as Decodable>::decode(decoder)?; + // We already have a reserved `AllocId`. let alloc_id = alloc_id.unwrap(); - trace!("decoded alloc {:?} {:#?}", alloc_id, allocation); - decoder.tcx().alloc_map.lock().set_alloc_id_same_memory(alloc_id, allocation); + trace!("decoded alloc {:?}: {:#?}", alloc_id, alloc); + decoder.tcx().alloc_map.lock().set_alloc_id_same_memory(alloc_id, alloc); Ok(alloc_id) }, AllocDiscriminant::Fn => { assert!(alloc_id.is_none()); - trace!("creating fn alloc id"); + trace!("creating fn alloc ID"); let instance = ty::Instance::decode(decoder)?; trace!("decoded fn alloc instance: {:?}", instance); let alloc_id = decoder.tcx().alloc_map.lock().create_fn_alloc(instance); @@ -314,8 +313,9 @@ impl<'s> AllocDecodingSession<'s> { }, AllocDiscriminant::Static => { assert!(alloc_id.is_none()); - trace!("creating extern static alloc id at"); + trace!("creating extern static alloc ID"); let did = DefId::decode(decoder)?; + trace!("decoded static def-ID: {:?}", did); let alloc_id = decoder.tcx().alloc_map.lock().create_static_alloc(did); Ok(alloc_id) } @@ -340,7 +340,7 @@ impl fmt::Display for AllocId { /// a static, or a "real" allocation with some data in it. #[derive(Debug, Clone, Eq, PartialEq, Hash, RustcDecodable, RustcEncodable, HashStable)] pub enum GlobalAlloc<'tcx> { - /// The alloc ID is used as a function pointer + /// The alloc ID is used as a function pointer. Function(Instance<'tcx>), /// The alloc ID points to a "lazy" static variable that did not get computed (yet). /// This is also used to break the cycle in recursive statics. @@ -350,16 +350,17 @@ pub enum GlobalAlloc<'tcx> { } pub struct AllocMap<'tcx> { - /// Lets you know what an `AllocId` refers to. + /// Maps `AllocId`s to their corresponding allocations. alloc_map: FxHashMap>, /// Used to ensure that statics and functions only get one associated `AllocId`. /// Should never contain a `GlobalAlloc::Memory`! - /// FIXME: Should we just have two separate dedup maps for statics and functions each? + // + // FIXME: Should we just have two separate dedup maps for statics and functions each? dedup: FxHashMap, AllocId>, /// The `AllocId` to assign to the next requested ID. - /// Always incremented, never gets smaller. + /// Always incremented; never gets smaller. next_id: AllocId, } @@ -389,7 +390,7 @@ impl<'tcx> AllocMap<'tcx> { next } - /// Reserve a new ID *if* this allocation has not been dedup-reserved before. + /// Reserves a new ID *if* this allocation has not been dedup-reserved before. /// Should only be used for function pointers and statics, we don't want /// to dedup IDs for "real" memory! fn reserve_and_set_dedup(&mut self, alloc: GlobalAlloc<'tcx>) -> AllocId { @@ -430,17 +431,17 @@ impl<'tcx> AllocMap<'tcx> { } }); if is_generic { - // Get a fresh ID + // Get a fresh ID. let id = self.reserve(); self.alloc_map.insert(id, GlobalAlloc::Function(instance)); id } else { - // Deduplicate + // Deduplicate. self.reserve_and_set_dedup(GlobalAlloc::Function(instance)) } } - /// Intern the `Allocation` and return a new `AllocId`, even if there's already an identical + /// Interns the `Allocation` and return a new `AllocId`, even if there's already an identical /// `Allocation` with a different `AllocId`. /// Statics with identical content will still point to the same `Allocation`, i.e., /// their data will be deduplicated through `Allocation` interning -- but they @@ -465,19 +466,19 @@ impl<'tcx> AllocMap<'tcx> { pub fn unwrap_memory(&self, id: AllocId) -> &'tcx Allocation { match self.get(id) { Some(GlobalAlloc::Memory(mem)) => mem, - _ => bug!("expected allocation id {} to point to memory", id), + _ => bug!("expected allocation ID {} to point to memory", id), } } - /// Freeze an `AllocId` created with `reserve` by pointing it at an `Allocation`. Trying to + /// Freezes an `AllocId` created with `reserve` by pointing it at an `Allocation`. Trying to /// call this function twice, even with the same `Allocation` will ICE the compiler. pub fn set_alloc_id_memory(&mut self, id: AllocId, mem: &'tcx Allocation) { if let Some(old) = self.alloc_map.insert(id, GlobalAlloc::Memory(mem)) { - bug!("tried to set allocation id {}, but it was already existing as {:#?}", id, old); + bug!("tried to set allocation ID {}, but it was already existing as {:#?}", id, old); } } - /// Freeze an `AllocId` created with `reserve` by pointing it at an `Allocation`. May be called + /// Freezes an `AllocId` created with `reserve` by pointing it at an `Allocation`. May be called /// twice for the same `(AllocId, Allocation)` pair. fn set_alloc_id_same_memory(&mut self, id: AllocId, mem: &'tcx Allocation) { self.alloc_map.insert_same(id, GlobalAlloc::Memory(mem)); @@ -513,7 +514,7 @@ pub fn read_target_uint(endianness: layout::Endian, mut source: &[u8]) -> Result // Methods to facilitate working with signed integers stored in a u128 //////////////////////////////////////////////////////////////////////////////// -/// Truncate `value` to `size` bits and then sign-extend it to 128 bits +/// Truncates `value` to `size` bits and then sign-extend it to 128 bits /// (i.e., if it is negative, fill with 1's on the left). #[inline] pub fn sign_extend(value: u128, size: Size) -> u128 { @@ -522,14 +523,14 @@ pub fn sign_extend(value: u128, size: Size) -> u128 { // Truncated until nothing is left. return 0; } - // sign extend + // Sign-extend it. let shift = 128 - size; - // shift the unsigned value to the left - // and back to the right as signed (essentially fills with FF on the left) + // Shift the unsigned value to the left, then shift back to the right as signed + // (essentially fills with FF on the left). (((value << shift) as i128) >> shift) as u128 } -/// Truncate `value` to `size` bits. +/// Truncates `value` to `size` bits. #[inline] pub fn truncate(value: u128, size: Size) -> u128 { let size = size.bits(); @@ -538,6 +539,6 @@ pub fn truncate(value: u128, size: Size) -> u128 { return 0; } let shift = 128 - size; - // truncate (shift left to drop out leftover values, shift right to fill with zeroes) + // Truncate (shift left to drop out leftover values, shift right to fill with zeroes). (value << shift) >> shift } diff --git a/src/librustc/mir/interpret/pointer.rs b/src/librustc/mir/interpret/pointer.rs index b55e6bc54bc5f..1bb4d9ea4d6d9 100644 --- a/src/librustc/mir/interpret/pointer.rs +++ b/src/librustc/mir/interpret/pointer.rs @@ -86,18 +86,17 @@ pub trait PointerArithmetic: layout::HasDataLayout { impl PointerArithmetic for T {} - -/// Pointer is generic over the type that represents a reference to Allocations, +/// `Pointer` is generic over the type that represents a reference to `Allocation`s, /// thus making it possible for the most convenient representation to be used in /// each context. /// -/// Defaults to the index based and loosely coupled AllocId. +/// Defaults to the index based and loosely coupled `AllocId`. /// /// Pointer is also generic over the `Tag` associated with each pointer, /// which is used to do provenance tracking during execution. #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, RustcEncodable, RustcDecodable, Hash, HashStable)] -pub struct Pointer { +pub struct Pointer { pub alloc_id: Id, pub offset: Size, pub tag: Tag, @@ -117,7 +116,7 @@ impl fmt::Debug for Pointer<(), Id> { } } -/// Produces a `Pointer` which points to the beginning of the Allocation +/// Produces a `Pointer` which points to the beginning of the `Allocation`. impl From for Pointer { #[inline(always)] fn from(alloc_id: AllocId) -> Self { diff --git a/src/librustc/mir/interpret/value.rs b/src/librustc/mir/interpret/value.rs index 3da5a65c37932..d72d879059369 100644 --- a/src/librustc/mir/interpret/value.rs +++ b/src/librustc/mir/interpret/value.rs @@ -91,7 +91,7 @@ impl<'tcx> ConstValue<'tcx> { /// of a simple value or a pointer into another `Allocation` #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, RustcEncodable, RustcDecodable, Hash, HashStable)] -pub enum Scalar { +pub enum Scalar { /// The raw bytes of a simple value. Raw { /// The first `size` bytes of `data` are the value. @@ -359,7 +359,7 @@ impl<'tcx, Tag> Scalar { #[inline(always)] pub fn assert_bits(self, target_size: Size) -> u128 { - self.to_bits(target_size).expect("Expected Raw bits but got a Pointer") + self.to_bits(target_size).expect("expected Raw bits but got a Pointer") } /// Do not call this method! Use either `assert_ptr` or `force_ptr`. @@ -374,7 +374,7 @@ impl<'tcx, Tag> Scalar { #[inline(always)] pub fn assert_ptr(self) -> Pointer { - self.to_ptr().expect("Expected a Pointer but got Raw bits") + self.to_ptr().expect("expected a Pointer but got Raw bits") } /// Do not call this method! Dispatch based on the type instead. @@ -482,8 +482,8 @@ impl From> for Scalar { } } -#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, RustcEncodable, RustcDecodable, Hash)] -pub enum ScalarMaybeUndef { +#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash, RustcEncodable, RustcDecodable)] +pub enum ScalarMaybeUndef { Scalar(Scalar), Undef, } diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs index 8956cbb2baefc..18a5142208d2d 100644 --- a/src/librustc/mir/mod.rs +++ b/src/librustc/mir/mod.rs @@ -18,6 +18,7 @@ use crate::ty::{ self, AdtDef, CanonicalUserTypeAnnotations, ClosureSubsts, GeneratorSubsts, Region, Ty, TyCtxt, UserTypeAnnotationIndex, }; + use polonius_engine::Atom; use rustc_data_structures::bit_set::BitMatrix; use rustc_data_structures::fx::FxHashSet; @@ -70,7 +71,7 @@ impl<'tcx> HasLocalDecls<'tcx> for Body<'tcx> { /// The various "big phases" that MIR goes through. /// -/// Warning: ordering of variants is significant +/// Warning: ordering of variants is significant. #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, PartialEq, Eq, PartialOrd, Ord)] pub enum MirPhase { Build = 0, @@ -80,16 +81,16 @@ pub enum MirPhase { } impl MirPhase { - /// Gets the index of the current MirPhase within the set of all MirPhases. + /// Gets the index of the current MirPhase within the set of all `MirPhase`s. pub fn phase_index(&self) -> usize { *self as usize } } -/// Lowered representation of a single function. +/// The lowered representation of a single function. #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Body<'tcx> { - /// List of basic blocks. References to basic block use a newtyped index type `BasicBlock` + /// A list of basic blocks. References to basic block use a newtyped index type `BasicBlock` /// that indexes into this vector. basic_blocks: IndexVec>, @@ -100,7 +101,7 @@ pub struct Body<'tcx> { /// us to see the difference and forego optimization on the inlined promoted items. pub phase: MirPhase, - /// List of source scopes; these are referenced by statements + /// A list of source scopes; these are referenced by statements /// and used for debuginfo. Indexed by a `SourceScope`. pub source_scopes: IndexVec, @@ -108,10 +109,10 @@ pub struct Body<'tcx> { /// needn't) be tracked across crates. pub source_scope_local_data: ClearCrossCrate>, - /// Yields type of the function, if it is a generator. + /// The yield type of the function, if it is a generator. pub yield_ty: Option>, - /// Generator drop glue + /// Generator drop glue. pub generator_drop: Option>>, /// The layout of a generator. Produced by the state transformation. @@ -124,10 +125,10 @@ pub struct Body<'tcx> { /// variables and temporaries. pub local_decls: LocalDecls<'tcx>, - /// User type annotations + /// User type annotations. pub user_type_annotations: CanonicalUserTypeAnnotations<'tcx>, - /// Number of arguments this function takes. + /// The number of arguments this function takes. /// /// Starting at local 1, `arg_count` locals will be provided by the caller /// and can be assumed to be initialized. @@ -143,10 +144,11 @@ pub struct Body<'tcx> { /// Names and capture modes of all the closure upvars, assuming /// the first argument is either the closure or a reference to it. + // // NOTE(eddyb) This is *strictly* a temporary hack for codegen // debuginfo generation, and will be removed at some point. - // Do **NOT** use it for anything else, upvar information should not be - // in the MIR, please rely on local crate HIR or other side-channels. + // Do **NOT** use it for anything else; upvar information should not be + // in the MIR, so please rely on local crate HIR or other side-channels. pub __upvar_debuginfo_codegen_only_do_not_use: Vec, /// Mark this MIR of a const context other than const functions as having converted a `&&` or @@ -157,10 +159,10 @@ pub struct Body<'tcx> { /// List of places where control flow was destroyed. Used for error reporting. pub control_flow_destroyed: Vec<(Span, String)>, - /// A span representing this MIR, for error reporting + /// A span representing this MIR, for error reporting. pub span: Span, - /// A cache for various calculations + /// A cache for various calculations. cache: cache::Cache, } @@ -177,7 +179,7 @@ impl<'tcx> Body<'tcx> { span: Span, control_flow_destroyed: Vec<(Span, String)>, ) -> Self { - // We need `arg_count` locals, and one for the return place + // We need `arg_count` locals, and one for the return place. assert!( local_decls.len() >= arg_count + 1, "expected at least {} locals, got {}", @@ -384,12 +386,12 @@ impl<'tcx> Body<'tcx> { true } - /// Returns the return type, it always return first element from `local_decls` array + /// Returns the return type; it always return first element from `local_decls` array. pub fn return_ty(&self) -> Ty<'tcx> { self.local_decls[RETURN_PLACE].ty } - /// Gets the location of the terminator for the given block + /// Gets the location of the terminator for the given block. pub fn terminator_loc(&self, bb: BasicBlock) -> Location { Location { block: bb, statement_index: self[bb].statements.len() } } @@ -463,7 +465,7 @@ impl rustc_serialize::UseSpecializedDecodable for ClearCrossCrate< /// Most passes can work with it as a whole, within a single function. #[derive(Copy, Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, HashStable)] pub struct SourceInfo { - /// Source span for the AST pertaining to this MIR entity. + /// The source span for the AST pertaining to this MIR entity. pub span: Span, /// The source scope, keeping track of which bindings can be @@ -591,13 +593,13 @@ impl Atom for Local { /// Classifies locals into categories. See `Body::local_kind`. #[derive(PartialEq, Eq, Debug, HashStable)] pub enum LocalKind { - /// User-declared variable binding + /// User-declared variable binding. Var, - /// Compiler-introduced temporary + /// Compiler-introduced temporary. Temp, - /// Function argument + /// Function argument. Arg, - /// Location of function's return value + /// Location of function's return value. ReturnPointer, } @@ -619,7 +621,7 @@ pub struct VarBindingForm<'tcx> { /// (b) it gives a way to separate this case from the remaining cases /// for diagnostics. pub opt_match_place: Option<(Option>, Span)>, - /// Span of the pattern in which this variable was bound. + /// The span of the pattern in which this variable was bound. pub pat_span: Span, } @@ -721,12 +723,12 @@ impl_stable_hash_for!(struct BlockTailInfo { tail_result_is_ignored }); /// argument, or the return place. #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] pub struct LocalDecl<'tcx> { - /// `let mut x` vs `let x`. + /// Whether this is a mutable minding (i.e., `let x` or `let mut x`). /// /// Temporaries and the return place are always mutable. pub mutability: Mutability, - /// Some(binding_mode) if this corresponds to a user-declared local variable. + /// `Some(binding_mode)` if this corresponds to a user-declared local variable. /// /// This is solely used for local diagnostics when generating /// warnings/errors when compiling the current crate, and @@ -760,7 +762,7 @@ pub struct LocalDecl<'tcx> { /// intervening statement context). pub is_block_tail: Option, - /// Type of this local. + /// The type of this local. pub ty: Ty<'tcx>, /// If the user manually ascribed a type to this variable, @@ -769,7 +771,7 @@ pub struct LocalDecl<'tcx> { /// region inference. pub user_ty: UserTypeProjections, - /// Name of the local, used in debuginfo and pretty-printing. + /// The name of the local, used in debuginfo and pretty-printing. /// /// Note that function arguments can also have this set to `Some(_)` /// to generate better debuginfo. @@ -837,8 +839,8 @@ pub struct LocalDecl<'tcx> { /// ROOT SCOPE /// │{ argument x: &str } /// │ - /// │ │{ #[allow(unused_mut)] } // this is actually split into 2 scopes - /// │ │ // in practice because I'm lazy. + /// │ │{ #[allow(unused_mut)] } // This is actually split into 2 scopes + /// │ │ // in practice because I'm lazy. /// │ │ /// │ │← x.source_info.scope /// │ │← `x.parse().unwrap()` @@ -852,7 +854,7 @@ pub struct LocalDecl<'tcx> { /// │ /// │ │{ let x: u32 } /// │ │← x.visibility_scope - /// │ │← `drop(x)` // this accesses `x: u32` + /// │ │← `drop(x)` // This accesses `x: u32`. /// ``` pub source_info: SourceInfo, @@ -1038,16 +1040,16 @@ pub struct Terminator<'tcx> { #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)] pub enum TerminatorKind<'tcx> { - /// block should have one successor in the graph; we jump there + /// Block should have one successor in the graph; we jump there. Goto { target: BasicBlock }, - /// operand evaluates to an integer; jump depending on its value - /// to one of the targets, and otherwise fallback to `otherwise` + /// Operand evaluates to an integer; jump depending on its value + /// to one of the targets, and otherwise fallback to `otherwise`. SwitchInt { - /// discriminant value being tested + /// The discriminant value being tested. discr: Operand<'tcx>, - /// type of value being tested + /// The type of value being tested. switch_ty: Ty<'tcx>, /// Possible values. The locations to branch to in each case @@ -1057,6 +1059,7 @@ pub enum TerminatorKind<'tcx> { /// Possible branch sites. The last element of this vector is used /// for the otherwise branch, so targets.len() == values.len() + 1 /// should hold. + // // This invariant is quite non-obvious and also could be improved. // One way to make this invariant is to have something like this instead: // @@ -1069,7 +1072,7 @@ pub enum TerminatorKind<'tcx> { }, /// Indicates that the landing pad is finished and unwinding should - /// continue. Emitted by build::scope::diverge_cleanup. + /// continue. Emitted by `build::scope::diverge_cleanup`. Resume, /// Indicates that the landing pad is finished and that the process @@ -1083,10 +1086,10 @@ pub enum TerminatorKind<'tcx> { /// Indicates a terminator that can never be reached. Unreachable, - /// Drop the Place + /// Drop the `Place`. Drop { location: Place<'tcx>, target: BasicBlock, unwind: Option }, - /// Drop the Place and assign the new value over it. This ensures + /// Drop the `Place` and assign the new value over it. This ensures /// that the assignment to `P` occurs *even if* the destructor for /// place unwinds. Its semantics are best explained by the /// elaboration: @@ -1119,9 +1122,9 @@ pub enum TerminatorKind<'tcx> { unwind: Option, }, - /// Block ends with a call of a converging function + /// Block ends with a call of a converging function. Call { - /// The function that’s being called + /// The function that’s being called. func: Operand<'tcx>, /// Arguments the function is called with. /// These are owned by the callee, which is free to modify them. @@ -1132,7 +1135,7 @@ pub enum TerminatorKind<'tcx> { destination: Option<(Place<'tcx>, BasicBlock)>, /// Cleanups to be done if the call unwinds. cleanup: Option, - /// Whether this is from a call in HIR, rather than from an overloaded + /// `true` if this is from a call in HIR rather than from an overloaded /// operator. True for overloaded function call. from_hir_call: bool, }, @@ -1147,40 +1150,40 @@ pub enum TerminatorKind<'tcx> { cleanup: Option, }, - /// A suspend point + /// A suspend point. Yield { - /// The value to return + /// The value to return. value: Operand<'tcx>, - /// Where to resume to + /// Where to resume to. resume: BasicBlock, - /// Cleanup to be done if the generator is dropped at this suspend point + /// Cleanup to be done if the generator is dropped at this suspend point. drop: Option, }, - /// Indicates the end of the dropping of a generator + /// Indicates the end of the dropping of a generator. GeneratorDrop, /// A block where control flow only ever takes one real path, but borrowck /// needs to be more conservative. FalseEdges { - /// The target normal control flow will take + /// The target normal control flow will take. real_target: BasicBlock, /// A block control flow could conceptually jump to, but won't in - /// practice + /// practice. imaginary_target: BasicBlock, }, /// A terminator for blocks that only take one path in reality, but where we /// reserve the right to unwind in borrowck, even if it won't happen in practice. /// This can arise in infinite loops with no function calls for example. FalseUnwind { - /// The target normal control flow will take + /// The target normal control flow will take. real_target: BasicBlock, /// The imaginary cleanup block link. This particular path will never be taken /// in practice, but in order to avoid fragility we want to always /// consider it in borrowck. We don't want to accept programs which - /// pass borrowck only when panic=abort or some assertions are disabled - /// due to release vs. debug mode builds. This needs to be an Option because - /// of the remove_noop_landing_pads and no_landing_pads passes + /// pass borrowck only when `panic=abort` or some assertions are disabled + /// due to release vs. debug mode builds. This needs to be an `Option` because + /// of the `remove_noop_landing_pads` and `no_landing_pads` passes. unwind: Option, }, } @@ -1445,7 +1448,7 @@ impl<'tcx> Debug for TerminatorKind<'tcx> { } impl<'tcx> TerminatorKind<'tcx> { - /// Write the "head" part of the terminator; that is, its name and the data it uses to pick the + /// Writes the "head" part of the terminator; that is, its name and the data it uses to pick the /// successor basic block, if any. The only information not included is the list of possible /// successors, which may be rendered differently between the text and the graphviz format. pub fn fmt_head(&self, fmt: &mut W) -> fmt::Result { @@ -1615,20 +1618,20 @@ pub enum StatementKind<'tcx> { Nop, } -/// `RetagKind` describes what kind of retag is to be performed. +/// Describes what kind of retag is to be performed. #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, PartialEq, Eq, HashStable)] pub enum RetagKind { - /// The initial retag when entering a function + /// The initial retag when entering a function. FnEntry, - /// Retag preparing for a two-phase borrow + /// Retag preparing for a two-phase borrow. TwoPhase, - /// Retagging raw pointers + /// Retagging raw pointers. Raw, - /// A "normal" retag + /// A "normal" retag. Default, } -/// The `FakeReadCause` describes the type of pattern why a `FakeRead` statement exists. +/// The `FakeReadCause` describes the type of pattern why a FakeRead statement exists. #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable)] pub enum FakeReadCause { /// Inject a fake read of the borrowed input at the end of each guards @@ -2171,7 +2174,7 @@ pub struct SourceScopeData { #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] pub struct SourceScopeLocalData { - /// A HirId with lint levels equivalent to this scope's lint levels. + /// An `HirId` with lint levels equivalent to this scope's lint levels. pub lint_root: hir::HirId, /// The unsafe block that contains this node. pub safety: Safety, @@ -2760,11 +2763,12 @@ impl<'a, 'b> graph::GraphSuccessors<'b> for Body<'a> { #[derive(Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd, HashStable)] pub struct Location { - /// the location is within this block + /// The block that the location is within. pub block: BasicBlock, - /// the location is the start of the statement; or, if `statement_index` - /// == num-statements, then the start of the terminator. + /// The location is the position of the start of the statement; or, if + /// `statement_index` equals the number of statements, then the start of the + /// terminator. pub statement_index: usize, } @@ -2827,7 +2831,7 @@ impl Location { #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)] pub enum UnsafetyViolationKind { General, - /// Permitted in const fn and regular fns. + /// Permitted both in `const fn`s and regular `fn`s. GeneralAndConstFn, ExternStatic(hir::HirId), BorrowPacked(hir::HirId), @@ -2843,9 +2847,9 @@ pub struct UnsafetyViolation { #[derive(Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)] pub struct UnsafetyCheckResult { - /// Violations that are propagated *upwards* from this function + /// Violations that are propagated *upwards* from this function. pub violations: Lrc<[UnsafetyViolation]>, - /// unsafe blocks in this function, along with whether they are used. This is + /// `unsafe` blocks in this function, along with whether they are used. This is /// used for the "unused_unsafe" lint. pub unsafe_blocks: Lrc<[(hir::HirId, bool)]>, } @@ -2857,7 +2861,7 @@ newtype_index! { } } -/// The layout of generator state +/// The layout of generator state. #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] pub struct GeneratorLayout<'tcx> { /// The type of every local stored inside the generator. @@ -2872,11 +2876,14 @@ pub struct GeneratorLayout<'tcx> { /// layout. pub storage_conflicts: BitMatrix, - /// Names and scopes of all the stored generator locals. - /// NOTE(tmandry) This is *strictly* a temporary hack for codegen + /// The names and scopes of all the stored generator locals. + /// + /// N.B., this is *strictly* a temporary hack for codegen /// debuginfo generation, and will be removed at some point. /// Do **NOT** use it for anything else, local information should not be /// in the MIR, please rely on local crate HIR or other side-channels. + // + // FIXME(tmandry): see above. pub __local_debuginfo_codegen_only_do_not_use: IndexVec>, } @@ -2934,7 +2941,7 @@ pub struct BorrowCheckResult<'tcx> { /// instances assigned one of these same indices. Those regions will /// be substituted away by the creator. We use `ReClosureBound` in /// that case because the regions must be allocated in the global -/// TyCtxt, and hence we cannot use `ReVar` (which is what we use +/// `TyCtxt`, and hence we cannot use `ReVar` (which is what we use /// internally within the rest of the NLL code). #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] pub struct ClosureRegionRequirements<'tcx> { @@ -2950,8 +2957,8 @@ pub struct ClosureRegionRequirements<'tcx> { pub outlives_requirements: Vec>, } -/// Indicates an outlives constraint between a type or between two -/// free-regions declared on the closure. +/// Indicates an outlives-constraint between a type or between two +/// free regions declared on the closure. #[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] pub struct ClosureOutlivesRequirement<'tcx> { // This region or type ... @@ -2967,11 +2974,11 @@ pub struct ClosureOutlivesRequirement<'tcx> { pub category: ConstraintCategory, } -/// Outlives constraints can be categorized to determine whether and why they +/// Outlives-constraints can be categorized to determine whether and why they /// are interesting (for error reporting). Order of variants indicates sort /// order of the category, thereby influencing diagnostic output. /// -/// See also [rustc_mir::borrow_check::nll::constraints] +/// See also [rustc_mir::borrow_check::nll::constraints]. #[derive( Copy, Clone, @@ -3019,7 +3026,7 @@ pub enum ConstraintCategory { Internal, } -/// The subject of a ClosureOutlivesRequirement -- that is, the thing +/// The subject of a `ClosureOutlivesRequirement` -- that is, the thing /// that must outlive some region. #[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, HashStable)] pub enum ClosureOutlivesSubject<'tcx> { @@ -3037,7 +3044,7 @@ pub enum ClosureOutlivesSubject<'tcx> { } /* - * TypeFoldable implementations for MIR types + * `TypeFoldable` implementations for MIR types */ CloneTypeFoldableAndLiftImpls! { diff --git a/src/librustc/query/mod.rs b/src/librustc/query/mod.rs index ef838114f6c36..4ebc2e72490d4 100644 --- a/src/librustc/query/mod.rs +++ b/src/librustc/query/mod.rs @@ -17,7 +17,6 @@ use crate::traits::query::{ use std::borrow::Cow; use syntax_pos::symbol::InternedString; - // Each of these queries corresponds to a function pointer field in the // `Providers` struct for requesting a value of that type, and a method // on `tcx: TyCtxt` (and `tcx.at(span)`) for doing that request in a way @@ -854,7 +853,7 @@ rustc_queries! { desc { "calculating the lang items map" } } - /// Returns all diagnostic items defined in all crates + /// Returns all diagnostic items defined in all crates. query all_diagnostic_items(_: CrateNum) -> &'tcx FxHashMap { eval_always desc { "calculating the diagnostic items map" } @@ -865,7 +864,7 @@ rustc_queries! { desc { "calculating the lang items defined in a crate" } } - /// Returns the diagnostic items defined in a crate + /// Returns the diagnostic items defined in a crate. query diagnostic_items(_: CrateNum) -> &'tcx FxHashMap { desc { "calculating the diagnostic items map in a crate" } } diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 296c6ad19c1cf..c74b2fee41d6c 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1,36 +1,36 @@ //! Contains infrastructure for configuring the compiler, including parsing -//! command line options. - -use std::str::FromStr; +//! command-line options. +use crate::lint; +use crate::middle::cstore; use crate::session::{early_error, early_warn, Session}; use crate::session::search_paths::SearchPath; +use rustc_data_structures::fx::FxHashSet; + use rustc_target::spec::{LinkerFlavor, MergeFunctions, PanicStrategy, RelroLevel}; use rustc_target::spec::{Target, TargetTriple}; -use crate::lint; -use crate::middle::cstore; use syntax; use syntax::ast::{self, IntTy, UintTy, MetaItemKind}; use syntax::source_map::{FileName, FilePathMapping}; use syntax::edition::{Edition, EDITION_NAME_LIST, DEFAULT_EDITION}; +use syntax::parse::{ParseSess, new_parser_from_source_str}; use syntax::parse::token; -use syntax::parse; use syntax::symbol::{sym, Symbol}; use syntax::feature_gate::UnstableFeatures; -use errors::emitter::HumanReadableErrorType; +use errors::emitter::HumanReadableErrorType; use errors::{ColorConfig, FatalError, Handler}; use getopts; -use std::collections::{BTreeMap, BTreeSet}; -use std::collections::btree_map::Iter as BTreeMapIter; -use std::collections::btree_map::Keys as BTreeMapKeysIter; -use std::collections::btree_map::Values as BTreeMapValuesIter; -use rustc_data_structures::fx::FxHashSet; -use std::{fmt, str}; +use std::collections::{BTreeMap, BTreeSet}; +use std::collections::btree_map::{ + Iter as BTreeMapIter, Keys as BTreeMapKeysIter, Values as BTreeMapValuesIter, +}; +use std::fmt; +use std::str::{self, FromStr}; use std::hash::Hasher; use std::collections::hash_map::DefaultHasher; use std::iter::FromIterator; @@ -241,14 +241,14 @@ pub enum ErrorOutputType { } impl Default for ErrorOutputType { - fn default() -> ErrorOutputType { - ErrorOutputType::HumanReadable(HumanReadableErrorType::Default(ColorConfig::Auto)) + fn default() -> Self { + Self::HumanReadable(HumanReadableErrorType::Default(ColorConfig::Auto)) } } -// Use tree-based collections to cheaply get a deterministic Hash implementation. -// DO NOT switch BTreeMap out for an unsorted container type! That would break -// dependency tracking for command-line arguments. +/// Use tree-based collections to cheaply get a deterministic `Hash` implementation. +/// *Do not* switch `BTreeMap` out for an unsorted container type! That would break +/// dependency tracking for command-line arguments. #[derive(Clone, Hash)] pub struct OutputTypes(BTreeMap>); @@ -281,7 +281,7 @@ impl OutputTypes { self.0.len() } - // True if any of the output types require codegen or linking. + // Returns `true` if any of the output types require codegen or linking. pub fn should_codegen(&self) -> bool { self.0.keys().any(|k| match *k { OutputType::Bitcode @@ -295,9 +295,9 @@ impl OutputTypes { } } -// Use tree-based collections to cheaply get a deterministic Hash implementation. -// DO NOT switch BTreeMap or BTreeSet out for an unsorted container type! That -// would break dependency tracking for command-line arguments. +/// Use tree-based collections to cheaply get a deterministic `Hash` implementation. +/// *Do not* switch `BTreeMap` or `BTreeSet` out for an unsorted container type! That +/// would break dependency tracking for command-line arguments. #[derive(Clone, Hash)] pub struct Externs(BTreeMap); @@ -327,7 +327,7 @@ macro_rules! hash_option { ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, [TRACKED]) => ({ if $sub_hashes.insert(stringify!($opt_name), $opt_expr as &dyn dep_tracking::DepTrackingHash).is_some() { - bug!("Duplicate key in CLI DepTrackingHash: {}", stringify!($opt_name)) + bug!("duplicate key in CLI DepTrackingHash: {}", stringify!($opt_name)) } }); } @@ -362,7 +362,7 @@ macro_rules! top_level_options { ); } -// The top-level command-line options struct +// The top-level command-line options struct. // // For each option, one has to specify how it behaves with regard to the // dependency tracking system of incremental compilation. This is done via the @@ -376,16 +376,16 @@ macro_rules! top_level_options { // Incremental compilation is not influenced by this option. // // If you add a new option to this struct or one of the sub-structs like -// CodegenOptions, think about how it influences incremental compilation. If in +// `CodegenOptions`, think about how it influences incremental compilation. If in // doubt, specify [TRACKED], which is always "correct" but might lead to // unnecessary re-compilation. top_level_options!( pub struct Options { // The crate config requested for the session, which may be combined - // with additional crate configurations during the compile process + // with additional crate configurations during the compile process. crate_types: Vec [TRACKED], optimize: OptLevel [TRACKED], - // Include the debug_assertions flag into dependency tracking, since it + // Include the `debug_assertions` flag in dependency tracking, since it // can influence whether overflow checks are done or not. debug_assertions: bool [TRACKED], debuginfo: DebugInfo [TRACKED], @@ -402,8 +402,8 @@ top_level_options!( test: bool [TRACKED], error_format: ErrorOutputType [UNTRACKED], - // if Some, enable incremental compilation, using the given - // directory to store intermediate results + // If `Some`, enable incremental compilation, using the given + // directory to store intermediate results. incremental: Option [UNTRACKED], debugging_opts: DebuggingOptions [TRACKED], @@ -418,7 +418,7 @@ top_level_options!( // written `extern crate name as std`. Defaults to `std`. Used by // out-of-tree drivers. alt_std_name: Option [TRACKED], - // Indicates how the compiler should treat unstable features + // Indicates how the compiler should treat unstable features. unstable_features: UnstableFeatures [TRACKED], // Indicates whether this run of the compiler is actually rustdoc. This @@ -434,12 +434,12 @@ top_level_options!( cli_forced_codegen_units: Option [UNTRACKED], cli_forced_thinlto_off: bool [UNTRACKED], - // Remap source path prefixes in all output (messages, object files, debug, etc) + // Remap source path prefixes in all output (messages, object files, debug, etc.). remap_path_prefix: Vec<(PathBuf, PathBuf)> [UNTRACKED], edition: Edition [TRACKED], - // Whether or not we're emitting JSON blobs about each artifact produced + // `true` if we're emitting JSON blobs about each artifact produced // by the compiler. json_artifact_notifications: bool [TRACKED], } @@ -468,7 +468,7 @@ pub enum BorrowckMode { } impl BorrowckMode { - /// Should we run the MIR-based borrow check, but also fall back + /// Returns whether we should run the MIR-based borrow check, but also fall back /// on the AST borrow check if the MIR-based one errors. pub fn migrate(self) -> bool { match self { @@ -477,7 +477,7 @@ impl BorrowckMode { } } - /// Should we emit the AST-based borrow checker errors? + /// Returns whether we should emit the AST-based borrow checker errors. pub fn use_ast(self) -> bool { match self { BorrowckMode::Mir => false, @@ -487,12 +487,13 @@ impl BorrowckMode { } pub enum Input { - /// Loads source from file + /// Load source code from a file. File(PathBuf), + /// Load source code from a string. Str { - /// String that is shown in place of a filename + /// A string that is shown in place of a filename. name: FileName, - /// Anonymous source string + /// An anonymous string containing the source code. input: String, }, } @@ -651,7 +652,7 @@ impl Options { FilePathMapping::new(self.remap_path_prefix.clone()) } - /// Returns `true` if there will be an output file generated + /// Returns `true` if there will be an output file generated. pub fn will_create_output_file(&self) -> bool { !self.debugging_opts.parse_only && // The file is just being parsed !self.debugging_opts.ls // The file is just being queried @@ -709,16 +710,14 @@ impl Passes { } } -/// Declare a macro that will define all CodegenOptions/DebuggingOptions fields and parsers all -/// at once. The goal of this macro is to define an interface that can be -/// programmatically used by the option parser in order to initialize the struct -/// without hardcoding field names all over the place. +/// Defines all `CodegenOptions`/`DebuggingOptions` fields and parsers all at once. The goal of this +/// macro is to define an interface that can be programmatically used by the option parser +/// to initialize the struct without hardcoding field names all over the place. /// -/// The goal is to invoke this macro once with the correct fields, and then this -/// macro generates all necessary code. The main gotcha of this macro is the -/// cgsetters module which is a bunch of generated code to parse an option into -/// its respective field in the struct. There are a few hand-written parsers for -/// parsing specific types of values in this module. +/// The goal is to invoke this macro once with the correct fields, and then this macro generates all +/// necessary code. The main gotcha of this macro is the `cgsetters` module which is a bunch of +/// generated code to parse an option into its respective field in the struct. There are a few +/// hand-written parsers for parsing specific types of values in this module. macro_rules! options { ($struct_name:ident, $setter_name:ident, $defaultfn:ident, $buildfn:ident, $prefix:expr, $outputname:expr, @@ -1539,7 +1538,7 @@ pub fn default_configuration(sess: &Session) -> ast::CrateConfig { ret } -/// Converts the crate cfg! configuration from String to Symbol. +/// Converts the crate `cfg!` configuration from `String` to `Symbol`. /// `rustc_interface::interface::Config` accepts this in the compiler configuration, /// but the symbol interner is not yet set up then, so we must convert it later. pub fn to_crate_config(cfg: FxHashSet<(String, Option)>) -> ast::CrateConfig { @@ -1550,9 +1549,9 @@ pub fn to_crate_config(cfg: FxHashSet<(String, Option)>) -> ast::CrateCo pub fn build_configuration(sess: &Session, mut user_cfg: ast::CrateConfig) -> ast::CrateConfig { // Combine the configuration requested by the session (command line) with - // some default and generated configuration items + // some default and generated configuration items. let default_cfg = default_configuration(sess); - // If the user wants a test runner, then add the test cfg + // If the user wants a test runner, then add the test cfg. if sess.opts.test { user_cfg.insert((sym::test, None)); } @@ -1851,13 +1850,13 @@ pub fn rustc_optgroups() -> Vec { opts } -// Convert strings provided as --cfg [cfgspec] into a crate_cfg +// Converts strings provided as `--cfg [cfgspec]` into a `crate_cfg`. pub fn parse_cfgspecs(cfgspecs: Vec) -> FxHashSet<(String, Option)> { syntax::with_default_globals(move || { let cfg = cfgspecs.into_iter().map(|s| { - let sess = parse::ParseSess::new(FilePathMapping::empty()); + let sess = ParseSess::new(FilePathMapping::empty()); let filename = FileName::cfg_spec_source_code(&s); - let mut parser = parse::new_parser_from_source_str(&sess, filename, s.to_string()); + let mut parser = new_parser_from_source_str(&sess, filename, s.to_string()); macro_rules! error {($reason: expr) => { early_error(ErrorOutputType::default(), @@ -1917,7 +1916,7 @@ pub fn get_cmd_lint_options(matches: &getopts::Matches, (lint_opts, describe_lints, lint_cap) } -/// Parse the `--color` flag +/// Parses the `--color` flag. pub fn parse_color(matches: &getopts::Matches) -> ColorConfig { match matches.opt_str("color").as_ref().map(|s| &s[..]) { Some("auto") => ColorConfig::Auto, @@ -1929,7 +1928,7 @@ pub fn parse_color(matches: &getopts::Matches) -> ColorConfig { Some(arg) => early_error( ErrorOutputType::default(), &format!( - "argument for --color must be auto, \ + "argument for `--color` must be auto, \ always or never (instead was `{}`)", arg ), @@ -1974,16 +1973,16 @@ pub fn parse_json(matches: &getopts::Matches) -> (HumanReadableErrorType, bool) (json_rendered(json_color), json_artifact_notifications) } -/// Parse the `--error-format` flag +/// Parses the `--error-format` flag. pub fn parse_error_format( matches: &getopts::Matches, color: ColorConfig, json_rendered: HumanReadableErrorType, ) -> ErrorOutputType { - // We need the opts_present check because the driver will send us Matches + // We need the `opts_present` check because the driver will send us Matches // with only stable options if no unstable options are used. Since error-format - // is unstable, it will not be present. We have to use opts_present not - // opt_present because the latter will panic. + // is unstable, it will not be present. We have to use `opts_present` not + // `opt_present` because the latter will panic. let error_format = if matches.opts_present(&["error-format".to_owned()]) { match matches.opt_str("error-format").as_ref().map(|s| &s[..]) { None | @@ -2116,7 +2115,7 @@ pub fn build_session_options_and_crate_config( let mut codegen_units = cg.codegen_units; let mut disable_thinlto = false; - // Issue #30063: if user requests llvm-related output to one + // Issue #30063: if user requests LLVM-related output to one // particular path, disable codegen-units. let incompatible: Vec<_> = output_types .iter() @@ -2414,10 +2413,10 @@ pub fn build_session_options_and_crate_config( ) } - // We start out with a Vec<(Option, bool)>>, - // and later convert it into a BTreeSet<(Option, bool)> + // We start out with a `Vec<(Option, bool)>>`, + // and later convert it into a `BTreeSet<(Option, bool)>` // This allows to modify entries in-place to set their correct - // 'public' value + // 'public' value. let mut externs: BTreeMap = BTreeMap::new(); for (arg, private) in matches.opt_strs("extern").into_iter().map(|v| (v, false)) .chain(matches.opt_strs("extern-private").into_iter().map(|v| (v, true))) { @@ -2616,15 +2615,15 @@ impl fmt::Display for CrateType { /// The values of all command-line arguments that are relevant for dependency /// tracking are hashed into a single value that determines whether the /// incremental compilation cache can be re-used or not. This hashing is done -/// via the DepTrackingHash trait defined below, since the standard Hash -/// implementation might not be suitable (e.g., arguments are stored in a Vec, +/// via the `DepTrackingHash` trait defined below, since the standard `Hash` +/// implementation might not be suitable (e.g., arguments are stored in a `Vec`, /// the hash of which is order dependent, but we might not want the order of /// arguments to make a difference for the hash). /// -/// However, since the value provided by Hash::hash often *is* suitable, +/// However, since the value provided by `Hash::hash` often *is* suitable, /// especially for primitive types, there is the -/// impl_dep_tracking_hash_via_hash!() macro that allows to simply reuse the -/// Hash implementation for DepTrackingHash. It's important though that +/// `impl_dep_tracking_hash_via_hash!()` macro that allows to simply reuse the +/// `Hash` implementation for `DepTrackingHash`. It's important though that /// 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 { @@ -2637,9 +2636,9 @@ mod dep_tracking { use super::{CrateType, DebugInfo, ErrorOutputType, OptLevel, OutputTypes, Passes, Sanitizer, LtoCli, LinkerPluginLto, SwitchWithOptPath, SymbolManglingVersion}; - use syntax::feature_gate::UnstableFeatures; use rustc_target::spec::{MergeFunctions, PanicStrategy, RelroLevel, TargetTriple}; use syntax::edition::Edition; + use syntax::feature_gate::UnstableFeatures; pub trait DepTrackingHash { fn hash(&self, hasher: &mut DefaultHasher, error_format: ErrorOutputType); diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index f01883d9634cd..8656ebb2e6d72 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -79,12 +79,12 @@ pub struct Session { /// if the value stored here has been affected by path remapping. pub working_dir: (PathBuf, bool), - // FIXME: lint_store and buffered_lints are not thread-safe, - // but are only used in a single thread + // FIXME: `lint_store` and `buffered_lints` are not thread-safe, + // but are only used in a single thread. pub lint_store: RwLock, pub buffered_lints: Lock>, - /// Set of (DiagnosticId, Option, message) tuples tracking + /// Set of `(DiagnosticId, Option, message)` tuples tracking /// (sub)diagnostics that have been set once, but should not be set again, /// in order to avoid redundantly verbose output (Issue #24690, #44953). pub one_time_diagnostics: Lock, String)>>, @@ -92,11 +92,11 @@ pub struct Session { pub plugin_attributes: Lock>, pub crate_types: Once>, pub dependency_formats: Once, - /// The crate_disambiguator is constructed out of all the `-C metadata` + /// The `crate_disambiguator` is constructed out of all the `-C metadata` /// arguments passed to the compiler. Its value together with the crate-name /// forms a unique global identifier for the crate. It is used to allow /// multiple crates with the same name to coexist. See the - /// rustc_codegen_llvm::back::symbol_names module for more information. + /// `rustc_codegen_llvm::back::symbol_names` module for more information. pub crate_disambiguator: Once, features: Once, @@ -111,7 +111,7 @@ pub struct Session { /// The maximum number of stackframes allowed in const eval. pub const_eval_stack_frame_limit: usize, - /// The metadata::creader module may inject an allocator/panic_runtime + /// The `metadata::creader` module may inject an allocator/`panic_runtime` /// dependency if it didn't already find one, and this tracks what was /// injected. pub allocator_kind: Once>, @@ -130,7 +130,7 @@ pub struct Session { /// Used by `-Z profile-queries` in `util::common`. pub profile_channel: Lock>>, - /// Used by -Z self-profile + /// Used by `-Z self-profile`. pub self_profiling: Option>, /// Some measurements that are being gathered during compilation. @@ -187,16 +187,16 @@ pub struct PerfStats { pub normalize_projection_ty: AtomicUsize, } -/// Enum to support dispatch of one-time diagnostics (in Session.diag_once) +/// Enum to support dispatch of one-time diagnostics (in `Session.diag_once`). enum DiagnosticBuilderMethod { Note, SpanNote, SpanSuggestion(String), // suggestion - // add more variants as needed to support one-time diagnostics + // Add more variants as needed to support one-time diagnostics. } -/// Diagnostic message ID—used by `Session.one_time_diagnostics` to avoid -/// emitting the same message more than once +/// Diagnostic message ID, used by `Session.one_time_diagnostics` to avoid +/// emitting the same message more than once. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum DiagnosticMessageId { ErrorId(u16), // EXXXX error code as integer @@ -408,7 +408,7 @@ impl Session { Some(next) => { self.next_node_id.set(ast::NodeId::from_usize(next)); } - None => bug!("Input too large, ran out of node ids!"), + None => bug!("input too large; ran out of node-IDs!"), } id @@ -440,11 +440,11 @@ impl Session { diag_builder.note(message); } DiagnosticBuilderMethod::SpanNote => { - let span = span_maybe.expect("span_note needs a span"); + let span = span_maybe.expect("`span_note` needs a span"); diag_builder.span_note(span, message); } DiagnosticBuilderMethod::SpanSuggestion(suggestion) => { - let span = span_maybe.expect("span_suggestion_* needs a span"); + let span = span_maybe.expect("`span_suggestion_*` needs a span"); diag_builder.span_suggestion( span, message, @@ -688,7 +688,7 @@ impl Session { pub fn must_not_eliminate_frame_pointers(&self) -> bool { // "mcount" function relies on stack pointer. - // See https://sourceware.org/binutils/docs/gprof/Implementation.html + // See . if self.instrument_mcount() { true } else if let Some(x) = self.opts.cg.force_frame_pointers { @@ -699,7 +699,7 @@ impl Session { } /// Returns the symbol name for the registrar function, - /// given the crate Svh and the function DefIndex. + /// given the crate `Svh` and the function `DefIndex`. pub fn generate_plugin_registrar_symbol(&self, disambiguator: CrateDisambiguator) -> String { format!( "__rustc_plugin_registrar_{}__", @@ -719,7 +719,7 @@ impl Session { &self.sysroot, self.opts.target_triple.triple(), &self.opts.search_paths, - // target_tlib_path==None means it's the same as host_tlib_path. + // `target_tlib_path == None` means it's the same as `host_tlib_path`. self.target_tlib_path.as_ref().unwrap_or(&self.host_tlib_path), kind, ) @@ -779,12 +779,12 @@ impl Session { if let IncrCompSession::Active { .. } = *incr_comp_session { } else { bug!( - "Trying to finalize IncrCompSession `{:?}`", + "trying to finalize `IncrCompSession` `{:?}`", *incr_comp_session - ) + ); } - // Note: This will also drop the lock file, thus unlocking the directory + // Note: this will also drop the lock file, thus unlocking the directory. *incr_comp_session = IncrCompSession::Finalized { session_directory: new_directory_path, }; @@ -800,13 +800,15 @@ impl Session { } => session_directory.clone(), IncrCompSession::InvalidBecauseOfErrors { .. } => return, _ => bug!( - "Trying to invalidate IncrCompSession `{:?}`", + "trying to invalidate `IncrCompSession` `{:?}`", *incr_comp_session ), }; - // Note: This will also drop the lock file, thus unlocking the directory - *incr_comp_session = IncrCompSession::InvalidBecauseOfErrors { session_directory }; + // Note: this will also drop the lock file, thus unlocking the directory. + *incr_comp_session = IncrCompSession::InvalidBecauseOfErrors { + session_directory, + }; } pub fn incr_comp_session_dir(&self) -> cell::Ref<'_, PathBuf> { @@ -815,8 +817,8 @@ impl Session { incr_comp_session, |incr_comp_session| match *incr_comp_session { IncrCompSession::NotInitialized => bug!( - "Trying to get session directory from IncrCompSession `{:?}`", - *incr_comp_session + "trying to get session directory from `IncrCompSession`: {:?}", + *incr_comp_session, ), IncrCompSession::Active { ref session_directory, @@ -1185,7 +1187,10 @@ fn build_session_( ); let target_cfg = config::build_target_config(&sopts, &span_diagnostic); - let p_s = parse::ParseSess::with_span_handler(span_diagnostic, source_map); + let parse_sess = parse::ParseSess::with_span_handler( + span_diagnostic, + source_map, + ); let sysroot = match &sopts.maybe_sysroot { Some(sysroot) => sysroot.clone(), None => filesearch::get_or_default_sysroot(), @@ -1214,7 +1219,7 @@ fn build_session_( let print_fuel = AtomicU64::new(0); let working_dir = env::current_dir().unwrap_or_else(|e| - p_s.span_diagnostic + parse_sess.span_diagnostic .fatal(&format!("Current directory is invalid: {}", e)) .raise() ); @@ -1232,7 +1237,7 @@ fn build_session_( opts: sopts, host_tlib_path, target_tlib_path, - parse_sess: p_s, + parse_sess, sysroot, local_crate_source_file, working_dir, diff --git a/src/librustc/traits/object_safety.rs b/src/librustc/traits/object_safety.rs index c759981b8e8c9..a7990c4af69fd 100644 --- a/src/librustc/traits/object_safety.rs +++ b/src/librustc/traits/object_safety.rs @@ -130,13 +130,13 @@ impl<'tcx> TyCtxt<'tcx> { } /// We say a method is *vtable safe* if it can be invoked on a trait - /// object. Note that object-safe traits can have some - /// non-vtable-safe methods, so long as they require `Self:Sized` or - /// otherwise ensure that they cannot be used when `Self=Trait`. + /// object. Note that object-safe traits can have some + /// non-vtable-safe methods, so long as they require `Self: Sized` or + /// otherwise ensure that they cannot be used when `Self = Trait`. pub fn is_vtable_safe_method(self, trait_def_id: DefId, method: &ty::AssocItem) -> bool { debug_assert!(self.generics_of(trait_def_id).has_self); debug!("is_vtable_safe_method({:?}, {:?})", trait_def_id, method); - // Any method that has a `Self : Sized` requisite can't be called. + // Any method that has a `Self: Sized` bound cannot be called. if self.generics_require_sized_self(method.def_id) { return false; } @@ -350,15 +350,15 @@ impl<'tcx> TyCtxt<'tcx> { &sig.map_bound(|sig| sig.inputs()[0]), ); - // until `unsized_locals` is fully implemented, `self: Self` can't be dispatched on. + // Until `unsized_locals` is fully implemented, `self: Self` can't be dispatched on. // However, this is already considered object-safe. We allow it as a special case here. // FIXME(mikeyhew) get rid of this `if` statement once `receiver_is_dispatchable` allows - // `Receiver: Unsize dyn Trait]>` + // `Receiver: Unsize dyn Trait]>`. if receiver_ty != self.types.self_param { if !self.receiver_is_dispatchable(method, receiver_ty) { return Some(MethodViolationCode::UndispatchableReceiver); } else { - // sanity check to make sure the receiver actually has the layout of a pointer + // Do sanity check to make sure the receiver actually has the layout of a pointer. use crate::ty::layout::Abi; @@ -373,7 +373,7 @@ impl<'tcx> TyCtxt<'tcx> { } }; - // e.g., Rc<()> + // e.g., `Rc<()>` let unit_receiver_ty = self.receiver_for_self_ty( receiver_ty, self.mk_unit(), method.def_id ); @@ -395,7 +395,7 @@ impl<'tcx> TyCtxt<'tcx> { trait_def_id, self.mk_region(ty::ReStatic) ); - // e.g., Rc + // e.g., `Rc` let trait_object_receiver = self.receiver_for_self_ty( receiver_ty, trait_object_ty, method.def_id ); @@ -419,8 +419,8 @@ impl<'tcx> TyCtxt<'tcx> { None } - /// Performs a type substitution to produce the version of receiver_ty when `Self = self_ty` - /// e.g., for receiver_ty = `Rc` and self_ty = `Foo`, returns `Rc`. + /// Performs a type substitution to produce the version of `receiver_ty` when `Self = self_ty`. + /// For example, for `receiver_ty = Rc` and `self_ty = Foo`, returns `Rc`. fn receiver_for_self_ty( self, receiver_ty: Ty<'tcx>, diff --git a/src/librustc/traits/query/evaluate_obligation.rs b/src/librustc/traits/query/evaluate_obligation.rs index 2ee63647aaded..b9557ceaa6d9f 100644 --- a/src/librustc/traits/query/evaluate_obligation.rs +++ b/src/librustc/traits/query/evaluate_obligation.rs @@ -1,7 +1,8 @@ use crate::infer::InferCtxt; use crate::infer::canonical::OriginalQueryValues; -use crate::traits::{EvaluationResult, PredicateObligation, SelectionContext, - TraitQueryMode, OverflowError}; +use crate::traits::{ + EvaluationResult, PredicateObligation, SelectionContext, TraitQueryMode, OverflowError, +}; impl<'cx, 'tcx> InferCtxt<'cx, 'tcx> { /// Evaluates whether the predicate can be satisfied (by any means) diff --git a/src/librustc/traits/query/method_autoderef.rs b/src/librustc/traits/query/method_autoderef.rs index 6b9bdfd63f4d0..039dea1ffcd16 100644 --- a/src/librustc/traits/query/method_autoderef.rs +++ b/src/librustc/traits/query/method_autoderef.rs @@ -6,11 +6,11 @@ use crate::ty::Ty; pub struct CandidateStep<'tcx> { pub self_ty: Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>, pub autoderefs: usize, - // true if the type results from a dereference of a raw pointer. - // when assembling candidates, we include these steps, but not when - // picking methods. This so that if we have `foo: *const Foo` and `Foo` has methods - // `fn by_raw_ptr(self: *const Self)` and `fn by_ref(&self)`, then - // `foo.by_raw_ptr()` will work and `foo.by_ref()` won't. + /// `true` if the type results from a dereference of a raw pointer. + /// when assembling candidates, we include these steps, but not when + /// picking methods. This so that if we have `foo: *const Foo` and `Foo` has methods + /// `fn by_raw_ptr(self: *const Self)` and `fn by_ref(&self)`, then + /// `foo.by_raw_ptr()` will work and `foo.by_ref()` won't. pub from_unsafe_deref: bool, pub unsize: bool, } diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs index 07d6f633143a2..3d36790c94b8c 100644 --- a/src/librustc/traits/util.rs +++ b/src/librustc/traits/util.rs @@ -512,7 +512,7 @@ pub fn impl_trait_ref_and_oblig<'a, 'tcx>( (impl_trait_ref, impl_obligations) } -/// See `super::obligations_for_generics` +/// See [`super::obligations_for_generics`]. pub fn predicates_for_generics<'tcx>(cause: ObligationCause<'tcx>, recursion_depth: usize, param_env: ty::ParamEnv<'tcx>, @@ -562,7 +562,7 @@ impl<'tcx> TyCtxt<'tcx> { predicate_for_trait_ref(cause, param_env, trait_ref, recursion_depth) } - /// Cast a trait reference into a reference to one of its super + /// Casts a trait reference into a reference to one of its super /// traits; returns `None` if `target_trait_def_id` is not a /// supertrait. pub fn upcast_choices(self, @@ -571,7 +571,7 @@ impl<'tcx> TyCtxt<'tcx> { -> Vec> { if source_trait_ref.def_id() == target_trait_def_id { - return vec![source_trait_ref]; // shorcut the most common case + return vec![source_trait_ref]; // Shortcut the most common case. } supertraits(self, source_trait_ref) diff --git a/src/librustc/ty/codec.rs b/src/librustc/ty/codec.rs index 1ddc6780aca89..1aa21501129c8 100644 --- a/src/librustc/ty/codec.rs +++ b/src/librustc/ty/codec.rs @@ -284,9 +284,11 @@ where #[macro_export] macro_rules! __impl_decoder_methods { ($($name:ident -> $ty:ty;)*) => { - $(fn $name(&mut self) -> Result<$ty, Self::Error> { - self.opaque.$name() - })* + $( + fn $name(&mut self) -> Result<$ty, Self::Error> { + self.opaque.$name() + } + )* } } @@ -327,14 +329,17 @@ macro_rules! impl_arena_allocatable_decoders { macro_rules! implement_ty_decoder { ($DecoderName:ident <$($typaram:tt),*>) => { mod __ty_decoder_impl { - use super::$DecoderName; + use std::borrow::Cow; + + use rustc_serialize::{Decoder, SpecializedDecoder}; + use $crate::infer::canonical::CanonicalVarInfos; use $crate::ty; use $crate::ty::codec::*; use $crate::ty::subst::SubstsRef; use $crate::hir::def_id::{CrateNum}; - use rustc_serialize::{Decoder, SpecializedDecoder}; - use std::borrow::Cow; + + use super::$DecoderName; impl<$($typaram ),*> Decoder for $DecoderName<$($typaram),*> { type Error = String; @@ -368,8 +373,8 @@ macro_rules! implement_ty_decoder { } } - // FIXME(#36588) These impls are horribly unsound as they allow - // the caller to pick any lifetime for 'tcx, including 'static, + // FIXME(#36588): These impls are horribly unsound as they allow + // the caller to pick any lifetime for `'tcx`, including `'static`, // by using the unspecialized proxies to them. arena_types!(impl_arena_allocatable_decoders, [$DecoderName [$($typaram),*]], 'tcx); diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 17c9e520bcea2..8e8472a5aacc9 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -7,7 +7,7 @@ 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::{self, TraitCandidate, HirId, ItemKind, ItemLocalId, Node}; use crate::hir::def::{Res, DefKind, Export}; use crate::hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE}; use crate::hir::map as hir_map; @@ -45,15 +45,16 @@ use crate::ty::CanonicalPolyFnSig; use crate::util::common::ErrorReported; use crate::util::nodemap::{DefIdMap, DefIdSet, ItemLocalMap, ItemLocalSet}; use crate::util::nodemap::{FxHashMap, FxHashSet}; + use errors::DiagnosticBuilder; -use smallvec::SmallVec; -use rustc_data_structures::stable_hasher::{HashStable, hash_stable_hashmap, - StableHasher, StableHasherResult, - StableVec}; use arena::SyncDroplessArena; +use smallvec::SmallVec; +use rustc_data_structures::stable_hasher::{ + HashStable, StableHasher, StableHasherResult, StableVec, hash_stable_hashmap, +}; use rustc_data_structures::indexed_vec::{Idx, IndexVec}; -use rustc_data_structures::sync::{Lrc, Lock, WorkerLocal}; use rustc_data_structures::sharded::ShardedHashMap; +use rustc_data_structures::sync::{Lrc, Lock, WorkerLocal}; use std::any::Any; use std::borrow::Borrow; use std::cmp::Ordering; @@ -74,8 +75,6 @@ use syntax::feature_gate; use syntax::symbol::{Symbol, InternedString, kw, sym}; use syntax_pos::Span; -use crate::hir; - pub struct AllArenas { pub interner: SyncDroplessArena, } @@ -91,10 +90,10 @@ impl AllArenas { type InternedSet<'tcx, T> = ShardedHashMap, ()>; pub struct CtxtInterners<'tcx> { - /// The arena that types, regions, etc are allocated from + /// The arena that types, regions, etc. are allocated from. arena: &'tcx SyncDroplessArena, - /// Specifically use a speedy hash algorithm for these hash sets, + /// Specifically use a speedy hash algorithm for these hash sets, since /// they're accessed quite often. type_: InternedSet<'tcx, TyS<'tcx>>, type_list: InternedSet<'tcx, List>>, @@ -129,7 +128,7 @@ impl<'tcx> CtxtInterners<'tcx> { } } - /// Intern a type + /// Interns a type. #[allow(rustc::usage_of_ty_tykind)] #[inline(never)] fn intern_ty(&self, @@ -144,7 +143,6 @@ impl<'tcx> CtxtInterners<'tcx> { outer_exclusive_binder: flags.outer_exclusive_binder, }; - Interned(self.arena.alloc(ty_struct)) }).0 } @@ -1025,7 +1023,7 @@ pub struct GlobalCtxt<'tcx> { hir_map: hir_map::Map<'tcx>, - /// A map from DefPathHash -> DefId. Includes DefIds from the local crate + /// A map from `DefPathHash` -> `DefId`. Includes `DefId`s from the local crate /// as well as all upstream crates. Only populated in incremental mode. pub def_path_hash_to_def_id: Option>, @@ -1124,9 +1122,9 @@ impl<'tcx> TyCtxt<'tcx> { }) } - /// Allocates a byte or string literal for `mir::interpret`, read-only + /// Allocates a read-only byte or string literal for `mir::interpret`. pub fn allocate_bytes(self, bytes: &[u8]) -> interpret::AllocId { - // create an allocation that just contains these bytes + // Create an allocation that just contains these bytes. let alloc = interpret::Allocation::from_byte_aligned_bytes(bytes); let alloc = self.intern_const_alloc(alloc); self.alloc_map.lock().create_memory_alloc(alloc) @@ -1346,7 +1344,7 @@ impl<'tcx> TyCtxt<'tcx> { } /// Converts a `DefId` into its fully expanded `DefPath` (every - /// `DefId` is really just an interned def-path). + /// `DefId` is really just an interned `DefPath`). /// /// Note that if `id` is not local to this crate, the result will /// be a non-local `DefPath`. @@ -1402,6 +1400,10 @@ impl<'tcx> TyCtxt<'tcx> { self.cstore.metadata_encoding_version().to_vec() } + pub fn encode_metadata(self)-> EncodedMetadata { + self.cstore.encode_metadata(self) + } + // Note that this is *untracked* and should only be used within the query // system if the result is otherwise tracked through queries pub fn crate_data_as_rc_any(self, cnum: CrateNum) -> Lrc { @@ -1446,25 +1448,25 @@ impl<'tcx> TyCtxt<'tcx> { self.queries.on_disk_cache.serialize(self.global_tcx(), encoder) } - /// If true, we should use the AST-based borrowck (we may *also* use + /// If `true`, we should use the AST-based borrowck (we may *also* use /// the MIR-based borrowck). pub fn use_ast_borrowck(self) -> bool { self.borrowck_mode().use_ast() } - /// If true, we should use the MIR-based borrow check, but also - /// fall back on the AST borrow check if the MIR-based one errors. + /// If `true`, we should use the MIR-based borrowck, but also + /// fall back on the AST borrowck if the MIR-based one errors. pub fn migrate_borrowck(self) -> bool { self.borrowck_mode().migrate() } - /// If true, make MIR codegen for `match` emit a temp that holds a + /// If `true`, make MIR codegen for `match` emit a temp that holds a /// borrow of the input to the match expression. pub fn generate_borrow_of_any_match_input(&self) -> bool { self.emit_read_for_match() } - /// If true, make MIR codegen for `match` emit FakeRead + /// If `true`, make MIR codegen for `match` emit FakeRead /// statements (which simulate the maximal effect of executing the /// patterns in a match arm). pub fn emit_read_for_match(&self) -> bool { @@ -1517,7 +1519,7 @@ impl<'tcx> TyCtxt<'tcx> { }) } - // This method returns the DefId and the BoundRegion corresponding to the given region. + // Returns the `DefId` and the `BoundRegion` corresponding to the given region. pub fn is_suitable_region(&self, region: Region<'tcx>) -> Option { let (suitable_region_binding_scope, bound_region) = match *region { ty::ReFree(ref free_region) => (free_region.scope, free_region.bound_region), @@ -1550,18 +1552,18 @@ impl<'tcx> TyCtxt<'tcx> { &self, scope_def_id: DefId, ) -> Option> { - // HACK: `type_of_def_id()` will fail on these (#55796), so return None + // HACK: `type_of_def_id()` will fail on these (#55796), so return `None`. let hir_id = self.hir().as_local_hir_id(scope_def_id).unwrap(); match self.hir().get(hir_id) { Node::Item(item) => { match item.node { - ItemKind::Fn(..) => { /* type_of_def_id() will work */ } + ItemKind::Fn(..) => { /* `type_of_def_id()` will work */ } _ => { return None; } } } - _ => { /* type_of_def_id() will work or panic */ } + _ => { /* `type_of_def_id()` will work or panic */ } } let ret_ty = self.type_of(scope_def_id); @@ -1579,7 +1581,7 @@ impl<'tcx> TyCtxt<'tcx> { } } - // Here we check if the bound region is in Impl Item. + // Checks if the bound region is in Impl Item. pub fn is_bound_region_in_impl_item( &self, suitable_region_binding_scope: DefId, @@ -1599,23 +1601,15 @@ impl<'tcx> TyCtxt<'tcx> { false } - /// Determine whether identifiers in the assembly have strict naming rules. + /// Determines whether identifiers in the assembly have strict naming rules. /// Currently, only NVPTX* targets need it. pub fn has_strict_asm_symbol_naming(&self) -> bool { - self.gcx.sess.target.target.arch.contains("nvptx") - } -} - -impl<'tcx> TyCtxt<'tcx> { - pub fn encode_metadata(self) - -> EncodedMetadata - { - self.cstore.encode_metadata(self) + self.sess.target.target.arch.contains("nvptx") } } impl<'tcx> GlobalCtxt<'tcx> { - /// Call the closure with a local `TyCtxt` using the given arena. + /// Calls the closure with a local `TyCtxt` using the given arena. /// `interners` is a slot passed so we can create a CtxtInterners /// with the same lifetime as `arena`. pub fn enter_local(&'tcx self, f: F) -> R @@ -1651,7 +1645,7 @@ impl<'tcx> GlobalCtxt<'tcx> { /// It would be more efficient if `TypedArena` provided a way to /// determine whether the address is in the allocated range. /// -/// None is returned if the value or one of the components is not part +/// `None` is returned if the value or one of the components is not part /// of the provided context. /// For `Ty`, `None` can be returned if either the type interner doesn't /// contain the `TyKind` key or if the address of the interned @@ -1662,7 +1656,6 @@ pub trait Lift<'tcx>: fmt::Debug { fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option; } - macro_rules! nop_lift { ($ty:ty => $lifted:ty) => { impl<'a, 'tcx> Lift<'tcx> for $ty { @@ -1709,7 +1702,7 @@ nop_list_lift!{Predicate<'a> => Predicate<'tcx>} nop_list_lift!{CanonicalVarInfo => CanonicalVarInfo} nop_list_lift!{ProjectionKind => ProjectionKind} -// this is the impl for `&'a InternalSubsts<'a>` +// This is the impl for `&'a InternalSubsts<'a>`. nop_list_lift!{Kind<'a> => Kind<'tcx>} pub mod tls { @@ -1732,43 +1725,43 @@ pub mod tls { 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 - /// executing a new query. Whenever there's a TyCtxt value available - /// you should also have access to an ImplicitCtxt through the functions + /// `TyCtxt` and query. It is updated when creating a local interner or + /// executing a new query. Whenever there's a `TyCtxt` value available + /// you should also have access to an `ImplicitCtxt` through the functions /// in this module. #[derive(Clone)] pub struct ImplicitCtxt<'a, 'tcx> { - /// The current TyCtxt. Initially created by `enter_global` and updated - /// by `enter_local` with a new local interner + /// The current `TyCtxt`. Initially created by `enter_global` and updated + /// by `enter_local` with a new local interner. pub tcx: TyCtxt<'tcx>, - /// The current query job, if any. This is updated by JobOwner::start in - /// ty::query::plumbing when executing a query + /// The current query job, if any. This is updated by `JobOwner::start` in + /// `ty::query::plumbing` when executing a query. pub query: Option>>, /// Where to store diagnostics for the current query job, if any. - /// This is updated by JobOwner::start in ty::query::plumbing when executing a query + /// This is updated by `JobOwner::start` in `ty::query::plumbing` when executing a query. pub diagnostics: Option<&'a Lock>>, /// Used to prevent layout from recursing too deeply. pub layout_depth: usize, /// The current dep graph task. This is used to add dependencies to queries - /// when executing them + /// when executing them. pub task_deps: Option<&'a Lock>, } - /// Sets Rayon's thread local variable which is preserved for Rayon jobs + /// Sets Rayon's thread-local variable, which is preserved for Rayon jobs /// to `value` during the call to `f`. It is restored to its previous value after. - /// This is used to set the pointer to the new ImplicitCtxt. + /// This is used to set the pointer to the new `ImplicitCtxt`. #[cfg(parallel_compiler)] #[inline] fn set_tlv R, R>(value: usize, f: F) -> R { rayon_core::tlv::with(value, f) } - /// Gets Rayon's thread local variable which is preserved for Rayon jobs. - /// This is used to get the pointer to the current ImplicitCtxt. + /// Gets Rayon's thread-local variable, which is preserved for Rayon jobs. + /// This is used to get the pointer to the current `ImplicitCtxt`. #[cfg(parallel_compiler)] #[inline] fn get_tlv() -> usize { @@ -1777,13 +1770,13 @@ pub mod tls { #[cfg(not(parallel_compiler))] thread_local! { - /// A thread local variable which stores a pointer to the current ImplicitCtxt. + /// A thread local variable that stores a pointer to the current `ImplicitCtxt`. static TLV: Cell = Cell::new(0); } /// Sets TLV to `value` during the call to `f`. /// It is restored to its previous value after. - /// This is used to set the pointer to the new ImplicitCtxt. + /// This is used to set the pointer to the new `ImplicitCtxt`. #[cfg(not(parallel_compiler))] #[inline] fn set_tlv R, R>(value: usize, f: F) -> R { @@ -1793,14 +1786,14 @@ pub mod tls { f() } - /// This is used to get the pointer to the current ImplicitCtxt. + /// Gets the pointer to the current `ImplicitCtxt`. #[cfg(not(parallel_compiler))] fn get_tlv() -> usize { TLV.with(|tlv| tlv.get()) } /// This is a callback from libsyntax as it cannot access the implicit state - /// in librustc otherwise + /// in librustc otherwise. fn span_debug(span: syntax_pos::Span, f: &mut fmt::Formatter<'_>) -> fmt::Result { with_opt(|tcx| { if let Some(tcx) = tcx { @@ -1825,7 +1818,7 @@ pub mod tls { }) } - /// Sets up the callbacks from libsyntax on the current thread + /// Sets up the callbacks from libsyntax on the current thread. pub fn with_thread_locals(f: F) -> R where F: FnOnce() -> R { @@ -1850,7 +1843,7 @@ pub mod tls { }) } - /// Sets `context` as the new current ImplicitCtxt for the duration of the function `f` + /// Sets `context` as the new current `ImplicitCtxt` for the duration of the function `f`. #[inline] pub fn enter_context<'a, 'tcx, F, R>(context: &ImplicitCtxt<'a, 'tcx>, f: F) -> R where @@ -1861,19 +1854,19 @@ pub mod tls { }) } - /// Enters GlobalCtxt by setting up libsyntax callbacks and - /// creating a initial TyCtxt and ImplicitCtxt. - /// This happens once per rustc session and TyCtxts only exists + /// Enters `GlobalCtxt` by setting up libsyntax callbacks and + /// creating a initial `TyCtxt` and `ImplicitCtxt`. + /// This happens once per rustc session and `TyCtxt`s only exists /// inside the `f` function. pub fn enter_global<'tcx, F, R>(gcx: &'tcx GlobalCtxt<'tcx>, f: F) -> R where F: FnOnce(TyCtxt<'tcx>) -> R, { - // Update GCX_PTR to indicate there's a GlobalCtxt available + // Update `GCX_PTR` to indicate there's a `GlobalCtxt` available. GCX_PTR.with(|lock| { *lock.lock() = gcx as *const _ as usize; }); - // Set GCX_PTR back to 0 when we exit + // Set `GCX_PTR` back to 0 when we exit. let _on_drop = OnDrop(move || { GCX_PTR.with(|lock| *lock.lock() = 0); }); @@ -1894,12 +1887,12 @@ pub mod tls { } scoped_thread_local! { - /// Stores a pointer to the GlobalCtxt if one is available. - /// This is used to access the GlobalCtxt in the deadlock handler given to Rayon. + /// Stores a pointer to the `GlobalCtxt` if one is available. + /// This is used to access the `GlobalCtxt` in the deadlock handler given to Rayon. pub static GCX_PTR: Lock } - /// Creates a TyCtxt and ImplicitCtxt based on the GCX_PTR thread local. + /// Creates a `TyCtxt` and `ImplicitCtxt` based on the `GCX_PTR` thread local. /// This is used in the deadlock handler. pub unsafe fn with_global(f: F) -> R where @@ -1921,7 +1914,7 @@ pub mod tls { enter_context(&icx, |_| f(tcx)) } - /// Allows access to the current ImplicitCtxt in a closure if one is available + /// Allows access to the current `ImplicitCtxt` in a closure if one is available. #[inline] pub fn with_context_opt(f: F) -> R where @@ -1931,16 +1924,16 @@ pub mod tls { if context == 0 { f(None) } else { - // We could get a ImplicitCtxt pointer from another thread. - // Ensure that ImplicitCtxt is Sync + // We could get a `ImplicitCtxt` pointer from another thread. + // Ensure that `ImplicitCtxt` is `Sync`. sync::assert_sync::>(); unsafe { f(Some(&*(context as *const ImplicitCtxt<'_, '_>))) } } } - /// Allows access to the current ImplicitCtxt. - /// Panics if there is no ImplicitCtxt available + /// Allows access to the current `ImplicitCtxt`. + /// Panics if there is no `ImplicitCtxt` available. #[inline] pub fn with_context(f: F) -> R where @@ -1949,11 +1942,11 @@ pub mod tls { with_context_opt(|opt_context| f(opt_context.expect("no ImplicitCtxt stored in tls"))) } - /// Allows access to the current ImplicitCtxt whose tcx field has the same global - /// interner as the tcx argument passed in. This means the closure is given an ImplicitCtxt - /// with the same 'tcx lifetime as the TyCtxt passed in. - /// This will panic if you pass it a TyCtxt which has a different global interner from - /// the current ImplicitCtxt's tcx field. + /// Allows access to the current `ImplicitCtxt` whose tcx field has the same global + /// interner as the tcx argument passed in. This means the closure is given an `ImplicitCtxt` + /// with the same `'tcx` lifetime as the `TyCtxt` passed in. + /// This will panic if you pass it a `TyCtxt` which has a different global interner from + /// the current `ImplicitCtxt`'s `tcx` field. #[inline] pub fn with_related_context<'tcx, F, R>(tcx: TyCtxt<'tcx>, f: F) -> R where @@ -1968,8 +1961,8 @@ pub mod tls { }) } - /// Allows access to the TyCtxt in the current ImplicitCtxt. - /// Panics if there is no ImplicitCtxt available + /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`. + /// Panics if there is no `ImplicitCtxt` available. #[inline] pub fn with(f: F) -> R where @@ -1978,8 +1971,8 @@ pub mod tls { with_context(|context| f(context.tcx)) } - /// Allows access to the TyCtxt in the current ImplicitCtxt. - /// The closure is passed None if there is no ImplicitCtxt available + /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`. + /// The closure is passed None if there is no `ImplicitCtxt` available. #[inline] pub fn with_opt(f: F) -> R where @@ -1991,7 +1984,7 @@ pub mod tls { macro_rules! sty_debug_print { ($ctxt: expr, $($variant: ident),*) => {{ - // curious inner module to allow variant names to be used as + // Curious inner module to allow variant names to be used as // variable names. #[allow(non_snake_case)] mod inner { @@ -2265,9 +2258,9 @@ slice_interners!( projs: _intern_projs(ProjectionKind) ); -// This isn't a perfect fit: CanonicalVarInfo slices are always +// This isn't a perfect fit: `CanonicalVarInfo` slices are always // allocated in the global arena, so this `intern_method!` macro is -// overly general. But we just return false for the code that checks +// overly general. However, we just return `false` for the code that checks // whether they belong in the thread-local arena, so no harm done, and // seems better than open-coding the rest. intern_method! { @@ -2366,7 +2359,7 @@ impl<'tcx> TyCtxt<'tcx> { #[inline] pub fn mk_adt(self, def: &'tcx AdtDef, substs: SubstsRef<'tcx>) -> Ty<'tcx> { - // take a copy of substs so that we own the vectors inside + // Take a copy of substs so that we own the vectors inside. self.mk_ty(Adt(def, substs)) } diff --git a/src/librustc/ty/fold.rs b/src/librustc/ty/fold.rs index 4b30412b41954..1e08ae45951d1 100644 --- a/src/librustc/ty/fold.rs +++ b/src/librustc/ty/fold.rs @@ -39,8 +39,8 @@ use std::collections::BTreeMap; use std::fmt; 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. +/// This trait is implemented for every type that can be folded. +/// Basically, every type that has a corresponding method in `TypeFolder`. /// /// To implement this conveniently, use the /// `BraceStructTypeFoldableImpl` etc macros found in `macros.rs`. diff --git a/src/librustc/ty/inhabitedness/def_id_forest.rs b/src/librustc/ty/inhabitedness/def_id_forest.rs index 4453624fa4502..63cc60d80aada 100644 --- a/src/librustc/ty/inhabitedness/def_id_forest.rs +++ b/src/librustc/ty/inhabitedness/def_id_forest.rs @@ -4,20 +4,20 @@ use rustc::hir::CRATE_HIR_ID; 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 -/// DefIds defined in that module or submodules are also implicitly contained +/// Represents a forest of `DefId`s closed under the ancestor relation. That is, +/// if a `DefId` representing a module is contained in the forest then all +/// `DefId`s defined in that module or submodules are also implicitly contained /// in the forest. /// /// This is used to represent a set of modules in which a type is visibly /// uninhabited. #[derive(Clone)] pub struct DefIdForest { - /// The minimal set of DefIds required to represent the whole set. - /// If A and B are DefIds in the DefIdForest, and A is a descendant - /// of B, then only B will be in root_ids. - /// We use a SmallVec here because (for its use for caching inhabitedness) - /// its rare that this will contain even two ids. + /// The minimal set of `DefId`s required to represent the whole set. + /// If A and B are DefIds in the `DefIdForest`, and A is a descendant + /// of B, then only B will be in `root_ids`. + /// We use a `SmallVec` here because (for its use for caching inhabitedness) + /// its rare that this will contain even two IDs. root_ids: SmallVec<[DefId; 1]>, } @@ -37,7 +37,7 @@ impl<'tcx> DefIdForest { DefIdForest::from_id(crate_id) } - /// Creates 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); diff --git a/src/librustc/ty/inhabitedness/mod.rs b/src/librustc/ty/inhabitedness/mod.rs index 2b3291656653f..1a0e351733877 100644 --- a/src/librustc/ty/inhabitedness/mod.rs +++ b/src/librustc/ty/inhabitedness/mod.rs @@ -1,3 +1,5 @@ +pub use self::def_id_forest::DefIdForest; + use crate::ty::context::TyCtxt; use crate::ty::{AdtDef, VariantDef, FieldDef, Ty, TyS}; use crate::ty::{DefId, SubstsRef}; @@ -5,12 +7,10 @@ use crate::ty::{AdtKind, Visibility}; use crate::ty::TyKind::*; use crate::ty; -pub use self::def_id_forest::DefIdForest; - mod def_id_forest; -// The methods in this module calculate DefIdForests of modules in which a -// AdtDef/VariantDef/FieldDef is visibly uninhabited. +// The methods in this module calculate `DefIdForest`s of modules in which a +// `AdtDef`/`VariantDef`/`FieldDef` is visibly uninhabited. // // # Example // ```rust @@ -36,24 +36,25 @@ mod def_id_forest; // y: c::AlsoSecretlyUninhabited, // } // ``` -// In this code, the type Foo will only be visibly uninhabited inside the -// modules b, c and d. Calling uninhabited_from on Foo or its AdtDef will -// return the forest of modules {b, c->d} (represented in a DefIdForest by the -// set {b, c}) +// In this code, the type `Foo` will only be visibly uninhabited inside the +// modules `b`, `c` and `d`. Calling `uninhabited_from` on `Foo` or its `AdtDef` will +// return the forest of modules {`b`, `c`->`d`} (represented in a `DefIdForest` by the +// set {`b`, `c`}). // -// We need this information for pattern-matching on Foo or types that contain -// Foo. +// We need this information for pattern-matching on `Foo` or types that contain +// `Foo`. // // # Example // ```rust // let foo_result: Result = ... ; // let Ok(t) = foo_result; // ``` -// This code should only compile in modules where the uninhabitedness of Foo is +// This code should only compile in modules where the uninhabitedness of `Foo` is // visible. impl<'tcx> TyCtxt<'tcx> { /// Checks whether a type is visibly uninhabited from a particular module. + /// /// # Example /// ```rust /// enum Void {} @@ -91,7 +92,7 @@ impl<'tcx> TyCtxt<'tcx> { /// visible. pub fn is_ty_uninhabited_from(self, module: DefId, ty: Ty<'tcx>) -> bool { // To check whether this type is uninhabited at all (not just from the - // given node) you could check whether the forest is empty. + // given node), you could check whether the forest is empty. // ``` // forest.is_empty() // ``` @@ -108,7 +109,7 @@ impl<'tcx> TyCtxt<'tcx> { } impl<'tcx> AdtDef { - /// Calculate the forest of DefIds from which this adt is visibly uninhabited. + /// Calculates the forest of `DefId`s from which this ADT is visibly uninhabited. fn uninhabited_from(&self, tcx: TyCtxt<'tcx>, substs: SubstsRef<'tcx>) -> DefIdForest { // Non-exhaustive ADTs from other crates are always considered inhabited. if self.is_variant_list_non_exhaustive() && !self.did.is_local() { @@ -122,7 +123,7 @@ impl<'tcx> AdtDef { } impl<'tcx> VariantDef { - /// Calculate the forest of DefIds from which this variant is visibly uninhabited. + /// Calculates the forest of `DefId`s from which this variant is visibly uninhabited. pub fn uninhabited_from( &self, tcx: TyCtxt<'tcx>, @@ -148,7 +149,7 @@ impl<'tcx> VariantDef { } impl<'tcx> FieldDef { - /// Calculate the forest of DefIds from which this field is visibly uninhabited. + /// Calculates the forest of `DefId`s from which this field is visibly uninhabited. fn uninhabited_from( &self, tcx: TyCtxt<'tcx>, @@ -159,7 +160,7 @@ impl<'tcx> FieldDef { self.ty(tcx, substs).uninhabited_from(tcx) }; // FIXME(canndrew): Currently enum fields are (incorrectly) stored with - // Visibility::Invisible so we need to override self.vis if we're + // `Visibility::Invisible` so we need to override `self.vis` if we're // dealing with an enum. if is_enum { data_uninhabitedness() @@ -178,7 +179,7 @@ impl<'tcx> FieldDef { } impl<'tcx> TyS<'tcx> { - /// Calculate the forest of DefIds from which this type is visibly uninhabited. + /// Calculates the forest of `DefId`s from which this type is visibly uninhabited. fn uninhabited_from(&self, tcx: TyCtxt<'tcx>) -> DefIdForest { match self.sty { Adt(def, substs) => def.uninhabited_from(tcx, substs), diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 2da50f37409ae..41e4295caecce 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -590,7 +590,7 @@ impl<'tcx> rustc_serialize::UseSpecializedDecodable for Ty<'tcx> {} pub type CanonicalTy<'tcx> = Canonical<'tcx, Ty<'tcx>>; extern { - /// A dummy type used to force List to by unsized without requiring fat pointers + /// A dummy type used to force `List` to by unsized without requiring fat pointers. type OpaqueListContents; } diff --git a/src/librustc/ty/print/mod.rs b/src/librustc/ty/print/mod.rs index 092e7c6f3fffb..50789bf6213b6 100644 --- a/src/librustc/ty/print/mod.rs +++ b/src/librustc/ty/print/mod.rs @@ -27,7 +27,8 @@ pub trait Print<'tcx, P> { /// which the associated types allow passing through the methods. /// /// For pretty-printing/formatting in particular, see `PrettyPrinter`. -// FIXME(eddyb) find a better name, this is more general than "printing". +// +// FIXME(eddyb) find a better name; this is more general than "printing". pub trait Printer<'tcx>: Sized { type Error; @@ -46,6 +47,7 @@ pub trait Printer<'tcx>: Sized { ) -> Result { self.default_print_def_path(def_id, substs) } + fn print_impl_path( self, impl_def_id: DefId, @@ -80,6 +82,7 @@ pub trait Printer<'tcx>: Sized { self, cnum: CrateNum, ) -> Result; + fn path_qualified( self, self_ty: Ty<'tcx>, @@ -93,11 +96,13 @@ pub trait Printer<'tcx>: Sized { self_ty: Ty<'tcx>, trait_ref: Option>, ) -> Result; + fn path_append( self, print_prefix: impl FnOnce(Self) -> Result, disambiguated_data: &DisambiguatedDefPathData, ) -> Result; + fn path_generic_args( self, print_prefix: impl FnOnce(Self) -> Result, diff --git a/src/librustc/ty/print/pretty.rs b/src/librustc/ty/print/pretty.rs index a72ecdb5745bb..d99580116e4ae 100644 --- a/src/librustc/ty/print/pretty.rs +++ b/src/librustc/ty/print/pretty.rs @@ -8,10 +8,11 @@ use crate::ty::{self, DefIdTree, ParamConst, Ty, TyCtxt, TypeFoldable}; use crate::ty::subst::{Kind, Subst, UnpackedKind}; use crate::ty::layout::{Integer, IntegerExt, Size}; use crate::mir::interpret::{ConstValue, sign_extend, Scalar, truncate}; -use syntax::ast; + use rustc_apfloat::ieee::{Double, Single}; use rustc_apfloat::Float; use rustc_target::spec::abi::Abi; +use syntax::ast; use syntax::attr::{SignedInt, UnsignedInt}; use syntax::symbol::{kw, InternedString}; @@ -194,7 +195,7 @@ pub trait PrettyPrinter<'tcx>: value.skip_binder().print(self) } - /// Print comma-separated elements. + /// Prints comma-separated elements. fn comma_sep(mut self, mut elems: impl Iterator) -> Result where T: Print<'tcx, Self, Output = Self, Error = Self::Error>, @@ -209,14 +210,14 @@ pub trait PrettyPrinter<'tcx>: Ok(self) } - /// Print `<...>` around what `f` prints. + /// Prints `<...>` around what `f` prints. fn generic_delimiters( self, f: impl FnOnce(Self) -> Result, ) -> Result; - /// Return `true` if the region should be printed in - /// optional positions, e.g. `&'a T` or `dyn Tr + 'b`. + /// Returns `true` if the region should be printed in + /// optional positions, e.g., `&'a T` or `dyn Tr + 'b`. /// This is typically the case for all non-`'_` regions. fn region_should_not_be_omitted( &self, @@ -226,7 +227,7 @@ pub trait PrettyPrinter<'tcx>: // Defaults (should not be overriden): /// If possible, this returns a global path resolving to `def_id` that is visible - /// from at least one local module and returns true. If the crate defining `def_id` is + /// from at least one local module, and returns `true`. If the crate defining `def_id` is /// declared with an `extern crate`, the path is guaranteed to use the `extern crate`. fn try_print_visible_def_path( self, @@ -267,11 +268,11 @@ pub trait PrettyPrinter<'tcx>: // In local mode, when we encounter a crate other than // LOCAL_CRATE, execution proceeds in one of two ways: // - // 1. for a direct dependency, where user added an + // 1. For a direct dependency, where user added an // `extern crate` manually, we put the `extern // crate` as the parent. So you wind up with // something relative to the current crate. - // 2. for an extern inferred from a path or an indirect crate, + // 2. For an extern inferred from a path or an indirect crate, // where there is no explicit `extern crate`, we just prepend // the crate name. match self.tcx().extern_crate(def_id) { @@ -304,13 +305,13 @@ pub trait PrettyPrinter<'tcx>: let mut cur_def_key = self.tcx().def_key(def_id); debug!("try_print_visible_def_path: cur_def_key={:?}", cur_def_key); - // For a constructor we want the name of its parent rather than . + // For a constructor, we want the name of its parent rather than . match cur_def_key.disambiguated_data.data { DefPathData::Ctor => { let parent = DefId { krate: def_id.krate, index: cur_def_key.parent - .expect("DefPathData::Ctor/VariantData missing a parent"), + .expect("`DefPathData::Ctor` / `VariantData` missing a parent"), }; cur_def_key = self.tcx().def_key(parent); @@ -630,7 +631,7 @@ pub trait PrettyPrinter<'tcx>: sep = ", "; } } else { - // cross-crate closure types should only be + // Cross-crate closure types should only be // visible in codegen bug reports, I imagine. p!(write("@{:?}", did)); let mut sep = " "; @@ -673,7 +674,7 @@ pub trait PrettyPrinter<'tcx>: sep = ", "; } } else { - // cross-crate closure types should only be + // Cross-crate closure types should only be // visible in codegen bug reports, I imagine. p!(write("@{:?}", did)); let mut sep = " "; @@ -1173,6 +1174,7 @@ impl Printer<'tcx> for FmtPrinter<'_, 'tcx, F> { } Ok(self) } + fn path_qualified( mut self, self_ty: Ty<'tcx>, @@ -1201,6 +1203,7 @@ impl Printer<'tcx> for FmtPrinter<'_, 'tcx, F> { self.empty_path = false; Ok(self) } + fn path_append( mut self, print_prefix: impl FnOnce(Self) -> Result, @@ -1238,6 +1241,7 @@ impl Printer<'tcx> for FmtPrinter<'_, 'tcx, F> { Ok(self) } + fn path_generic_args( mut self, print_prefix: impl FnOnce(Self) -> Result, diff --git a/src/librustc/ty/query/on_disk_cache.rs b/src/librustc/ty/query/on_disk_cache.rs index 674f8944f261a..4cef6a09925ad 100644 --- a/src/librustc/ty/query/on_disk_cache.rs +++ b/src/librustc/ty/query/on_disk_cache.rs @@ -5,9 +5,6 @@ use crate::hir::map::definitions::DefPathHash; use crate::ich::{CachingSourceMapView, Fingerprint}; use crate::mir::{self, interpret}; use crate::mir::interpret::{AllocDecodingSession, AllocDecodingState}; -use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque, - SpecializedDecoder, SpecializedEncoder, - UseSpecializedDecodable, UseSpecializedEncodable}; use crate::session::{CrateDisambiguator, Session}; use crate::ty::{self, Ty}; use crate::ty::codec::{self as ty_codec, TyDecoder, TyEncoder}; @@ -19,6 +16,10 @@ 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, SpecializedDecoder, SpecializedEncoder, + UseSpecializedDecodable, UseSpecializedEncodable, opaque, +}; use std::mem; use syntax::ast::{Ident, NodeId}; use syntax::source_map::{SourceMap, StableSourceFileId}; @@ -37,17 +38,16 @@ const TAG_EXPN_DATA_INLINE: u8 = 2; const TAG_VALID_SPAN: u8 = 0; const TAG_INVALID_SPAN: u8 = 1; -/// `OnDiskCache` provides an interface to incr. comp. data cached from the +/// Provides an interface to incremental compilation data cached from the /// previous compilation session. This data will eventually include the results /// of a few selected queries (like `typeck_tables_of` and `mir_optimized`) and /// any diagnostics that have been emitted during a query. pub struct OnDiskCache<'sess> { - // The complete cache data in serialized form. serialized_data: Vec, - // This field collects all Diagnostics emitted during the current - // compilation session. + // Collects all `Diagnostic`s emitted during the current compilation + // session. current_diagnostics: Lock>>, prev_cnums: Vec<(u32, String, CrateDisambiguator)>, @@ -56,7 +56,7 @@ pub struct OnDiskCache<'sess> { source_map: &'sess SourceMap, file_index_to_stable_id: FxHashMap, - // These two fields caches that are populated lazily during decoding. + // Caches that are populated lazily during decoding. file_index_to_file: Lock>>, synthetic_syntax_contexts: Lock>, @@ -78,7 +78,7 @@ struct Footer { prev_cnums: Vec<(u32, String, CrateDisambiguator)>, query_result_index: EncodedQueryResultIndex, diagnostics_index: EncodedQueryResultIndex, - // the location of all allocations + // The location of all allocations. interpret_alloc_index: Vec, } @@ -104,28 +104,28 @@ impl AbsoluteBytePos { } impl<'sess> OnDiskCache<'sess> { - /// Creates a new OnDiskCache instance from the serialized data in `data`. - pub fn new(sess: &'sess Session, data: Vec, start_pos: usize) -> OnDiskCache<'sess> { + /// Creates a new `OnDiskCache` instance from the serialized data in `data`. + pub fn new(sess: &'sess Session, data: Vec, start_pos: usize) -> Self { debug_assert!(sess.opts.incremental.is_some()); - // Wrapping in a scope so we can borrow `data` + // Wrap in a scope so we can borrow `data`. let footer: Footer = { let mut decoder = opaque::Decoder::new(&data[..], start_pos); - // Decode the *position* of the footer which can be found in the + // Decode the *position* of the footer, which can be found in the // last 8 bytes of the file. decoder.set_position(data.len() - IntEncodedWithFixedSize::ENCODED_SIZE); - let query_result_index_pos = IntEncodedWithFixedSize::decode(&mut decoder) - .expect("Error while trying to decode query result index position.") + let footer_pos = IntEncodedWithFixedSize::decode(&mut decoder) + .expect("error while trying to decode footer position") .0 as usize; - // Decoder the file footer which contains all the lookup tables, etc. - decoder.set_position(query_result_index_pos); + // Decode the file footer, which contains all the lookup tables, etc. + decoder.set_position(footer_pos); decode_tagged(&mut decoder, TAG_FILE_FOOTER) - .expect("Error while trying to decode query result index position.") + .expect("error while trying to decode footer position") }; - OnDiskCache { + Self { serialized_data: data, file_index_to_stable_id: footer.file_index_to_stable_id, file_index_to_file: Default::default(), @@ -140,8 +140,8 @@ impl<'sess> OnDiskCache<'sess> { } } - pub fn new_empty(source_map: &'sess SourceMap) -> OnDiskCache<'sess> { - OnDiskCache { + pub fn new_empty(source_map: &'sess SourceMap) -> Self { + Self { serialized_data: Vec::new(), file_index_to_stable_id: Default::default(), file_index_to_file: Default::default(), @@ -158,11 +158,11 @@ impl<'sess> OnDiskCache<'sess> { pub fn serialize<'tcx, E>(&self, tcx: TyCtxt<'tcx>, encoder: &mut E) -> Result<(), E::Error> where - E: ty_codec::TyEncoder, + E: TyEncoder, { - // Serializing the DepGraph should not modify it: + // Serializing the `DepGraph` should not modify it. tcx.dep_graph.with_ignore(|| { - // Allocate SourceFileIndices + // Allocate `SourceFileIndex`es. let (file_to_file_index, file_index_to_stable_id) = { let files = tcx.sess.source_map().files(); let mut file_to_file_index = FxHashMap::with_capacity_and_hasher( @@ -197,7 +197,7 @@ impl<'sess> OnDiskCache<'sess> { // be in memory, so this should be a cheap operation. tcx.dep_graph.exec_cache_promotions(tcx); - // Encode query results + // Encode query results. let mut query_result_index = EncodedQueryResultIndex::new(); time(tcx.sess, "encode query results", || { @@ -221,29 +221,28 @@ impl<'sess> OnDiskCache<'sess> { Ok(()) })?; - // Encode diagnostics + // Encode diagnostics. let diagnostics_index: EncodedDiagnosticsIndex = self.current_diagnostics.borrow() .iter() - .map(|(dep_node_index, diagnostics)| - { - let pos = AbsoluteBytePos::new(encoder.position()); - // Let's make sure we get the expected type here: - let diagnostics: &EncodedDiagnostics = diagnostics; - let dep_node_index = SerializedDepNodeIndex::new(dep_node_index.index()); - encoder.encode_tagged(dep_node_index, diagnostics)?; - - Ok((dep_node_index, pos)) - }) - .collect::>()?; + .map(|(dep_node_index, diagnostics)| { + let pos = AbsoluteBytePos::new(encoder.position()); + // Let's make sure we get the expected type here. + let diagnostics: &EncodedDiagnostics = diagnostics; + let dep_node_index = SerializedDepNodeIndex::new(dep_node_index.index()); + encoder.encode_tagged(dep_node_index, diagnostics)?; + + Ok((dep_node_index, pos)) + }) + .collect::>()?; let interpret_alloc_index = { let mut interpret_alloc_index = Vec::new(); let mut n = 0; loop { let new_n = encoder.interpret_allocs_inverse.len(); - // if we have found new ids, serialize those, too + // If we have found new IDs, serialize those too. if n == new_n { - // otherwise, abort + // Otherwise, abort. break; } interpret_alloc_index.reserve(new_n - n); @@ -263,13 +262,15 @@ impl<'sess> OnDiskCache<'sess> { }; let sorted_cnums = sorted_cnums_including_local_crate(tcx); - let prev_cnums: Vec<_> = sorted_cnums.iter().map(|&cnum| { - let crate_name = tcx.original_crate_name(cnum).as_str().to_string(); - let crate_disambiguator = tcx.crate_disambiguator(cnum); - (cnum.as_u32(), crate_name, crate_disambiguator) - }).collect(); - - // Encode the file footer + let prev_cnums: Vec<_> = sorted_cnums.iter() + .map(|&cnum| { + let crate_name = tcx.original_crate_name(cnum).as_str().to_string(); + let crate_disambiguator = tcx.crate_disambiguator(cnum); + (cnum.as_u32(), crate_name, crate_disambiguator) + }) + .collect(); + + // Encode the file footer. let footer_pos = encoder.position() as u64; encoder.encode_tagged(TAG_FILE_FOOTER, &Footer { file_index_to_stable_id, @@ -371,7 +372,7 @@ impl<'sess> OnDiskCache<'sess> { { let pos = index.get(&dep_node_index).cloned()?; - // Initialize the cnum_map using the value from the thread which finishes the closure first + // Initialize `cnum_map` using the value from the thread that finishes the closure first. self.cnum_map.init_nonlocking_same(|| { Self::compute_cnum_map(tcx, &self.prev_cnums[..]) }); @@ -381,25 +382,21 @@ impl<'sess> OnDiskCache<'sess> { opaque: opaque::Decoder::new(&self.serialized_data[..], pos.to_usize()), source_map: self.source_map, cnum_map: self.cnum_map.get(), + synthetic_syntax_contexts: &self.synthetic_syntax_contexts, file_index_to_file: &self.file_index_to_file, file_index_to_stable_id: &self.file_index_to_stable_id, - synthetic_syntax_contexts: &self.synthetic_syntax_contexts, alloc_decoding_session: self.alloc_decoding_state.new_decoding_session(), }; match decode_tagged(&mut decoder, dep_node_index) { - Ok(value) => { - Some(value) - } - Err(e) => { - bug!("Could not decode cached {}: {}", debug_tag, e) - } + Ok(v) => Some(v), + Err(e) => bug!("could not decode cached {}: {}", debug_tag, e), } } - // This function builds mapping from previous-session-CrateNum to - // current-session-CrateNum. There might be CrateNums from the previous - // Session that don't occur in the current one. For these, the mapping + // This function builds mapping from previous-session-`CrateNum` to + // current-session-`CrateNum`. There might be `CrateNum`s from the previous + // `Session` that don't occur in the current one. For these, the mapping // maps to None. fn compute_cnum_map( tcx: TyCtxt<'_>, @@ -432,9 +429,9 @@ impl<'sess> OnDiskCache<'sess> { //- DECODING ------------------------------------------------------------------- -/// A decoder that can read the incr. comp. cache. It is similar to the one -/// we use for crate metadata decoding in that it can rebase spans and -/// eventually will also handle things that contain `Ty` instances. +/// A decoder that can read fro the incr. comp. cache. It is similar to the one +/// we use for crate metadata decoding in that it can rebase spans and eventually +/// will also handle things that contain `Ty` instances. struct CacheDecoder<'a, 'tcx> { tcx: TyCtxt<'tcx>, opaque: opaque::Decoder<'a>, @@ -458,7 +455,7 @@ impl<'a, 'tcx> CacheDecoder<'a, 'tcx> { file_index_to_file.borrow_mut().entry(index).or_insert_with(|| { let stable_id = file_index_to_stable_id[&index]; source_map.source_file_by_stable_id(stable_id) - .expect("Failed to lookup SourceFile in new context.") + .expect("failed to lookup `SourceFile` in new context") }).clone() } } @@ -479,7 +476,7 @@ impl<'a, 'tcx> DecoderWithPosition for CacheDecoder<'a, 'tcx> { } } -// Decode something that was encoded with encode_tagged() and verify that the +// Decodes something that was encoded with `encode_tagged()` and verify that the // tag matches and the correct amount of bytes was read. fn decode_tagged(decoder: &mut D, expected_tag: T) -> Result where @@ -500,7 +497,7 @@ where Ok(value) } -impl<'a, 'tcx> ty_codec::TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> { +impl<'a, 'tcx> TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> { #[inline] fn tcx(&self) -> TyCtxt<'tcx> { self.tcx @@ -534,7 +531,7 @@ impl<'a, 'tcx> ty_codec::TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> { } let ty = or_insert_with(self)?; - // This may overwrite the entry, but it should overwrite with the same value + // This may overwrite the entry, but it should overwrite with the same value. tcx.rcache.borrow_mut().insert_same(cache_key, ty); Ok(ty) } @@ -553,7 +550,7 @@ impl<'a, 'tcx> ty_codec::TyDecoder<'tcx> for CacheDecoder<'a, 'tcx> { fn map_encoded_cnum_to_current(&self, cnum: CrateNum) -> CrateNum { self.cnum_map[cnum].unwrap_or_else(|| { - bug!("Could not find new CrateNum for {:?}", cnum) + bug!("could not find new `CrateNum` for {:?}", cnum) }) } } @@ -635,25 +632,25 @@ impl<'a, 'tcx> SpecializedDecoder for CacheDecoder<'a, 'tcx> { } // This impl makes sure that we get a runtime error when we try decode a -// DefIndex that is not contained in a DefId. Such a case would be problematic -// because we would not know how to transform the DefIndex to the current +// `DefIndex` that is not contained in a `DefId`. Such a case would be problematic +// because we would not know how to transform the `DefIndex` to the current // context. impl<'a, 'tcx> SpecializedDecoder for CacheDecoder<'a, 'tcx> { fn specialized_decode(&mut self) -> Result { - bug!("Trying to decode DefIndex outside the context of a DefId") + bug!("trying to decode `DefIndex` outside the context of a `DefId`") } } -// Both the CrateNum and the DefIndex of a DefId can change in between two -// compilation sessions. We use the DefPathHash, which is stable across -// sessions, to map the old DefId to the new one. +// Both the `CrateNum` and the `DefIndex` of a `DefId` can change in between two +// compilation sessions. We use the `DefPathHash`, which is stable across +// sessions, to map the old DefId`` to the new one. impl<'a, 'tcx> SpecializedDecoder for CacheDecoder<'a, 'tcx> { #[inline] fn specialized_decode(&mut self) -> Result { - // Load the DefPathHash which is was we encoded the DefId as. + // Load the `DefPathHash` which is was we encoded the `DefId` as. let def_path_hash = DefPathHash::decode(self)?; - // Using the DefPathHash, we can lookup the new DefId + // Using the `DefPathHash`, we can lookup the new `DefId`. Ok(self.tcx().def_path_hash_to_def_id.as_ref().unwrap()[&def_path_hash]) } } @@ -667,10 +664,10 @@ impl<'a, 'tcx> SpecializedDecoder for CacheDecoder<'a, 'tcx> { impl<'a, 'tcx> SpecializedDecoder for CacheDecoder<'a, 'tcx> { fn specialized_decode(&mut self) -> Result { - // Load the DefPathHash which is was we encoded the DefIndex as. + // Load the `DefPathHash` which is what we encoded the `DefIndex` as. let def_path_hash = DefPathHash::decode(self)?; - // Use the DefPathHash to map to the current DefId. + // Use the `DefPathHash` to map to the current `DefId`. let def_id = self.tcx() .def_path_hash_to_def_id .as_ref() @@ -678,10 +675,10 @@ impl<'a, 'tcx> SpecializedDecoder for CacheDecoder<'a, 'tcx> { debug_assert!(def_id.is_local()); - // The ItemLocalId needs no remapping. + // The `ItemLocalId` needs no remapping. let local_id = hir::ItemLocalId::decode(self)?; - // Reconstruct the HirId and look up the corresponding NodeId in the + // Reconstruct the `HirId` and look up the corresponding `NodeId` in the // context of the current session. Ok(hir::HirId { owner: def_id.index, @@ -690,8 +687,8 @@ impl<'a, 'tcx> SpecializedDecoder for CacheDecoder<'a, 'tcx> { } } -// NodeIds are not stable across compilation sessions, so we store them in their -// HirId representation. This allows use to map them to the current NodeId. +// `NodeId`s are not stable across compilation sessions, so we store them in their +// `HirId` representation. This allows use to map them to the current `NodeId`. impl<'a, 'tcx> SpecializedDecoder for CacheDecoder<'a, 'tcx> { #[inline] fn specialized_decode(&mut self) -> Result { @@ -728,6 +725,7 @@ impl<'a, 'tcx, T: Decodable> SpecializedDecoder> //- ENCODING ------------------------------------------------------------------- +/// An encoder that can write the incr. comp. cache. struct CacheEncoder<'a, 'tcx, E: ty_codec::TyEncoder> { tcx: TyCtxt<'tcx>, encoder: &'a mut E, @@ -742,7 +740,7 @@ struct CacheEncoder<'a, 'tcx, E: ty_codec::TyEncoder> { impl<'a, 'tcx, E> CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { fn source_file_index(&mut self, source_file: Lrc) -> SourceFileIndex { self.file_to_file_index[&(&*source_file as *const SourceFile)] @@ -753,11 +751,11 @@ where /// encode the specified tag, then the given value, then the number of /// bytes taken up by tag and value. On decoding, we can then verify that /// we get the expected tag and read the expected number of bytes. - fn encode_tagged(&mut self, - tag: T, - value: &V) - -> Result<(), E::Error> - { + fn encode_tagged( + &mut self, + tag: T, + value: &V + ) -> Result<(), E::Error> { let start_pos = self.position(); tag.encode(self)?; @@ -770,7 +768,7 @@ where impl<'a, 'tcx, E> SpecializedEncoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { fn specialized_encode(&mut self, alloc_id: &interpret::AllocId) -> Result<(), Self::Error> { use std::collections::hash_map::Entry; @@ -790,10 +788,9 @@ where impl<'a, 'tcx, E> SpecializedEncoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { fn specialized_encode(&mut self, span: &Span) -> Result<(), Self::Error> { - if *span == DUMMY_SP { return TAG_INVALID_SPAN.encode(self); } @@ -849,14 +846,14 @@ where // We don't currently encode enough information to ensure hygiene works // with incremental, so panic rather than risk incremental bugs. - // FIXME: Handle hygiene in incremental - bug!("Trying to encode Ident for incremental") + // FIXME: handle hygiene in incremental. + bug!("trying to encode `Ident` for incremental"); } } impl<'a, 'tcx, E> ty_codec::TyEncoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { #[inline] fn position(&self) -> usize { @@ -866,7 +863,7 @@ where impl<'a, 'tcx, E> SpecializedEncoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { #[inline] fn specialized_encode(&mut self, cnum: &CrateNum) -> Result<(), Self::Error> { @@ -876,7 +873,7 @@ where impl<'a, 'tcx, E> SpecializedEncoder> for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { #[inline] fn specialized_encode(&mut self, ty: &Ty<'tcx>) -> Result<(), Self::Error> { @@ -887,7 +884,7 @@ where impl<'a, 'tcx, E> SpecializedEncoder> for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { #[inline] fn specialized_encode(&mut self, @@ -900,7 +897,7 @@ where impl<'a, 'tcx, E> SpecializedEncoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { #[inline] fn specialized_encode(&mut self, id: &hir::HirId) -> Result<(), Self::Error> { @@ -918,7 +915,7 @@ where impl<'a, 'tcx, E> SpecializedEncoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { #[inline] fn specialized_encode(&mut self, id: &DefId) -> Result<(), Self::Error> { @@ -929,7 +926,7 @@ where impl<'a, 'tcx, E> SpecializedEncoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { #[inline] fn specialized_encode(&mut self, id: &LocalDefId) -> Result<(), Self::Error> { @@ -939,18 +936,18 @@ where impl<'a, 'tcx, E> SpecializedEncoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { fn specialized_encode(&mut self, _: &DefIndex) -> Result<(), Self::Error> { - bug!("Encoding DefIndex without context.") + bug!("encoding `DefIndex` without context"); } } -// NodeIds are not stable across compilation sessions, so we store them in their -// HirId representation. This allows use to map them to the current NodeId. +// `NodeId`s are not stable across compilation sessions, so we store them in their +// `HirId` representation. This allows use to map them to the current `NodeId`. impl<'a, 'tcx, E> SpecializedEncoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { #[inline] fn specialized_encode(&mut self, node_id: &NodeId) -> Result<(), Self::Error> { @@ -967,7 +964,7 @@ impl<'a, 'tcx> SpecializedEncoder for CacheEncoder<'a, 'tcx, opaque impl<'a, 'tcx, E, T> SpecializedEncoder> for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, T: Encodable, { #[inline] @@ -996,7 +993,7 @@ macro_rules! encoder_methods { impl<'a, 'tcx, E> Encoder for CacheEncoder<'a, 'tcx, E> where - E: 'a + ty_codec::TyEncoder, + E: 'a + TyEncoder, { type Error = E::Error; @@ -1040,7 +1037,7 @@ impl UseSpecializedDecodable for IntEncodedWithFixedSize {} impl SpecializedEncoder for opaque::Encoder { fn specialized_encode(&mut self, x: &IntEncodedWithFixedSize) -> Result<(), Self::Error> { let start_pos = self.position(); - for i in 0 .. IntEncodedWithFixedSize::ENCODED_SIZE { + for i in 0..IntEncodedWithFixedSize::ENCODED_SIZE { ((x.0 >> i * 8) as u8).encode(self)?; } let end_pos = self.position(); @@ -1085,10 +1082,10 @@ where if Q::cache_on_disk(tcx, key.clone(), Some(&entry.value)) { let dep_node = SerializedDepNodeIndex::new(entry.index.index()); - // Record position of the cache entry + // Record position of the cache entry. query_result_index.push((dep_node, AbsoluteBytePos::new(encoder.position()))); - // Encode the type check tables with the SerializedDepNodeIndex + // Encode the type check tables with the `SerializedDepNodeIndex` // as tag. encoder.encode_tagged(dep_node, &entry.value)?; } diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs index 4dce55f589233..d199a26475be7 100644 --- a/src/librustc/ty/query/plumbing.rs +++ b/src/librustc/ty/query/plumbing.rs @@ -61,7 +61,7 @@ impl<'tcx, M: QueryConfig<'tcx>> Default for QueryCache<'tcx, M> { } } -// If enabled, send a message to the profile-queries thread +// If enabled, sends a message to the profile-queries thread. macro_rules! profq_msg { ($tcx:expr, $msg:expr) => { if cfg!(debug_assertions) { @@ -72,7 +72,7 @@ macro_rules! profq_msg { } } -// If enabled, format a key using its debug string, which can be +// If enabled, formats a key using its debug string, which can be // expensive to compute (in terms of time). macro_rules! profq_query_msg { ($query:expr, $tcx:expr, $key:expr) => {{ @@ -98,7 +98,7 @@ pub(super) struct JobOwner<'a, 'tcx, Q: QueryDescription<'tcx>> { impl<'a, 'tcx, Q: QueryDescription<'tcx>> JobOwner<'a, 'tcx, Q> { /// Either gets a `JobOwner` corresponding the query, allowing us to - /// start executing the query, or it returns with the result of the query. + /// start executing the query, or returns with the result of the query. /// If the query is executing elsewhere, this will wait for it. /// If the query panicked, this will silently panic. /// @@ -215,30 +215,30 @@ impl<'a, 'tcx, Q: QueryDescription<'tcx>> Drop for JobOwner<'a, 'tcx, Q> { #[inline(never)] #[cold] fn drop(&mut self) { - // Poison the query so jobs waiting on it panic + // Poison the query so jobs waiting on it panic. let shard = self.cache.get_shard_by_value(&self.key); shard.lock().active.insert(self.key.clone(), QueryResult::Poisoned); // Also signal the completion of the job, so waiters - // will continue execution + // will continue execution. self.job.signal_complete(); } } #[derive(Clone)] pub struct CycleError<'tcx> { - /// The query and related span which uses the cycle + /// The query and related span that uses the cycle. pub(super) usage: Option<(Span, Query<'tcx>)>, pub(super) cycle: Vec>, } -/// The result of `try_get_lock` +/// The result of `try_get_lock`. pub(super) enum TryGetJob<'a, 'tcx, D: QueryDescription<'tcx>> { /// The query is not yet started. Contains a guard to the cache eventually used to start it. NotYetStarted(JobOwner<'a, 'tcx, D>), /// The query was already completed. - /// Returns the result of the query and its dep node index - /// if it succeeded or a cycle error if it failed + /// Returns the result of the query and its dep-node index + /// if it succeeded or a cycle error if it failed. JobCompleted((D::Value, DepNodeIndex)), /// Trying to execute the query resulted in a cycle. @@ -246,7 +246,7 @@ pub(super) enum TryGetJob<'a, 'tcx, D: QueryDescription<'tcx>> { } impl<'tcx> TyCtxt<'tcx> { - /// Executes a job by changing the ImplicitCtxt to point to the + /// Executes a job by changing the `ImplicitCtxt` to point to the /// new query job while it executes. It returns the diagnostics /// captured during execution and the actual result. #[inline(always)] @@ -259,11 +259,11 @@ impl<'tcx> TyCtxt<'tcx> { where F: FnOnce(TyCtxt<'tcx>) -> R, { - // The TyCtxt stored in TLS has the same global interner lifetime + // The `TyCtxt` stored in TLS has the same global interner lifetime // as `self`, so we use `with_related_context` to relate the 'tcx lifetimes - // when accessing the ImplicitCtxt + // when accessing the `ImplicitCtxt`. tls::with_related_context(self, move |current_icx| { - // Update the ImplicitCtxt to point to our new query job + // Update the `ImplicitCtxt` to point to our new query job. let new_icx = tls::ImplicitCtxt { tcx: self.global_tcx(), query: Some(job), @@ -272,7 +272,7 @@ impl<'tcx> TyCtxt<'tcx> { task_deps: current_icx.task_deps, }; - // Use the ImplicitCtxt while we execute the query + // Use the `ImplicitCtxt` while we execute the query. tls::enter_context(&new_icx, |_| { compute(self.global_tcx()) }) @@ -372,7 +372,7 @@ impl<'tcx> TyCtxt<'tcx> { }; // Fast path for when incr. comp. is off. `to_dep_node` is - // expensive for some DepKinds. + // expensive for some `DepKind`s. if !self.dep_graph.is_fully_enabled() { let null_dep_node = DepNode::new_no_params(crate::dep_graph::DepKind::Null); return self.force_query_with_job::(key, job, null_dep_node).0; @@ -410,7 +410,7 @@ impl<'tcx> TyCtxt<'tcx> { if !Q::EVAL_ALWAYS { // The diagnostics for this query will be // promoted to the current session during - // try_mark_green(), so we can ignore them here. + // `try_mark_green()`, so we can ignore them here. let loaded = self.start_query(job.job.clone(), None, |tcx| { let marked = tcx.dep_graph.try_mark_green_and_read(tcx, &dep_node); marked.map(|(prev_dep_node_index, dep_node_index)| { @@ -441,11 +441,11 @@ impl<'tcx> TyCtxt<'tcx> { dep_node: &DepNode, ) -> Q::Value { // Note this function can be called concurrently from the same query - // We must ensure that this is handled correctly + // We must ensure that this is handled correctly. debug_assert!(self.dep_graph.is_green(dep_node)); - // First we try to load the result from the on-disk cache + // First we try to load the result from the on-disk cache. let result = if Q::cache_on_disk(self.global_tcx(), key.clone(), None) && self.sess.opts.debugging_opts.incremental_queries { self.sess.profiler(|p| p.incremental_load_result_start(Q::NAME)); @@ -453,10 +453,10 @@ impl<'tcx> TyCtxt<'tcx> { self.sess.profiler(|p| p.incremental_load_result_end(Q::NAME)); // We always expect to find a cached result for things that - // can be forced from DepNode. + // can be forced from `DepNode`. debug_assert!(!dep_node.kind.can_reconstruct_query_key() || result.is_some(), - "Missing on-disk cache entry for {:?}", + "missing on-disk cache entry for {:?}", dep_node); result } else { @@ -475,8 +475,7 @@ impl<'tcx> TyCtxt<'tcx> { self.sess.profiler(|p| p.start_query(Q::NAME)); - // The dep-graph for this computation is already in - // place + // The dep-graph for this computation is already in-place. let result = self.dep_graph.with_ignore(|| { Q::compute(self, key) }); @@ -485,7 +484,7 @@ impl<'tcx> TyCtxt<'tcx> { result }; - // If -Zincremental-verify-ich is specified, re-hash results from + // If `-Zincremental-verify-ich` is specified, re-hash results from // the cache and make sure that they have the expected fingerprint. if unlikely!(self.sess.opts.debugging_opts.incremental_verify_ich) { self.incremental_verify_ich::(&result, dep_node, dep_node_index); @@ -508,10 +507,12 @@ impl<'tcx> TyCtxt<'tcx> { ) { use crate::ich::Fingerprint; - assert!(Some(self.dep_graph.fingerprint_of(dep_node_index)) == + assert!( + Some(self.dep_graph.fingerprint_of(dep_node_index)) == self.dep_graph.prev_fingerprint_of(dep_node), - "Fingerprint for green query instance not loaded \ - from cache: {:?}", dep_node); + "fingerprint for green query instance not loaded from cache: {:?}", + dep_node, + ); debug!("BEGIN verify_ich({:?})", dep_node); let mut hcx = self.create_stable_hashing_context(); @@ -521,8 +522,11 @@ impl<'tcx> TyCtxt<'tcx> { let old_hash = self.dep_graph.fingerprint_of(dep_node_index); - assert!(new_hash == old_hash, "Found unstable fingerprints \ - for {:?}", dep_node); + assert!( + new_hash == old_hash, + "found unstable fingerprints for {:?}", + dep_node, + ); } #[inline(always)] @@ -534,11 +538,11 @@ impl<'tcx> TyCtxt<'tcx> { ) -> (Q::Value, DepNodeIndex) { // If the following assertion triggers, it can have two reasons: // 1. Something is wrong with DepNode creation, either here or - // in DepGraph::try_mark_green() - // 2. Two distinct query keys get mapped to the same DepNode - // (see for example #48923) + // in `DepGraph::try_mark_green()`. + // 2. Two distinct query keys get mapped to the same `DepNode` + // (see for example #48923). assert!(!self.dep_graph.dep_node_exists(&dep_node), - "Forcing query with already existing DepNode.\n\ + "forcing query with already existing `DepNode`\n\ - query-key: {:?}\n\ - dep-node: {:?}", key, dep_node); @@ -584,7 +588,7 @@ impl<'tcx> TyCtxt<'tcx> { } /// Ensure that either this query has all green inputs or been executed. - /// Executing query::ensure(D) is considered a read of the dep-node D. + /// Executing `query::ensure(D)` is considered a read of the dep-node `D`. /// /// This function is particularly useful when executing passes for their /// side-effects -- e.g., in order to report errors for erroneous programs. @@ -899,13 +903,13 @@ macro_rules! define_queries_inner { } } - // FIXME(eddyb) Get more valid Span's on queries. + // FIXME(eddyb) Get more valid `Span`s on queries. pub fn default_span(&self, tcx: TyCtxt<$tcx>, span: Span) -> Span { if !span.is_dummy() { return span; } - // The def_span query is used to calculate default_span, - // so exit to avoid infinite recursion + // The `def_span` query is used to calculate `default_span`, + // so exit to avoid infinite recursion. if let Query::def_span(..) = *self { return span } @@ -1116,7 +1120,7 @@ macro_rules! define_provider_struct { impl<$tcx> Default for Providers<$tcx> { fn default() -> Self { $(fn $name<$tcx>(_: TyCtxt<$tcx>, key: $K) -> $R { - bug!("tcx.{}({:?}) unsupported by its crate", + bug!("`tcx.{}({:?})` unsupported by its crate", stringify!($name), key); })* Providers { $($name),* } @@ -1128,26 +1132,26 @@ macro_rules! define_provider_struct { /// The red/green evaluation system will try to mark a specific DepNode in the /// dependency graph as green by recursively trying to mark the dependencies of -/// that DepNode as green. While doing so, it will sometimes encounter a DepNode +/// that `DepNode` as green. While doing so, it will sometimes encounter a `DepNode` /// where we don't know if it is red or green and we therefore actually have /// to recompute its value in order to find out. Since the only piece of -/// information that we have at that point is the DepNode we are trying to +/// information that we have at that point is the `DepNode` we are trying to /// re-evaluate, we need some way to re-run a query from just that. This is what /// `force_from_dep_node()` implements. /// -/// In the general case, a DepNode consists of a DepKind and an opaque +/// In the general case, a `DepNode` consists of a `DepKind` and an opaque /// GUID/fingerprint that will uniquely identify the node. This GUID/fingerprint /// is usually constructed by computing a stable hash of the query-key that the -/// DepNode corresponds to. Consequently, it is not in general possible to go +/// `DepNode` corresponds to. Consequently, it is not in general possible to go /// back from hash to query-key (since hash functions are not reversible). For /// this reason `force_from_dep_node()` is expected to fail from time to time -/// because we just cannot find out, from the DepNode alone, what the +/// because we just cannot find out, from the `DepNode` alone, what the /// corresponding query-key is and therefore cannot re-run the query. /// /// The system deals with this case letting `try_mark_green` fail which forces /// the root query to be re-evaluated. /// -/// Now, if force_from_dep_node() would always fail, it would be pretty useless. +/// 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 `DepNode`s. In particular, we /// enforce by construction that the GUID/fingerprint of certain `DepNode`s is a @@ -1171,9 +1175,9 @@ macro_rules! define_provider_struct { pub fn force_from_dep_node(tcx: TyCtxt<'_>, dep_node: &DepNode) -> bool { use crate::dep_graph::RecoverKey; - // We must avoid ever having to call force_from_dep_node() for a - // DepNode::codegen_unit: - // Since we cannot reconstruct the query key of a DepNode::codegen_unit, we + // We must avoid ever having to call `force_from_dep_node()` for a + // `DepNode::codegen_unit`: + // Since we cannot reconstruct the query key of a `DepNode::codegen_unit`, we // would always end up having to evaluate the first caller of the // `codegen_unit` query that *is* reconstructible. This might very well be // the `compile_codegen_unit` query, thus re-codegenning the whole CGU just @@ -1196,7 +1200,7 @@ pub fn force_from_dep_node(tcx: TyCtxt<'_>, dep_node: &DepNode) -> bool { if let Some(def_id) = dep_node.extract_def_id(tcx) { def_id } else { - // return from the whole function + // Return from the whole function. return false } } @@ -1224,20 +1228,20 @@ pub fn force_from_dep_node(tcx: TyCtxt<'_>, dep_node: &DepNode) -> bool { rustc_dep_node_force!([dep_node, tcx] // These are inputs that are expected to be pre-allocated and that - // should therefore always be red or green already + // should therefore always be red or green already. DepKind::AllLocalTraitImpls | DepKind::Krate | DepKind::CrateMetadata | DepKind::HirBody | DepKind::Hir | - // This are anonymous nodes + // These are anonymous nodes. DepKind::TraitSelect | // We don't have enough information to reconstruct the query key of - // these + // these. DepKind::CompileCodegenUnit => { - bug!("force_from_dep_node() - Encountered {:?}", dep_node) + bug!("force_from_dep_node: encountered {:?}", dep_node) } DepKind::Analysis => { force!(analysis, krate!()); } diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs index d2edf6fb1ee80..e73a51e6f78e5 100644 --- a/src/librustc/ty/sty.rs +++ b/src/librustc/ty/sty.rs @@ -644,7 +644,7 @@ impl<'tcx> Binder> { impl<'tcx> rustc_serialize::UseSpecializedDecodable for &'tcx List> {} impl<'tcx> List> { - /// Returns the "principal def id" of this set of existential predicates. + /// Returns the "principal `DefId`" of this set of existential predicates. /// /// A Rust trait object type consists (in addition to a lifetime bound) /// of a set of trait bounds, which are separated into any number @@ -1052,7 +1052,7 @@ impl<'tcx> PolyGenSig<'tcx> { } } -/// Signature of a function type, which I have arbitrarily +/// Signature of a function type, which we have arbitrarily /// decided to use to refer to the input/output types. /// /// - `inputs`: is the list of arguments and their modes. @@ -1076,7 +1076,8 @@ impl<'tcx> FnSig<'tcx> { self.inputs_and_output[self.inputs_and_output.len() - 1] } - // Create a minimal `FnSig` to be used when encountering a `TyKind::Error` in a fallible method + // Creates a minimal `FnSig` to be used when encountering a `TyKind::Error` in a fallible + // method. fn fake() -> FnSig<'tcx> { FnSig { inputs_and_output: List::empty(), @@ -1118,7 +1119,6 @@ impl<'tcx> PolyFnSig<'tcx> { pub type CanonicalPolyFnSig<'tcx> = Canonical<'tcx, Binder>>; - #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable, HashStable)] pub struct ParamTy { diff --git a/src/librustc_ast_borrowck/cfg/construct.rs b/src/librustc_ast_borrowck/cfg/construct.rs index 339d92145c64f..0dc999083a91a 100644 --- a/src/librustc_ast_borrowck/cfg/construct.rs +++ b/src/librustc_ast_borrowck/cfg/construct.rs @@ -1,11 +1,12 @@ use crate::cfg::*; -use rustc_data_structures::graph::implementation as graph; -use rustc::middle::region; -use rustc::ty::{self, TyCtxt}; use rustc::hir::{self, PatKind}; use rustc::hir::def_id::DefId; use rustc::hir::ptr::P; +use rustc::middle::region; +use rustc::ty::{self, TyCtxt}; + +use rustc_data_structures::graph::implementation as graph; struct CFGBuilder<'a, 'tcx> { tcx: TyCtxt<'tcx>, @@ -19,15 +20,15 @@ struct CFGBuilder<'a, 'tcx> { #[derive(Copy, Clone)] struct BlockScope { - block_expr_id: hir::ItemLocalId, // id of breakable block expr node + block_expr_id: hir::ItemLocalId, // ID of breakable block expr node break_index: CFGIndex, // where to go on `break` } #[derive(Copy, Clone)] struct LoopScope { - loop_id: hir::ItemLocalId, // id of loop/while node + loop_id: hir::ItemLocalId, // ID of `loop`/`while` node continue_index: CFGIndex, // where to go on a `loop` - break_index: CFGIndex, // where to go on a `break` + break_index: CFGIndex, // where to go on a `break` } pub(super) fn construct(tcx: TyCtxt<'_>, body: &hir::Body) -> CFG { @@ -103,9 +104,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { let init_exit = self.opt_expr(&local.init, pred); self.pat(&local.pat, init_exit) } - hir::StmtKind::Item(_) => { - pred - } + hir::StmtKind::Item(_) => pred, hir::StmtKind::Expr(ref expr) | hir::StmtKind::Semi(ref expr) => { self.expr(&expr, pred) @@ -154,12 +153,12 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { } } - fn pats_all<'b, I: Iterator>>( + /// Handles case where all of the patterns must match. + fn pats_all<'b, I: Iterator>>( &mut self, pats: I, - pred: CFGIndex + pred: CFGIndex, ) -> CFGIndex { - //! Handles case where all of the patterns must match. pats.fold(pred, |pred, pat| self.pat(&pat, pred)) } @@ -185,15 +184,15 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { // Note that `break` and `loop` statements // may cause additional edges. - let loopback = self.add_dummy_node(&[pred]); // 1 - let expr_exit = self.add_ast_node(expr.hir_id.local_id, &[]); // 2 + let loopback = self.add_dummy_node(&[pred]); // 1 + let expr_exit = self.add_ast_node(expr.hir_id.local_id, &[]); // 2 self.loop_scopes.push(LoopScope { loop_id: expr.hir_id.local_id, continue_index: loopback, break_index: expr_exit, }); - let body_exit = self.block(&body, loopback); // 3 - self.add_contained_edge(body_exit, loopback); // 4 + let body_exit = self.block(&body, loopback); // 3 + self.add_contained_edge(body_exit, loopback); // 4 self.loop_scopes.pop(); expr_exit } @@ -217,9 +216,9 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { // v 3 v 4 // [..exit..] // - let l_exit = self.expr(&l, pred); // 1 - let r_exit = self.expr(&r, l_exit); // 2 - self.add_ast_node(expr.hir_id.local_id, &[l_exit, r_exit]) // 3,4 + let l_exit = self.expr(&l, pred); // 1 + let r_exit = self.expr(&r, l_exit); // 2 + self.add_ast_node(expr.hir_id.local_id, &[l_exit, r_exit]) // 3,4 } hir::ExprKind::Ret(ref v) => { @@ -313,11 +312,13 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { } } - fn call<'b, I: Iterator>(&mut self, - call_expr: &hir::Expr, - pred: CFGIndex, - func_or_rcvr: &hir::Expr, - args: I) -> CFGIndex { + fn call<'b, I: Iterator>( + &mut self, + call_expr: &hir::Expr, + pred: CFGIndex, + func_or_rcvr: &hir::Expr, + args: I, + ) -> CFGIndex { let func_or_rcvr_exit = self.expr(func_or_rcvr, pred); let ret = self.straightline(call_expr, func_or_rcvr_exit, args); let m = self.tcx.hir().get_module_parent(call_expr.hir_id); @@ -328,33 +329,38 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { } } - fn exprs<'b, I: Iterator>(&mut self, - exprs: I, - pred: CFGIndex) -> CFGIndex { - //! Constructs graph for `exprs` evaluated in order + /// Constructs graph for `exprs` evaluated in order. + fn exprs<'b, I: Iterator>( + &mut self, + exprs: I, + pred: CFGIndex, + ) -> CFGIndex { exprs.fold(pred, |p, e| self.expr(e, p)) } - fn opt_expr(&mut self, - opt_expr: &Option>, - pred: CFGIndex) -> CFGIndex { - //! Constructs graph for `opt_expr` evaluated, if Some + /// Constructs graph for `opt_expr` evaluated, if `Some`. + fn opt_expr( + &mut self, + opt_expr: &Option>, + pred: CFGIndex, + ) -> CFGIndex { opt_expr.iter().fold(pred, |p, e| self.expr(&e, p)) } - fn straightline<'b, I: Iterator>(&mut self, - expr: &hir::Expr, - pred: CFGIndex, - subexprs: I) -> CFGIndex { - //! Handles case of an expression that evaluates `subexprs` in order - + /// Handles case of an expression that evaluates `subexprs` in order. + fn straightline<'b, I: Iterator>( + &mut self, + expr: &hir::Expr, + pred: CFGIndex, + subexprs: I, + ) -> CFGIndex { let subexprs_exit = self.exprs(subexprs, pred); self.add_ast_node(expr.hir_id.local_id, &[subexprs_exit]) } fn match_(&mut self, id: hir::ItemLocalId, discr: &hir::Expr, arms: &[hir::Arm], pred: CFGIndex) -> CFGIndex { - // The CFG for match expression is quite complex, so no ASCII + // The CFG for match expressions is quite complex, so no ASCII // art for it (yet). // // The CFG generated below matches roughly what MIR contains. @@ -369,13 +375,13 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { // // What is going on is explained in further comments. - // Visit the discriminant expression + // Visit the discriminant expression. let discr_exit = self.expr(discr, pred); // Add a node for the exit of the match expression as a whole. let expr_exit = self.add_ast_node(id, &[]); - // Keep track of the previous guard expressions + // Keep track of the previous guard expressions. let mut prev_guard = None; let match_scope = region::Scope { id, data: region::ScopeData::Node }; @@ -388,12 +394,12 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { // Visit the pattern, coming from the discriminant exit let mut pat_exit = self.pat(&pat, discr_exit); - // If there is a guard expression, handle it here + // If there is a guard expression, handle it here. if let Some(ref guard) = arm.guard { // Add a dummy node for the previous guard - // expression to target + // expression to target. let guard_start = self.add_dummy_node(&[pat_exit]); - // Visit the guard expression + // Visit the guard expression. let guard_exit = match guard { hir::Guard::If(ref e) => (&**e, self.expr(e, guard_start)), }; @@ -407,24 +413,23 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { self.add_exiting_edge(prev_guard, prev_index, match_scope, guard_start); } - // Push the guard onto the list of previous guards + // Push the guard onto the list of previous guards. prev_guard = Some(guard_exit); - // Update the exit node for the pattern + // Update the exit node for the pattern. pat_exit = guard_exit.1; } - // Add an edge from the exit of this pattern to the - // exit of the arm + // Add an edge from the exit of this pattern to the exit of the arm. self.add_contained_edge(pat_exit, bindings_exit); } - // Visit the body of this arm + // Visit the body of this arm. let body_exit = self.expr(&arm.body, bindings_exit); let arm_exit = self.add_ast_node(arm.hir_id.local_id, &[body_exit]); - // Link the body to the exit of the expression + // Link the body to the exit of the expression. self.add_contained_edge(arm_exit, expr_exit); } @@ -451,18 +456,22 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { node } - fn add_contained_edge(&mut self, - source: CFGIndex, - target: CFGIndex) { + fn add_contained_edge( + &mut self, + source: CFGIndex, + target: CFGIndex, + ) { let data = CFGEdgeData {exiting_scopes: vec![] }; self.graph.add_edge(source, target, data); } - fn add_exiting_edge(&mut self, - from_expr: &hir::Expr, - from_index: CFGIndex, - target_scope: region::Scope, - to_index: CFGIndex) { + fn add_exiting_edge( + &mut self, + from_expr: &hir::Expr, + from_index: CFGIndex, + target_scope: region::Scope, + to_index: CFGIndex, + ) { let mut data = CFGEdgeData { exiting_scopes: vec![] }; let mut scope = region::Scope { id: from_expr.hir_id.local_id, @@ -476,9 +485,11 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { self.graph.add_edge(from_index, to_index, data); } - fn add_returning_edge(&mut self, - _from_expr: &hir::Expr, - from_index: CFGIndex) { + fn add_returning_edge( + &mut self, + _from_expr: &hir::Expr, + from_index: CFGIndex, + ) { let data = CFGEdgeData { exiting_scopes: self.loop_scopes.iter() .rev() @@ -488,11 +499,12 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { self.graph.add_edge(from_index, self.fn_exit, data); } - fn find_scope_edge(&self, - expr: &hir::Expr, - destination: hir::Destination, - scope_cf_kind: ScopeCfKind) -> (region::Scope, CFGIndex) { - + fn find_scope_edge( + &self, + expr: &hir::Expr, + destination: hir::Destination, + scope_cf_kind: ScopeCfKind, + ) -> (region::Scope, CFGIndex) { match destination.target_id { Ok(loop_id) => { for b in &self.breakable_block_scopes { @@ -519,7 +531,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> { }); } } - span_bug!(expr.span, "no scope for id {}", loop_id); + span_bug!(expr.span, "no scope for ID {}", loop_id); } Err(err) => span_bug!(expr.span, "scope error: {}", err), } diff --git a/src/librustc_ast_borrowck/cfg/graphviz.rs b/src/librustc_ast_borrowck/cfg/graphviz.rs index 46409f1a1cebf..99c6b49cad5d9 100644 --- a/src/librustc_ast_borrowck/cfg/graphviz.rs +++ b/src/librustc_ast_borrowck/cfg/graphviz.rs @@ -1,4 +1,4 @@ -/// This module provides linkage between rustc::middle::graph and +/// This module provides linkage between `rustc::middle::graph` and /// libgraphviz traits. use crate::cfg; @@ -12,7 +12,7 @@ pub struct LabelledCFG<'a, 'tcx> { pub tcx: TyCtxt<'tcx>, pub cfg: &'a cfg::CFG, pub name: String, - /// `labelled_edges` controls whether we emit labels on the edges + /// `labelled_edges` controls whether we emit labels on the edges. pub labelled_edges: bool, } @@ -25,12 +25,12 @@ impl<'a, 'tcx> LabelledCFG<'a, 'tcx> { }; let s = self.tcx.hir().node_to_string(hir_id); - // Replacing newlines with \\l causes each line to be left-aligned, + // Replacing newlines with `\\l` causes each line to be left-aligned, // improving presentation of (long) pretty-printed expressions. if s.contains("\n") { let mut s = s.replace("\n", "\\l"); // Apparently left-alignment applies to the line that precedes - // \l, not the line that follows; so, add \l at end of string + // `\l`, not the line that follows; so, add `\l` at end of string // if not already present, ensuring last line gets left-aligned // as well. let mut last_two: Vec<_> = @@ -109,8 +109,7 @@ impl<'a> dot::GraphWalk<'a> for &'a cfg::CFG { } } -impl<'a, 'hir> dot::GraphWalk<'a> for LabelledCFG<'a, 'hir> -{ +impl<'a, 'hir> dot::GraphWalk<'a> for LabelledCFG<'a, 'hir> { type Node = Node<'a>; type Edge = Edge<'a>; fn nodes(&'a self) -> dot::Nodes<'a, Node<'a>> { self.cfg.nodes() } diff --git a/src/librustc_codegen_llvm/Cargo.toml b/src/librustc_codegen_llvm/Cargo.toml index 5e1b0eafdec36..98efa6a5804bd 100644 --- a/src/librustc_codegen_llvm/Cargo.toml +++ b/src/librustc_codegen_llvm/Cargo.toml @@ -11,11 +11,7 @@ crate-type = ["dylib"] test = false [dependencies] -cc = "1.0.1" # Used to locate MSVC -num_cpus = "1.0" -tempfile = "3.0" rustc_llvm = { path = "../librustc_llvm" } -memmap = "0.6" [features] # This is used to convince Cargo to separately cache builds of `rustc_codegen_llvm` diff --git a/src/librustc_codegen_llvm/error_codes.rs b/src/librustc_codegen_llvm/error_codes.rs index c6b5dc03a6f0a..042e51ed2ba7a 100644 --- a/src/librustc_codegen_llvm/error_codes.rs +++ b/src/librustc_codegen_llvm/error_codes.rs @@ -1,4 +1,4 @@ -register_long_diagnostics! { +register_diagnostics! { E0511: r##" Invalid monomorphization of an intrinsic function was used. Erroneous code diff --git a/src/librustc_codegen_llvm/lib.rs b/src/librustc_codegen_llvm/lib.rs index 2fd78885bd01e..9f2c303145dc8 100644 --- a/src/librustc_codegen_llvm/lib.rs +++ b/src/librustc_codegen_llvm/lib.rs @@ -14,7 +14,6 @@ #![feature(in_band_lifetimes)] #![feature(libc)] #![feature(nll)] -#![feature(rustc_diagnostic_macros)] #![feature(optin_builtin_traits)] #![feature(concat_idents)] #![feature(link_args)] @@ -256,7 +255,7 @@ impl CodegenBackend for LlvmCodegenBackend { } fn diagnostics(&self) -> &[(&'static str, &'static str)] { - &DIAGNOSTICS + &error_codes::DIAGNOSTICS } fn target_features(&self, sess: &Session) -> Vec { @@ -425,5 +424,3 @@ impl Drop for ModuleLlvm { } } } - -__build_diagnostic_array! { librustc_codegen_llvm, DIAGNOSTICS } diff --git a/src/librustc_codegen_ssa/error_codes.rs b/src/librustc_codegen_ssa/error_codes.rs index 8d46dcb7c09c3..8ff41c275a8f4 100644 --- a/src/librustc_codegen_ssa/error_codes.rs +++ b/src/librustc_codegen_ssa/error_codes.rs @@ -1,4 +1,4 @@ -register_long_diagnostics! { +syntax::register_diagnostics! { E0668: r##" Malformed inline assembly rejected by LLVM. diff --git a/src/librustc_codegen_ssa/lib.rs b/src/librustc_codegen_ssa/lib.rs index 68640abb0433e..90bf964ceaa13 100644 --- a/src/librustc_codegen_ssa/lib.rs +++ b/src/librustc_codegen_ssa/lib.rs @@ -4,7 +4,6 @@ #![feature(box_syntax)] #![feature(core_intrinsics)] #![feature(libc)] -#![feature(rustc_diagnostic_macros)] #![feature(stmt_expr_attributes)] #![feature(try_blocks)] #![feature(in_band_lifetimes)] @@ -35,8 +34,6 @@ use rustc_data_structures::svh::Svh; use rustc::middle::cstore::{LibSource, CrateSource, NativeLibrary}; use syntax_pos::symbol::Symbol; -// N.B., this module needs to be declared first so diagnostics are -// registered before they are used. mod error_codes; pub mod common; @@ -158,5 +155,3 @@ pub struct CodegenResults { pub linker_info: back::linker::LinkerInfo, pub crate_info: CrateInfo, } - -__build_diagnostic_array! { librustc_codegen_ssa, DIAGNOSTICS } diff --git a/src/librustc_codegen_utils/lib.rs b/src/librustc_codegen_utils/lib.rs index 4ea375b59b2c0..1201446afb531 100644 --- a/src/librustc_codegen_utils/lib.rs +++ b/src/librustc_codegen_utils/lib.rs @@ -10,7 +10,6 @@ #![feature(core_intrinsics)] #![feature(never_type)] #![feature(nll)] -#![feature(rustc_diagnostic_macros)] #![feature(in_band_lifetimes)] #![recursion_limit="256"] diff --git a/src/librustc_driver/Cargo.toml b/src/librustc_driver/Cargo.toml index b030517e28ec2..a839ee56b2b6e 100644 --- a/src/librustc_driver/Cargo.toml +++ b/src/librustc_driver/Cargo.toml @@ -12,7 +12,7 @@ crate-type = ["dylib"] [dependencies] graphviz = { path = "../libgraphviz" } log = "0.4" -env_logger = { version = "0.5", default-features = false } +env_logger = { version = "0.6", default-features = false } rustc = { path = "../librustc" } rustc_target = { path = "../librustc_target" } rustc_ast_borrowck = { path = "../librustc_ast_borrowck" } diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 9a6a12e261c10..a912ea3c35821 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -9,7 +9,6 @@ #![feature(box_syntax)] #![cfg_attr(unix, feature(libc))] #![feature(nll)] -#![feature(rustc_diagnostic_macros)] #![feature(set_stdio)] #![feature(no_debug)] #![feature(integer_atomics)] diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs index 7fcad4d79c204..3cfae1686dfdf 100644 --- a/src/librustc_interface/passes.rs +++ b/src/librustc_interface/passes.rs @@ -34,7 +34,7 @@ use rustc_privacy; use rustc_resolve::{Resolver, ResolverArenas}; use rustc_traits; use rustc_typeck as typeck; -use syntax::{self, ast, diagnostics, visit}; +use syntax::{self, ast, visit}; use syntax::early_buffered_lints::BufferedEarlyLint; use syntax::ext::base::{NamedSyntaxExtension, ExtCtxt}; use syntax::mut_visit::MutVisitor; @@ -283,21 +283,6 @@ pub fn register_plugins<'a>( let mut registry = Registry::new(sess, krate.span); time(sess, "plugin registration", || { - if sess.features_untracked().rustc_diagnostic_macros { - registry.register_macro( - "__diagnostic_used", - diagnostics::plugin::expand_diagnostic_used, - ); - registry.register_macro( - "__register_diagnostic", - diagnostics::plugin::expand_register_diagnostic, - ); - registry.register_macro( - "__build_diagnostic_array", - diagnostics::plugin::expand_build_diagnostic_array, - ); - } - for registrar in registrars { registry.args_hidden = Some(registrar.args); (registrar.fun)(&mut registry); diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs index f007a0cf2abee..9eaf7b77716f3 100644 --- a/src/librustc_interface/util.rs +++ b/src/librustc_interface/util.rs @@ -43,17 +43,17 @@ use std::{thread, panic}; pub fn diagnostics_registry() -> Registry { let mut all_errors = Vec::new(); - all_errors.extend_from_slice(&rustc::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_typeck::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_resolve::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_privacy::DIAGNOSTICS); + all_errors.extend_from_slice(&rustc::error_codes::DIAGNOSTICS); + all_errors.extend_from_slice(&rustc_typeck::error_codes::DIAGNOSTICS); + all_errors.extend_from_slice(&rustc_resolve::error_codes::DIAGNOSTICS); + all_errors.extend_from_slice(&rustc_privacy::error_codes::DIAGNOSTICS); // FIXME: need to figure out a way to get these back in here // all_errors.extend_from_slice(get_codegen_backend(sess).diagnostics()); - all_errors.extend_from_slice(&rustc_metadata::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_passes::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_plugin::DIAGNOSTICS); - all_errors.extend_from_slice(&rustc_mir::DIAGNOSTICS); - all_errors.extend_from_slice(&syntax::DIAGNOSTICS); + all_errors.extend_from_slice(&rustc_metadata::error_codes::DIAGNOSTICS); + all_errors.extend_from_slice(&rustc_passes::error_codes::DIAGNOSTICS); + all_errors.extend_from_slice(&rustc_plugin::error_codes::DIAGNOSTICS); + all_errors.extend_from_slice(&rustc_mir::error_codes::DIAGNOSTICS); + all_errors.extend_from_slice(&syntax::error_codes::DIAGNOSTICS); Registry::new(&all_errors) } diff --git a/src/librustc_lint/error_codes.rs b/src/librustc_lint/error_codes.rs index d7c39b780bfdf..ea2e1d9ecc53f 100644 --- a/src/librustc_lint/error_codes.rs +++ b/src/librustc_lint/error_codes.rs @@ -1,5 +1,4 @@ -use syntax::register_diagnostics; - -register_diagnostics! { +syntax::register_diagnostics! { +; E0721, // `await` keyword } diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs index 27833161ef23d..4ee6551f78781 100644 --- a/src/librustc_lint/lib.rs +++ b/src/librustc_lint/lib.rs @@ -15,7 +15,6 @@ #![feature(box_patterns)] #![feature(box_syntax)] #![feature(nll)] -#![feature(rustc_diagnostic_macros)] #![recursion_limit="256"] diff --git a/src/librustc_metadata/error_codes.rs b/src/librustc_metadata/error_codes.rs index 0708a6243bf29..cd8e95e6c3a11 100644 --- a/src/librustc_metadata/error_codes.rs +++ b/src/librustc_metadata/error_codes.rs @@ -1,6 +1,4 @@ -use syntax::{register_diagnostics, register_long_diagnostics}; - -register_long_diagnostics! { +syntax::register_diagnostics! { E0454: r##" A link name was given with an empty name. Erroneous code example: @@ -84,10 +82,7 @@ You need to link your code to the relevant crate in order to be able to use it (through Cargo or the `-L` option of rustc example). Plugins are crates as well, and you link to them the same way. "##, - -} - -register_diagnostics! { +; E0456, // plugin `..` is not available for triple `..` E0457, // plugin `..` only found in rlib format, but must be available... E0514, // metadata version mismatch @@ -97,5 +92,6 @@ register_diagnostics! { E0464, // multiple matching crates for `..` E0465, // multiple .. candidates for `..` found E0519, // local crate and dependency have same (crate-name, disambiguator) - E0523, // two dependencies have same (crate-name, disambiguator) but different SVH + // two dependencies have same (crate-name, disambiguator) but different SVH + E0523, } diff --git a/src/librustc_metadata/lib.rs b/src/librustc_metadata/lib.rs index c96d02d9b37de..e6104e629e9fb 100644 --- a/src/librustc_metadata/lib.rs +++ b/src/librustc_metadata/lib.rs @@ -8,7 +8,6 @@ #![feature(nll)] #![feature(proc_macro_internals)] #![feature(proc_macro_quote)] -#![feature(rustc_diagnostic_macros)] #![feature(rustc_private)] #![feature(slice_patterns)] #![feature(specialization)] @@ -23,7 +22,7 @@ extern crate rustc; #[macro_use] extern crate rustc_data_structures; -mod error_codes; +pub mod error_codes; mod index; mod encoder; @@ -68,5 +67,3 @@ pub fn validate_crate_name( sess.unwrap().abort_if_errors(); } } - -__build_diagnostic_array! { librustc_metadata, DIAGNOSTICS } diff --git a/src/librustc_mir/error_codes.rs b/src/librustc_mir/error_codes.rs index 22432db819020..d80449ac23724 100644 --- a/src/librustc_mir/error_codes.rs +++ b/src/librustc_mir/error_codes.rs @@ -1,4 +1,4 @@ -register_long_diagnostics! { +syntax::register_diagnostics! { E0001: r##" @@ -2448,9 +2448,9 @@ information. There are some known bugs that trigger this message. "##, -} -register_diagnostics! { +; + // E0298, // cannot compare constants // E0299, // mismatched types between arms // E0471, // constant evaluation error (in pattern) diff --git a/src/librustc_mir/lib.rs b/src/librustc_mir/lib.rs index cccf7b9545bdb..f27db351b74db 100644 --- a/src/librustc_mir/lib.rs +++ b/src/librustc_mir/lib.rs @@ -14,7 +14,6 @@ Rust MIR: a lowered representation of Rust. Also: an experiment! #![feature(const_fn)] #![feature(decl_macro)] #![feature(exhaustive_patterns)] -#![feature(rustc_diagnostic_macros)] #![feature(never_type)] #![feature(specialization)] #![feature(try_trait)] @@ -32,7 +31,7 @@ Rust MIR: a lowered representation of Rust. Also: an experiment! #[macro_use] extern crate rustc_data_structures; #[macro_use] extern crate syntax; -mod error_codes; +pub mod error_codes; mod borrow_check; mod build; @@ -62,5 +61,3 @@ pub fn provide(providers: &mut Providers<'_>) { }; providers.type_name = interpret::type_name; } - -__build_diagnostic_array! { librustc_mir, DIAGNOSTICS } diff --git a/src/librustc_passes/error_codes.rs b/src/librustc_passes/error_codes.rs index a30cd8a627fe3..af07c790e2a87 100644 --- a/src/librustc_passes/error_codes.rs +++ b/src/librustc_passes/error_codes.rs @@ -1,6 +1,4 @@ -use syntax::{register_diagnostics, register_long_diagnostics}; - -register_long_diagnostics! { +syntax::register_diagnostics! { /* E0014: r##" Constants can only be initialized by a constant value or, in a future @@ -320,10 +318,8 @@ async fn foo() {} ``` Switch to the Rust 2018 edition to use `async fn`. -"## -} - -register_diagnostics! { +"##, +; E0226, // only a single explicit lifetime bound is permitted E0472, // asm! is unsupported on this target E0561, // patterns aren't allowed in function pointer types diff --git a/src/librustc_passes/lib.rs b/src/librustc_passes/lib.rs index 5614b570b927a..cf2da4ffa2af0 100644 --- a/src/librustc_passes/lib.rs +++ b/src/librustc_passes/lib.rs @@ -9,7 +9,6 @@ #![feature(in_band_lifetimes)] #![feature(nll)] #![feature(bind_by_move_pattern_guards)] -#![feature(rustc_diagnostic_macros)] #![recursion_limit="256"] @@ -18,7 +17,7 @@ extern crate rustc; use rustc::ty::query::Providers; -mod error_codes; +pub mod error_codes; pub mod ast_validation; pub mod rvalue_promotion; @@ -26,8 +25,6 @@ pub mod hir_stats; pub mod layout_test; pub mod loops; -__build_diagnostic_array! { librustc_passes, DIAGNOSTICS } - pub fn provide(providers: &mut Providers<'_>) { rvalue_promotion::provide(providers); loops::provide(providers); diff --git a/src/librustc_plugin/error_codes.rs b/src/librustc_plugin/error_codes.rs index b5f6a8d905d31..7b3f01c0ee111 100644 --- a/src/librustc_plugin/error_codes.rs +++ b/src/librustc_plugin/error_codes.rs @@ -1,9 +1,4 @@ -use syntax::{register_diagnostics, register_long_diagnostics}; - -register_long_diagnostics! { - -} - -register_diagnostics! { - E0498 // malformed plugin attribute +syntax::register_diagnostics! { +; + E0498, // malformed plugin attribute } diff --git a/src/librustc_plugin/lib.rs b/src/librustc_plugin/lib.rs index 952bc9fff6a71..4e1a47c503e59 100644 --- a/src/librustc_plugin/lib.rs +++ b/src/librustc_plugin/lib.rs @@ -54,15 +54,12 @@ #![doc(html_root_url = "https://doc.rust-lang.org/nightly/")] #![feature(nll)] -#![feature(rustc_diagnostic_macros)] #![recursion_limit="256"] pub use registry::Registry; -mod error_codes; +pub mod error_codes; pub mod registry; pub mod load; pub mod build; - -__build_diagnostic_array! { librustc_plugin, DIAGNOSTICS } diff --git a/src/librustc_privacy/error_codes.rs b/src/librustc_privacy/error_codes.rs index 70a799d426a07..67066466f1d22 100644 --- a/src/librustc_privacy/error_codes.rs +++ b/src/librustc_privacy/error_codes.rs @@ -1,4 +1,4 @@ -register_long_diagnostics! { +syntax::register_diagnostics! { E0445: r##" A private trait was used on a public type parameter bound. Erroneous code @@ -154,8 +154,5 @@ let f = Bar::Foo::new(); // ok! ``` "##, -} - -register_diagnostics! { // E0450, moved into resolve } diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 146058963b69d..1e61f78c357df 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -2,7 +2,6 @@ #![feature(in_band_lifetimes)] #![feature(nll)] -#![feature(rustc_diagnostic_macros)] #![recursion_limit="256"] @@ -31,7 +30,7 @@ use syntax_pos::Span; use std::{cmp, fmt, mem}; use std::marker::PhantomData; -mod error_codes; +pub mod error_codes; //////////////////////////////////////////////////////////////////////////////// /// Generic infrastructure used to implement specific visitors below. @@ -2035,5 +2034,3 @@ fn check_private_in_public(tcx: TyCtxt<'_>, krate: CrateNum) { }; krate.visit_all_item_likes(&mut DeepVisitor::new(&mut visitor)); } - -__build_diagnostic_array! { librustc_privacy, DIAGNOSTICS } diff --git a/src/librustc_resolve/error_codes.rs b/src/librustc_resolve/error_codes.rs index 1faaf97e981c1..adbff67cc8dac 100644 --- a/src/librustc_resolve/error_codes.rs +++ b/src/librustc_resolve/error_codes.rs @@ -1,9 +1,7 @@ -use syntax::{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. -register_long_diagnostics! { +syntax::register_diagnostics! { E0128: r##" Type parameter defaults can only use parameters that occur before them. @@ -1662,10 +1660,7 @@ fn const_id() -> T { // error: const parameter } ``` "##, - -} - -register_diagnostics! { +; // E0153, unused error code // E0157, unused error code // E0257, diff --git a/src/librustc_resolve/late.rs b/src/librustc_resolve/late.rs index 3ddaf2d94f9c8..aae283b745236 100644 --- a/src/librustc_resolve/late.rs +++ b/src/librustc_resolve/late.rs @@ -298,18 +298,18 @@ impl<'a> PathSource<'a> { } fn error_code(self, has_unexpected_resolution: bool) -> &'static str { - __diagnostic_used!(E0404); - __diagnostic_used!(E0405); - __diagnostic_used!(E0412); - __diagnostic_used!(E0422); - __diagnostic_used!(E0423); - __diagnostic_used!(E0425); - __diagnostic_used!(E0531); - __diagnostic_used!(E0532); - __diagnostic_used!(E0573); - __diagnostic_used!(E0574); - __diagnostic_used!(E0575); - __diagnostic_used!(E0576); + syntax::diagnostic_used!(E0404); + syntax::diagnostic_used!(E0405); + syntax::diagnostic_used!(E0412); + syntax::diagnostic_used!(E0422); + syntax::diagnostic_used!(E0423); + syntax::diagnostic_used!(E0425); + syntax::diagnostic_used!(E0531); + syntax::diagnostic_used!(E0532); + syntax::diagnostic_used!(E0573); + syntax::diagnostic_used!(E0574); + syntax::diagnostic_used!(E0575); + syntax::diagnostic_used!(E0576); match (self, has_unexpected_resolution) { (PathSource::Trait(_), true) => "E0404", (PathSource::Trait(_), false) => "E0405", diff --git a/src/librustc_resolve/late/diagnostics.rs b/src/librustc_resolve/late/diagnostics.rs index a822fa049ca1c..0c86d8494fde8 100644 --- a/src/librustc_resolve/late/diagnostics.rs +++ b/src/librustc_resolve/late/diagnostics.rs @@ -113,7 +113,7 @@ impl<'a> LateResolutionVisitor<'a, '_> { // Emit special messages for unresolved `Self` and `self`. if is_self_type(path, ns) { - __diagnostic_used!(E0411); + syntax::diagnostic_used!(E0411); err.code(DiagnosticId::Error("E0411".into())); err.span_label(span, format!("`Self` is only available in impls, traits, \ and type definitions")); @@ -122,7 +122,7 @@ impl<'a> LateResolutionVisitor<'a, '_> { if is_self_value(path, ns) { debug!("smart_resolve_path_fragment: E0424, source={:?}", source); - __diagnostic_used!(E0424); + syntax::diagnostic_used!(E0424); err.code(DiagnosticId::Error("E0424".into())); err.span_label(span, match source { PathSource::Pat => { diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 7f65e5dfaa2bf..e980b8d01f7a8 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -14,7 +14,6 @@ #![feature(label_break_value)] #![feature(mem_take)] #![feature(nll)] -#![feature(rustc_diagnostic_macros)] #![recursion_limit="256"] @@ -68,9 +67,7 @@ use macros::{LegacyBinding, LegacyScope}; type Res = def::Res; -// N.B., this module needs to be declared first so diagnostics are -// registered before they are used. -mod error_codes; +pub mod error_codes; mod diagnostics; mod late; mod macros; @@ -2840,5 +2837,3 @@ impl CrateLint { } } } - -__build_diagnostic_array! { librustc_resolve, DIAGNOSTICS } diff --git a/src/librustc_typeck/error_codes.rs b/src/librustc_typeck/error_codes.rs index 093446d28533e..e11dcfafb8f8b 100644 --- a/src/librustc_typeck/error_codes.rs +++ b/src/librustc_typeck/error_codes.rs @@ -1,6 +1,6 @@ // ignore-tidy-filelength -register_long_diagnostics! { +syntax::register_diagnostics! { E0023: r##" A pattern used to match against an enum variant must provide a sub-pattern for @@ -4870,10 +4870,7 @@ fn foo_recursive(n: usize) -> Pin>> { The `Box<...>` ensures that the result is of known size, and the pin is required to keep it in the same place in memory. "##, - -} // (end of detailed error messages) - -register_diagnostics! { +; // E0035, merged into E0087/E0089 // E0036, merged into E0087/E0089 // E0068, @@ -4930,7 +4927,8 @@ register_diagnostics! { // E0245, // not a trait // E0246, // invalid recursive type // E0247, -// E0248, // value used as a type, now reported earlier during resolution as E0412 +// E0248, // value used as a type, now reported earlier during resolution + // as E0412 // E0249, // E0319, // trait impls for defaulted traits allowed just for structs/enums // E0372, // coherence not object safe @@ -4938,7 +4936,7 @@ register_diagnostics! { // between structures with the same definition // E0558, // replaced with a generic attribute input check E0533, // `{}` does not name a unit variant, unit struct or a constant -// E0563, // cannot determine a type for this `impl Trait`: {} // removed in 6383de15 +// E0563, // cannot determine a type for this `impl Trait` removed in 6383de15 E0564, // only named lifetimes are allowed in `impl Trait`, // but `{}` was found in the type `{}` E0587, // type has conflicting packed and align representation hints @@ -4947,8 +4945,8 @@ register_diagnostics! { // E0612, // merged into E0609 // E0613, // Removed (merged with E0609) E0627, // yield statement outside of generator literal - E0632, // cannot provide explicit type parameters when `impl Trait` is used in - // argument position. + E0632, // cannot provide explicit type parameters when `impl Trait` is used + // in argument position. E0634, // type has conflicting packed representaton hints E0640, // infer outlives requirements E0641, // cannot cast to/from a pointer with an unknown kind diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 9d9a9d9b559e4..959483e4439ff 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -65,7 +65,6 @@ This API is completely unstable and subject to change. #![feature(exhaustive_patterns)] #![feature(in_band_lifetimes)] #![feature(nll)] -#![feature(rustc_diagnostic_macros)] #![feature(slice_patterns)] #![feature(never_type)] #![feature(inner_deref)] @@ -78,9 +77,7 @@ This API is completely unstable and subject to change. #[macro_use] extern crate rustc; -// N.B., this module needs to be declared first so diagnostics are -// registered before they are used. -mod error_codes; +pub mod error_codes; mod astconv; mod check; @@ -389,5 +386,3 @@ pub fn hir_trait_to_predicates<'tcx>( bounds } - -__build_diagnostic_array! { librustc_typeck, DIAGNOSTICS } diff --git a/src/librustc_typeck/structured_errors.rs b/src/librustc_typeck/structured_errors.rs index 3e3eab8cf4cfb..273a36edc56ff 100644 --- a/src/librustc_typeck/structured_errors.rs +++ b/src/librustc_typeck/structured_errors.rs @@ -48,7 +48,7 @@ impl<'tcx> StructuredDiagnostic<'tcx> for VariadicError<'tcx> { fn session(&self) -> &Session { self.sess } fn code(&self) -> DiagnosticId { - __diagnostic_used!(E0617); + syntax::diagnostic_used!(E0617); DiagnosticId::Error("E0617".to_owned()) } @@ -104,7 +104,7 @@ impl<'tcx> StructuredDiagnostic<'tcx> for SizedUnsizedCastError<'tcx> { fn session(&self) -> &Session { self.sess } fn code(&self) -> DiagnosticId { - __diagnostic_used!(E0607); + syntax::diagnostic_used!(E0607); DiagnosticId::Error("E0607".to_owned()) } diff --git a/src/libstd/sys/unix/process/process_common.rs b/src/libstd/sys/unix/process/process_common.rs index 72e66cc8e7240..713d308555956 100644 --- a/src/libstd/sys/unix/process/process_common.rs +++ b/src/libstd/sys/unix/process/process_common.rs @@ -1,19 +1,27 @@ use crate::os::unix::prelude::*; -use crate::ffi::{OsString, OsStr, CString, CStr}; +use crate::ffi::{OsString, OsStr, CString}; use crate::fmt; use crate::io; use crate::ptr; use crate::sys::fd::FileDesc; -use crate::sys::fs::{File, OpenOptions}; +use crate::sys::fs::File; use crate::sys::pipe::{self, AnonPipe}; use crate::sys_common::process::CommandEnv; use crate::collections::BTreeMap; +#[cfg(not(target_os = "fuchsia"))] +use { + crate::ffi::CStr, + crate::sys::fs::OpenOptions, +}; + use libc::{c_int, gid_t, uid_t, c_char, EXIT_SUCCESS, EXIT_FAILURE}; cfg_if::cfg_if! { - if #[cfg(target_os = "redox")] { + if #[cfg(target_os = "fuchsia")] { + // fuchsia doesn't have /dev/null + } else if #[cfg(target_os = "redox")] { const DEV_NULL: &'static str = "null:\0"; } else { const DEV_NULL: &'static str = "/dev/null\0"; @@ -107,6 +115,11 @@ pub enum ChildStdio { Inherit, Explicit(c_int), Owned(FileDesc), + + // On Fuchsia, null stdio is the default, so we simply don't specify + // any actions at the time of spawning. + #[cfg(target_os = "fuchsia")] + Null, } pub enum Stdio { @@ -325,6 +338,7 @@ impl Stdio { Ok((ChildStdio::Owned(theirs.into_fd()), Some(ours))) } + #[cfg(not(target_os = "fuchsia"))] Stdio::Null => { let mut opts = OpenOptions::new(); opts.read(readable); @@ -335,6 +349,11 @@ impl Stdio { let fd = File::open_c(&path, &opts)?; Ok((ChildStdio::Owned(fd.into_fd()), None)) } + + #[cfg(target_os = "fuchsia")] + Stdio::Null => { + Ok((ChildStdio::Null, None)) + } } } } @@ -357,6 +376,9 @@ impl ChildStdio { ChildStdio::Inherit => None, ChildStdio::Explicit(fd) => Some(fd), ChildStdio::Owned(ref fd) => Some(fd.raw()), + + #[cfg(target_os = "fuchsia")] + ChildStdio::Null => None, } } } diff --git a/src/libstd/sys/unix/process/process_fuchsia.rs b/src/libstd/sys/unix/process/process_fuchsia.rs index 7c6be9b0a6047..fff9fc6b3bbc8 100644 --- a/src/libstd/sys/unix/process/process_fuchsia.rs +++ b/src/libstd/sys/unix/process/process_fuchsia.rs @@ -48,30 +48,51 @@ impl Command { use crate::sys::process::zircon::*; let envp = match maybe_envp { - Some(envp) => envp.as_ptr(), + // None means to clone the current environment, which is done in the + // flags below. None => ptr::null(), + Some(envp) => envp.as_ptr(), }; - let transfer_or_clone = |opt_fd, target_fd| if let Some(local_fd) = opt_fd { - fdio_spawn_action_t { - action: FDIO_SPAWN_ACTION_TRANSFER_FD, - local_fd, - target_fd, - ..Default::default() - } - } else { - fdio_spawn_action_t { - action: FDIO_SPAWN_ACTION_CLONE_FD, - local_fd: target_fd, - target_fd, - ..Default::default() + let make_action = |local_io: &ChildStdio, target_fd| -> io::Result { + if let Some(local_fd) = local_io.fd() { + Ok(fdio_spawn_action_t { + action: FDIO_SPAWN_ACTION_TRANSFER_FD, + local_fd, + target_fd, + ..Default::default() + }) + } else { + if let ChildStdio::Null = local_io { + // acts as no-op + return Ok(Default::default()); + } + + let mut handle = ZX_HANDLE_INVALID; + let status = fdio_fd_clone(target_fd, &mut handle); + if status == ERR_INVALID_ARGS || status == ERR_NOT_SUPPORTED { + // This descriptor is closed; skip it rather than generating an + // error. + return Ok(Default::default()); + } + zx_cvt(status)?; + + let mut cloned_fd = 0; + zx_cvt(fdio_fd_create(handle, &mut cloned_fd))?; + + Ok(fdio_spawn_action_t { + action: FDIO_SPAWN_ACTION_TRANSFER_FD, + local_fd: cloned_fd as i32, + target_fd, + ..Default::default() + }) } }; // Clone stdin, stdout, and stderr - let action1 = transfer_or_clone(stdio.stdin.fd(), 0); - let action2 = transfer_or_clone(stdio.stdout.fd(), 1); - let action3 = transfer_or_clone(stdio.stderr.fd(), 2); + let action1 = make_action(&stdio.stdin, 0)?; + let action2 = make_action(&stdio.stdout, 1)?; + let action3 = make_action(&stdio.stderr, 2)?; let actions = [action1, action2, action3]; // We don't want FileDesc::drop to be called on any stdio. fdio_spawn_etc @@ -84,9 +105,11 @@ impl Command { let mut process_handle: zx_handle_t = 0; zx_cvt(fdio_spawn_etc( - 0, - FDIO_SPAWN_CLONE_JOB | FDIO_SPAWN_CLONE_LDSVC | FDIO_SPAWN_CLONE_NAMESPACE, - self.get_argv()[0], self.get_argv().as_ptr(), envp, 3, actions.as_ptr(), + ZX_HANDLE_INVALID, + FDIO_SPAWN_CLONE_JOB | FDIO_SPAWN_CLONE_LDSVC | FDIO_SPAWN_CLONE_NAMESPACE + | FDIO_SPAWN_CLONE_ENVIRON, // this is ignored when envp is non-null + self.get_argv()[0], self.get_argv().as_ptr(), envp, + actions.len() as size_t, actions.as_ptr(), &mut process_handle, ptr::null_mut(), ))?; diff --git a/src/libstd/sys/unix/process/zircon.rs b/src/libstd/sys/unix/process/zircon.rs index ec715d5490f6f..1ba48de3c0785 100644 --- a/src/libstd/sys/unix/process/zircon.rs +++ b/src/libstd/sys/unix/process/zircon.rs @@ -2,8 +2,9 @@ use crate::convert::TryInto; use crate::io; +use crate::i64; +use crate::mem::MaybeUninit; use crate::os::raw::c_char; -use crate::u64; use libc::{c_int, c_void, size_t}; @@ -14,8 +15,8 @@ pub type zx_status_t = i32; pub const ZX_HANDLE_INVALID: zx_handle_t = 0; -pub type zx_time_t = u64; -pub const ZX_TIME_INFINITE : zx_time_t = u64::MAX; +pub type zx_time_t = i64; +pub const ZX_TIME_INFINITE : zx_time_t = i64::MAX; pub type zx_signals_t = u32; @@ -120,8 +121,11 @@ pub struct fdio_spawn_action_t { extern { pub fn fdio_spawn_etc(job: zx_handle_t, flags: u32, path: *const c_char, argv: *const *const c_char, envp: *const *const c_char, - action_count: u64, actions: *const fdio_spawn_action_t, + action_count: size_t, actions: *const fdio_spawn_action_t, process: *mut zx_handle_t, err_msg: *mut c_char) -> zx_status_t; + + pub fn fdio_fd_clone(fd: c_int, out_handle: *mut zx_handle_t) -> zx_status_t; + pub fn fdio_fd_create(handle: zx_handle_t, fd: *mut c_int) -> zx_status_t; } // fdio_spawn_etc flags diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index c93e6d11ce711..bfb2db9596363 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -413,11 +413,11 @@ impl WherePredicate { #[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: Vec, - /// The type being bounded + /// The type being bounded. pub bounded_ty: P, - /// Trait and lifetime bounds (`Clone+Send+'static`) + /// Trait and lifetime bounds (`Clone + Send + 'static`). pub bounds: GenericBounds, } @@ -495,15 +495,15 @@ pub enum MetaItemKind { NameValue(Lit), } -/// A Block (`{ .. }`). +/// A block (`{ .. }`). /// /// E.g., `{ .. }` as in `fn foo() { .. }`. #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Block { - /// Statements in a block + /// The statements in the block. pub stmts: Vec, pub id: NodeId, - /// Distinguishes between `unsafe { ... }` and `{ ... }` + /// Distinguishes between `unsafe { ... }` and `{ ... }`. pub rules: BlockCheckMode, pub span: Span, } @@ -908,11 +908,11 @@ pub enum MacStmtStyle { /// Local represents a `let` statement, e.g., `let : = ;`. #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Local { + pub id: NodeId, pub pat: P, pub ty: Option>, /// Initializer expression to set the value, if any. pub init: Option>, - pub id: NodeId, pub span: Span, pub attrs: ThinVec, } @@ -970,7 +970,7 @@ pub struct AnonConst { pub value: P, } -/// An expression +/// An expression. #[derive(Clone, RustcEncodable, RustcDecodable)] pub struct Expr { pub id: NodeId, @@ -984,26 +984,26 @@ pub struct Expr { static_assert_size!(Expr, 96); impl Expr { - /// Whether this expression would be valid somewhere that expects a value; for example, an `if` - /// condition. + /// Returns `true` if this expression would be valid somewhere that expects a value; + /// for example, an `if` condition. pub fn returns(&self) -> bool { if let ExprKind::Block(ref block, _) = self.node { match block.stmts.last().map(|last_stmt| &last_stmt.node) { - // implicit return + // Implicit return Some(&StmtKind::Expr(_)) => true, Some(&StmtKind::Semi(ref expr)) => { if let ExprKind::Ret(_) = expr.node { - // last statement is explicit return + // Last statement is explicit return. true } else { false } } - // This is a block that doesn't end in either an implicit or explicit return + // This is a block that doesn't end in either an implicit or explicit return. _ => false, } } else { - // This is not a block, it is a value + // This is not a block, it is a value. true } } @@ -2307,37 +2307,37 @@ impl Default for FnHeader { #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub enum ItemKind { - /// An `extern crate` item, with optional *original* crate name if the crate was renamed. + /// An `extern crate` item, with the optional *original* crate name if the crate was renamed. /// /// E.g., `extern crate foo` or `extern crate foo_bar as foo`. ExternCrate(Option), - /// A use declaration (`use` or `pub use`) item. + /// A use declaration item (`use`). /// /// E.g., `use foo;`, `use foo::bar;` or `use foo::bar as FooBar;`. Use(P), - /// A static item (`static` or `pub static`). + /// A static item (`static`). /// /// E.g., `static FOO: i32 = 42;` or `static FOO: &'static str = "bar";`. Static(P, Mutability, P), - /// A constant item (`const` or `pub const`). + /// A constant item (`const`). /// /// E.g., `const FOO: i32 = 42;`. Const(P, P), - /// A function declaration (`fn` or `pub fn`). + /// A function declaration (`fn`). /// /// E.g., `fn foo(bar: usize) -> usize { .. }`. Fn(P, FnHeader, Generics, P), - /// A module declaration (`mod` or `pub mod`). + /// A module declaration (`mod`). /// /// E.g., `mod foo;` or `mod foo { .. }`. Mod(Mod), - /// An external module (`extern` or `pub extern`). + /// An external module (`extern`). /// /// E.g., `extern {}` or `extern "C" {}`. ForeignMod(ForeignMod), /// Module-level inline assembly (from `global_asm!()`). GlobalAsm(P), - /// A type alias (`type` or `pub type`). + /// A type alias (`type`). /// /// E.g., `type Foo = Bar;`. TyAlias(P, Generics), @@ -2345,19 +2345,19 @@ pub enum ItemKind { /// /// E.g., `type Foo = impl Bar + Boo;`. OpaqueTy(GenericBounds, Generics), - /// An enum definition (`enum` or `pub enum`). + /// An enum definition (`enum`). /// /// E.g., `enum Foo { C, D }`. Enum(EnumDef, Generics), - /// A struct definition (`struct` or `pub struct`). + /// A struct definition (`struct`). /// /// E.g., `struct Foo { x: A }`. Struct(VariantData, Generics), - /// A union definition (`union` or `pub union`). + /// A union definition (`union`). /// /// E.g., `union Foo { x: A, y: B }`. Union(VariantData, Generics), - /// A Trait declaration (`trait` or `pub trait`). + /// A trait declaration (`trait`). /// /// E.g., `trait Foo { .. }`, `trait Foo { .. }` or `auto trait Foo {}`. Trait(IsAuto, Unsafety, Generics, GenericBounds, Vec), diff --git a/src/libsyntax/attr/mod.rs b/src/libsyntax/attr/mod.rs index 69de3150354e7..1f954064944dc 100644 --- a/src/libsyntax/attr/mod.rs +++ b/src/libsyntax/attr/mod.rs @@ -1,4 +1,4 @@ -//! Functions dealing with attributes and meta items +//! Functions dealing with attributes and meta items. mod builtin; @@ -61,7 +61,7 @@ pub fn is_known_lint_tool(m_item: Ident) -> bool { } impl NestedMetaItem { - /// Returns the MetaItem if self is a NestedMetaItem::MetaItem. + /// Returns the `MetaItem` if `self` is a `NestedMetaItem::MetaItem`. pub fn meta_item(&self) -> Option<&MetaItem> { match *self { NestedMetaItem::MetaItem(ref item) => Some(item), @@ -69,7 +69,7 @@ impl NestedMetaItem { } } - /// Returns the Lit if self is a NestedMetaItem::Literal. + /// Returns the `Lit` if `self` is a `NestedMetaItem::Literal`s. pub fn literal(&self) -> Option<&Lit> { match *self { NestedMetaItem::Literal(ref lit) => Some(lit), @@ -82,7 +82,7 @@ impl NestedMetaItem { self.meta_item().map_or(false, |meta_item| meta_item.check_name(name)) } - /// For a single-segment meta-item returns its name, otherwise returns `None`. + /// For a single-segment meta item, returns its name; otherwise, returns `None`. pub fn ident(&self) -> Option { self.meta_item().and_then(|meta_item| meta_item.ident()) } @@ -90,13 +90,13 @@ impl NestedMetaItem { self.ident().unwrap_or(Ident::invalid()).name } - /// Gets the string value if self is a MetaItem and the MetaItem is a - /// MetaItemKind::NameValue variant containing a string, otherwise None. + /// Gets the string value if `self` is a `MetaItem` and the `MetaItem` is a + /// `MetaItemKind::NameValue` variant containing a string, otherwise `None`. pub fn value_str(&self) -> Option { self.meta_item().and_then(|meta_item| meta_item.value_str()) } - /// Returns a name and single literal value tuple of the MetaItem. + /// Returns a name and single literal value tuple of the `MetaItem`. pub fn name_value_literal(&self) -> Option<(Name, &Lit)> { self.meta_item().and_then( |meta_item| meta_item.meta_item_list().and_then( @@ -112,32 +112,32 @@ impl NestedMetaItem { })) } - /// Gets a list of inner meta items from a list MetaItem type. + /// Gets a list of inner meta items from a list `MetaItem` type. pub fn meta_item_list(&self) -> Option<&[NestedMetaItem]> { self.meta_item().and_then(|meta_item| meta_item.meta_item_list()) } - /// Returns `true` if the variant is MetaItem. + /// Returns `true` if the variant is `MetaItem`. pub fn is_meta_item(&self) -> bool { self.meta_item().is_some() } - /// Returns `true` if the variant is Literal. + /// Returns `true` if the variant is `Literal`. pub fn is_literal(&self) -> bool { self.literal().is_some() } - /// Returns `true` if self is a MetaItem and the meta item is a word. + /// Returns `true` if `self` is a `MetaItem` and the meta item is a word. pub fn is_word(&self) -> bool { self.meta_item().map_or(false, |meta_item| meta_item.is_word()) } - /// Returns `true` if self is a MetaItem and the meta item is a ValueString. + /// Returns `true` if `self` is a `MetaItem` and the meta item is a `ValueString`. pub fn is_value_str(&self) -> bool { self.value_str().is_some() } - /// Returns `true` if self is a MetaItem and the meta item is a list. + /// Returns `true` if `self` is a `MetaItem` and the meta item is a list. pub fn is_meta_item_list(&self) -> bool { self.meta_item_list().is_some() } @@ -156,7 +156,7 @@ impl Attribute { matches } - /// For a single-segment attribute returns its name, otherwise returns `None`. + /// For a single-segment attribute, returns its name; otherwise, returns `None`. pub fn ident(&self) -> Option { if self.path.segments.len() == 1 { Some(self.path.segments[0].ident) @@ -187,14 +187,14 @@ impl Attribute { self.meta_item_list().is_some() } - /// Indicates if the attribute is a Value String. + /// Indicates if the attribute is a `ValueString`. pub fn is_value_str(&self) -> bool { self.value_str().is_some() } } impl MetaItem { - /// For a single-segment meta-item returns its name, otherwise returns `None`. + /// For a single-segment meta item, returns its name; otherwise, returns `None`. pub fn ident(&self) -> Option { if self.path.segments.len() == 1 { Some(self.path.segments[0].ident) @@ -206,8 +206,9 @@ impl MetaItem { self.ident().unwrap_or(Ident::invalid()).name } - // #[attribute(name = "value")] - // ^^^^^^^^^^^^^^ + // Example: + // #[attribute(name = "value")] + // ^^^^^^^^^^^^^^ pub fn name_value_literal(&self) -> Option<&Lit> { match &self.node { MetaItemKind::NameValue(v) => Some(v), @@ -255,7 +256,7 @@ impl MetaItem { } impl Attribute { - /// Extracts the MetaItem from inside this Attribute. + /// Extracts the `MetaItem` from inside this `Attribute`. pub fn meta(&self) -> Option { let mut tokens = self.tokens.trees().peekable(); Some(MetaItem { @@ -318,8 +319,8 @@ impl Attribute { }) } - /// Converts self to a normal #[doc="foo"] comment, if it is a - /// comment like `///` or `/** */`. (Returns self unchanged for + /// Converts `self` to a normal `#[doc="foo"]` comment, if it is a + /// comment like `///` or `/** */`. (Returns `self` unchanged for /// non-sugared doc attributes.) pub fn with_desugared_doc(&self, f: F) -> T where F: FnOnce(&Attribute) -> T, diff --git a/src/libsyntax/diagnostics/macros.rs b/src/libsyntax/diagnostics/macros.rs index b754d0833761e..c95c5bd5d02d4 100644 --- a/src/libsyntax/diagnostics/macros.rs +++ b/src/libsyntax/diagnostics/macros.rs @@ -1,13 +1,14 @@ #[macro_export] -macro_rules! register_diagnostic { - ($code:tt, $description:tt) => (__register_diagnostic! { $code, $description }); - ($code:tt) => (__register_diagnostic! { $code }) +macro_rules! diagnostic_used { + ($code:ident) => ( + let _ = crate::error_codes::$code; + ) } #[macro_export] macro_rules! span_fatal { ($session:expr, $span:expr, $code:ident, $($message:tt)*) => ({ - __diagnostic_used!($code); + $crate::diagnostic_used!($code); $session.span_fatal_with_code( $span, &format!($($message)*), @@ -19,7 +20,7 @@ macro_rules! span_fatal { #[macro_export] macro_rules! span_err { ($session:expr, $span:expr, $code:ident, $($message:tt)*) => ({ - __diagnostic_used!($code); + $crate::diagnostic_used!($code); $session.span_err_with_code( $span, &format!($($message)*), @@ -31,7 +32,7 @@ macro_rules! span_err { #[macro_export] macro_rules! span_warn { ($session:expr, $span:expr, $code:ident, $($message:tt)*) => ({ - __diagnostic_used!($code); + $crate::diagnostic_used!($code); $session.span_warn_with_code( $span, &format!($($message)*), @@ -43,7 +44,7 @@ macro_rules! span_warn { #[macro_export] macro_rules! struct_err { ($session:expr, $code:ident, $($message:tt)*) => ({ - __diagnostic_used!($code); + $crate::diagnostic_used!($code); $session.struct_err_with_code( &format!($($message)*), $crate::errors::DiagnosticId::Error(stringify!($code).to_owned()), @@ -54,7 +55,7 @@ macro_rules! struct_err { #[macro_export] macro_rules! span_err_or_warn { ($is_warning:expr, $session:expr, $span:expr, $code:ident, $($message:tt)*) => ({ - __diagnostic_used!($code); + $crate::diagnostic_used!($code); if $is_warning { $session.span_warn_with_code( $span, @@ -74,7 +75,7 @@ macro_rules! span_err_or_warn { #[macro_export] macro_rules! struct_span_fatal { ($session:expr, $span:expr, $code:ident, $($message:tt)*) => ({ - __diagnostic_used!($code); + $crate::diagnostic_used!($code); $session.struct_span_fatal_with_code( $span, &format!($($message)*), @@ -86,7 +87,7 @@ macro_rules! struct_span_fatal { #[macro_export] macro_rules! struct_span_err { ($session:expr, $span:expr, $code:ident, $($message:tt)*) => ({ - __diagnostic_used!($code); + $crate::diagnostic_used!($code); $session.struct_span_err_with_code( $span, &format!($($message)*), @@ -98,7 +99,7 @@ macro_rules! struct_span_err { #[macro_export] macro_rules! stringify_error_code { ($code:ident) => ({ - __diagnostic_used!($code); + $crate::diagnostic_used!($code); $crate::errors::DiagnosticId::Error(stringify!($code).to_owned()) }) } @@ -117,7 +118,7 @@ macro_rules! type_error_struct { #[macro_export] macro_rules! struct_span_warn { ($session:expr, $span:expr, $code:ident, $($message:tt)*) => ({ - __diagnostic_used!($code); + $crate::diagnostic_used!($code); $session.struct_span_warn_with_code( $span, &format!($($message)*), @@ -129,7 +130,7 @@ macro_rules! struct_span_warn { #[macro_export] macro_rules! struct_span_err_or_warn { ($is_warning:expr, $session:expr, $span:expr, $code:ident, $($message:tt)*) => ({ - __diagnostic_used!($code); + $crate::diagnostic_used!($code); if $is_warning { $session.struct_span_warn_with_code( $span, @@ -169,20 +170,22 @@ macro_rules! help { #[macro_export] macro_rules! register_diagnostics { - ($($code:tt),*) => ( - $($crate::register_diagnostic! { $code })* + ($($ecode:ident: $message:expr,)*) => ( + $crate::register_diagnostics!{$($ecode:$message,)* ;} ); - ($($code:tt),*,) => ( - $($crate::register_diagnostic! { $code })* - ) -} -#[macro_export] -macro_rules! register_long_diagnostics { - ($($code:tt: $description:tt),*) => ( - $($crate::register_diagnostic! { $code, $description })* - ); - ($($code:tt: $description:tt),*,) => ( - $($crate::register_diagnostic! { $code, $description })* + ($($ecode:ident: $message:expr,)* ; $($code:ident,)*) => ( + pub static DIAGNOSTICS: &[(&str, &str)] = &[ + $( (stringify!($ecode), $message), )* + ]; + + $( + #[deny(unused)] + pub(crate) const $ecode: &str = $message; + )* + $( + #[deny(unused)] + pub(crate) const $code: () = (); + )* ) } diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs deleted file mode 100644 index 5de39c8d14d17..0000000000000 --- a/src/libsyntax/diagnostics/plugin.rs +++ /dev/null @@ -1,185 +0,0 @@ -use std::collections::BTreeMap; - -use crate::ast::{self, Ident, Name}; -use crate::source_map; -use crate::ext::base::{ExtCtxt, MacEager, MacResult}; -use crate::parse::token::{self, Token}; -use crate::ptr::P; -use crate::symbol::kw; -use crate::tokenstream::{TokenTree, TokenStream}; - -use smallvec::smallvec; -use syntax_pos::Span; - -pub use errors::*; - -// Maximum width of any line in an extended error description (inclusive). -const MAX_DESCRIPTION_WIDTH: usize = 80; - -/// Error information type. -pub struct ErrorInfo { - pub description: Option, - pub use_site: Option -} - -/// Mapping from error codes to metadata. -pub type ErrorMap = BTreeMap; - -pub fn expand_diagnostic_used<'cx>(ecx: &'cx mut ExtCtxt<'_>, - span: Span, - tts: TokenStream) - -> Box { - assert_eq!(tts.len(), 1); - let code = match tts.into_trees().next() { - Some(TokenTree::Token(Token { kind: token::Ident(code, _), .. })) => code, - _ => unreachable!() - }; - - ecx.parse_sess.registered_diagnostics.with_lock(|diagnostics| { - match diagnostics.get_mut(&code) { - // Previously used errors. - Some(&mut ErrorInfo { description: _, use_site: Some(previous_span) }) => { - ecx.struct_span_warn(span, &format!( - "diagnostic code {} already used", code - )).span_note(previous_span, "previous invocation") - .emit(); - } - // Newly used errors. - Some(ref mut info) => { - info.use_site = Some(span); - } - // Unregistered errors. - None => { - ecx.span_err(span, &format!( - "used diagnostic code {} not registered", code - )); - } - } - }); - MacEager::expr(ecx.expr_tuple(span, Vec::new())) -} - -pub fn expand_register_diagnostic<'cx>(ecx: &'cx mut ExtCtxt<'_>, - span: Span, - tts: TokenStream) - -> Box { - assert!(tts.len() == 1 || tts.len() == 3); - let mut cursor = tts.into_trees(); - let code = match cursor.next() { - Some(TokenTree::Token(Token { kind: token::Ident(code, _), .. })) => code, - _ => unreachable!() - }; - let description = match (cursor.next(), cursor.next()) { - (None, None) => None, - ( - Some(TokenTree::Token(Token { kind: token::Comma, .. })), - Some(TokenTree::Token(Token { kind: token::Literal(token::Lit { symbol, .. }), ..})) - ) => { - Some(symbol) - }, - _ => unreachable!() - }; - - // Check that the description starts and ends with a newline and doesn't - // overflow the maximum line width. - description.map(|raw_msg| { - let msg = raw_msg.as_str(); - if !msg.starts_with("\n") || !msg.ends_with("\n") { - ecx.span_err(span, &format!( - "description for error code {} doesn't start and end with a newline", - code - )); - } - - // URLs can be unavoidably longer than the line limit, so we allow them. - // Allowed format is: `[name]: https://www.rust-lang.org/` - let is_url = |l: &str| l.starts_with("[") && l.contains("]:") && l.contains("http"); - - if msg.lines().any(|line| line.len() > MAX_DESCRIPTION_WIDTH && !is_url(line)) { - ecx.span_err(span, &format!( - "description for error code {} contains a line longer than {} characters.\n\ - if you're inserting a long URL use the footnote style to bypass this check.", - code, MAX_DESCRIPTION_WIDTH - )); - } - }); - // Add the error to the map. - ecx.parse_sess.registered_diagnostics.with_lock(|diagnostics| { - let info = ErrorInfo { - description, - use_site: None - }; - if diagnostics.insert(code, info).is_some() { - ecx.span_err(span, &format!( - "diagnostic code {} already registered", code - )); - } - }); - - MacEager::items(smallvec![]) -} - -pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt<'_>, - span: Span, - tts: TokenStream) - -> Box { - assert_eq!(tts.len(), 3); - let ident = match tts.into_trees().nth(2) { - // DIAGNOSTICS ident. - Some(TokenTree::Token(Token { kind: token::Ident(name, _), span })) - => Ident::new(name, span), - _ => unreachable!() - }; - - // Construct the output expression. - let (count, expr) = - ecx.parse_sess.registered_diagnostics.with_lock(|diagnostics| { - let descriptions: Vec> = - diagnostics.iter().filter_map(|(&code, info)| { - info.description.map(|description| { - ecx.expr_tuple(span, vec![ - ecx.expr_str(span, code), - ecx.expr_str(span, description) - ]) - }) - }).collect(); - (descriptions.len(), ecx.expr_vec(span, descriptions)) - }); - - let static_ = ecx.lifetime(span, Ident::with_dummy_span(kw::StaticLifetime)); - let ty_str = ecx.ty_rptr( - span, - ecx.ty_ident(span, ecx.ident_of("str")), - Some(static_), - ast::Mutability::Immutable, - ); - - let ty = ecx.ty( - span, - ast::TyKind::Array( - ecx.ty( - span, - ast::TyKind::Tup(vec![ty_str.clone(), ty_str]) - ), - ast::AnonConst { - id: ast::DUMMY_NODE_ID, - value: ecx.expr_usize(span, count), - }, - ), - ); - - MacEager::items(smallvec![ - P(ast::Item { - ident, - attrs: Vec::new(), - id: ast::DUMMY_NODE_ID, - node: ast::ItemKind::Const( - ty, - expr, - ), - vis: source_map::respan(span.shrink_to_lo(), ast::VisibilityKind::Public), - span, - tokens: None, - }) - ]) -} diff --git a/src/libsyntax/error_codes.rs b/src/libsyntax/error_codes.rs index 1ba29011f75a4..9925dd8ada0d5 100644 --- a/src/libsyntax/error_codes.rs +++ b/src/libsyntax/error_codes.rs @@ -1,7 +1,8 @@ // 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. -register_long_diagnostics! { +// 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. +register_diagnostics! { E0178: r##" In types, the `+` type operator has low precedence, so it is often necessary @@ -420,9 +421,8 @@ Delete the offending feature attribute, or add it to the list of allowed features in the `-Z allow_features` flag. "##, -} +; -register_diagnostics! { E0539, // incorrect meta item E0540, // multiple rustc_deprecated attributes E0542, // missing 'since' @@ -432,7 +432,9 @@ register_diagnostics! { E0546, // missing 'feature' E0547, // missing 'issue' // E0548, // replaced with a generic attribute input check - E0549, // rustc_deprecated attribute must be paired with either stable or unstable attribute + // rustc_deprecated attribute must be paired with either stable or unstable + // attribute + E0549, E0550, // multiple deprecated attributes E0551, // incorrect meta item E0553, // multiple rustc_const_unstable attributes @@ -440,9 +442,11 @@ register_diagnostics! { E0556, // malformed feature, expected just one word E0584, // file for module `..` found at both .. and .. E0629, // missing 'feature' (rustc_const_unstable) - E0630, // rustc_const_unstable attribute must be paired with stable/unstable attribute + // rustc_const_unstable attribute must be paired with stable/unstable + // attribute + E0630, E0693, // incorrect `repr(align)` attribute format - E0694, // an unknown tool name found in scoped attributes +// E0694, // an unknown tool name found in scoped attributes E0703, // invalid ABI E0717, // rustc_promotable without stability attribute } diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 5b2515d20cbab..c4569b3fba1be 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -958,7 +958,7 @@ impl<'a> ExtCtxt<'a> { self.resolver.check_unused_macros(); } - /// Resolve a path mentioned inside Rust code. + /// Resolves a path mentioned inside Rust code. /// /// This unifies the logic used for resolving `include_X!`, and `#[doc(include)]` file paths. /// diff --git a/src/libsyntax/feature_gate/active.rs b/src/libsyntax/feature_gate/active.rs index c947b09fdcb57..5a248df6af252 100644 --- a/src/libsyntax/feature_gate/active.rs +++ b/src/libsyntax/feature_gate/active.rs @@ -1,9 +1,11 @@ //! List of the active feature gates. +use super::{State, Feature}; + use crate::edition::Edition; use crate::symbol::{Symbol, sym}; + use syntax_pos::Span; -use super::{State, Feature}; macro_rules! set { ($field: ident) => {{ @@ -37,9 +39,9 @@ macro_rules! declare_features { /// A set of features to be used by later passes. #[derive(Clone)] pub struct Features { - /// `#![feature]` attrs for language features, for error reporting + /// `#![feature]` attrs for language features, for error reporting. pub declared_lang_features: Vec<(Symbol, Span, Option)>, - /// `#![feature]` attrs for non-language (library) features + /// `#![feature]` attrs for non-language (library) features. pub declared_lib_features: Vec<(Symbol, Span)>, $( $(#[doc = $doc])* @@ -66,11 +68,11 @@ macro_rules! declare_features { } impl Feature { - /// Set this feature in `Features`. Panics if called on a non-active feature. + /// Sets this feature in `Features`. Panics if called on a non-active feature. pub fn set(&self, features: &mut Features, span: Span) { match self.state { State::Active { set } => set(features, span), - _ => panic!("Called `set` on feature `{}` which is not `active`", self.name) + _ => panic!("called `set` on feature `{}` which is not `active`", self.name) } } } @@ -120,12 +122,6 @@ declare_features! ( /// macros disappear). (active, allow_internal_unsafe, "1.0.0", None, None), - /// Allows using the macros: - /// + `__diagnostic_used` - /// + `__register_diagnostic` - /// +`__build_diagnostic_array` - (active, rustc_diagnostic_macros, "1.0.0", None, None), - /// Allows using `#[rustc_const_unstable(feature = "foo", ..)]` which /// lets a function to be `const` when opted into with `#![feature(foo)]`. (active, rustc_const_unstable, "1.0.0", None, None), @@ -478,7 +474,7 @@ declare_features! ( (active, precise_pointer_size_matching, "1.32.0", Some(56354), None), /// Allows relaxing the coherence rules such that - /// `impl ForeignTrait for ForeignType is permitted. + /// `impl ForeignTrait for ForeignType` is permitted. (active, re_rebalance_coherence, "1.32.0", Some(55437), None), /// Allows using `#[ffi_returns_twice]` on foreign functions. @@ -520,7 +516,7 @@ declare_features! ( /// Allows `async || body` closures. (active, async_closure, "1.37.0", Some(62290), None), - /// Allows the use of `#[cfg(doctest)]`, set when rustdoc is collecting doctests + /// Allows the use of `#[cfg(doctest)]`; set when rustdoc is collecting doctests. (active, cfg_doctest, "1.37.0", Some(62210), None), /// Allows `[x; N]` where `x` is a constant (RFC 2203). @@ -529,7 +525,7 @@ declare_features! ( /// Allows `impl Trait` to be used inside type aliases (RFC 2515). (active, type_alias_impl_trait, "1.38.0", Some(63063), None), - /// Allows the use of or-patterns, e.g. `0 | 1`. + /// Allows the use of or-patterns (e.g., `0 | 1`). (active, or_patterns, "1.38.0", Some(54883), None), // ------------------------------------------------------------------------- diff --git a/src/libsyntax/feature_gate/builtin_attrs.rs b/src/libsyntax/feature_gate/builtin_attrs.rs index ee7ac3b15d955..763c3ffd782df 100644 --- a/src/libsyntax/feature_gate/builtin_attrs.rs +++ b/src/libsyntax/feature_gate/builtin_attrs.rs @@ -169,7 +169,7 @@ const INTERAL_UNSTABLE: &str = "this is an internal attribute that will never be pub type BuiltinAttribute = (Symbol, AttributeType, AttributeTemplate, AttributeGate); -/// Attributes that have a special meaning to rustc or rustdoc +/// Attributes that have a special meaning to rustc or rustdoc. pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // ========================================================================== // Stable attributes: diff --git a/src/libsyntax/feature_gate/check.rs b/src/libsyntax/feature_gate/check.rs index f3a9d135125ae..5711b269ff092 100644 --- a/src/libsyntax/feature_gate/check.rs +++ b/src/libsyntax/feature_gate/check.rs @@ -920,9 +920,9 @@ pub enum UnstableFeatures { impl UnstableFeatures { pub fn from_environment() -> UnstableFeatures { - // Whether this is a feature-staged build, i.e., on the beta or stable channel + // `true` if this is a feature-staged build, i.e., on the beta or stable channel. let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some(); - // Whether we should enable unstable features for bootstrapping + // `true` if we should enable unstable features for bootstrapping. let bootstrap = env::var("RUSTC_BOOTSTRAP").is_ok(); match (disable_unstable_features, bootstrap) { (_, true) => UnstableFeatures::Cheat, diff --git a/src/libsyntax/feature_gate/removed.rs b/src/libsyntax/feature_gate/removed.rs index ad7d69b3e7372..2c29e1ebf1493 100644 --- a/src/libsyntax/feature_gate/removed.rs +++ b/src/libsyntax/feature_gate/removed.rs @@ -94,6 +94,11 @@ declare_features! ( /// Allows defining `existential type`s. (removed, existential_type, "1.38.0", Some(63063), None, Some("removed in favor of `#![feature(type_alias_impl_trait)]`")), + /// Allows using the macros: + /// + `__diagnostic_used` + /// + `__register_diagnostic` + /// +`__build_diagnostic_array` + (removed, rustc_diagnostic_macros, "1.38.0", None, None, None), // ------------------------------------------------------------------------- // feature-group-end: removed features diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 1741932c1b80e..49efbce482fa3 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -18,7 +18,6 @@ #![feature(proc_macro_diagnostic)] #![feature(proc_macro_internals)] #![feature(proc_macro_span)] -#![feature(rustc_diagnostic_macros)] #![feature(try_trait)] #![feature(unicode_internals)] @@ -123,11 +122,8 @@ scoped_tls::scoped_thread_local!(pub static GLOBALS: Globals); pub mod diagnostics { #[macro_use] pub mod macros; - pub mod plugin; } -// N.B., this module needs to be declared first so diagnostics are -// registered before they are used. pub mod error_codes; pub mod util { @@ -182,5 +178,3 @@ pub mod ext { } pub mod early_buffered_lints; - -__build_diagnostic_array! { libsyntax, DIAGNOSTICS } diff --git a/src/libsyntax/mut_visit.rs b/src/libsyntax/mut_visit.rs index 6023c5149d05b..1c35688666836 100644 --- a/src/libsyntax/mut_visit.rs +++ b/src/libsyntax/mut_visit.rs @@ -1,10 +1,10 @@ -//! 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 +//! 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 MutVisitor (other than the MacroExpander MutVisitor) on +//! Note: using a `MutVisitor` (other than the `MacroExpander` `MutVisitor`) on //! an AST before macro expansion is probably a bad idea. For instance, -//! a MutVisitor 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 crate::ast::*; @@ -614,7 +614,7 @@ pub fn noop_visit_tts(TokenStream(tts): &mut TokenStream, vis: &m }) } -// Apply ident visitor if it's an ident, apply other visits to interpolated nodes. +// Applies ident visitor if it's an ident; applies other visits to interpolated nodes. // In practice the ident part is not actually used by specific visitors right now, // but there's a test below checking that it works. pub fn noop_visit_token(t: &mut Token, vis: &mut T) { @@ -625,7 +625,7 @@ pub fn noop_visit_token(t: &mut Token, vis: &mut T) { vis.visit_ident(&mut ident); *name = ident.name; *span = ident.span; - return; // avoid visiting the span for the second time + return; // Avoid visiting the span for the second time. } token::Interpolated(nt) => { let mut nt = Lrc::make_mut(nt); @@ -636,28 +636,28 @@ pub fn noop_visit_token(t: &mut Token, vis: &mut T) { vis.visit_span(span); } -/// Apply visitor to elements of interpolated nodes. +/// Applies the visitor to elements of interpolated nodes. // // 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 flat_map_item, flat_map_stmt, -// etc. allow the visitor to return *multiple* items; this is a problem for the +// 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 +// 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 +// `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 +// 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 +// `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 { @@ -1014,7 +1014,7 @@ pub fn noop_visit_crate(krate: &mut Crate, vis: &mut T) { }); } -// Mutate one item into possibly many items. +// Mutates 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(); @@ -1224,7 +1224,7 @@ pub fn noop_visit_expr(Expr { node, id, span, attrs }: &mut Expr, ExprKind::Paren(expr) => { vis.visit_expr(expr); - // Nodes that are equal modulo `Paren` sugar no-ops should have the same ids. + // 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); diff --git a/src/libsyntax/mut_visit/tests.rs b/src/libsyntax/mut_visit/tests.rs index 6868736976b25..f779e0d0a6014 100644 --- a/src/libsyntax/mut_visit/tests.rs +++ b/src/libsyntax/mut_visit/tests.rs @@ -6,13 +6,13 @@ use crate::print::pprust; use crate::mut_visit; use crate::with_default_globals; -// this version doesn't care about getting comments or docstrings in. +// This version doesn't care about getting comments or doc-strings in. fn fake_print_crate(s: &mut pprust::State<'_>, krate: &ast::Crate) { s.print_mod(&krate.module, &krate.attrs) } -// change every identifier to "zz" +// Change every identifier to "zz". struct ToZzIdentMutVisitor; impl MutVisitor for ToZzIdentMutVisitor { @@ -24,7 +24,7 @@ impl MutVisitor for ToZzIdentMutVisitor { } } -// maybe add to expand.rs... +// Maybe add to `expand.rs`. macro_rules! assert_pred { ($pred:expr, $predname:expr, $a:expr , $b:expr) => ( { @@ -39,7 +39,7 @@ macro_rules! assert_pred { ) } -// make sure idents get transformed everywhere +// Make sure idents get transformed everywhere. #[test] fn ident_transformation () { with_default_globals(|| { let mut zz_visitor = ToZzIdentMutVisitor; @@ -54,7 +54,7 @@ macro_rules! assert_pred { }) } -// even inside macro defs.... +// Make sure idents get transformed even inside macro defs. #[test] fn ident_transformation_in_defs () { with_default_globals(|| { let mut zz_visitor = ToZzIdentMutVisitor; diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs index d9c4baad49ded..9aa1ec0b14fe9 100644 --- a/src/libsyntax/parse/attr.rs +++ b/src/libsyntax/parse/attr.rs @@ -26,7 +26,7 @@ impl<'a> Parser<'a> { Ok(attrs) } - /// Parse attributes that appear before an item + /// Parses attributes that appear before an item. crate fn parse_outer_attributes(&mut self) -> PResult<'a, Vec> { let mut attrs: Vec = Vec::new(); let mut just_parsed_doc_comment = false; @@ -69,10 +69,10 @@ impl<'a> Parser<'a> { Ok(attrs) } - /// Matches `attribute = # ! [ meta_item ]` + /// Matches `attribute = # ! [ meta_item ]`. /// - /// If permit_inner is true, then a leading `!` indicates an inner - /// attribute + /// If `permit_inner` is `true`, then a leading `!` indicates an inner + /// attribute. pub fn parse_attribute(&mut self, permit_inner: bool) -> PResult<'a, ast::Attribute> { debug!("parse_attribute: permit_inner={:?} self.token={:?}", permit_inner, @@ -167,14 +167,14 @@ impl<'a> Parser<'a> { }) } - /// Parse an inner part of attribute - path and following tokens. + /// Parses an inner part of an attribute (the path and following tokens). /// The tokens must be either a delimited token stream, or empty token stream, /// or the "legacy" key-value form. - /// PATH `(` TOKEN_STREAM `)` - /// PATH `[` TOKEN_STREAM `]` - /// PATH `{` TOKEN_STREAM `}` - /// PATH - /// PATH `=` TOKEN_TREE + /// PATH `(` TOKEN_STREAM `)` + /// PATH `[` TOKEN_STREAM `]` + /// PATH `{` TOKEN_STREAM `}` + /// PATH + /// PATH `=` TOKEN_TREE /// The delimiters or `=` are still put into the resulting token stream. pub fn parse_meta_item_unrestricted(&mut self) -> PResult<'a, (ast::Path, TokenStream)> { let meta = match self.token.kind { @@ -217,11 +217,11 @@ impl<'a> Parser<'a> { }) } - /// Parse attributes that appear after the opening of an item. These should + /// Parses attributes that appear after the opening of an item. These should /// be preceded by an exclamation mark, but we accept and warn about one /// terminated by a semicolon. - - /// matches inner_attrs* + /// + /// Matches `inner_attrs*`. crate fn parse_inner_attributes(&mut self) -> PResult<'a, Vec> { let mut attrs: Vec = vec![]; loop { @@ -237,7 +237,7 @@ impl<'a> Parser<'a> { attrs.push(attr); } token::DocComment(s) => { - // we need to get the position of this token before we bump. + // We need to get the position of this token before we bump. let attr = attr::mk_sugared_doc_attr(s, self.token.span); if attr.style == ast::AttrStyle::Inner { attrs.push(attr); @@ -268,10 +268,10 @@ impl<'a> Parser<'a> { Ok(lit) } - /// Per RFC#1559, matches the following grammar: + /// Matches the following grammar (per RFC 1559). /// - /// meta_item : IDENT ( '=' UNSUFFIXED_LIT | '(' meta_item_inner? ')' )? ; - /// meta_item_inner : (meta_item | UNSUFFIXED_LIT) (',' meta_item_inner)? ; + /// meta_item : IDENT ( '=' UNSUFFIXED_LIT | '(' meta_item_inner? ')' )? ; + /// meta_item_inner : (meta_item | UNSUFFIXED_LIT) (',' meta_item_inner)? ; pub fn parse_meta_item(&mut self) -> PResult<'a, ast::MetaItem> { let nt_meta = match self.token.kind { token::Interpolated(ref nt) => match **nt { @@ -303,7 +303,7 @@ impl<'a> Parser<'a> { }) } - /// matches meta_item_inner : (meta_item | UNSUFFIXED_LIT) ; + /// Matches `meta_item_inner : (meta_item | UNSUFFIXED_LIT) ;`. fn parse_meta_item_inner(&mut self) -> PResult<'a, ast::NestedMetaItem> { match self.parse_unsuffixed_lit() { Ok(lit) => { @@ -324,7 +324,7 @@ impl<'a> Parser<'a> { Err(self.diagnostic().struct_span_err(self.token.span, &msg)) } - /// matches meta_seq = ( COMMASEP(meta_item_inner) ) + /// Matches `meta_seq = ( COMMASEP(meta_item_inner) )`. fn parse_meta_seq(&mut self) -> PResult<'a, Vec> { self.parse_seq_to_end(&token::CloseDelim(token::Paren), SeqSep::trailing_allowed(token::Comma), diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/diagnostics.rs index d050d4f4ce705..3120d0e35173d 100644 --- a/src/libsyntax/parse/diagnostics.rs +++ b/src/libsyntax/parse/diagnostics.rs @@ -240,7 +240,7 @@ impl<'a> Parser<'a> { ) -> PResult<'a, bool /* recovered */> { fn tokens_to_string(tokens: &[TokenType]) -> String { let mut i = tokens.iter(); - // This might be a sign we need a connect method on Iterator. + // This might be a sign we need a connect method on `Iterator`. let b = i.next() .map_or(String::new(), |t| t.to_string()); i.enumerate().fold(b, |mut b, (i, a)| { @@ -301,7 +301,7 @@ impl<'a> Parser<'a> { ); } let sp = if self.token == token::Eof { - // This is EOF, don't want to point at the following char, but rather the last token + // This is EOF; don't want to point at the following char, but rather the last token. self.prev_span } else { label_sp @@ -317,9 +317,9 @@ impl<'a> Parser<'a> { } let is_semi_suggestable = expected.iter().any(|t| match t { - TokenType::Token(token::Semi) => true, // we expect a `;` here + TokenType::Token(token::Semi) => true, // We expect a `;` here. _ => false, - }) && ( // a `;` would be expected before the current keyword + }) && ( // A `;` would be expected before the current keyword. self.token.is_keyword(kw::Break) || self.token.is_keyword(kw::Continue) || self.token.is_keyword(kw::For) || @@ -541,16 +541,16 @@ impl<'a> Parser<'a> { } } - /// Produce an error if comparison operators are chained (RFC #558). - /// We only need to check lhs, not rhs, because all comparison ops - /// have same precedence and are left-associative + /// Produces an error if comparison operators are chained (RFC #558). + /// We only need to check the LHS, not the RHS, because all comparison ops + /// have same precedence and are left-associative. crate fn check_no_chained_comparison(&self, lhs: &Expr, outer_op: &AssocOp) -> PResult<'a, ()> { debug_assert!(outer_op.is_comparison(), "check_no_chained_comparison: {:?} is not comparison", outer_op); match lhs.node { ExprKind::Binary(op, _, _) if op.node.is_comparison() => { - // respan to include both operators + // Respan to include both operators. let op_span = op.span.to(self.token.span); let mut err = self.struct_span_err( op_span, @@ -691,9 +691,9 @@ impl<'a> Parser<'a> { Ok(()) } - /// Try to recover from associated item paths like `[T]::AssocItem`/`(T, U)::AssocItem`. - /// Attempt to convert the base expression/pattern/type into a type, parse the `::AssocItem` - /// tail, and combine them into a `::AssocItem` expression/pattern/type. + /// Tries to recover from associated item paths like `[T]::AssocItem` / `(T, U)::AssocItem`. + /// Attempts to convert the base expression/pattern/type into a type, parses the `::AssocItem` + /// tail, and combines them into a `::AssocItem` expression/pattern/type. crate fn maybe_recover_from_bad_qpath( &mut self, base: P, @@ -708,8 +708,8 @@ impl<'a> Parser<'a> { Ok(base) } - /// Given an already parsed `Ty` parse the `::AssocItem` tail and - /// combine them into a `::AssocItem` expression/pattern/type. + /// Given an already parsed `Ty`, parses the `::AssocItem` tail and + /// combines them into a `::AssocItem` expression/pattern/type. crate fn maybe_recover_from_bad_qpath_stage_2( &mut self, ty_span: Span, @@ -730,7 +730,7 @@ impl<'a> Parser<'a> { self.diagnostic() .struct_span_err(path.span, "missing angle brackets in associated item path") .span_suggestion( - // this is a best-effort recovery + // This is a best-effort recovery. path.span, "try", format!("<{}>::{}", ty_str, path), @@ -738,7 +738,7 @@ impl<'a> Parser<'a> { ) .emit(); - let path_span = ty_span.shrink_to_hi(); // use an empty path since `position` == 0 + let path_span = ty_span.shrink_to_hi(); // Use an empty path since `position == 0`. Ok(P(T::recovered( Some(QSelf { ty, @@ -761,8 +761,8 @@ impl<'a> Parser<'a> { if !items.is_empty() { let previous_item = &items[items.len() - 1]; let previous_item_kind_name = match previous_item.node { - // say "braced struct" because tuple-structs and - // braceless-empty-struct declarations do take a semicolon + // Say "braced struct" because tuple-structs and + // braceless-empty-struct declarations do take a semicolon. ItemKind::Struct(..) => Some("braced struct"), ItemKind::Enum(..) => Some("enum"), ItemKind::Trait(..) => Some("trait"), @@ -783,7 +783,7 @@ impl<'a> Parser<'a> { } } - /// Create a `DiagnosticBuilder` for an unexpected token `t` and try to recover if it is a + /// Creates a `DiagnosticBuilder` for an unexpected token `t` and tries to recover if it is a /// closing delimiter. pub fn unexpected_try_recover( &mut self, @@ -841,7 +841,7 @@ impl<'a> Parser<'a> { extern_sp: Span, ) -> PResult<'a, ()> { if self.token != token::Semi { - // this might be an incorrect fn definition (#62109) + // This might be an incorrect fn definition (#62109). let parser_snapshot = self.clone(); match self.parse_inner_attrs_and_block() { Ok((_, body)) => { @@ -871,7 +871,7 @@ impl<'a> Parser<'a> { Ok(()) } - /// Consume alternative await syntaxes like `await!()`, `await `, + /// Consumes alternative await syntaxes like `await!()`, `await `, /// `await? `, `await()`, and `await { }`. crate fn parse_incorrect_await_syntax( &mut self, @@ -924,7 +924,7 @@ impl<'a> Parser<'a> { sp } - /// If encountering `future.await()`, consume and emit error. + /// If encountering `future.await()`, consumes and emits an error. crate fn recover_from_await_method_call(&mut self) { if self.token == token::OpenDelim(token::Paren) && self.look_ahead(1, |t| t == &token::CloseDelim(token::Paren)) @@ -944,7 +944,7 @@ impl<'a> Parser<'a> { } } - /// Recover a situation like `for ( $pat in $expr )` + /// Recovers a situation like `for ( $pat in $expr )` /// and suggest writing `for $pat in $expr` instead. /// /// This should be called before parsing the `$block`. @@ -1010,7 +1010,7 @@ impl<'a> Parser<'a> { Ok(x) => x, Err(mut err) => { err.emit(); - // recover from parse error + // Recover from parse error. self.consume_block(delim); self.mk_expr(lo.to(self.prev_span), ExprKind::Err, ThinVec::new()) } @@ -1023,7 +1023,7 @@ impl<'a> Parser<'a> { mut err: DiagnosticBuilder<'a>, ) -> PResult<'a, bool> { let mut pos = None; - // we want to use the last closing delim that would apply + // We want to use the last closing delim that would apply. for (i, unmatched) in self.unclosed_delims.iter().enumerate().rev() { if tokens.contains(&token::CloseDelim(unmatched.expected_delim)) && Some(self.token.span) > unmatched.unclosed_span @@ -1041,7 +1041,7 @@ impl<'a> Parser<'a> { let unmatched = self.unclosed_delims.remove(pos); let delim = TokenType::Token(token::CloseDelim(unmatched.expected_delim)); - // We want to suggest the inclusion of the closing delimiter where it makes + // We want to suggest the inclusion of the closing delimiter where it makes // the most sense, which is immediately after the last token: // // {foo(bar {}} @@ -1067,7 +1067,7 @@ impl<'a> Parser<'a> { } } - /// Recover from `pub` keyword in places where it seems _reasonable_ but isn't valid. + /// Recovers from `pub` keyword in places where it seems _reasonable_ but isn't valid. crate fn eat_bad_pub(&mut self) { if self.token.is_keyword(kw::Pub) { match self.parse_visibility(false) { @@ -1082,21 +1082,21 @@ impl<'a> Parser<'a> { } } - // Eat tokens until we can be relatively sure we reached the end of the - // statement. This is something of a best-effort heuristic. - // - // We terminate when we find an unmatched `}` (without consuming it). + /// Eats tokens until we can be relatively sure we reached the end of the + /// statement. This is something of a best-effort heuristic. + /// + /// We terminate when we find an unmatched `}` (without consuming it). crate fn recover_stmt(&mut self) { self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore) } - // If `break_on_semi` is `Break`, then we will stop consuming tokens after - // finding (and consuming) a `;` outside of `{}` or `[]` (note that this is - // approximate - it can mean we break too early due to macros, but that - // should only lead to sub-optimal recovery, not inaccurate parsing). - // - // If `break_on_block` is `Break`, then we will stop consuming tokens - // after finding (and consuming) a brace-delimited block. + /// If `break_on_semi` is `Break`, then we will stop consuming tokens after + /// finding (and consuming) a `;` outside of `{}` or `[]` (note that this is + /// approximate -- it can mean we break too early due to macros, but that + /// should only lead to sub-optimal recovery, not inaccurate parsing). + /// + /// If `break_on_block` is `Break`, then we will stop consuming tokens + /// after finding (and consuming) a brace-delimited block. crate fn recover_stmt_(&mut self, break_on_semi: SemiColonMode, break_on_block: BlockMode) { let mut brace_depth = 0; let mut bracket_depth = 0; diff --git a/src/libsyntax/parse/lexer/tests.rs b/src/libsyntax/parse/lexer/tests.rs index 652ae95c85349..c1ec41902e2be 100644 --- a/src/libsyntax/parse/lexer/tests.rs +++ b/src/libsyntax/parse/lexer/tests.rs @@ -4,9 +4,10 @@ use crate::symbol::Symbol; use crate::source_map::{SourceMap, FilePathMapping}; use crate::parse::token; use crate::with_default_globals; + +use errors::{Handler, emitter::EmitterWriter}; use std::io; use std::path::PathBuf; -use errors::{Handler, emitter::EmitterWriter}; use syntax_pos::{BytePos, Span}; fn mk_sess(sm: Lrc) -> ParseSess { @@ -21,7 +22,7 @@ fn mk_sess(sm: Lrc) -> ParseSess { ParseSess::with_span_handler(Handler::with_emitter(true, None, Box::new(emitter)), sm) } -// open a string reader for the given string +// Creates a string reader for the given string. fn setup<'a>(sm: &SourceMap, sess: &'a ParseSess, teststr: String) @@ -50,7 +51,7 @@ fn t1() { assert_eq!(tok1.kind, tok2.kind); assert_eq!(tok1.span, tok2.span); assert_eq!(string_reader.next_token(), token::Whitespace); - // read another token: + // Read another token. let tok3 = string_reader.next_token(); assert_eq!(string_reader.pos.clone(), BytePos(28)); let tok4 = Token::new( @@ -65,15 +66,15 @@ fn t1() { }) } -// check that the given reader produces the desired stream -// of tokens (stop checking after exhausting the expected vec) +// Checks that the given reader produces the desired stream +// of tokens (stop checking after exhausting `expected`). fn check_tokenization(mut string_reader: StringReader<'_>, expected: Vec) { for expected_tok in &expected { assert_eq!(&string_reader.next_token(), expected_tok); } } -// make the identifier by looking up the string in the interner +// Makes the identifier by looking up the string in the interner. fn mk_ident(id: &str) -> TokenKind { token::Ident(Symbol::intern(id), false) } @@ -201,7 +202,7 @@ fn literal_suffixes() { setup(&sm, &sh, format!("{}suffix", $input)).next_token(), mk_lit(token::$tok_type, $tok_contents, Some("suffix")), ); - // with a whitespace separator: + // with a whitespace separator assert_eq!( setup(&sm, &sh, format!("{} suffix", $input)).next_token(), mk_lit(token::$tok_type, $tok_contents, None), diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index b1af4806e2d78..bc1bc00ac8405 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -8,17 +8,16 @@ use crate::parse::parser::Parser; use crate::parse::parser::emit_unclosed_delims; use crate::parse::token::TokenKind; use crate::tokenstream::{TokenStream, TokenTree}; -use crate::diagnostics::plugin::ErrorMap; use crate::print::pprust; use crate::symbol::Symbol; use errors::{Applicability, FatalError, Level, Handler, ColorConfig, Diagnostic, DiagnosticBuilder}; +use rustc_data_structures::fx::{FxHashSet, FxHashMap}; use rustc_data_structures::sync::{Lrc, Lock, Once}; use syntax_pos::{Span, SourceFile, FileName, MultiSpan}; use syntax_pos::edition::Edition; use syntax_pos::hygiene::ExpnId; -use rustc_data_structures::fx::{FxHashSet, FxHashMap}; use std::borrow::Cow; use std::path::{Path, PathBuf}; use std::str; @@ -64,8 +63,6 @@ pub struct ParseSess { pub missing_fragment_specifiers: Lock>, /// Places where raw identifiers were used. This is used for feature-gating raw identifiers. pub raw_identifier_spans: Lock>, - /// The registered diagnostics codes. - crate registered_diagnostics: Lock, /// Used to determine and report recursive module inclusions. included_mod_stack: Lock>, source_map: Lrc, @@ -81,25 +78,26 @@ pub struct ParseSess { impl ParseSess { pub fn new(file_path_mapping: FilePathMapping) -> Self { let cm = Lrc::new(SourceMap::new(file_path_mapping)); - let handler = Handler::with_tty_emitter(ColorConfig::Auto, - true, - None, - Some(cm.clone())); + let handler = Handler::with_tty_emitter( + ColorConfig::Auto, + true, + None, + Some(cm.clone()), + ); ParseSess::with_span_handler(handler, cm) } - pub fn with_span_handler(handler: Handler, source_map: Lrc) -> ParseSess { - ParseSess { + pub fn with_span_handler(handler: Handler, source_map: Lrc) -> Self { + Self { span_diagnostic: handler, unstable_features: UnstableFeatures::from_environment(), config: FxHashSet::default(), + edition: ExpnId::root().expn_data().edition, missing_fragment_specifiers: Lock::new(FxHashSet::default()), raw_identifier_spans: Lock::new(Vec::new()), - registered_diagnostics: Lock::new(ErrorMap::new()), included_mod_stack: Lock::new(vec![]), source_map, buffered_lints: Lock::new(vec![]), - edition: ExpnId::root().expn_data().edition, ambiguous_block_expr_parse: Lock::new(FxHashMap::default()), injected_crate_name: Once::new(), gated_spans: GatedSpans::default(), @@ -155,17 +153,17 @@ pub struct Directory<'a> { #[derive(Copy, Clone)] pub enum DirectoryOwnership { Owned { - // None if `mod.rs`, `Some("foo")` if we're in `foo.rs` + // None if `mod.rs`, `Some("foo")` if we're in `foo.rs`. relative: Option, }, UnownedViaBlock, UnownedViaMod(bool /* legacy warnings? */), } -// a bunch of utility functions of the form parse__from_ +// A bunch of utility functions of the form `parse__from_` // where includes crate, expr, item, stmt, tts, and one that // uses a HOF to parse anything, and includes file and -// source_str. +// `source_str`. pub fn parse_crate_from_file<'a>(input: &Path, sess: &'a ParseSess) -> PResult<'a, ast::Crate> { let mut parser = new_parser_from_file(sess, input); @@ -219,14 +217,13 @@ pub fn maybe_new_parser_from_source_str(sess: &ParseSess, name: FileName, source Ok(parser) } -/// Creates a new parser, handling errors as appropriate -/// if the file doesn't exist +/// Creates a new parser, handling errors as appropriate if the file doesn't exist. pub fn new_parser_from_file<'a>(sess: &'a ParseSess, path: &Path) -> Parser<'a> { source_file_to_parser(sess, file_to_source_file(sess, path, None)) } -/// Creates a new parser, returning buffered diagnostics if the file doesn't -/// exist or from lexing the initial token stream. +/// Creates a new parser, returning buffered diagnostics if the file doesn't exist, +/// or from lexing the initial token stream. pub fn maybe_new_parser_from_file<'a>(sess: &'a ParseSess, path: &Path) -> Result, Vec> { let file = try_file_to_source_file(sess, path, None).map_err(|db| vec![db])?; @@ -234,8 +231,8 @@ pub fn maybe_new_parser_from_file<'a>(sess: &'a ParseSess, path: &Path) } /// Given a session, a crate config, a path, and a span, add -/// the file at the given path to the source_map, and return a parser. -/// On an error, use the given span as the source of the problem. +/// the file at the given path to the `source_map`, and returns a parser. +/// On an error, uses the given span as the source of the problem. pub fn new_sub_parser_from_file<'a>(sess: &'a ParseSess, path: &Path, directory_ownership: DirectoryOwnership, @@ -247,13 +244,13 @@ pub fn new_sub_parser_from_file<'a>(sess: &'a ParseSess, p } -/// Given a source_file and config, return a parser +/// Given a `source_file` and config, returns a parser. fn source_file_to_parser(sess: &ParseSess, source_file: Lrc) -> Parser<'_> { panictry_buffer!(&sess.span_diagnostic, maybe_source_file_to_parser(sess, source_file)) } -/// Given a source_file and config, return a parser. Returns any buffered errors from lexing the +/// Given a `source_file` and config, return a parser. Returns any buffered errors from lexing the /// initial token stream. fn maybe_source_file_to_parser( sess: &ParseSess, @@ -270,14 +267,14 @@ fn maybe_source_file_to_parser( Ok(parser) } -// must preserve old name for now, because quote! from the *existing* -// compiler expands into it +// Must preserve old name for now, because `quote!` from the *existing* +// compiler expands into it. pub fn new_parser_from_tts(sess: &ParseSess, tts: Vec) -> Parser<'_> { stream_to_parser(sess, tts.into_iter().collect(), crate::MACRO_ARGUMENTS) } -// base abstractions +// Base abstractions /// Given a session and a path and an optional span (for error reporting), /// add the path to the session's source_map and return the new source_file or @@ -296,7 +293,7 @@ fn try_file_to_source_file(sess: &ParseSess, path: &Path, spanopt: Option) } /// Given a session and a path and an optional span (for error reporting), -/// add the path to the session's `source_map` and return the new `source_file`. +/// adds the path to the session's `source_map` and returns the new `source_file`. fn file_to_source_file(sess: &ParseSess, path: &Path, spanopt: Option) -> Lrc { match try_file_to_source_file(sess, path, spanopt) { @@ -308,7 +305,7 @@ fn file_to_source_file(sess: &ParseSess, path: &Path, spanopt: Option) } } -/// Given a source_file, produces a sequence of token trees. +/// Given a `source_file`, produces a sequence of token trees. pub fn source_file_to_stream( sess: &ParseSess, source_file: Lrc, @@ -352,7 +349,7 @@ pub fn maybe_file_to_stream( } } -/// Given stream and the `ParseSess`, produces a parser. +/// Given a stream and the `ParseSess`, produces a parser. pub fn stream_to_parser<'a>( sess: &'a ParseSess, stream: TokenStream, @@ -361,7 +358,7 @@ pub fn stream_to_parser<'a>( Parser::new(sess, stream, None, true, false, subparser_name) } -/// Given stream, the `ParseSess` and the base directory, produces a parser. +/// Given a stream, the `ParseSess` and the base directory, produces a parser. /// /// Use this function when you are creating a parser from the token stream /// and also care about the current working directory of the parser (e.g., diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index ab5462baaf721..fcaf5065dac78 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -10,22 +10,22 @@ pub use path::PathStyle; mod stmt; mod generics; -use crate::ast::{self, AttrStyle, Attribute, Param, BindingMode, StrStyle, SelfKind}; -use crate::ast::{FnDecl, Ident, IsAsync, MacDelimiter, Mutability, TyKind}; -use crate::ast::{Visibility, VisibilityKind, Unsafety, CrateSugar}; -use crate::source_map::{self, respan}; -use crate::parse::{SeqSep, literal, token}; +use crate::ast::{ + self, DUMMY_NODE_ID, AttrStyle, Attribute, BindingMode, CrateSugar, FnDecl, Ident, + IsAsync, MacDelimiter, Mutability, Param, StrStyle, SelfKind, TyKind, Visibility, + VisibilityKind, Unsafety, +}; +use crate::parse::{ParseSess, PResult, Directory, DirectoryOwnership, SeqSep, literal, token}; +use crate::parse::diagnostics::{Error, dummy_arg}; use crate::parse::lexer::UnmatchedBrace; use crate::parse::lexer::comments::{doc_comment_style, strip_doc_comment_decoration}; use crate::parse::token::{Token, TokenKind, DelimToken}; -use crate::parse::{ParseSess, Directory, DirectoryOwnership}; use crate::print::pprust; use crate::ptr::P; -use crate::parse::PResult; -use crate::ThinVec; -use crate::tokenstream::{self, DelimSpan, TokenTree, TokenStream, TreeAndJoint}; +use crate::source_map::{self, respan}; use crate::symbol::{kw, sym, Symbol}; -use crate::parse::diagnostics::{Error, dummy_arg}; +use crate::tokenstream::{self, DelimSpan, TokenTree, TokenStream, TreeAndJoint}; +use crate::ThinVec; use errors::{Applicability, DiagnosticId, FatalError}; use rustc_target::spec::abi::{self, Abi}; @@ -56,7 +56,7 @@ crate enum BlockMode { Ignore, } -/// As maybe_whole_expr, but for things other than expressions +/// Like `maybe_whole_expr`, but for things other than expressions. #[macro_export] macro_rules! maybe_whole { ($p:expr, $constructor:ident, |$x:ident| $e:expr) => { @@ -116,11 +116,11 @@ pub struct Parser<'a> { /// with non-interpolated identifier and lifetime tokens they refer to. /// Perhaps the normalized / non-normalized setup can be simplified somehow. pub token: Token, - /// Span of the current non-normalized token. + /// The span of the current non-normalized token. meta_var_span: Option, - /// Span of the previous non-normalized token. + /// The span of the previous non-normalized token. pub prev_span: Span, - /// Kind of the previous normalized token (in simplified form). + /// The kind of the previous normalized token (in simplified form). prev_token_kind: PrevTokenKind, restrictions: Restrictions, /// Used to determine the path to externally loaded source files. @@ -143,7 +143,7 @@ pub struct Parser<'a> { /// See the comments in the `parse_path_segment` function for more details. crate unmatched_angle_bracket_count: u32, crate max_angle_bracket_count: u32, - /// List of all unclosed delimiters found by the lexer. If an entry is used for error recovery + /// A list of all unclosed delimiters found by the lexer. If an entry is used for error recovery /// it gets removed from here. Every entry left at the end gets emitted as an independent /// error. crate unclosed_delims: Vec, @@ -799,14 +799,14 @@ impl<'a> Parser<'a> { break; } Err(mut e) => { - // Attempt to keep parsing if it was a similar separator + // Attempt to keep parsing if it was a similar separator. if let Some(ref tokens) = t.similar_tokens() { if tokens.contains(&self.token.kind) { self.bump(); } } e.emit(); - // Attempt to keep parsing if it was an omitted separator + // Attempt to keep parsing if it was an omitted separator. match f(self) { Ok(t) => { v.push(t); @@ -871,7 +871,7 @@ impl<'a> Parser<'a> { self.parse_delim_comma_seq(token::Paren, f) } - /// Advance the parser by one token + /// Advance the parser by one token. pub fn bump(&mut self) { if self.prev_token_kind == PrevTokenKind::Eof { // Bumping after EOF is a bad sign, usually an infinite loop. @@ -894,17 +894,17 @@ impl<'a> Parser<'a> { self.token = self.next_tok(); self.expected_tokens.clear(); - // check after each token + // Check after each token. self.process_potential_macro_variable(); } - /// Advance the parser using provided token as a next one. Use this when + /// Advances the parser using provided token as a next one. Use this when /// consuming a part of a token. For example a single `<` from `<<`. fn bump_with(&mut self, next: TokenKind, span: Span) { self.prev_span = self.token.span.with_hi(span.lo()); // It would be incorrect to record the kind of the current token, but // fortunately for tokens currently using `bump_with`, the - // prev_token_kind will be of no use anyway. + // `prev_token_kind` will be of no use anyway. self.prev_token_kind = PrevTokenKind::Other; self.token = Token::new(next, span); self.expected_tokens.clear(); @@ -937,8 +937,8 @@ impl<'a> Parser<'a> { fn parse_asyncness(&mut self) -> IsAsync { if self.eat_keyword(kw::Async) { IsAsync::Async { - closure_id: ast::DUMMY_NODE_ID, - return_impl_trait_id: ast::DUMMY_NODE_ID, + closure_id: DUMMY_NODE_ID, + return_impl_trait_id: DUMMY_NODE_ID, } } else { IsAsync::NotAsync @@ -1040,7 +1040,7 @@ impl<'a> Parser<'a> { let span = lo.to(self.token.span); - Ok(Param { attrs: attrs.into(), id: ast::DUMMY_NODE_ID, pat, span, ty }) + Ok(Param { attrs: attrs.into(), id: DUMMY_NODE_ID, pat, span, ty }) } /// Parses mutability (`mut` or nothing). @@ -1497,7 +1497,7 @@ impl<'a> Parser<'a> { format!("in {}", path), Applicability::MachineApplicable, ) - .emit(); // emit diagnostic, but continue with public visibility + .emit(); // Emit diagnostic, but continue with public visibility. } } diff --git a/src/libsyntax/parse/parser/expr.rs b/src/libsyntax/parse/parser/expr.rs index e8c8e199fd06b..4dbb5ff75eb21 100644 --- a/src/libsyntax/parse/parser/expr.rs +++ b/src/libsyntax/parse/parser/expr.rs @@ -1,26 +1,26 @@ -use super::{Parser, PResult, Restrictions, PrevTokenKind, TokenType, PathStyle}; -use super::{BlockMode, SemiColonMode}; -use super::{SeqSep, TokenExpectType}; +use super::{ + Parser, PResult, Restrictions, PrevTokenKind, TokenType, PathStyle, BlockMode, SemiColonMode, + SeqSep, TokenExpectType, +}; use super::pat::{GateOr, PARAM_EXPECTED}; +use crate::ast::{ + self, DUMMY_NODE_ID, Attribute, AttrStyle, Ident, CaptureBy, BlockCheckMode, + Expr, ExprKind, RangeLimits, Label, Movability, IsAsync, Arm, Ty, TyKind, + FunctionRetTy, Param, FnDecl, BinOpKind, BinOp, UnOp, Mac, AnonConst, Field, +}; use crate::maybe_recover_from_interpolated_ty_qpath; -use crate::ptr::P; -use crate::ast::{self, Attribute, AttrStyle, Ident, CaptureBy, BlockCheckMode}; -use crate::ast::{Expr, ExprKind, RangeLimits, Label, Movability, IsAsync, Arm}; -use crate::ast::{Ty, TyKind, FunctionRetTy, Param, FnDecl}; -use crate::ast::{BinOpKind, BinOp, UnOp}; -use crate::ast::{Mac, AnonConst, Field}; - use crate::parse::classify; use crate::parse::token::{self, Token}; -use crate::parse::diagnostics::{Error}; +use crate::parse::diagnostics::Error; use crate::print::pprust; +use crate::ptr::P; use crate::source_map::{self, Span}; use crate::symbol::{kw, sym}; use crate::util::parser::{AssocOp, Fixity, prec_let_scrutinee_needs_par}; -use std::mem; use errors::Applicability; +use std::mem; use rustc_data_structures::thin_vec::ThinVec; /// Possibly accepts an `token::Interpolated` expression (a pre-parsed expression @@ -51,7 +51,7 @@ macro_rules! maybe_whole_expr { $p.token.span, ExprKind::Block(block, None), ThinVec::new() )); } - // N.B: `NtIdent(ident)` is normalized to `Ident` in `fn bump`. + // N.B., `NtIdent(ident)` is normalized to `Ident` in `fn bump`. _ => {}, }; } @@ -340,7 +340,7 @@ impl<'a> Parser<'a> { fn is_at_start_of_range_notation_rhs(&self) -> bool { if self.token.can_begin_expr() { - // parse `for i in 1.. { }` as infinite loop, not as `for i in (1..{})`. + // Parse `for i in 1.. { }` as infinite loop, not as `for i in (1..{})`. if self.token == token::OpenDelim(token::Brace) { return !self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL); } @@ -350,12 +350,12 @@ impl<'a> Parser<'a> { } } - /// Parse prefix-forms of range notation: `..expr`, `..`, `..=expr` + /// Parses prefix-forms of range notation: `..expr`, `..`, `..=expr`. fn parse_prefix_range_expr( &mut self, already_parsed_attrs: Option> ) -> PResult<'a, P> { - // Check for deprecated `...` syntax + // Check for deprecated `...` syntax. if self.token == token::DotDotDot { self.err_dotdotdot_syntax(self.token.span); } @@ -389,7 +389,7 @@ impl<'a> Parser<'a> { Ok(self.mk_expr(lo.to(hi), r, attrs)) } - /// Parse a prefix-unary-operator expr + /// Parses a prefix-unary-operator expr. fn parse_prefix_expr( &mut self, already_parsed_attrs: Option> @@ -549,7 +549,7 @@ impl<'a> Parser<'a> { let expr = mk_expr(self, P(Ty { span: path.span, node: TyKind::Path(None, path), - id: ast::DUMMY_NODE_ID + id: DUMMY_NODE_ID, })); let expr_str = self.span_to_snippet(expr.span) @@ -565,7 +565,7 @@ impl<'a> Parser<'a> { expr.span, &format!("try {} the cast value", op_verb), format!("({})", expr_str), - Applicability::MachineApplicable + Applicability::MachineApplicable, ) .emit(); @@ -741,7 +741,6 @@ impl<'a> Parser<'a> { }) } - /// At the bottom (top?) of the precedence hierarchy, /// Parses things like parenthesized exprs, macros, `return`, etc. /// @@ -755,7 +754,7 @@ impl<'a> Parser<'a> { // added to the return value after the fact. // // Therefore, prevent sub-parser from parsing - // attributes by giving them a empty "already parsed" list. + // attributes by giving them a empty "already-parsed" list. let mut attrs = ThinVec::new(); let lo = self.token.span; @@ -778,7 +777,7 @@ impl<'a> Parser<'a> { } } - // Note: when adding new syntax here, don't forget to adjust TokenKind::can_begin_expr(). + // Note: when adding new syntax here, don't forget to adjust `TokenKind::can_begin_expr()`. match self.token.kind { // This match arm is a special-case of the `_` match arm below and // could be removed without changing functionality, but it's faster @@ -791,8 +790,8 @@ impl<'a> Parser<'a> { attrs.extend(self.parse_inner_attributes()?); - // (e) is parenthesized e - // (e,) is a tuple with only one field, e + // `(e)` is parenthesized `e`. + // `(e,)` is a tuple with only one field, `e`. let mut es = vec![]; let mut trailing_comma = false; let mut recovered = false; @@ -800,7 +799,7 @@ impl<'a> Parser<'a> { es.push(match self.parse_expr() { Ok(es) => es, Err(mut err) => { - // recover from parse error in tuple list + // Recover from parse error in tuple list. match self.token.kind { token::Ident(name, false) if name == kw::Underscore && self.look_ahead(1, |t| { @@ -844,7 +843,7 @@ impl<'a> Parser<'a> { return self.parse_block_expr(None, lo, BlockCheckMode::Default, attrs); } token::BinOp(token::Or) | token::OrOr => { - return self.parse_lambda_expr(attrs); + return self.parse_closure_expr(attrs); } token::OpenDelim(token::Bracket) => { self.bump(); @@ -852,21 +851,21 @@ impl<'a> Parser<'a> { attrs.extend(self.parse_inner_attributes()?); if self.eat(&token::CloseDelim(token::Bracket)) { - // Empty vector. + // Empty vector ex = ExprKind::Array(Vec::new()); } else { - // Nonempty vector. + // Non-empty vector let first_expr = self.parse_expr()?; if self.eat(&token::Semi) { - // Repeating array syntax: [ 0; 512 ] + // Repeating array syntax: `[ 0; 512 ]` let count = AnonConst { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, value: self.parse_expr()?, }; self.expect(&token::CloseDelim(token::Bracket))?; ex = ExprKind::Repeat(first_expr, count); } else if self.eat(&token::Comma) { - // Vector with two or more elements. + // Vector with two or more elements let remaining_exprs = self.parse_seq_to_end( &token::CloseDelim(token::Bracket), SeqSep::trailing_allowed(token::Comma), @@ -876,7 +875,7 @@ impl<'a> Parser<'a> { exprs.extend(remaining_exprs); ex = ExprKind::Array(exprs); } else { - // Vector with one element. + // Vector with one element self.expect(&token::CloseDelim(token::Bracket))?; ex = ExprKind::Array(vec![first_expr]); } @@ -892,7 +891,7 @@ impl<'a> Parser<'a> { if self.token.is_path_start() { let path = self.parse_path(PathStyle::Expr)?; - // `!`, as an operator, is prefix, so we know this isn't that + // `!`, as an operator, is prefix, so we know this isn't that. if self.eat(&token::Not) { // MACRO INVOCATION expression let (delim, tts) = self.expect_delimited_token_tree()?; @@ -920,7 +919,7 @@ impl<'a> Parser<'a> { return self.maybe_recover_from_bad_qpath(expr, true); } if self.check_keyword(kw::Move) || self.check_keyword(kw::Static) { - return self.parse_lambda_expr(attrs); + return self.parse_closure_expr(attrs); } if self.eat_keyword(kw::If) { return self.parse_if_expr(attrs); @@ -991,13 +990,13 @@ impl<'a> Parser<'a> { return self.parse_try_block(lo, attrs); } - // Span::rust_2018() is somewhat expensive; don't get it repeatedly. + // `Span::rust_2018()` is somewhat expensive; don't get it repeatedly. let is_span_rust_2018 = self.token.span.rust_2018(); if is_span_rust_2018 && self.check_keyword(kw::Async) { - return if self.is_async_block() { // check for `async {` and `async move {` + return if self.is_async_block() { // Check for `async {` and `async move {`. self.parse_async_block(attrs) } else { - self.parse_lambda_expr(attrs) + self.parse_closure_expr(attrs) }; } if self.eat_keyword(kw::Return) { @@ -1043,13 +1042,12 @@ impl<'a> Parser<'a> { // recovery in order to keep the error count down. Fixing the // delimiters will possibly also fix the bare semicolon found in // expression context. For example, silence the following error: - // ``` - // error: expected expression, found `;` - // --> file.rs:2:13 - // | - // 2 | foo(bar(; - // | ^ expected expression - // ``` + // + // error: expected expression, found `;` + // --> file.rs:2:13 + // | + // 2 | foo(bar(; + // | ^ expected expression self.bump(); return Ok(self.mk_expr(self.token.span, ExprKind::Err, ThinVec::new())); } @@ -1096,11 +1094,11 @@ impl<'a> Parser<'a> { attrs.extend(self.parse_inner_attributes()?); let blk = self.parse_block_tail(lo, blk_mode)?; - return Ok(self.mk_expr(blk.span, ExprKind::Block(blk, opt_label), attrs)); + Ok(self.mk_expr(blk.span, ExprKind::Block(blk, opt_label), attrs)) } - /// Parses `move |args| expr`. - fn parse_lambda_expr(&mut self, attrs: ThinVec) -> PResult<'a, P> { + /// Parses a closure expression (e.g., `move |args| expr`). + fn parse_closure_expr(&mut self, attrs: ThinVec) -> PResult<'a, P> { let lo = self.token.span; let movability = if self.eat_keyword(kw::Static) { @@ -1115,7 +1113,7 @@ impl<'a> Parser<'a> { IsAsync::NotAsync }; if asyncness.is_async() { - // Feature gate `async ||` closures. + // Feature-gate `async ||` closures. self.sess.gated_spans.async_closure.borrow_mut().push(self.prev_span); } @@ -1128,8 +1126,7 @@ impl<'a> Parser<'a> { self.parse_expr_res(restrictions, None)? }, _ => { - // If an explicit return type is given, require a - // block to appear (RFC 968). + // If an explicit return type is given, require a block to appear (RFC 968). let body_lo = self.token.span; self.parse_block_expr(None, body_lo, BlockCheckMode::Default, ThinVec::new())? } @@ -1141,7 +1138,7 @@ impl<'a> Parser<'a> { attrs)) } - /// Parse an optional `move` prefix to a closure lke construct. + /// Parses an optional `move` prefix to a closure lke construct. fn parse_capture_clause(&mut self) -> CaptureBy { if self.eat_keyword(kw::Move) { CaptureBy::Value @@ -1176,7 +1173,7 @@ impl<'a> Parser<'a> { })) } - /// Parses a parameter in a lambda header (e.g., `|arg, arg|`). + /// Parses a parameter in a closure header (e.g., `|arg, arg|`). fn parse_fn_block_param(&mut self) -> PResult<'a, Param> { let lo = self.token.span; let attrs = self.parse_param_attributes()?; @@ -1185,7 +1182,7 @@ impl<'a> Parser<'a> { self.parse_ty()? } else { P(Ty { - id: ast::DUMMY_NODE_ID, + id: DUMMY_NODE_ID, node: TyKind::Infer, span: self.prev_span, }) @@ -1196,7 +1193,7 @@ impl<'a> Parser<'a> { ty: t, pat, span, - id: ast::DUMMY_NODE_ID + id: DUMMY_NODE_ID }) } @@ -1233,7 +1230,7 @@ impl<'a> Parser<'a> { Ok(self.mk_expr(lo.to(hi), ExprKind::If(cond, thn, els), attrs)) } - /// Parse the condition of a `if`- or `while`-expression + /// Parses the condition of a `if` or `while` expression. fn parse_cond_expr(&mut self) -> PResult<'a, P> { let cond = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, None)?; @@ -1261,7 +1258,7 @@ impl<'a> Parser<'a> { Ok(self.mk_expr(span, ExprKind::Let(pat, expr), attrs)) } - /// `else` token already eaten + /// Parses an `else { ... }` expression (`else` token already eaten). fn parse_else_expr(&mut self) -> PResult<'a, P> { if self.eat_keyword(kw::If) { return self.parse_if_expr(ThinVec::new()); @@ -1271,7 +1268,7 @@ impl<'a> Parser<'a> { } } - /// Parse a 'for' .. 'in' expression ('for' token already eaten) + /// Parses a `for ... in` expression (`for` token already eaten). fn parse_for_expr( &mut self, opt_label: Option