#![feature(crate_visibility_modifier)]
#![cfg_attr(not(stage0), feature(nll))]
+#![cfg_attr(not(stage0), feature(infer_outlives_requirements))]
#![feature(rustc_diagnostic_macros)]
#![feature(slice_sort_by_cached_key)]
use self::RibKind::*;
use rustc::hir::map::{Definitions, DefCollector};
-use rustc::hir::{self, PrimTy, TyBool, TyChar, TyFloat, TyInt, TyUint, TyStr};
+use rustc::hir::{self, PrimTy, Bool, Char, Float, Int, Uint, Str};
use rustc::middle::cstore::CrateStore;
use rustc::session::Session;
use rustc::lint;
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;
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 {
Def::Trait(..) | Def::TyAlias(..) | Def::AssociatedTy(..) |
Def::PrimTy(..) | Def::TyParam(..) | Def::SelfTy(..) |
Def::Existential(..) |
- Def::TyForeign(..) => true,
+ Def::ForeignTy(..) => true,
_ => false,
},
PathSource::Trait(AliasPossibility::No) => match def {
fn new() -> PrimitiveTypeTable {
let mut table = PrimitiveTypeTable { primitive_types: FxHashMap() };
- table.intern("bool", TyBool);
- table.intern("char", TyChar);
- table.intern("f32", TyFloat(FloatTy::F32));
- table.intern("f64", TyFloat(FloatTy::F64));
- table.intern("isize", TyInt(IntTy::Isize));
- table.intern("i8", TyInt(IntTy::I8));
- table.intern("i16", TyInt(IntTy::I16));
- table.intern("i32", TyInt(IntTy::I32));
- table.intern("i64", TyInt(IntTy::I64));
- table.intern("i128", TyInt(IntTy::I128));
- table.intern("str", TyStr);
- table.intern("usize", TyUint(UintTy::Usize));
- table.intern("u8", TyUint(UintTy::U8));
- table.intern("u16", TyUint(UintTy::U16));
- table.intern("u32", TyUint(UintTy::U32));
- table.intern("u64", TyUint(UintTy::U64));
- table.intern("u128", TyUint(UintTy::U128));
+ table.intern("bool", Bool);
+ table.intern("char", Char);
+ table.intern("f32", Float(FloatTy::F32));
+ table.intern("f64", Float(FloatTy::F64));
+ table.intern("isize", Int(IntTy::Isize));
+ table.intern("i8", Int(IntTy::I8));
+ table.intern("i16", Int(IntTy::I16));
+ table.intern("i32", Int(IntTy::I32));
+ table.intern("i64", Int(IntTy::I64));
+ table.intern("i128", Int(IntTy::I128));
+ table.intern("str", Str);
+ table.intern("usize", Uint(UintTy::Usize));
+ table.intern("u8", Uint(UintTy::U8));
+ table.intern("u16", Uint(UintTy::U16));
+ table.intern("u32", Uint(UintTy::U32));
+ table.intern("u64", Uint(UintTy::U64));
+ table.intern("u128", Uint(UintTy::U128));
table
}
"access to extern crates through prelude is experimental").emit();
}
- let crate_id = self.crate_loader.process_path_extern(ident.name, ident.span);
- let crate_root = self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX });
- self.populate_module_if_necessary(crate_root);
+ let crate_root = self.load_extern_prelude_crate_if_needed(ident);
let binding = (crate_root, ty::Visibility::Public,
ident.span, Mark::root()).to_name_binding(self.arenas);
None
}
+ fn load_extern_prelude_crate_if_needed(&mut self, ident: Ident) -> Module<'a> {
+ let crate_id = self.crate_loader.process_path_extern(ident.name, ident.span);
+ let crate_root = self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX });
+ self.populate_module_if_necessary(&crate_root);
+ crate_root
+ }
+
fn hygienic_lexical_parent(&mut self, module: Module<'a>, span: &mut Span)
-> Option<Module<'a>> {
if !module.expansion.is_descendant_of(span.ctxt().outer()) {
// This has to happen *after* we determine which pat_idents are variants
self.check_consistent_bindings(&arm.pats);
- walk_list!(self, visit_expr, &arm.guard);
+ match arm.guard {
+ Some(ast::Guard::If(ref expr)) => self.visit_expr(expr),
+ _ => {}
+ }
self.visit_expr(&arm.body);
self.ribs[ValueNS].pop();
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,
+ );
}
}
}
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);
}
}
// Add primitive types to the mix
- if filter_fn(Def::PrimTy(TyBool)) {
+ if filter_fn(Def::PrimTy(Bool)) {
names.extend(
self.primitive_type_table.primitive_types.iter().map(|(name, _)| name)
)
}
}
- /// When name resolution fails, this method can be used to look up candidate
- /// entities with the expected name. It allows filtering them using the
- /// supplied predicate (which should be used to only accept the types of
- /// definitions expected e.g. traits). The lookup spans across all crates.
- ///
- /// NOTE: The method does not look into imports, but this is not a problem,
- /// since we report the definitions (thus, the de-aliased imports).
- fn lookup_import_candidates<FilterFn>(&mut self,
+ fn lookup_import_candidates_from_module<FilterFn>(&mut self,
lookup_name: Name,
namespace: Namespace,
+ start_module: &'a ModuleData<'a>,
+ crate_name: Ident,
filter_fn: FilterFn)
-> Vec<ImportSuggestion>
where FilterFn: Fn(Def) -> bool
let mut candidates = Vec::new();
let mut worklist = Vec::new();
let mut seen_modules = FxHashSet();
- worklist.push((self.graph_root, Vec::new(), false));
+ let not_local_module = crate_name != keywords::Crate.ident();
+ worklist.push((start_module, Vec::<ast::PathSegment>::new(), not_local_module));
while let Some((in_module,
path_segments,
if ident.name == lookup_name && ns == namespace {
if filter_fn(name_binding.def()) {
// create the path
- let mut segms = if self.session.rust_2018() && !in_module_is_extern {
+ let mut segms = path_segments.clone();
+ if self.session.rust_2018() {
// crate-local absolute paths start with `crate::` in edition 2018
// FIXME: may also be stabilized for Rust 2015 (Issues #45477, #44660)
- let mut full_segms = vec![
- ast::PathSegment::from_ident(keywords::Crate.ident())
- ];
- full_segms.extend(path_segments.clone());
- full_segms
- } else {
- path_segments.clone()
- };
+ segms.insert(
+ 0, ast::PathSegment::from_ident(crate_name)
+ );
+ }
segms.push(ast::PathSegment::from_ident(ident));
let path = Path {
let mut path_segments = path_segments.clone();
path_segments.push(ast::PathSegment::from_ident(ident));
- if !in_module_is_extern || name_binding.vis == ty::Visibility::Public {
+ let is_extern_crate_that_also_appears_in_prelude =
+ name_binding.is_extern_crate() &&
+ self.session.rust_2018();
+
+ let is_visible_to_user =
+ !in_module_is_extern || name_binding.vis == ty::Visibility::Public;
+
+ if !is_extern_crate_that_also_appears_in_prelude && is_visible_to_user {
// add the module to the lookup
let is_extern = in_module_is_extern || name_binding.is_extern_crate();
if seen_modules.insert(module.def_id().unwrap()) {
candidates
}
+ /// When name resolution fails, this method can be used to look up candidate
+ /// entities with the expected name. It allows filtering them using the
+ /// supplied predicate (which should be used to only accept the types of
+ /// definitions expected e.g. traits). The lookup spans across all crates.
+ ///
+ /// NOTE: The method does not look into imports, but this is not a problem,
+ /// since we report the definitions (thus, the de-aliased imports).
+ fn lookup_import_candidates<FilterFn>(&mut self,
+ lookup_name: Name,
+ namespace: Namespace,
+ filter_fn: FilterFn)
+ -> Vec<ImportSuggestion>
+ where FilterFn: Fn(Def) -> bool
+ {
+ let mut suggestions = vec![];
+
+ suggestions.extend(
+ self.lookup_import_candidates_from_module(
+ lookup_name, namespace, self.graph_root, keywords::Crate.ident(), &filter_fn
+ )
+ );
+
+ if self.session.features_untracked().extern_prelude {
+ let extern_prelude_names = self.extern_prelude.clone();
+ for &krate_name in extern_prelude_names.iter() {
+ let krate_ident = Ident::with_empty_ctxt(krate_name);
+ let external_prelude_module = self.load_extern_prelude_crate_if_needed(krate_ident);
+
+ suggestions.extend(
+ self.lookup_import_candidates_from_module(
+ lookup_name, namespace, external_prelude_module, krate_ident, &filter_fn
+ )
+ );
+ }
+ }
+
+ suggestions
+ }
+
fn find_module(&mut self,
module_def: Def)
-> Option<(Module<'a>, ImportSuggestion)>
for &(span_use, span_def) in &self.macro_expanded_macro_export_errors {
let msg = "macro-expanded `macro_export` macros from the current crate \
cannot be referred to by absolute paths";
- self.session.struct_span_err(span_use, msg)
- .span_note(span_def, "the macro is defined here")
- .emit();
+ self.session.buffer_lint_with_diagnostic(
+ lint::builtin::MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
+ CRATE_NODE_ID, span_use, msg,
+ lint::builtin::BuiltinLintDiagnostics::
+ MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def),
+ );
}
for &AmbiguityError { span, name, b1, b2, lexical } in &self.ambiguity_errors {
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);
}
projects / rust.git / blobdiff