diff --git a/src/Cargo.lock b/src/Cargo.lock index 9d5f3bbd9e367..3e813523dda8e 100644 --- a/src/Cargo.lock +++ b/src/Cargo.lock @@ -294,7 +294,6 @@ dependencies = [ name = "clippy" version = "0.0.212" dependencies = [ - "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)", "cargo_metadata 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)", "clippy-mini-macro-test 0.2.0", "clippy_lints 0.0.212", @@ -303,7 +302,6 @@ dependencies = [ "lazy_static 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", "rustc-workspace-hack 1.0.0", - "rustc_version 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", "semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)", "serde 1.0.75 (registry+https://github.com/rust-lang/crates.io-index)", "serde_derive 1.0.75 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/src/bootstrap/flags.rs b/src/bootstrap/flags.rs index 60b4d65f44401..2084b8bdb65ff 100644 --- a/src/bootstrap/flags.rs +++ b/src/bootstrap/flags.rs @@ -125,7 +125,8 @@ To learn more about a subcommand, run `./x.py -h`" "stage to build (indicates compiler to use/test, e.g. stage 0 uses the \ bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)", "N"); - opts.optmulti("", "keep-stage", "stage(s) to keep without recompiling", "N"); + opts.optmulti("", "keep-stage", "stage(s) to keep without recompiling \ + (pass multiple times to keep e.g. both stages 0 and 1)", "N"); opts.optopt("", "src", "path to the root of the rust checkout", "DIR"); opts.optopt("j", "jobs", "number of jobs to run in parallel", "JOBS"); opts.optflag("h", "help", "print this help message"); diff --git a/src/liballoc/borrow.rs b/src/liballoc/borrow.rs index c6741ddb822d5..5ae5339138fbe 100644 --- a/src/liballoc/borrow.rs +++ b/src/liballoc/borrow.rs @@ -141,6 +141,41 @@ impl ToOwned for T /// let mut input = Cow::from(vec![-1, 0, 1]); /// abs_all(&mut input); /// ``` +/// +/// Another example showing how to keep `Cow` in a struct: +/// +/// ``` +/// use std::borrow::{Cow, ToOwned}; +/// +/// struct Items<'a, X: 'a> where [X]: ToOwned> { +/// values: Cow<'a, [X]>, +/// } +/// +/// impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned> { +/// fn new(v: Cow<'a, [X]>) -> Self { +/// Items { values: v } +/// } +/// } +/// +/// // Creates a container from borrowed values of a slice +/// let readonly = [1, 2]; +/// let borrowed = Items::new((&readonly[..]).into()); +/// match borrowed { +/// Items { values: Cow::Borrowed(b) } => println!("borrowed {:?}", b), +/// _ => panic!("expect borrowed value"), +/// } +/// +/// let mut clone_on_write = borrowed; +/// // Mutates the data from slice into owned vec and pushes a new value on top +/// clone_on_write.values.to_mut().push(3); +/// println!("clone_on_write = {:?}", clone_on_write.values); +/// +/// // The data was mutated. Let check it out. +/// match clone_on_write { +/// Items { values: Cow::Owned(_) } => println!("clone_on_write contains owned data"), +/// _ => panic!("expect owned data"), +/// } +/// ``` #[stable(feature = "rust1", since = "1.0.0")] pub enum Cow<'a, B: ?Sized + 'a> where B: ToOwned diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 58d6c4f5e0923..ef7d83a0993da 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -75,7 +75,12 @@ use self::Ordering::*; /// the same book if their ISBN matches, even if the formats differ: /// /// ``` -/// enum BookFormat { Paperback, Hardback, Ebook } +/// enum BookFormat { +/// Paperback, +/// Hardback, +/// Ebook, +/// } +/// /// struct Book { /// isbn: i32, /// format: BookFormat, @@ -95,6 +100,84 @@ use self::Ordering::*; /// assert!(b1 != b3); /// ``` /// +/// ## How can I compare two different types? +/// +/// The type you can compare with is controlled by `PartialEq`'s type parameter. +/// For example, let's tweak our previous code a bit: +/// +/// ``` +/// enum BookFormat { +/// Paperback, +/// Hardback, +/// Ebook, +/// } +/// +/// struct Book { +/// isbn: i32, +/// format: BookFormat, +/// } +/// +/// impl PartialEq for Book { +/// fn eq(&self, other: &BookFormat) -> bool { +/// match (&self.format, other) { +/// (BookFormat::Paperback, BookFormat::Paperback) => true, +/// (BookFormat::Hardback, BookFormat::Hardback) => true, +/// (BookFormat::Ebook, BookFormat::Ebook) => true, +/// (_, _) => false, +/// } +/// } +/// } +/// +/// let b1 = Book { isbn: 3, format: BookFormat::Paperback }; +/// +/// assert!(b1 == BookFormat::Paperback); +/// assert!(b1 != BookFormat::Ebook); +/// ``` +/// +/// By changing `impl PartialEq for Book` to `impl PartialEq for Book`, +/// we've changed what type we can use on the right side of the `==` operator. +/// This lets us use it in the `assert!` statements at the bottom. +/// +/// You can also combine these implementations to let the `==` operator work with +/// two different types: +/// +/// ``` +/// enum BookFormat { +/// Paperback, +/// Hardback, +/// Ebook, +/// } +/// +/// struct Book { +/// isbn: i32, +/// format: BookFormat, +/// } +/// +/// impl PartialEq for Book { +/// fn eq(&self, other: &BookFormat) -> bool { +/// match (&self.format, other) { +/// (&BookFormat::Paperback, &BookFormat::Paperback) => true, +/// (&BookFormat::Hardback, &BookFormat::Hardback) => true, +/// (&BookFormat::Ebook, &BookFormat::Ebook) => true, +/// (_, _) => false, +/// } +/// } +/// } +/// +/// impl PartialEq for Book { +/// fn eq(&self, other: &Book) -> bool { +/// self.isbn == other.isbn +/// } +/// } +/// +/// let b1 = Book { isbn: 3, format: BookFormat::Paperback }; +/// let b2 = Book { isbn: 3, format: BookFormat::Ebook }; +/// +/// assert!(b1 == BookFormat::Paperback); +/// assert!(b1 != BookFormat::Ebook); +/// assert!(b1 == b2); +/// ``` +/// /// # Examples /// /// ``` diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index cb05f7b44c3b9..8584b534ff240 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -50,6 +50,7 @@ use hir::GenericArg; use lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES, ELIDED_LIFETIMES_IN_PATHS}; use middle::cstore::CrateStore; +use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::indexed_vec::IndexVec; use rustc_data_structures::small_vec::OneVector; use rustc_data_structures::thin_vec::ThinVec; @@ -57,7 +58,7 @@ use session::Session; use util::common::FN_OUTPUT_NAME; use util::nodemap::{DefIdMap, NodeMap}; -use std::collections::{BTreeMap, HashSet}; +use std::collections::BTreeMap; use std::fmt::Debug; use std::iter; use std::mem; @@ -1342,7 +1343,7 @@ impl<'a> LoweringContext<'a> { exist_ty_id: NodeId, collect_elided_lifetimes: bool, currently_bound_lifetimes: Vec, - already_defined_lifetimes: HashSet, + already_defined_lifetimes: FxHashSet, output_lifetimes: Vec, output_lifetime_params: Vec, } @@ -1476,7 +1477,7 @@ impl<'a> LoweringContext<'a> { exist_ty_id, collect_elided_lifetimes: true, currently_bound_lifetimes: Vec::new(), - already_defined_lifetimes: HashSet::new(), + already_defined_lifetimes: FxHashSet::default(), output_lifetimes: Vec::new(), output_lifetime_params: Vec::new(), }; diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs index a3c9d14eef295..a379438275d89 100644 --- a/src/librustc/infer/mod.rs +++ b/src/librustc/infer/mod.rs @@ -1116,7 +1116,11 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { self.resolve_type_vars_if_possible(t).to_string() } - pub fn shallow_resolve(&self, typ: Ty<'tcx>) -> Ty<'tcx> { + // We have this force-inlined variant of shallow_resolve() for the one + // callsite that is extremely hot. All other callsites use the normal + // variant. + #[inline(always)] + pub fn inlined_shallow_resolve(&self, typ: Ty<'tcx>) -> Ty<'tcx> { match typ.sty { ty::Infer(ty::TyVar(v)) => { // Not entirely obvious: if `typ` is a type variable, @@ -1157,6 +1161,10 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { } } + pub fn shallow_resolve(&self, typ: Ty<'tcx>) -> Ty<'tcx> { + self.inlined_shallow_resolve(typ) + } + pub fn resolve_type_vars_if_possible(&self, value: &T) -> T where T: TypeFoldable<'tcx> { diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs index bfc27e3b5806c..cbf6722c0fd37 100644 --- a/src/librustc/middle/weak_lang_items.rs +++ b/src/librustc/middle/weak_lang_items.rs @@ -13,6 +13,7 @@ use session::config; use middle::lang_items; +use rustc_data_structures::fx::FxHashSet; use rustc_target::spec::PanicStrategy; use syntax::ast; use syntax::symbol::Symbol; @@ -23,8 +24,6 @@ use hir::intravisit; use hir; use ty::TyCtxt; -use std::collections::HashSet; - macro_rules! weak_lang_items { ($($name:ident, $item:ident, $sym:ident;)*) => ( @@ -101,7 +100,7 @@ fn verify<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, return } - let mut missing = HashSet::new(); + let mut missing = FxHashSet::default(); for &cnum in tcx.crates().iter() { for &item in tcx.missing_lang_items(cnum).iter() { missing.insert(item); diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index a58bb4724d2e2..ee683e37648f0 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -37,10 +37,10 @@ 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::hash::Hasher; use std::collections::hash_map::DefaultHasher; -use std::collections::HashSet; use std::iter::FromIterator; use std::path::{Path, PathBuf}; @@ -1373,7 +1373,7 @@ pub fn default_configuration(sess: &Session) -> ast::CrateConfig { let max_atomic_width = sess.target.target.max_atomic_width(); let atomic_cas = sess.target.target.options.atomic_cas; - let mut ret = HashSet::new(); + let mut ret = FxHashSet::default(); // Target bindings. ret.insert((Symbol::intern("target_os"), Some(Symbol::intern(os)))); if let Some(ref fam) = sess.target.target.options.target_family { diff --git a/src/librustc/session/filesearch.rs b/src/librustc/session/filesearch.rs index 32044fdf2a8cb..0de5d3d03d5c3 100644 --- a/src/librustc/session/filesearch.rs +++ b/src/librustc/session/filesearch.rs @@ -12,8 +12,8 @@ pub use self::FileMatch::*; +use rustc_data_structures::fx::FxHashSet; use std::borrow::Cow; -use std::collections::HashSet; use std::env; use std::fs; use std::path::{Path, PathBuf}; @@ -40,7 +40,7 @@ impl<'a> FileSearch<'a> { pub fn for_each_lib_search_path(&self, mut f: F) where F: FnMut(&Path, PathKind) { - let mut visited_dirs = HashSet::new(); + let mut visited_dirs = FxHashSet::default(); for (path, kind) in self.search_paths.iter(self.kind) { f(path, kind); diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index ef81cd3a4575e..adab73c3b7290 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -47,7 +47,6 @@ use jobserver::Client; use std; use std::cell::{self, Cell, RefCell}; -use std::collections::HashMap; use std::env; use std::fmt; use std::io::Write; @@ -122,7 +121,7 @@ pub struct Session { /// Map from imported macro spans (which consist of /// the localized span for the macro body) to the /// macro name and definition span in the source crate. - pub imported_macro_spans: OneThread>>, + pub imported_macro_spans: OneThread>>, incr_comp_session: OneThread>, @@ -1129,7 +1128,7 @@ pub fn build_session_( injected_allocator: Once::new(), allocator_kind: Once::new(), injected_panic_runtime: Once::new(), - imported_macro_spans: OneThread::new(RefCell::new(HashMap::new())), + imported_macro_spans: OneThread::new(RefCell::new(FxHashMap::default())), incr_comp_session: OneThread::new(RefCell::new(IncrCompSession::NotInitialized)), self_profiling: Lock::new(SelfProfiler::new()), profile_channel: Lock::new(None), diff --git a/src/librustc/traits/fulfill.rs b/src/librustc/traits/fulfill.rs index 5c977e1bf624b..9998db4ad1d48 100644 --- a/src/librustc/traits/fulfill.rs +++ b/src/librustc/traits/fulfill.rs @@ -269,7 +269,8 @@ impl<'a, 'b, 'gcx, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'b, 'gcx, // doing more work yet if !pending_obligation.stalled_on.is_empty() { if pending_obligation.stalled_on.iter().all(|&ty| { - let resolved_ty = self.selcx.infcx().shallow_resolve(&ty); + // Use the force-inlined variant of shallow_resolve() because this code is hot. + let resolved_ty = self.selcx.infcx().inlined_shallow_resolve(&ty); resolved_ty == ty // nothing changed here }) { debug!("process_predicate: pending obligation {:?} still stalled on {:?}", diff --git a/src/librustc/ty/query/job.rs b/src/librustc/ty/query/job.rs index e3b0f8c4570df..d07891fca12ae 100644 --- a/src/librustc/ty/query/job.rs +++ b/src/librustc/ty/query/job.rs @@ -11,6 +11,7 @@ #![allow(warnings)] use std::mem; +use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::sync::{Lock, LockGuard, Lrc, Weak}; use rustc_data_structures::OnDrop; use syntax_pos::Span; @@ -21,7 +22,7 @@ use ty::context::TyCtxt; use errors::Diagnostic; use std::process; use std::{fmt, ptr}; -use std::collections::HashSet; + #[cfg(parallel_queries)] use { rayon_core, @@ -282,7 +283,7 @@ where fn cycle_check<'tcx>(query: Lrc>, span: Span, stack: &mut Vec<(Span, Lrc>)>, - visited: &mut HashSet<*const QueryJob<'tcx>> + visited: &mut FxHashSet<*const QueryJob<'tcx>> ) -> Option>> { if visited.contains(&query.as_ptr()) { return if let Some(p) = stack.iter().position(|q| q.1.as_ptr() == query.as_ptr()) { @@ -321,7 +322,7 @@ fn cycle_check<'tcx>(query: Lrc>, #[cfg(parallel_queries)] fn connected_to_root<'tcx>( query: Lrc>, - visited: &mut HashSet<*const QueryJob<'tcx>> + visited: &mut FxHashSet<*const QueryJob<'tcx>> ) -> bool { // We already visited this or we're deliberately ignoring it if visited.contains(&query.as_ptr()) { @@ -357,7 +358,7 @@ fn remove_cycle<'tcx>( wakelist: &mut Vec>>, tcx: TyCtxt<'_, 'tcx, '_> ) -> bool { - let mut visited = HashSet::new(); + let mut visited = FxHashSet::default(); let mut stack = Vec::new(); // Look for a cycle starting with the last query in `jobs` if let Some(waiter) = cycle_check(jobs.pop().unwrap(), @@ -389,7 +390,7 @@ fn remove_cycle<'tcx>( // connected to queries outside the cycle let entry_points: Vec>> = stack.iter().filter_map(|query| { // Mark all the other queries in the cycle as already visited - let mut visited = HashSet::from_iter(stack.iter().filter_map(|q| { + let mut visited = FxHashSet::from_iter(stack.iter().filter_map(|q| { if q.1.as_ptr() != query.1.as_ptr() { Some(q.1.as_ptr()) } else { diff --git a/src/librustc/util/time_graph.rs b/src/librustc/util/time_graph.rs index a8502682a806b..3ba4e4ddbb13b 100644 --- a/src/librustc/util/time_graph.rs +++ b/src/librustc/util/time_graph.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::collections::HashMap; +use rustc_data_structures::fx::FxHashMap; use std::fs::File; use std::io::prelude::*; use std::marker::PhantomData; @@ -40,7 +40,7 @@ struct PerThread { #[derive(Clone)] pub struct TimeGraph { - data: Arc>>, + data: Arc>>, } #[derive(Clone, Copy)] @@ -68,7 +68,7 @@ impl Drop for RaiiToken { impl TimeGraph { pub fn new() -> TimeGraph { TimeGraph { - data: Arc::new(Mutex::new(HashMap::new())) + data: Arc::new(Mutex::new(FxHashMap::default())) } } diff --git a/src/librustc_codegen_llvm/back/linker.rs b/src/librustc_codegen_llvm/back/linker.rs index a429e8f2d815d..24f6156bd7692 100644 --- a/src/librustc_codegen_llvm/back/linker.rs +++ b/src/librustc_codegen_llvm/back/linker.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::collections::HashMap; +use rustc_data_structures::fx::FxHashMap; use std::ffi::{OsStr, OsString}; use std::fs::{self, File}; use std::io::prelude::*; @@ -30,7 +30,7 @@ use serialize::{json, Encoder}; /// For all the linkers we support, and information they might /// need out of the shared crate context before we get rid of it. pub struct LinkerInfo { - exports: HashMap>, + exports: FxHashMap>, } impl LinkerInfo { diff --git a/src/librustc_codegen_llvm/back/rpath.rs b/src/librustc_codegen_llvm/back/rpath.rs index 2c3a143646c24..aa4f7688b0f42 100644 --- a/src/librustc_codegen_llvm/back/rpath.rs +++ b/src/librustc_codegen_llvm/back/rpath.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::collections::HashSet; +use rustc_data_structures::fx::FxHashSet; use std::env; use std::path::{Path, PathBuf}; use std::fs; @@ -172,7 +172,7 @@ fn get_install_prefix_rpath(config: &mut RPathConfig) -> String { } fn minimize_rpaths(rpaths: &[String]) -> Vec { - let mut set = HashSet::new(); + let mut set = FxHashSet::default(); let mut minimized = Vec::new(); for rpath in rpaths { if set.insert(rpath) { diff --git a/src/librustc_data_structures/graph/test.rs b/src/librustc_data_structures/graph/test.rs index b72d011c99bad..26cc2c9f17cfb 100644 --- a/src/librustc_data_structures/graph/test.rs +++ b/src/librustc_data_structures/graph/test.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::collections::HashMap; +use fx::FxHashMap; use std::cmp::max; use std::slice; use std::iter; @@ -18,8 +18,8 @@ use super::*; pub struct TestGraph { num_nodes: usize, start_node: usize, - successors: HashMap>, - predecessors: HashMap>, + successors: FxHashMap>, + predecessors: FxHashMap>, } impl TestGraph { @@ -27,8 +27,8 @@ impl TestGraph { let mut graph = TestGraph { num_nodes: start_node + 1, start_node, - successors: HashMap::new(), - predecessors: HashMap::new(), + successors: FxHashMap::default(), + predecessors: FxHashMap::default(), }; for &(source, target) in edges { graph.num_nodes = max(graph.num_nodes, source + 1); diff --git a/src/librustc_driver/profile/trace.rs b/src/librustc_driver/profile/trace.rs index 56cb3e9dbb829..e329b037d22aa 100644 --- a/src/librustc_driver/profile/trace.rs +++ b/src/librustc_driver/profile/trace.rs @@ -10,10 +10,10 @@ use super::*; use syntax_pos::SpanData; +use rustc_data_structures::fx::FxHashMap; use rustc::util::common::QueryMsg; use std::fs::File; use std::time::{Duration, Instant}; -use std::collections::hash_map::HashMap; use rustc::dep_graph::{DepNode}; #[derive(Debug, Clone, Eq, PartialEq)] @@ -149,7 +149,7 @@ fn write_traces_rec(file: &mut File, traces: &[Rec], total: Duration, depth: usi } } -fn compute_counts_rec(counts: &mut HashMap, traces: &[Rec]) { +fn compute_counts_rec(counts: &mut FxHashMap, traces: &[Rec]) { for t in traces.iter() { match t.effect { Effect::TimeBegin(ref msg) => { @@ -200,7 +200,7 @@ fn compute_counts_rec(counts: &mut HashMap, traces: &[Rec]) } } -pub fn write_counts(count_file: &mut File, counts: &mut HashMap) { +pub fn write_counts(count_file: &mut File, counts: &mut FxHashMap) { use rustc::util::common::duration_to_secs_str; use std::cmp::Reverse; @@ -219,7 +219,7 @@ pub fn write_counts(count_file: &mut File, counts: &mut HashMap = HashMap::with_capacity(capacity); + let mut counts = FxHashMap::with_capacity_and_hasher(capacity, Default::default()); compute_counts_rec(&mut counts, traces); write_counts(counts_file, &mut counts); diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs index c08cf3d039df5..5f275b7003873 100644 --- a/src/librustc_errors/emitter.rs +++ b/src/librustc_errors/emitter.rs @@ -16,12 +16,12 @@ use {Level, CodeSuggestion, DiagnosticBuilder, SubDiagnostic, SourceMapperDyn, D use snippet::{Annotation, AnnotationType, Line, MultilineAnnotation, StyledString, Style}; use styled_buffer::StyledBuffer; +use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::sync::Lrc; use atty; use std::borrow::Cow; use std::io::prelude::*; use std::io; -use std::collections::HashMap; use std::cmp::{min, Reverse}; use termcolor::{StandardStream, ColorChoice, ColorSpec, BufferWriter}; use termcolor::{WriteColor, Color, Buffer}; @@ -1090,7 +1090,7 @@ impl EmitterWriter { max_line_num_len + 1); // Contains the vertical lines' positions for active multiline annotations - let mut multilines = HashMap::new(); + let mut multilines = FxHashMap::default(); // Next, output the annotate source for this file for line_idx in 0..annotated_file.lines.len() { @@ -1109,7 +1109,7 @@ impl EmitterWriter { width_offset, code_offset); - let mut to_add = HashMap::new(); + let mut to_add = FxHashMap::default(); for (depth, style) in depths { if multilines.get(&depth).is_some() { diff --git a/src/librustc_errors/registry.rs b/src/librustc_errors/registry.rs index 83737681471e2..9a2302171bab3 100644 --- a/src/librustc_errors/registry.rs +++ b/src/librustc_errors/registry.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::collections::HashMap; +use rustc_data_structures::fx::FxHashMap; #[derive(Clone)] pub struct Registry { - descriptions: HashMap<&'static str, &'static str>, + descriptions: FxHashMap<&'static str, &'static str>, } impl Registry { diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index f715057541ffa..1b3819474c22e 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -24,7 +24,6 @@ //! the required condition is not met. //! -use std::collections::HashSet; use std::iter::FromIterator; use std::vec::Vec; use rustc::dep_graph::{DepNode, label_strs}; @@ -193,7 +192,7 @@ const LABELS_TRAIT: &[&[&str]] = &[ // // TypeOfItem for these. -type Labels = HashSet; +type Labels = FxHashSet; /// Represents the requested configuration by rustc_clean/dirty struct Assertion { @@ -205,13 +204,13 @@ impl Assertion { fn from_clean_labels(labels: Labels) -> Assertion { Assertion { clean: labels, - dirty: Labels::new(), + dirty: Labels::default(), } } fn from_dirty_labels(labels: Labels) -> Assertion { Assertion { - clean: Labels::new(), + clean: Labels::default(), dirty: labels, } } @@ -328,7 +327,7 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> { } } // if no `label` or `except` is given, only the node's group are asserted - Labels::new() + Labels::default() } /// Return all DepNode labels that should be asserted for this item. @@ -436,7 +435,7 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> { } fn resolve_labels(&self, item: &NestedMetaItem, value: &str) -> Labels { - let mut out: Labels = HashSet::new(); + let mut out = Labels::default(); for label in value.split(',') { let label = label.trim(); if DepNode::has_label_string(label) { diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index d84972b32c108..ab210b013c308 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -39,7 +39,6 @@ use util::nodemap::NodeSet; use lint::{LateContext, LintContext, LintArray}; use lint::{LintPass, LateLintPass, EarlyLintPass, EarlyContext}; -use std::collections::HashSet; use rustc::util::nodemap::FxHashSet; use syntax::tokenstream::{TokenTree, TokenStream}; @@ -304,14 +303,14 @@ pub struct MissingDoc { doc_hidden_stack: Vec, /// Private traits or trait items that leaked through. Don't check their methods. - private_traits: HashSet, + private_traits: FxHashSet, } impl MissingDoc { pub fn new() -> MissingDoc { MissingDoc { doc_hidden_stack: vec![false], - private_traits: HashSet::new(), + private_traits: FxHashSet::default(), } } @@ -908,7 +907,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnconditionalRecursion { let mut work_queue = vec![cfg.entry]; let mut reached_exit_without_self_call = false; let mut self_call_spans = vec![]; - let mut visited = HashSet::new(); + let mut visited = FxHashSet::default(); while let Some(idx) = work_queue.pop() { if idx == cfg.exit { diff --git a/src/librustc_metadata/locator.rs b/src/librustc_metadata/locator.rs index f78a19403acf8..9492385957eab 100644 --- a/src/librustc_metadata/locator.rs +++ b/src/librustc_metadata/locator.rs @@ -226,6 +226,7 @@ use cstore::{MetadataRef, MetadataBlob}; use creader::Library; use schema::{METADATA_HEADER, rustc_version}; +use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::svh::Svh; use rustc::middle::cstore::MetadataLoader; use rustc::session::{config, Session}; @@ -239,7 +240,6 @@ use syntax_pos::Span; use rustc_target::spec::{Target, TargetTriple}; use std::cmp; -use std::collections::HashSet; use std::fmt; use std::fs; use std::io::{self, Read}; @@ -308,7 +308,7 @@ impl CratePaths { impl<'a> Context<'a> { pub fn maybe_load_library_crate(&mut self) -> Option { - let mut seen_paths = HashSet::new(); + let mut seen_paths = FxHashSet::default(); match self.extra_filename { Some(s) => self.find_library_crate(s, &mut seen_paths) .or_else(|| self.find_library_crate("", &mut seen_paths)), @@ -431,7 +431,7 @@ impl<'a> Context<'a> { fn find_library_crate(&mut self, extra_prefix: &str, - seen_paths: &mut HashSet) + seen_paths: &mut FxHashSet) -> Option { // If an SVH is specified, then this is a transitive dependency that // must be loaded via -L plus some filtering. diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs index e9afa7df5c4f2..dcbf92b57b13a 100644 --- a/src/librustc_mir/transform/generator.rs +++ b/src/librustc_mir/transform/generator.rs @@ -67,9 +67,9 @@ use rustc::ty::{self, TyCtxt, AdtDef, Ty}; use rustc::ty::subst::Substs; use util::dump_mir; use util::liveness::{self, IdentityMap}; +use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::indexed_vec::Idx; use rustc_data_structures::indexed_set::IdxSet; -use std::collections::HashMap; use std::borrow::Cow; use std::iter::once; use std::mem; @@ -142,10 +142,12 @@ struct TransformVisitor<'a, 'tcx: 'a> { state_field: usize, // Mapping from Local to (type of local, generator struct index) - remap: HashMap, usize)>, + // FIXME(eddyb) This should use `IndexVec>`. + remap: FxHashMap, usize)>, // A map from a suspension point in a block to the locals which have live storage at that point - storage_liveness: HashMap>, + // FIXME(eddyb) This should use `IndexVec>`. + storage_liveness: FxHashMap>, // A list of suspension points, generated during the transform suspension_points: Vec, @@ -364,12 +366,15 @@ impl<'tcx> Visitor<'tcx> for BorrowedLocals { } } -fn locals_live_across_suspend_points<'a, 'tcx,>(tcx: TyCtxt<'a, 'tcx, 'tcx>, - mir: &Mir<'tcx>, - source: MirSource, - movable: bool) -> - (liveness::LiveVarSet, - HashMap>) { +fn locals_live_across_suspend_points( + tcx: TyCtxt<'a, 'tcx, 'tcx>, + mir: &Mir<'tcx>, + source: MirSource, + movable: bool, +) -> ( + liveness::LiveVarSet, + FxHashMap>, +) { let dead_unwinds = IdxSet::new_empty(mir.basic_blocks().len()); let node_id = tcx.hir.as_local_node_id(source.def_id).unwrap(); @@ -413,7 +418,7 @@ fn locals_live_across_suspend_points<'a, 'tcx,>(tcx: TyCtxt<'a, 'tcx, 'tcx>, &liveness, ); - let mut storage_liveness_map = HashMap::new(); + let mut storage_liveness_map = FxHashMap::default(); for (block, data) in mir.basic_blocks().iter_enumerated() { if let TerminatorKind::Yield { .. } = data.terminator().kind { @@ -477,9 +482,9 @@ fn compute_layout<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, interior: Ty<'tcx>, movable: bool, mir: &mut Mir<'tcx>) - -> (HashMap, usize)>, + -> (FxHashMap, usize)>, GeneratorLayout<'tcx>, - HashMap>) + FxHashMap>) { // Use a liveness analysis to compute locals which are live across a suspension point let (live_locals, storage_liveness) = locals_live_across_suspend_points(tcx, diff --git a/src/librustc_plugin/registry.rs b/src/librustc_plugin/registry.rs index b1ab86674cf90..5ef05cb1d6b6e 100644 --- a/src/librustc_plugin/registry.rs +++ b/src/librustc_plugin/registry.rs @@ -12,6 +12,7 @@ use rustc::lint::{EarlyLintPassObject, LateLintPassObject, LintId, Lint}; use rustc::session::Session; +use rustc::util::nodemap::FxHashMap; use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT, IdentTT}; use syntax::ext::base::MacroExpanderFn; @@ -21,7 +22,6 @@ use syntax::ast; use syntax::feature_gate::AttributeType; use syntax_pos::Span; -use std::collections::HashMap; use std::borrow::ToOwned; /// Structure used to register plugins. @@ -53,7 +53,7 @@ pub struct Registry<'a> { pub late_lint_passes: Vec, #[doc(hidden)] - pub lint_groups: HashMap<&'static str, Vec>, + pub lint_groups: FxHashMap<&'static str, Vec>, #[doc(hidden)] pub llvm_passes: Vec, @@ -74,7 +74,7 @@ impl<'a> Registry<'a> { syntax_exts: vec![], early_lint_passes: vec![], late_lint_passes: vec![], - lint_groups: HashMap::new(), + lint_groups: FxHashMap::default(), llvm_passes: vec![], attributes: vec![], whitelisted_custom_derives: Vec::new(), diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 78c518aea961d..95d5fba9668d4 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -70,7 +70,7 @@ use syntax::feature_gate::{feature_err, GateIssue}; use syntax::ptr::P; use syntax_pos::{Span, DUMMY_SP, MultiSpan}; -use errors::{DiagnosticBuilder, DiagnosticId}; +use errors::{Applicability, DiagnosticBuilder, DiagnosticId}; use std::cell::{Cell, RefCell}; use std::cmp; @@ -221,9 +221,12 @@ fn resolve_struct_error<'sess, 'a>(resolver: &'sess Resolver, let sugg_msg = "try using a local type parameter instead"; if let Some((sugg_span, new_snippet)) = cm.generate_local_type_param_snippet(span) { // Suggest the modification to the user - err.span_suggestion(sugg_span, - sugg_msg, - new_snippet); + err.span_suggestion_with_applicability( + sugg_span, + sugg_msg, + new_snippet, + Applicability::MachineApplicable, + ); } else if let Some(sp) = cm.generate_fn_name_span(span) { err.span_label(sp, "try adding a local type parameter in this method instead"); } else { @@ -3004,8 +3007,12 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { enum_path); err.help(&msg); } else { - err.span_suggestion(span, "you can try using the variant's enum", - enum_path); + err.span_suggestion_with_applicability( + span, + "you can try using the variant's enum", + enum_path, + Applicability::MachineApplicable, + ); } } } @@ -3014,20 +3021,32 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { let self_is_available = this.self_value_is_available(path[0].span, span); match candidate { AssocSuggestion::Field => { - err.span_suggestion(span, "try", - format!("self.{}", path_str)); + err.span_suggestion_with_applicability( + span, + "try", + format!("self.{}", path_str), + Applicability::MachineApplicable, + ); if !self_is_available { err.span_label(span, format!("`self` value is only available in \ methods with `self` parameter")); } } AssocSuggestion::MethodWithSelf if self_is_available => { - err.span_suggestion(span, "try", - format!("self.{}", path_str)); + err.span_suggestion_with_applicability( + span, + "try", + format!("self.{}", path_str), + Applicability::MachineApplicable, + ); } AssocSuggestion::MethodWithSelf | AssocSuggestion::AssocItem => { - err.span_suggestion(span, "try", - format!("Self::{}", path_str)); + err.span_suggestion_with_applicability( + span, + "try", + format!("Self::{}", path_str), + Applicability::MachineApplicable, + ); } } return (err, candidates); @@ -4662,15 +4681,16 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { format!("other_{}", name) }; - err.span_suggestion(binding.span, - rename_msg, - if snippet.ends_with(';') { - format!("{} as {};", - &snippet[..snippet.len()-1], - suggested_name) - } else { - format!("{} as {}", snippet, suggested_name) - }); + err.span_suggestion_with_applicability( + binding.span, + rename_msg, + if snippet.ends_with(';') { + format!("{} as {};", &snippet[..snippet.len() - 1], suggested_name) + } else { + format!("{} as {}", snippet, suggested_name) + }, + Applicability::MachineApplicable, + ); } else { err.span_label(binding.span, rename_msg); } diff --git a/src/librustc_save_analysis/dump_visitor.rs b/src/librustc_save_analysis/dump_visitor.rs index dc9310cdcdaa4..6f5655b8cec53 100644 --- a/src/librustc_save_analysis/dump_visitor.rs +++ b/src/librustc_save_analysis/dump_visitor.rs @@ -91,7 +91,7 @@ pub struct DumpVisitor<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> { // of macro use (callsite) spans. We store these to ensure // we only write one macro def per unique macro definition, and // one macro use per unique callsite span. - // mac_defs: HashSet, + // mac_defs: FxHashSet, macro_calls: FxHashSet, } @@ -107,7 +107,7 @@ impl<'l, 'tcx: 'l, 'll, O: DumpOutput + 'll> DumpVisitor<'l, 'tcx, 'll, O> { dumper, span: span_utils.clone(), cur_scope: CRATE_NODE_ID, - // mac_defs: HashSet::new(), + // mac_defs: FxHashSet::default(), macro_calls: FxHashSet(), } } diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index fd29dac5af8cc..56dfac8461192 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -148,7 +148,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { filter!(self.span_utils, sub_span, item.span, None); Some(Data::DefData(Def { - kind: DefKind::Function, + kind: DefKind::ForeignFunction, id: id_from_node_id(item.id, self), span: self.span_from_span(sub_span.unwrap()), name: item.ident.to_string(), @@ -171,7 +171,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { let span = self.span_from_span(sub_span.unwrap()); Some(Data::DefData(Def { - kind: DefKind::Static, + kind: DefKind::ForeignStatic, id, span, name: item.ident.to_string(), diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 85646b9ab675a..4e22ead8db987 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -351,11 +351,14 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { if !self.infcx.type_moves_by_default(self.param_env, checked, sp) { - let sp = cm.call_span_if_macro(sp); - if let Ok(code) = cm.span_to_snippet(sp) { - return Some((sp, - "consider dereferencing the borrow", - format!("*{}", code))); + // do not suggest if the span comes from a macro (#52783) + if let (Ok(code), + true) = (cm.span_to_snippet(sp), sp == expr.span) { + return Some(( + sp, + "consider dereferencing the borrow", + format!("*{}", code), + )); } } } diff --git a/src/librustc_typeck/structured_errors.rs b/src/librustc_typeck/structured_errors.rs index ffd9da8c8b95c..12863cc66a053 100644 --- a/src/librustc_typeck/structured_errors.rs +++ b/src/librustc_typeck/structured_errors.rs @@ -10,7 +10,7 @@ use rustc::session::Session; use syntax_pos::Span; -use errors::{DiagnosticId, DiagnosticBuilder}; +use errors::{Applicability, DiagnosticId, DiagnosticBuilder}; use rustc::ty::{Ty, TypeFoldable}; pub trait StructuredDiagnostic<'tcx> { @@ -73,9 +73,12 @@ impl<'tcx> StructuredDiagnostic<'tcx> for VariadicError<'tcx> { ) }; if let Ok(snippet) = self.sess.source_map().span_to_snippet(self.span) { - err.span_suggestion(self.span, - &format!("cast the value to `{}`", self.cast_ty), - format!("{} as {}", snippet, self.cast_ty)); + err.span_suggestion_with_applicability( + self.span, + &format!("cast the value to `{}`", self.cast_ty), + format!("{} as {}", snippet, self.cast_ty), + Applicability::MachineApplicable, + ); } else { err.help(&format!("cast the value to `{}`", self.cast_ty)); } diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs index c104b88334061..18ad862c11bb0 100644 --- a/src/librustdoc/html/markdown.rs +++ b/src/librustdoc/html/markdown.rs @@ -29,8 +29,9 @@ #![allow(non_camel_case_types)] +use rustc_data_structures::fx::FxHashMap; use std::cell::RefCell; -use std::collections::{HashMap, VecDeque}; +use std::collections::VecDeque; use std::default::Default; use std::fmt::{self, Write}; use std::borrow::Cow; @@ -417,14 +418,14 @@ impl<'a, I: Iterator>> Iterator for SummaryLine<'a, I> { /// references. struct Footnotes<'a, I: Iterator>> { inner: I, - footnotes: HashMap>, u16)>, + footnotes: FxHashMap>, u16)>, } impl<'a, I: Iterator>> Footnotes<'a, I> { fn new(iter: I) -> Self { Footnotes { inner: iter, - footnotes: HashMap::new(), + footnotes: FxHashMap::default(), } } fn get_entry(&mut self, key: &str) -> &mut (Vec>, u16) { @@ -865,7 +866,7 @@ pub fn markdown_links(md: &str) -> Vec<(String, Option>)> { #[derive(Default)] pub struct IdMap { - map: HashMap, + map: FxHashMap, } impl IdMap { @@ -880,7 +881,7 @@ impl IdMap { } pub fn reset(&mut self) { - self.map = HashMap::new(); + self.map = FxHashMap::default(); } pub fn derive(&mut self, candidate: String) -> String { diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 8fb3b570f8a4b..1abe01dd0ac20 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -38,7 +38,7 @@ pub use self::ExternalLocation::*; use std::borrow::Cow; use std::cell::RefCell; use std::cmp::Ordering; -use std::collections::{BTreeMap, HashSet, VecDeque}; +use std::collections::{BTreeMap, VecDeque}; use std::default::Default; use std::error; use std::fmt::{self, Display, Formatter, Write as FmtWrite}; @@ -741,7 +741,7 @@ fn write_shared(cx: &Context, // To avoid "light.css" to be overwritten, we'll first run over the received themes and only // then we'll run over the "official" styles. - let mut themes: HashSet = HashSet::new(); + let mut themes: FxHashSet = FxHashSet::default(); for entry in &cx.shared.themes { let mut content = Vec::with_capacity(100000); @@ -1539,35 +1539,36 @@ impl Ord for ItemEntry { #[derive(Debug)] struct AllTypes { - structs: HashSet, - enums: HashSet, - unions: HashSet, - primitives: HashSet, - traits: HashSet, - macros: HashSet, - functions: HashSet, - typedefs: HashSet, - existentials: HashSet, - statics: HashSet, - constants: HashSet, - keywords: HashSet, + structs: FxHashSet, + enums: FxHashSet, + unions: FxHashSet, + primitives: FxHashSet, + traits: FxHashSet, + macros: FxHashSet, + functions: FxHashSet, + typedefs: FxHashSet, + existentials: FxHashSet, + statics: FxHashSet, + constants: FxHashSet, + keywords: FxHashSet, } impl AllTypes { fn new() -> AllTypes { + let new_set = |cap| FxHashSet::with_capacity_and_hasher(cap, Default::default()); AllTypes { - structs: HashSet::with_capacity(100), - enums: HashSet::with_capacity(100), - unions: HashSet::with_capacity(100), - primitives: HashSet::with_capacity(26), - traits: HashSet::with_capacity(100), - macros: HashSet::with_capacity(100), - functions: HashSet::with_capacity(100), - typedefs: HashSet::with_capacity(100), - existentials: HashSet::with_capacity(100), - statics: HashSet::with_capacity(100), - constants: HashSet::with_capacity(100), - keywords: HashSet::with_capacity(100), + structs: new_set(100), + enums: new_set(100), + unions: new_set(100), + primitives: new_set(26), + traits: new_set(100), + macros: new_set(100), + functions: new_set(100), + typedefs: new_set(100), + existentials: new_set(100), + statics: new_set(100), + constants: new_set(100), + keywords: new_set(100), } } @@ -1595,7 +1596,7 @@ impl AllTypes { } } -fn print_entries(f: &mut fmt::Formatter, e: &HashSet, title: &str, +fn print_entries(f: &mut fmt::Formatter, e: &FxHashSet, title: &str, class: &str) -> fmt::Result { if !e.is_empty() { let mut e: Vec<&ItemEntry> = e.iter().collect(); @@ -4185,7 +4186,7 @@ fn sidebar_assoc_items(it: &clean::Item) -> String { } } let format_impls = |impls: Vec<&Impl>| { - let mut links = HashSet::new(); + let mut links = FxHashSet::default(); impls.iter() .filter_map(|i| { let is_negative_impl = is_negative_impl(i.inner_impl()); diff --git a/src/librustdoc/html/static/main.js b/src/librustdoc/html/static/main.js index 88c25567d2963..51ed626782926 100644 --- a/src/librustdoc/html/static/main.js +++ b/src/librustdoc/html/static/main.js @@ -242,6 +242,7 @@ } } + highlightSourceLines(null); window.onhashchange = highlightSourceLines; // Gets the human-readable string for the virtual-key code of the diff --git a/src/librustdoc/html/static/rustdoc.css b/src/librustdoc/html/static/rustdoc.css index ffe6a40b36998..870b024a3ba00 100644 --- a/src/librustdoc/html/static/rustdoc.css +++ b/src/librustdoc/html/static/rustdoc.css @@ -502,6 +502,7 @@ h4 > code, h3 > code, .invisible > code { margin-left: 33px; margin-top: -13px; } + .content .stability::before { content: '˪'; font-size: 30px; @@ -510,6 +511,10 @@ h4 > code, h3 > code, .invisible > code { left: -13px; } +#main > .stability { + margin-top: 0; +} + nav { border-bottom: 1px solid; padding-bottom: 10px; diff --git a/src/librustdoc/theme.rs b/src/librustdoc/theme.rs index 96a67e0788758..73cc363009de5 100644 --- a/src/librustdoc/theme.rs +++ b/src/librustdoc/theme.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use std::collections::HashSet; +use rustc_data_structures::fx::FxHashSet; use std::fs::File; use std::hash::{Hash, Hasher}; use std::io::Read; @@ -31,7 +31,7 @@ macro_rules! try_something { #[derive(Debug, Clone, Eq)] pub struct CssPath { pub name: String, - pub children: HashSet, + pub children: FxHashSet, } // This PartialEq implementation IS NOT COMMUTATIVE!!! @@ -66,7 +66,7 @@ impl CssPath { fn new(name: String) -> CssPath { CssPath { name, - children: HashSet::new(), + children: FxHashSet::default(), } } } @@ -211,7 +211,7 @@ fn build_rule(v: &[u8], positions: &[usize]) -> String { .join(" ") } -fn inner(v: &[u8], events: &[Events], pos: &mut usize) -> HashSet { +fn inner(v: &[u8], events: &[Events], pos: &mut usize) -> FxHashSet { let mut paths = Vec::with_capacity(50); while *pos < events.len() { diff --git a/src/libstd/sys/unix/net.rs b/src/libstd/sys/unix/net.rs index 8c73fe8c6129f..2d10541752c83 100644 --- a/src/libstd/sys/unix/net.rs +++ b/src/libstd/sys/unix/net.rs @@ -395,30 +395,3 @@ fn on_resolver_failure() { #[cfg(not(target_env = "gnu"))] fn on_resolver_failure() {} - -#[cfg(all(test, taget_env = "gnu"))] -mod test { - use super::*; - - #[test] - fn test_res_init() { - // This mostly just tests that the weak linkage doesn't panic wildly... - res_init_if_glibc_before_2_26().unwrap(); - } - - #[test] - fn test_parse_glibc_version() { - let cases = [ - ("0.0", Some((0, 0))), - ("01.+2", Some((1, 2))), - ("3.4.5.six", Some((3, 4))), - ("1", None), - ("1.-2", None), - ("1.foo", None), - ("foo.1", None), - ]; - for &(version_str, parsed) in cases.iter() { - assert_eq!(parsed, parse_glibc_version(version_str)); - } - } -} diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index f8f0bbd5bc250..971e6501c2c2a 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -569,3 +569,30 @@ fn parse_glibc_version(version: &str) -> Option<(usize, usize)> { _ => None } } + +#[cfg(all(test, target_env = "gnu"))] +mod test { + use super::*; + + #[test] + fn test_glibc_version() { + // This mostly just tests that the weak linkage doesn't panic wildly... + glibc_version(); + } + + #[test] + fn test_parse_glibc_version() { + let cases = [ + ("0.0", Some((0, 0))), + ("01.+2", Some((1, 2))), + ("3.4.5.six", Some((3, 4))), + ("1", None), + ("1.-2", None), + ("1.foo", None), + ("foo.1", None), + ]; + for &(version_str, parsed) in cases.iter() { + assert_eq!(parsed, parse_glibc_version(version_str)); + } + } +} diff --git a/src/libstd/thread/mod.rs b/src/libstd/thread/mod.rs index 61c6084a25023..a7c7dbb1b4027 100644 --- a/src/libstd/thread/mod.rs +++ b/src/libstd/thread/mod.rs @@ -1310,11 +1310,17 @@ impl JoinHandle { /// Waits for the associated thread to finish. /// + /// In terms of [atomic memory orderings], the completion of the associated + /// thread synchronizes with this function returning. In other words, all + /// operations performed by that thread are ordered before all + /// operations that happen after `join` returns. + /// /// If the child thread panics, [`Err`] is returned with the parameter given /// to [`panic`]. /// /// [`Err`]: ../../std/result/enum.Result.html#variant.Err /// [`panic`]: ../../std/macro.panic.html + /// [atomic memory orderings]: ../../std/sync/atomic/index.html /// /// # Panics /// diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index b6084bcf34307..bd0e0d277ee54 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -28,8 +28,8 @@ use ThinVec; use tokenstream::{ThinTokenStream, TokenStream}; use serialize::{self, Encoder, Decoder}; -use std::collections::HashSet; use std::fmt; +use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::sync::Lrc; use std::u32; @@ -407,7 +407,7 @@ pub struct WhereEqPredicate { /// The set of MetaItems that define the compilation environment of the crate, /// used to drive conditional compilation -pub type CrateConfig = HashSet<(Name, Option)>; +pub type CrateConfig = FxHashSet<(Name, Option)>; #[derive(Clone, RustcEncodable, RustcDecodable, Debug)] pub struct Crate { diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 75d24df7b629f..e8a68b6d7676c 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -26,7 +26,7 @@ use OneVector; use symbol::{keywords, Ident, Symbol}; use ThinVec; -use std::collections::HashMap; +use rustc_data_structures::fx::FxHashMap; use std::iter; use std::path::PathBuf; use std::rc::Rc; @@ -800,7 +800,7 @@ pub struct ExtCtxt<'a> { pub resolver: &'a mut dyn Resolver, pub resolve_err_count: usize, pub current_expansion: ExpansionData, - pub expansions: HashMap>, + pub expansions: FxHashMap>, } impl<'a> ExtCtxt<'a> { @@ -821,7 +821,7 @@ impl<'a> ExtCtxt<'a> { directory_ownership: DirectoryOwnership::Owned { relative: None }, crate_span: None, }, - expansions: HashMap::new(), + expansions: FxHashMap::default(), } } diff --git a/src/libsyntax/ext/derive.rs b/src/libsyntax/ext/derive.rs index 80bbc618932ef..684cee3887463 100644 --- a/src/libsyntax/ext/derive.rs +++ b/src/libsyntax/ext/derive.rs @@ -17,7 +17,7 @@ use parse::parser::PathStyle; use symbol::Symbol; use syntax_pos::Span; -use std::collections::HashSet; +use rustc_data_structures::fx::FxHashSet; pub fn collect_derives(cx: &mut ExtCtxt, attrs: &mut Vec) -> Vec { let mut result = Vec::new(); @@ -48,7 +48,7 @@ pub fn collect_derives(cx: &mut ExtCtxt, attrs: &mut Vec) -> Vec pub fn add_derived_markers(cx: &mut ExtCtxt, span: Span, traits: &[ast::Path], item: T) -> T where T: HasAttrs, { - let (mut names, mut pretty_name) = (HashSet::new(), "derive(".to_owned()); + let (mut names, mut pretty_name) = (FxHashSet::default(), "derive(".to_owned()); for (i, path) in traits.iter().enumerate() { if i > 0 { pretty_name.push_str(", "); diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index a2e84b508dc12..6e38f820586ff 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -34,7 +34,7 @@ use syntax_pos::hygiene::ExpnFormat; use tokenstream::{TokenStream, TokenTree}; use visit::{self, Visitor}; -use std::collections::HashMap; +use rustc_data_structures::fx::FxHashMap; use std::fs::File; use std::io::Read; use std::iter::FromIterator; @@ -319,7 +319,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> { // Unresolved macros produce dummy outputs as a recovery measure. invocations.reverse(); let mut expanded_fragments = Vec::new(); - let mut derives: HashMap> = HashMap::new(); + let mut derives: FxHashMap> = FxHashMap::default(); let mut undetermined_invocations = Vec::new(); let (mut progress, mut force) = (false, !self.monotonic); loop { diff --git a/src/libsyntax/ext/placeholders.rs b/src/libsyntax/ext/placeholders.rs index 7a8ccfddf8eb6..5906412883ad0 100644 --- a/src/libsyntax/ext/placeholders.rs +++ b/src/libsyntax/ext/placeholders.rs @@ -21,7 +21,7 @@ use symbol::keywords; use ThinVec; use util::move_map::MoveMap; -use std::collections::HashMap; +use rustc_data_structures::fx::FxHashMap; pub fn placeholder(kind: AstFragmentKind, id: ast::NodeId) -> AstFragment { fn mac_placeholder() -> ast::Mac { @@ -81,7 +81,7 @@ pub fn placeholder(kind: AstFragmentKind, id: ast::NodeId) -> AstFragment { } pub struct PlaceholderExpander<'a, 'b: 'a> { - expanded_fragments: HashMap, + expanded_fragments: FxHashMap, cx: &'a mut ExtCtxt<'b>, monotonic: bool, } @@ -90,7 +90,7 @@ impl<'a, 'b> PlaceholderExpander<'a, 'b> { pub fn new(cx: &'a mut ExtCtxt<'b>, monotonic: bool) -> Self { PlaceholderExpander { cx, - expanded_fragments: HashMap::new(), + expanded_fragments: FxHashMap::default(), monotonic, } } diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index dcdeee5c2e700..c962e7fcbb4cf 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -96,11 +96,11 @@ use OneVector; use symbol::keywords; use tokenstream::TokenStream; +use rustc_data_structures::fx::FxHashMap; +use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::mem; use std::ops::{Deref, DerefMut}; use std::rc::Rc; -use std::collections::HashMap; -use std::collections::hash_map::Entry::{Occupied, Vacant}; // To avoid costly uniqueness checks, we require that `MatchSeq` always has a nonempty body. @@ -263,7 +263,7 @@ pub enum ParseResult { /// A `ParseResult` where the `Success` variant contains a mapping of `Ident`s to `NamedMatch`es. /// This represents the mapping of metavars to the token trees they bind to. -pub type NamedParseResult = ParseResult>>; +pub type NamedParseResult = ParseResult>>; /// Count how many metavars are named in the given matcher `ms`. pub fn count_names(ms: &[TokenTree]) -> usize { @@ -351,7 +351,7 @@ fn nameize>( sess: &ParseSess, m: &TokenTree, res: &mut I, - ret_val: &mut HashMap>, + ret_val: &mut FxHashMap>, ) -> Result<(), (syntax_pos::Span, String)> { match *m { TokenTree::Sequence(_, ref seq) => for next_m in &seq.tts { @@ -382,7 +382,7 @@ fn nameize>( Ok(()) } - let mut ret_val = HashMap::new(); + let mut ret_val = FxHashMap::default(); for m in ms { match n_rec(sess, m, res.by_ref(), &mut ret_val) { Ok(_) => {} diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 2c738ac2a04cd..d09127d6b08b7 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -27,8 +27,8 @@ use parse::token::Token::*; use symbol::Symbol; use tokenstream::{TokenStream, TokenTree}; +use rustc_data_structures::fx::FxHashMap; use std::borrow::Cow; -use std::collections::HashMap; use std::collections::hash_map::Entry; use rustc_data_structures::sync::Lrc; @@ -451,14 +451,14 @@ struct FirstSets { // If two sequences have the same span in a matcher, then map that // span to None (invalidating the mapping here and forcing the code to // use a slow path). - first: HashMap>, + first: FxHashMap>, } impl FirstSets { fn new(tts: &[quoted::TokenTree]) -> FirstSets { use self::quoted::TokenTree; - let mut sets = FirstSets { first: HashMap::new() }; + let mut sets = FirstSets { first: FxHashMap::default() }; build_recur(&mut sets, tts); return sets; diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs index 67a15b149f6d5..549e5f00dcec4 100644 --- a/src/libsyntax/ext/tt/transcribe.rs +++ b/src/libsyntax/ext/tt/transcribe.rs @@ -19,11 +19,11 @@ use OneVector; use syntax_pos::{Span, DUMMY_SP}; use tokenstream::{TokenStream, TokenTree, Delimited}; -use std::rc::Rc; +use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::sync::Lrc; use std::mem; use std::ops::Add; -use std::collections::HashMap; +use std::rc::Rc; // An iterator over the token trees in a delimited token tree (`{ ... }`) or a sequence (`$(...)`). enum Frame { @@ -67,11 +67,11 @@ impl Iterator for Frame { /// `src` contains no `TokenTree::{Sequence, MetaVar, MetaVarDecl}`s, `interp` can /// (and should) be None. pub fn transcribe(cx: &ExtCtxt, - interp: Option>>, + interp: Option>>, src: Vec) -> TokenStream { let mut stack: OneVector = smallvec![Frame::new(src)]; - let interpolations = interp.unwrap_or_else(HashMap::new); /* just a convenience */ + let interpolations = interp.unwrap_or_else(FxHashMap::default); /* just a convenience */ let mut repeats = Vec::new(); let mut result: Vec = Vec::new(); let mut result_stack = Vec::new(); @@ -187,7 +187,7 @@ pub fn transcribe(cx: &ExtCtxt, } fn lookup_cur_matched(ident: Ident, - interpolations: &HashMap>, + interpolations: &FxHashMap>, repeats: &[(usize, usize)]) -> Option> { interpolations.get(&ident).map(|matched| { @@ -234,7 +234,7 @@ impl Add for LockstepIterSize { } fn lockstep_iter_size(tree: "ed::TokenTree, - interpolations: &HashMap>, + interpolations: &FxHashMap>, repeats: &[(usize, usize)]) -> LockstepIterSize { use self::quoted::TokenTree; diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 6dd788bf6e2ac..961bafc267982 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -642,7 +642,7 @@ declare_features! ( // Defining procedural macros in `proc-macro` crates (accepted, proc_macro, "1.29.0", Some(38356), None), // Allows use of the :vis macro fragment specifier - (accepted, macro_vis_matcher, "1.29.0", Some(41022), None), + (accepted, macro_vis_matcher, "1.30.0", Some(41022), None), // Allows importing and reexporting macros with `use`, // enables macro modularization in general. (accepted, use_extern_macros, "1.30.0", Some(35896), None), diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 448ff9676c927..96584a580f175 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -1831,10 +1831,10 @@ mod tests { use errors; use feature_gate::UnstableFeatures; use parse::token; - use std::collections::HashSet; use std::io; use std::path::PathBuf; use diagnostics::plugin::ErrorMap; + use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::sync::Lock; use with_globals; fn mk_sess(cm: Lrc) -> ParseSess { @@ -1845,10 +1845,10 @@ mod tests { ParseSess { span_diagnostic: errors::Handler::with_emitter(true, false, Box::new(emitter)), unstable_features: UnstableFeatures::from_environment(), - config: CrateConfig::new(), + config: CrateConfig::default(), included_mod_stack: Lock::new(Vec::new()), code_map: cm, - missing_fragment_specifiers: Lock::new(HashSet::new()), + missing_fragment_specifiers: Lock::new(FxHashSet::default()), raw_identifier_spans: Lock::new(Vec::new()), registered_diagnostics: Lock::new(ErrorMap::new()), non_modrs_mods: Lock::new(vec![]), diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 1136cda5ee359..28d63399b4461 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -24,8 +24,8 @@ use symbol::Symbol; use tokenstream::{TokenStream, TokenTree}; use diagnostics::plugin::ErrorMap; +use rustc_data_structures::fx::FxHashSet; use std::borrow::Cow; -use std::collections::HashSet; use std::iter; use std::path::{Path, PathBuf}; use std::str; @@ -46,7 +46,7 @@ pub struct ParseSess { pub span_diagnostic: Handler, pub unstable_features: UnstableFeatures, pub config: CrateConfig, - pub missing_fragment_specifiers: Lock>, + pub missing_fragment_specifiers: Lock>, /// Places where raw identifiers were used. This is used for feature gating /// raw identifiers pub raw_identifier_spans: Lock>, @@ -75,8 +75,8 @@ impl ParseSess { ParseSess { span_diagnostic: handler, unstable_features: UnstableFeatures::from_environment(), - config: HashSet::new(), - missing_fragment_specifiers: Lock::new(HashSet::new()), + config: FxHashSet::default(), + 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![]), diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 1695d3a8f96b0..6c50b9c82f2b8 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -786,7 +786,12 @@ impl<'a> Parser<'a> { } else { err.span_label(self.span, "expected identifier"); if self.token == token::Comma && self.look_ahead(1, |t| t.is_ident()) { - err.span_suggestion(self.span, "remove this comma", String::new()); + err.span_suggestion_with_applicability( + self.span, + "remove this comma", + String::new(), + Applicability::MachineApplicable, + ); } } err @@ -6083,7 +6088,12 @@ impl<'a> Parser<'a> { self.this_token_to_string())); if self.token.is_ident() { // This is likely another field; emit the diagnostic and keep going - err.span_suggestion(sp, "try adding a comma", ",".into()); + err.span_suggestion_with_applicability( + sp, + "try adding a comma", + ",".into(), + Applicability::MachineApplicable, + ); err.emit(); } else { return Err(err) diff --git a/src/libsyntax_ext/format.rs b/src/libsyntax_ext/format.rs index b23c2ec3db101..efe9c2cefdebe 100644 --- a/src/libsyntax_ext/format.rs +++ b/src/libsyntax_ext/format.rs @@ -24,9 +24,9 @@ use syntax::tokenstream; use syntax_pos::{MultiSpan, Span, DUMMY_SP}; use errors::Applicability; +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use std::borrow::Cow; use std::collections::hash_map::Entry; -use std::collections::{HashMap, HashSet}; #[derive(PartialEq)] enum ArgumentType { @@ -65,7 +65,7 @@ struct Context<'a, 'b: 'a> { /// Unique format specs seen for each argument. arg_unique_types: Vec>, /// Map from named arguments to their resolved indices. - names: HashMap, + names: FxHashMap, /// The latest consecutive literal strings, or empty if there weren't any. literal: String, @@ -104,7 +104,7 @@ struct Context<'a, 'b: 'a> { /// * `count_args`: `vec![Exact(0), Exact(5), Exact(3)]` count_args: Vec, /// Relative slot numbers for count arguments. - count_positions: HashMap, + count_positions: FxHashMap, /// Number of count slots assigned. count_positions_count: usize, @@ -134,9 +134,9 @@ struct Context<'a, 'b: 'a> { fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree]) - -> Option<(P, Vec>, HashMap)> { + -> Option<(P, Vec>, FxHashMap)> { let mut args = Vec::>::new(); - let mut names = HashMap::::new(); + let mut names = FxHashMap::::default(); let mut p = ecx.new_parser_from_tts(tts); @@ -768,7 +768,7 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, sp: Span, efmt: P, args: Vec>, - names: HashMap, + names: FxHashMap, append_newline: bool) -> P { // NOTE: this verbose way of initializing `Vec>` is because @@ -852,7 +852,7 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, curpiece: 0, arg_index_map: Vec::new(), count_args: Vec::new(), - count_positions: HashMap::new(), + count_positions: FxHashMap::default(), count_positions_count: 0, count_args_index_offset: 0, literal: String::new(), @@ -952,7 +952,7 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, // The set of foreign substitutions we've explained. This prevents spamming the user // with `%d should be written as {}` over and over again. - let mut explained = HashSet::new(); + let mut explained = FxHashSet::default(); macro_rules! check_foreign { ($kind:ident) => {{ diff --git a/src/libsyntax_pos/hygiene.rs b/src/libsyntax_pos/hygiene.rs index 99342f362360b..7e985cf52f550 100644 --- a/src/libsyntax_pos/hygiene.rs +++ b/src/libsyntax_pos/hygiene.rs @@ -21,8 +21,7 @@ use edition::Edition; use symbol::Symbol; use serialize::{Encodable, Decodable, Encoder, Decoder}; -use std::collections::HashMap; -use rustc_data_structures::fx::FxHashSet; +use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use std::fmt; /// A SyntaxContext represents a chain of macro expansions (represented by marks). @@ -190,7 +189,7 @@ impl Mark { crate struct HygieneData { marks: Vec, syntax_contexts: Vec, - markings: HashMap<(SyntaxContext, Mark, Transparency), SyntaxContext>, + markings: FxHashMap<(SyntaxContext, Mark, Transparency), SyntaxContext>, default_edition: Edition, } @@ -212,7 +211,7 @@ impl HygieneData { opaque: SyntaxContext(0), opaque_and_semitransparent: SyntaxContext(0), }], - markings: HashMap::new(), + markings: FxHashMap::default(), default_edition: Edition::Edition2015, } } @@ -231,7 +230,7 @@ pub fn set_default_edition(edition: Edition) { } pub fn clear_markings() { - HygieneData::with(|data| data.markings = HashMap::new()); + HygieneData::with(|data| data.markings = FxHashMap::default()); } impl SyntaxContext { diff --git a/src/test/ui/deref-suggestion.rs b/src/test/ui/deref-suggestion.rs index 04ba4ab905eb1..1776a71a6bb47 100644 --- a/src/test/ui/deref-suggestion.rs +++ b/src/test/ui/deref-suggestion.rs @@ -15,20 +15,26 @@ macro_rules! borrow { fn foo(_: String) {} fn foo2(s: &String) { - foo(s); //~ ERROR mismatched types + foo(s); + //~^ ERROR mismatched types } fn foo3(_: u32) {} fn foo4(u: &u32) { - foo3(u); //~ ERROR mismatched types + foo3(u); + //~^ ERROR mismatched types } fn main() { let s = String::new(); let r_s = &s; foo2(r_s); - foo(&"aaa".to_owned()); //~ ERROR mismatched types - foo(&mut "aaa".to_owned()); //~ ERROR mismatched types + foo(&"aaa".to_owned()); + //~^ ERROR mismatched types + foo(&mut "aaa".to_owned()); + //~^ ERROR mismatched types foo3(borrow!(0)); foo4(&0); + assert_eq!(3i32, &3i32); + //~^ ERROR mismatched types } diff --git a/src/test/ui/deref-suggestion.stderr b/src/test/ui/deref-suggestion.stderr index a5f87928924ca..9811c5969dad6 100644 --- a/src/test/ui/deref-suggestion.stderr +++ b/src/test/ui/deref-suggestion.stderr @@ -1,7 +1,7 @@ error[E0308]: mismatched types --> $DIR/deref-suggestion.rs:18:9 | -LL | foo(s); //~ ERROR mismatched types +LL | foo(s); | ^ | | | expected struct `std::string::String`, found reference @@ -11,9 +11,9 @@ LL | foo(s); //~ ERROR mismatched types found type `&std::string::String` error[E0308]: mismatched types - --> $DIR/deref-suggestion.rs:23:10 + --> $DIR/deref-suggestion.rs:24:10 | -LL | foo3(u); //~ ERROR mismatched types +LL | foo3(u); | ^ | | | expected u32, found &u32 @@ -23,9 +23,9 @@ LL | foo3(u); //~ ERROR mismatched types found type `&u32` error[E0308]: mismatched types - --> $DIR/deref-suggestion.rs:30:9 + --> $DIR/deref-suggestion.rs:32:9 | -LL | foo(&"aaa".to_owned()); //~ ERROR mismatched types +LL | foo(&"aaa".to_owned()); | ^^^^^^^^^^^^^^^^^ | | | expected struct `std::string::String`, found reference @@ -35,9 +35,9 @@ LL | foo(&"aaa".to_owned()); //~ ERROR mismatched types found type `&std::string::String` error[E0308]: mismatched types - --> $DIR/deref-suggestion.rs:31:9 + --> $DIR/deref-suggestion.rs:34:9 | -LL | foo(&mut "aaa".to_owned()); //~ ERROR mismatched types +LL | foo(&mut "aaa".to_owned()); | ^^^^^^^^^^^^^^^^^^^^^ | | | expected struct `std::string::String`, found mutable reference @@ -58,6 +58,16 @@ LL | foo3(borrow!(0)); = note: expected type `u32` found type `&{integer}` -error: aborting due to 5 previous errors +error[E0308]: mismatched types + --> $DIR/deref-suggestion.rs:38:5 + | +LL | assert_eq!(3i32, &3i32); + | ^^^^^^^^^^^^^^^^^^^^^^^^ expected i32, found &i32 + | + = note: expected type `i32` + found type `&i32` + = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info) + +error: aborting due to 6 previous errors For more information about this error, try `rustc --explain E0308`. diff --git a/src/test/ui/enum/enum-discrim-autosizing.rs b/src/test/ui/enum/enum-discrim-autosizing.rs index 3a243330ad9b0..dab22de1b6e58 100644 --- a/src/test/ui/enum/enum-discrim-autosizing.rs +++ b/src/test/ui/enum/enum-discrim-autosizing.rs @@ -18,3 +18,4 @@ enum Eu64 { Bu64 = 0x8000_0000_0000_0000 //~ERROR already exists } +fn main() {} diff --git a/src/test/ui/enum/enum-discrim-autosizing.stderr b/src/test/ui/enum/enum-discrim-autosizing.stderr index 3b4ac436898e6..e4419d6285127 100644 --- a/src/test/ui/enum/enum-discrim-autosizing.stderr +++ b/src/test/ui/enum/enum-discrim-autosizing.stderr @@ -1,7 +1,3 @@ -error[E0601]: `main` function not found in crate `enum_discrim_autosizing` - | - = note: consider adding a `main` function to `$DIR/enum-discrim-autosizing.rs` - error[E0081]: discriminant value `0` already exists --> $DIR/enum-discrim-autosizing.rs:18:12 | @@ -10,7 +6,6 @@ LL | Au64 = 0, LL | Bu64 = 0x8000_0000_0000_0000 //~ERROR already exists | ^^^^^^^^^^^^^^^^^^^^^ enum already has `0` -error: aborting due to 2 previous errors +error: aborting due to previous error -Some errors occurred: E0081, E0601. -For more information about an error, try `rustc --explain E0081`. +For more information about this error, try `rustc --explain E0081`. diff --git a/src/test/ui/gated-bad-feature.rs b/src/test/ui/gated-bad-feature.rs index 5baafd4153159..0d74f9011c3ec 100644 --- a/src/test/ui/gated-bad-feature.rs +++ b/src/test/ui/gated-bad-feature.rs @@ -20,3 +20,5 @@ #![feature = "foo"] //~ ERROR: malformed feature #![feature(test_removed_feature)] //~ ERROR: feature has been removed + +fn main() {} diff --git a/src/test/ui/gated-bad-feature.stderr b/src/test/ui/gated-bad-feature.stderr index 2bed241d68cab..68be49a7277d2 100644 --- a/src/test/ui/gated-bad-feature.stderr +++ b/src/test/ui/gated-bad-feature.stderr @@ -28,11 +28,7 @@ error[E0557]: feature has been removed LL | #![feature(test_removed_feature)] //~ ERROR: feature has been removed | ^^^^^^^^^^^^^^^^^^^^ -error[E0601]: `main` function not found in crate `gated_bad_feature` - | - = note: consider adding a `main` function to `$DIR/gated-bad-feature.rs` - -error: aborting due to 6 previous errors +error: aborting due to 5 previous errors -Some errors occurred: E0555, E0556, E0557, E0601. +Some errors occurred: E0555, E0556, E0557. For more information about an error, try `rustc --explain E0555`. diff --git a/src/test/ui/hygiene/generate-mod.rs b/src/test/ui/hygiene/generate-mod.rs index 2b2108558a0f3..efb3696cf8513 100644 --- a/src/test/ui/hygiene/generate-mod.rs +++ b/src/test/ui/hygiene/generate-mod.rs @@ -55,3 +55,5 @@ fn check_legacy() { struct FromOutside; genmod_legacy!(); } + +fn main() {} diff --git a/src/test/ui/hygiene/generate-mod.stderr b/src/test/ui/hygiene/generate-mod.stderr index 0c5905c5acb4f..f86444bae77e8 100644 --- a/src/test/ui/hygiene/generate-mod.stderr +++ b/src/test/ui/hygiene/generate-mod.stderr @@ -46,11 +46,6 @@ LL | type Inner = Outer; //~ ERROR cannot find type `Outer` in this scop LL | genmod_legacy!(); | ----------------- in this macro invocation -error[E0601]: `main` function not found in crate `generate_mod` - | - = note: consider adding a `main` function to `$DIR/generate-mod.rs` - -error: aborting due to 7 previous errors +error: aborting due to 6 previous errors -Some errors occurred: E0412, E0601. -For more information about an error, try `rustc --explain E0412`. +For more information about this error, try `rustc --explain E0412`. diff --git a/src/test/ui/hygiene/no_implicit_prelude.rs b/src/test/ui/hygiene/no_implicit_prelude.rs index c90c7b3093c9f..bf07bc05491cc 100644 --- a/src/test/ui/hygiene/no_implicit_prelude.rs +++ b/src/test/ui/hygiene/no_implicit_prelude.rs @@ -23,3 +23,5 @@ mod bar { } fn f() { ::foo::m!(); } } + +fn main() {} diff --git a/src/test/ui/hygiene/no_implicit_prelude.stderr b/src/test/ui/hygiene/no_implicit_prelude.stderr index b3d82e9094ba7..463fdbf00ce54 100644 --- a/src/test/ui/hygiene/no_implicit_prelude.stderr +++ b/src/test/ui/hygiene/no_implicit_prelude.stderr @@ -7,10 +7,6 @@ LL | fn f() { ::bar::m!(); } LL | Vec::new(); //~ ERROR failed to resolve | ^^^ Use of undeclared type or module `Vec` -error[E0601]: `main` function not found in crate `no_implicit_prelude` - | - = note: consider adding a `main` function to `$DIR/no_implicit_prelude.rs` - error[E0599]: no method named `clone` found for type `()` in the current scope --> $DIR/no_implicit_prelude.rs:22:12 | @@ -24,7 +20,7 @@ LL | ().clone() //~ ERROR no method named `clone` found = note: the following trait is implemented but not in scope, perhaps add a `use` for it: `use std::clone::Clone;` -error: aborting due to 3 previous errors +error: aborting due to 2 previous errors -Some errors occurred: E0433, E0599, E0601. +Some errors occurred: E0433, E0599. For more information about an error, try `rustc --explain E0433`. diff --git a/src/test/ui/imports/import-glob-circular.rs b/src/test/ui/imports/import-glob-circular.rs index d9cc17791ed56..b2e92fe0e1bf9 100644 --- a/src/test/ui/imports/import-glob-circular.rs +++ b/src/test/ui/imports/import-glob-circular.rs @@ -25,3 +25,5 @@ mod test { fn test() { f1066(); } //~ ERROR cannot find function `f1066` in this scope } + +fn main() {} diff --git a/src/test/ui/imports/import-glob-circular.stderr b/src/test/ui/imports/import-glob-circular.stderr index 078a6a3937a47..fdff04cc24148 100644 --- a/src/test/ui/imports/import-glob-circular.stderr +++ b/src/test/ui/imports/import-glob-circular.stderr @@ -4,11 +4,6 @@ error[E0425]: cannot find function `f1066` in this scope LL | fn test() { f1066(); } //~ ERROR cannot find function `f1066` in this scope | ^^^^^ not found in this scope -error[E0601]: `main` function not found in crate `import_glob_circular` - | - = note: consider adding a `main` function to `$DIR/import-glob-circular.rs` - -error: aborting due to 2 previous errors +error: aborting due to previous error -Some errors occurred: E0425, E0601. -For more information about an error, try `rustc --explain E0425`. +For more information about this error, try `rustc --explain E0425`. diff --git a/src/test/ui/imports/import-loop-2.rs b/src/test/ui/imports/import-loop-2.rs index b7bbe11a4dc96..0bc968872db5b 100644 --- a/src/test/ui/imports/import-loop-2.rs +++ b/src/test/ui/imports/import-loop-2.rs @@ -19,3 +19,5 @@ mod b { fn main() { let y = x; } } + +fn main() {} diff --git a/src/test/ui/imports/import-loop-2.stderr b/src/test/ui/imports/import-loop-2.stderr index 717f74643ebb4..09c2e7918f376 100644 --- a/src/test/ui/imports/import-loop-2.stderr +++ b/src/test/ui/imports/import-loop-2.stderr @@ -4,16 +4,6 @@ error[E0432]: unresolved import `a::x` LL | pub use a::x; | ^^^^ no `x` in `a` -error[E0601]: `main` function not found in crate `import_loop_2` - | - = note: the main function must be defined at the crate level but you have one or more functions named 'main' that are not defined at the crate level. Either move the definition or attach the `#[main]` attribute to override this behavior. -note: here is a function named 'main' - --> $DIR/import-loop-2.rs:20:5 - | -LL | fn main() { let y = x; } - | ^^^^^^^^^^^^^^^^^^^^^^^^ - -error: aborting due to 2 previous errors +error: aborting due to previous error -Some errors occurred: E0432, E0601. -For more information about an error, try `rustc --explain E0432`. +For more information about this error, try `rustc --explain E0432`. diff --git a/src/test/ui/invalid_crate_type_syntax.rs b/src/test/ui/invalid_crate_type_syntax.rs index 6d42515704ea1..904a9acf9e530 100644 --- a/src/test/ui/invalid_crate_type_syntax.rs +++ b/src/test/ui/invalid_crate_type_syntax.rs @@ -12,3 +12,5 @@ #![crate_type(lib)] //~ ERROR `crate_type` requires a value fn my_lib_fn() {} + +fn main() {} diff --git a/src/test/ui/invalid_crate_type_syntax.stderr b/src/test/ui/invalid_crate_type_syntax.stderr index b609695b86ee5..6f02f96faca93 100644 --- a/src/test/ui/invalid_crate_type_syntax.stderr +++ b/src/test/ui/invalid_crate_type_syntax.stderr @@ -6,10 +6,5 @@ LL | #![crate_type(lib)] //~ ERROR `crate_type` requires a value | = note: for example: `#![crate_type="lib"]` -error[E0601]: `main` function not found in crate `invalid_crate_type_syntax` - | - = note: consider adding a `main` function to `$DIR/invalid_crate_type_syntax.rs` - -error: aborting due to 2 previous errors +error: aborting due to previous error -For more information about this error, try `rustc --explain E0601`. diff --git a/src/test/ui/issues/issue-38715.rs b/src/test/ui/issues/issue-38715.rs index 552653c21bad6..5c745d1fab3b5 100644 --- a/src/test/ui/issues/issue-38715.rs +++ b/src/test/ui/issues/issue-38715.rs @@ -14,3 +14,5 @@ macro_rules! foo { ($i:ident) => {} } #[macro_export] macro_rules! foo { () => {} } //~ ERROR a macro named `foo` has already been exported //~| WARN this was previously accepted + +fn main() {} diff --git a/src/test/ui/issues/issue-38715.stderr b/src/test/ui/issues/issue-38715.stderr index a0dbcbd18c673..67b27cc83cc89 100644 --- a/src/test/ui/issues/issue-38715.stderr +++ b/src/test/ui/issues/issue-38715.stderr @@ -13,10 +13,5 @@ note: previous macro export is now shadowed LL | macro_rules! foo { ($i:ident) => {} } | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error[E0601]: `main` function not found in crate `issue_38715` - | - = note: consider adding a `main` function to `$DIR/issue-38715.rs` - -error: aborting due to 2 previous errors +error: aborting due to previous error -For more information about this error, try `rustc --explain E0601`. diff --git a/src/test/ui/issues/issue-42755.rs b/src/test/ui/issues/issue-42755.rs index dd53a1c71a5bc..46c8cb740ded7 100644 --- a/src/test/ui/issues/issue-42755.rs +++ b/src/test/ui/issues/issue-42755.rs @@ -15,3 +15,5 @@ macro_rules! foo { } foo!(a); + +fn main() {} diff --git a/src/test/ui/issues/issue-42755.stderr b/src/test/ui/issues/issue-42755.stderr index 9143906199616..fa736edc47f5b 100644 --- a/src/test/ui/issues/issue-42755.stderr +++ b/src/test/ui/issues/issue-42755.stderr @@ -4,10 +4,5 @@ error: repetition matches empty token tree LL | ($($p:vis)*) => {} //~ ERROR repetition matches empty token tree | ^^^^^^^^ -error[E0601]: `main` function not found in crate `issue_42755` - | - = note: consider adding a `main` function to `$DIR/issue-42755.rs` - -error: aborting due to 2 previous errors +error: aborting due to previous error -For more information about this error, try `rustc --explain E0601`. diff --git a/src/test/ui/issues/issue-43784-associated-type.rs b/src/test/ui/issues/issue-43784-associated-type.rs index 94b5c0034a76d..1ff1238ec54b8 100644 --- a/src/test/ui/issues/issue-43784-associated-type.rs +++ b/src/test/ui/issues/issue-43784-associated-type.rs @@ -23,3 +23,5 @@ impl Partial for T::Assoc where impl Complete for T { //~ ERROR the trait bound `T: std::marker::Copy` is not satisfied type Assoc = T; } + +fn main() {} diff --git a/src/test/ui/issues/issue-43784-associated-type.stderr b/src/test/ui/issues/issue-43784-associated-type.stderr index 798d8c6601668..18e97e24b733a 100644 --- a/src/test/ui/issues/issue-43784-associated-type.stderr +++ b/src/test/ui/issues/issue-43784-associated-type.stderr @@ -1,7 +1,3 @@ -error[E0601]: `main` function not found in crate `issue_43784_associated_type` - | - = note: consider adding a `main` function to `$DIR/issue-43784-associated-type.rs` - error[E0277]: the trait bound `T: std::marker::Copy` is not satisfied --> $DIR/issue-43784-associated-type.rs:23:9 | @@ -10,7 +6,6 @@ LL | impl Complete for T { //~ ERROR the trait bound `T: std::marker::Copy` i | = help: consider adding a `where T: std::marker::Copy` bound -error: aborting due to 2 previous errors +error: aborting due to previous error -Some errors occurred: E0277, E0601. -For more information about an error, try `rustc --explain E0277`. +For more information about this error, try `rustc --explain E0277`. diff --git a/src/test/ui/issues/issue-43784-supertrait.rs b/src/test/ui/issues/issue-43784-supertrait.rs index e70df113da33c..30132c3be88a7 100644 --- a/src/test/ui/issues/issue-43784-supertrait.rs +++ b/src/test/ui/issues/issue-43784-supertrait.rs @@ -16,3 +16,5 @@ pub trait Complete: Partial { impl Partial for T where T: Complete {} impl Complete for T {} //~ ERROR the trait bound `T: std::marker::Copy` is not satisfied + +fn main() {} diff --git a/src/test/ui/issues/issue-43784-supertrait.stderr b/src/test/ui/issues/issue-43784-supertrait.stderr index 8646b315abdab..422075f62aa0d 100644 --- a/src/test/ui/issues/issue-43784-supertrait.stderr +++ b/src/test/ui/issues/issue-43784-supertrait.stderr @@ -1,7 +1,3 @@ -error[E0601]: `main` function not found in crate `issue_43784_supertrait` - | - = note: consider adding a `main` function to `$DIR/issue-43784-supertrait.rs` - error[E0277]: the trait bound `T: std::marker::Copy` is not satisfied --> $DIR/issue-43784-supertrait.rs:18:9 | @@ -10,7 +6,6 @@ LL | impl Complete for T {} //~ ERROR the trait bound `T: std::marker::Copy` | = help: consider adding a `where T: std::marker::Copy` bound -error: aborting due to 2 previous errors +error: aborting due to previous error -Some errors occurred: E0277, E0601. -For more information about an error, try `rustc --explain E0277`. +For more information about this error, try `rustc --explain E0277`. diff --git a/src/test/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.nll.stderr b/src/test/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.nll.stderr index c5f3510fa0ed2..b4cbed03153a7 100644 --- a/src/test/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.nll.stderr +++ b/src/test/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.nll.stderr @@ -4,14 +4,15 @@ warning: not reporting region error due to nll LL | x.push(y); //~ ERROR explicit lifetime required | ^ -error[E0282]: type annotations needed - --> $DIR/ex2a-push-one-existing-name-early-bound.rs:20:9 +error[E0621]: explicit lifetime required in the type of `y` + --> $DIR/ex2a-push-one-existing-name-early-bound.rs:17:5 | -LL | let x = baz; - | - ^^^ cannot infer type for `T` - | | - | consider giving `x` a type +LL | fn baz<'a, 'b, T>(x: &mut Vec<&'a T>, y: &T) + | -- help: add explicit lifetime `'a` to the type of `y`: `&'a T` +... +LL | x.push(y); //~ ERROR explicit lifetime required + | ^^^^^^^^^ lifetime `'a` required error: aborting due to previous error -For more information about this error, try `rustc --explain E0282`. +For more information about this error, try `rustc --explain E0621`. diff --git a/src/test/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.rs b/src/test/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.rs index 18a720f345d7f..cad0a3c6ac13d 100644 --- a/src/test/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.rs +++ b/src/test/ui/lifetimes/lifetime-errors/ex2a-push-one-existing-name-early-bound.rs @@ -17,5 +17,4 @@ fn baz<'a, 'b, T>(x: &mut Vec<&'a T>, y: &T) x.push(y); //~ ERROR explicit lifetime required } fn main() { -let x = baz; } diff --git a/src/test/ui/macros/macro-use-bad-args-1.rs b/src/test/ui/macros/macro-use-bad-args-1.rs index a07cc83441173..fefc6ff6ca615 100644 --- a/src/test/ui/macros/macro-use-bad-args-1.rs +++ b/src/test/ui/macros/macro-use-bad-args-1.rs @@ -13,3 +13,5 @@ #[allow(unused_extern_crates)] #[macro_use(foo(bar))] //~ ERROR bad macro import extern crate std; + +fn main() {} diff --git a/src/test/ui/macros/macro-use-bad-args-1.stderr b/src/test/ui/macros/macro-use-bad-args-1.stderr index 19a8c7c0382d1..308fb6c76e1b9 100644 --- a/src/test/ui/macros/macro-use-bad-args-1.stderr +++ b/src/test/ui/macros/macro-use-bad-args-1.stderr @@ -4,11 +4,6 @@ error[E0466]: bad macro import LL | #[macro_use(foo(bar))] //~ ERROR bad macro import | ^^^^^^^^ -error[E0601]: `main` function not found in crate `macro_use_bad_args_1` - | - = note: consider adding a `main` function to `$DIR/macro-use-bad-args-1.rs` - -error: aborting due to 2 previous errors +error: aborting due to previous error -Some errors occurred: E0466, E0601. -For more information about an error, try `rustc --explain E0466`. +For more information about this error, try `rustc --explain E0466`. diff --git a/src/test/ui/macros/macro-use-bad-args-2.rs b/src/test/ui/macros/macro-use-bad-args-2.rs index 89004f1689774..81352cf2e427d 100644 --- a/src/test/ui/macros/macro-use-bad-args-2.rs +++ b/src/test/ui/macros/macro-use-bad-args-2.rs @@ -13,3 +13,5 @@ #[allow(unused_extern_crates)] #[macro_use(foo="bar")] //~ ERROR bad macro import extern crate std; + +fn main() {} diff --git a/src/test/ui/macros/macro-use-bad-args-2.stderr b/src/test/ui/macros/macro-use-bad-args-2.stderr index 0ac18201d791e..62e3c22fab3ec 100644 --- a/src/test/ui/macros/macro-use-bad-args-2.stderr +++ b/src/test/ui/macros/macro-use-bad-args-2.stderr @@ -4,11 +4,6 @@ error[E0466]: bad macro import LL | #[macro_use(foo="bar")] //~ ERROR bad macro import | ^^^^^^^^^ -error[E0601]: `main` function not found in crate `macro_use_bad_args_2` - | - = note: consider adding a `main` function to `$DIR/macro-use-bad-args-2.rs` - -error: aborting due to 2 previous errors +error: aborting due to previous error -Some errors occurred: E0466, E0601. -For more information about an error, try `rustc --explain E0466`. +For more information about this error, try `rustc --explain E0466`. diff --git a/src/test/ui/nested-ty-params.rs b/src/test/ui/nested-ty-params.rs index aac37289bb749..2378cccf56f76 100644 --- a/src/test/ui/nested-ty-params.rs +++ b/src/test/ui/nested-ty-params.rs @@ -14,3 +14,5 @@ fn hd(v: Vec ) -> U { return hd1(v); } + +fn main() {} diff --git a/src/test/ui/nested-ty-params.stderr b/src/test/ui/nested-ty-params.stderr index 93b934f610f8c..58b6cd18989f2 100644 --- a/src/test/ui/nested-ty-params.stderr +++ b/src/test/ui/nested-ty-params.stderr @@ -18,11 +18,6 @@ LL | fn hd1(w: [U]) -> U { return w[0]; } | | | help: try using a local type parameter instead: `hd1` -error[E0601]: `main` function not found in crate `nested_ty_params` - | - = note: consider adding a `main` function to `$DIR/nested-ty-params.rs` - -error: aborting due to 3 previous errors +error: aborting due to 2 previous errors -Some errors occurred: E0401, E0601. -For more information about an error, try `rustc --explain E0401`. +For more information about this error, try `rustc --explain E0401`. diff --git a/src/test/ui/panic-runtime/runtime-depend-on-needs-runtime.rs b/src/test/ui/panic-runtime/runtime-depend-on-needs-runtime.rs index 7cfdacbd983c1..db932a45b455d 100644 --- a/src/test/ui/panic-runtime/runtime-depend-on-needs-runtime.rs +++ b/src/test/ui/panic-runtime/runtime-depend-on-needs-runtime.rs @@ -13,3 +13,5 @@ // error-pattern:cannot depend on a crate that needs a panic runtime extern crate depends; + +fn main() {} diff --git a/src/test/ui/panic-runtime/runtime-depend-on-needs-runtime.stderr b/src/test/ui/panic-runtime/runtime-depend-on-needs-runtime.stderr index 0e68c9b806d1d..27e27dda5effe 100644 --- a/src/test/ui/panic-runtime/runtime-depend-on-needs-runtime.stderr +++ b/src/test/ui/panic-runtime/runtime-depend-on-needs-runtime.stderr @@ -1,9 +1,4 @@ error: the crate `depends` cannot depend on a crate that needs a panic runtime, but it depends on `needs_panic_runtime` -error[E0601]: `main` function not found in crate `runtime_depend_on_needs_runtime` - | - = note: consider adding a `main` function to `$DIR/runtime-depend-on-needs-runtime.rs` +error: aborting due to previous error -error: aborting due to 2 previous errors - -For more information about this error, try `rustc --explain E0601`. diff --git a/src/test/ui/repr/repr-transparent-other-items.rs b/src/test/ui/repr/repr-transparent-other-items.rs index 685d62dc3a9c8..be6f3cf9eb205 100644 --- a/src/test/ui/repr/repr-transparent-other-items.rs +++ b/src/test/ui/repr/repr-transparent-other-items.rs @@ -36,3 +36,5 @@ fn cant_repr_this() {} #[repr(transparent)] //~ ERROR should be applied to struct static CANT_REPR_THIS: u32 = 0; + +fn main() {} diff --git a/src/test/ui/repr/repr-transparent-other-items.stderr b/src/test/ui/repr/repr-transparent-other-items.stderr index e5889cf53e58a..5a1978991480e 100644 --- a/src/test/ui/repr/repr-transparent-other-items.stderr +++ b/src/test/ui/repr/repr-transparent-other-items.stderr @@ -1,7 +1,3 @@ -error[E0601]: `main` function not found in crate `repr_transparent_other_items` - | - = note: consider adding a `main` function to `$DIR/repr-transparent-other-items.rs` - error[E0517]: attribute should be applied to struct --> $DIR/repr-transparent-other-items.rs:13:8 | @@ -67,7 +63,7 @@ LL | #[repr(transparent)] //~ ERROR unsupported representation for zero-variant LL | enum Void {} //~| ERROR should be applied to struct | ------------ zero-variant enum -error: aborting due to 8 previous errors +error: aborting due to 7 previous errors -Some errors occurred: E0084, E0517, E0601. +Some errors occurred: E0084, E0517. For more information about an error, try `rustc --explain E0084`. diff --git a/src/test/ui/repr/repr-transparent-other-reprs.rs b/src/test/ui/repr/repr-transparent-other-reprs.rs index fa5f1a2f7fb80..aed8a69f66ef8 100644 --- a/src/test/ui/repr/repr-transparent-other-reprs.rs +++ b/src/test/ui/repr/repr-transparent-other-reprs.rs @@ -26,3 +26,5 @@ struct TransparentPlusAlign(u8); #[repr(transparent)] //~ ERROR cannot have other repr #[repr(C)] struct SeparateAttributes(*mut u8); + +fn main() {} diff --git a/src/test/ui/repr/repr-transparent-other-reprs.stderr b/src/test/ui/repr/repr-transparent-other-reprs.stderr index 40f41c474dbda..c8f5dea3c1242 100644 --- a/src/test/ui/repr/repr-transparent-other-reprs.stderr +++ b/src/test/ui/repr/repr-transparent-other-reprs.stderr @@ -1,7 +1,3 @@ -error[E0601]: `main` function not found in crate `repr_transparent_other_reprs` - | - = note: consider adding a `main` function to `$DIR/repr-transparent-other-reprs.rs` - error[E0692]: transparent struct cannot have other repr hints --> $DIR/repr-transparent-other-reprs.rs:15:8 | @@ -28,7 +24,6 @@ LL | #[repr(transparent)] //~ ERROR cannot have other repr LL | #[repr(C)] | ^ -error: aborting due to 5 previous errors +error: aborting due to 4 previous errors -Some errors occurred: E0601, E0692. -For more information about an error, try `rustc --explain E0601`. +For more information about this error, try `rustc --explain E0692`. diff --git a/src/test/ui/repr/repr-transparent.rs b/src/test/ui/repr/repr-transparent.rs index 230573247316e..f5b99af156ee0 100644 --- a/src/test/ui/repr/repr-transparent.rs +++ b/src/test/ui/repr/repr-transparent.rs @@ -48,3 +48,5 @@ struct ZstAlign32(PhantomData); #[repr(transparent)] struct GenericAlign(ZstAlign32, u32); //~ ERROR alignment larger than 1 + +fn main() {} diff --git a/src/test/ui/repr/repr-transparent.stderr b/src/test/ui/repr/repr-transparent.stderr index 0f620880fa9d3..f7bfdbdc625bb 100644 --- a/src/test/ui/repr/repr-transparent.stderr +++ b/src/test/ui/repr/repr-transparent.stderr @@ -1,7 +1,3 @@ -error[E0601]: `main` function not found in crate `repr_transparent` - | - = note: consider adding a `main` function to `$DIR/repr-transparent.rs` - error[E0690]: transparent struct needs exactly one non-zero-sized field, but has 0 --> $DIR/repr-transparent.rs:21:1 | @@ -70,7 +66,7 @@ error[E0691]: zero-sized field in transparent struct has alignment larger than 1 LL | struct GenericAlign(ZstAlign32, u32); //~ ERROR alignment larger than 1 | ^^^^^^^^^^^^^ -error: aborting due to 9 previous errors +error: aborting due to 8 previous errors -Some errors occurred: E0601, E0690, E0691. -For more information about an error, try `rustc --explain E0601`. +Some errors occurred: E0690, E0691. +For more information about an error, try `rustc --explain E0690`. diff --git a/src/test/ui/resolve/resolve-unknown-trait.rs b/src/test/ui/resolve/resolve-unknown-trait.rs index 9432e727fa5b7..05bf4b928b725 100644 --- a/src/test/ui/resolve/resolve-unknown-trait.rs +++ b/src/test/ui/resolve/resolve-unknown-trait.rs @@ -17,3 +17,5 @@ impl SomeNonExistentTrait for isize {} fn f() {} //~^ ERROR cannot find trait `SomeNonExistentTrait` in this scope + +fn main() {} diff --git a/src/test/ui/resolve/resolve-unknown-trait.stderr b/src/test/ui/resolve/resolve-unknown-trait.stderr index 8a2d791654d2f..74b190f86845f 100644 --- a/src/test/ui/resolve/resolve-unknown-trait.stderr +++ b/src/test/ui/resolve/resolve-unknown-trait.stderr @@ -16,11 +16,6 @@ error[E0405]: cannot find trait `SomeNonExistentTrait` in this scope LL | fn f() {} | ^^^^^^^^^^^^^^^^^^^^ not found in this scope -error[E0601]: `main` function not found in crate `resolve_unknown_trait` - | - = note: consider adding a `main` function to `$DIR/resolve-unknown-trait.rs` - -error: aborting due to 4 previous errors +error: aborting due to 3 previous errors -Some errors occurred: E0405, E0601. -For more information about an error, try `rustc --explain E0405`. +For more information about this error, try `rustc --explain E0405`. diff --git a/src/test/ui/resolve_self_super_hint.rs b/src/test/ui/resolve_self_super_hint.rs index a89fd802baf0c..c5dd367c0ab88 100644 --- a/src/test/ui/resolve_self_super_hint.rs +++ b/src/test/ui/resolve_self_super_hint.rs @@ -32,3 +32,5 @@ mod a { } } } + +fn main() {} diff --git a/src/test/ui/resolve_self_super_hint.stderr b/src/test/ui/resolve_self_super_hint.stderr index 8538da06baf64..40b2a4bf96842 100644 --- a/src/test/ui/resolve_self_super_hint.stderr +++ b/src/test/ui/resolve_self_super_hint.stderr @@ -22,11 +22,6 @@ error[E0432]: unresolved import `alloc` LL | use alloc::HashMap; | ^^^^^ Did you mean `a::alloc`? -error[E0601]: `main` function not found in crate `resolve_self_super_hint` - | - = note: consider adding a `main` function to `$DIR/resolve_self_super_hint.rs` - -error: aborting due to 5 previous errors +error: aborting due to 4 previous errors -Some errors occurred: E0432, E0601. -For more information about an error, try `rustc --explain E0432`. +For more information about this error, try `rustc --explain E0432`. diff --git a/src/test/ui/specialization/defaultimpl/validation.rs b/src/test/ui/specialization/defaultimpl/validation.rs index 26b8b737f340d..068eb7a448556 100644 --- a/src/test/ui/specialization/defaultimpl/validation.rs +++ b/src/test/ui/specialization/defaultimpl/validation.rs @@ -21,3 +21,5 @@ default impl !Send for Z {} //~ ERROR impls of auto traits cannot be default trait Tr {} default impl !Tr for S {} //~ ERROR negative impls are only allowed for auto traits + +fn main() {} diff --git a/src/test/ui/specialization/defaultimpl/validation.stderr b/src/test/ui/specialization/defaultimpl/validation.stderr index 54b92da7b2192..c25c428eb4e94 100644 --- a/src/test/ui/specialization/defaultimpl/validation.stderr +++ b/src/test/ui/specialization/defaultimpl/validation.stderr @@ -6,10 +6,6 @@ LL | default impl S {} //~ ERROR inherent impls cannot be default | = note: only trait implementations may be annotated with default -error[E0601]: `main` function not found in crate `validation` - | - = note: consider adding a `main` function to `$DIR/validation.rs` - error: impls of auto traits cannot be default --> $DIR/validation.rs:19:1 | @@ -28,7 +24,6 @@ error[E0192]: negative impls are only allowed for auto traits (e.g., `Send` and LL | default impl !Tr for S {} //~ ERROR negative impls are only allowed for auto traits | ^^^^^^^^^^^^^^^^^^^^^^^^^ -error: aborting due to 5 previous errors +error: aborting due to 4 previous errors -Some errors occurred: E0192, E0601. -For more information about an error, try `rustc --explain E0192`. +For more information about this error, try `rustc --explain E0192`. diff --git a/src/test/ui/tuple/tuple-struct-fields/test.rs b/src/test/ui/tuple/tuple-struct-fields/test.rs index 22d54a3834073..c8b77bfabdb95 100644 --- a/src/test/ui/tuple/tuple-struct-fields/test.rs +++ b/src/test/ui/tuple/tuple-struct-fields/test.rs @@ -15,3 +15,5 @@ mod foo { //~^ ERROR expected one of `)` or `,`, found `(` //~| ERROR cannot find type `foo` in this scope } + +fn main() {} diff --git a/src/test/ui/tuple/tuple-struct-fields/test.stderr b/src/test/ui/tuple/tuple-struct-fields/test.stderr index 59228ea8c14d2..f83e9dd5458fb 100644 --- a/src/test/ui/tuple/tuple-struct-fields/test.stderr +++ b/src/test/ui/tuple/tuple-struct-fields/test.stderr @@ -10,11 +10,6 @@ error[E0412]: cannot find type `foo` in this scope LL | struct S2(pub((foo)) ()); | ^^^ not found in this scope -error[E0601]: `main` function not found in crate `test` - | - = note: consider adding a `main` function to `$DIR/test.rs` - -error: aborting due to 3 previous errors +error: aborting due to 2 previous errors -Some errors occurred: E0412, E0601. -For more information about an error, try `rustc --explain E0412`. +For more information about this error, try `rustc --explain E0412`. diff --git a/src/test/ui/unresolved/unresolved-import.rs b/src/test/ui/unresolved/unresolved-import.rs index a3eeb6de96bda..efa7494647691 100644 --- a/src/test/ui/unresolved/unresolved-import.rs +++ b/src/test/ui/unresolved/unresolved-import.rs @@ -55,3 +55,5 @@ mod items { fn item() {} } + +fn main() {} diff --git a/src/test/ui/unresolved/unresolved-import.stderr b/src/test/ui/unresolved/unresolved-import.stderr index 1e663cde48a65..9bcebb0011a75 100644 --- a/src/test/ui/unresolved/unresolved-import.stderr +++ b/src/test/ui/unresolved/unresolved-import.stderr @@ -34,11 +34,6 @@ error[E0432]: unresolved import `Enum` LL | use Enum::*; //~ ERROR unresolved import `Enum` [E0432] | ^^^^ Did you mean `self::Enum`? -error[E0601]: `main` function not found in crate `unresolved_import` - | - = note: consider adding a `main` function to `$DIR/unresolved-import.rs` - -error: aborting due to 7 previous errors +error: aborting due to 6 previous errors -Some errors occurred: E0432, E0601. -For more information about an error, try `rustc --explain E0432`. +For more information about this error, try `rustc --explain E0432`. diff --git a/src/test/ui/user-defined-macro-rules.rs b/src/test/ui/user-defined-macro-rules.rs index 02e1a585fa89d..fe76d58f1ef76 100644 --- a/src/test/ui/user-defined-macro-rules.rs +++ b/src/test/ui/user-defined-macro-rules.rs @@ -11,3 +11,5 @@ #![allow(unused_macros)] macro_rules! macro_rules { () => {} } //~ ERROR user-defined macros may not be named `macro_rules` + +fn main() {} diff --git a/src/test/ui/user-defined-macro-rules.stderr b/src/test/ui/user-defined-macro-rules.stderr index 3359aa4bcd720..1f8b18166c9c9 100644 --- a/src/test/ui/user-defined-macro-rules.stderr +++ b/src/test/ui/user-defined-macro-rules.stderr @@ -4,10 +4,5 @@ error: user-defined macros may not be named `macro_rules` LL | macro_rules! macro_rules { () => {} } //~ ERROR user-defined macros may not be named `macro_rules` | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -error[E0601]: `main` function not found in crate `user_defined_macro_rules` - | - = note: consider adding a `main` function to `$DIR/user-defined-macro-rules.rs` - -error: aborting due to 2 previous errors +error: aborting due to previous error -For more information about this error, try `rustc --explain E0601`. diff --git a/src/test/ui/wasm-custom-section-relocations.rs b/src/test/ui/wasm-custom-section-relocations.rs index 5631a70192afd..9f431e7806139 100644 --- a/src/test/ui/wasm-custom-section-relocations.rs +++ b/src/test/ui/wasm-custom-section-relocations.rs @@ -21,3 +21,5 @@ pub static C: usize = 3; #[link_section = "test"] pub static D: &usize = &C; //~ ERROR: no extra levels of indirection + +fn main() {} diff --git a/src/test/ui/wasm-custom-section-relocations.stderr b/src/test/ui/wasm-custom-section-relocations.stderr index 9b96b99e02ae4..cea6e5c41923a 100644 --- a/src/test/ui/wasm-custom-section-relocations.stderr +++ b/src/test/ui/wasm-custom-section-relocations.stderr @@ -1,7 +1,3 @@ -error[E0601]: `main` function not found in crate `wasm_custom_section_relocations` - | - = note: consider adding a `main` function to `$DIR/wasm-custom-section-relocations.rs` - error: statics with a custom `#[link_section]` must be a simple list of bytes on the wasm target with no extra levels of indirection such as references --> $DIR/wasm-custom-section-relocations.rs:14:1 | @@ -14,6 +10,5 @@ error: statics with a custom `#[link_section]` must be a simple list of bytes on LL | pub static D: &usize = &C; //~ ERROR: no extra levels of indirection | ^^^^^^^^^^^^^^^^^^^^^^^^^^ -error: aborting due to 3 previous errors +error: aborting due to 2 previous errors -For more information about this error, try `rustc --explain E0601`. diff --git a/src/tools/clippy b/src/tools/clippy index 628934424e9c1..d99cea0f16633 160000 --- a/src/tools/clippy +++ b/src/tools/clippy @@ -1 +1 @@ -Subproject commit 628934424e9c181a4162b3a5d01e4211ee98b7b7 +Subproject commit d99cea0f16633556871a59500c610782b07233b9