From d6ca34c9d26d03ed098ee472530d16994f8bfa29 Mon Sep 17 00:00:00 2001 From: Oliver Scherer Date: Tue, 14 May 2019 15:58:22 +0200 Subject: [PATCH] Use `Symbol` more in lint APIs --- src/librustc/lint/context.rs | 34 +++++++++++++++++----------------- src/librustc/lint/internal.rs | 26 ++++++++++++++++---------- src/libsyntax_pos/symbol.rs | 10 ++++++++++ 3 files changed, 43 insertions(+), 27 deletions(-) diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index b9ce42ac8f290..c6583dd7a27b7 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -759,27 +759,27 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> { /// # Examples /// /// ```rust,ignore (no context or def id available) - /// if cx.match_def_path(def_id, &["core", "option", "Option"]) { + /// if cx.match_def_path(def_id, &[sym::core, sym::option, sym::Option]) { /// // The given `def_id` is that of an `Option` type /// } /// ``` - pub fn match_def_path(&self, def_id: DefId, path: &[&str]) -> bool { + pub fn match_def_path(&self, def_id: DefId, path: &[Symbol]) -> bool { let names = self.get_def_path(def_id); - names.len() == path.len() && names.into_iter().zip(path.iter()).all(|(a, &b)| *a == *b) + names.len() == path.len() && names.into_iter().zip(path.iter()).all(|(a, &b)| a == b) } - /// Gets the absolute path of `def_id` as a vector of `&str`. + /// Gets the absolute path of `def_id` as a vector of `Symbol`. /// /// # Examples /// /// ```rust,ignore (no context or def id available) /// let def_path = cx.get_def_path(def_id); - /// if let &["core", "option", "Option"] = &def_path[..] { + /// if let &[sym::core, sym::option, sym::Option] = &def_path[..] { /// // The given `def_id` is that of an `Option` type /// } /// ``` - pub fn get_def_path(&self, def_id: DefId) -> Vec { + pub fn get_def_path(&self, def_id: DefId) -> Vec { pub struct AbsolutePathPrinter<'a, 'tcx> { pub tcx: TyCtxt<'a, 'tcx, 'tcx>, } @@ -787,7 +787,7 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> { impl<'tcx> Printer<'tcx, 'tcx> for AbsolutePathPrinter<'_, 'tcx> { type Error = !; - type Path = Vec; + type Path = Vec; type Region = (); type Type = (); type DynExistential = (); @@ -820,14 +820,14 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> { } fn path_crate(self, cnum: CrateNum) -> Result { - Ok(vec![self.tcx.original_crate_name(cnum).as_str()]) + Ok(vec![self.tcx.original_crate_name(cnum)]) } fn path_qualified( self, self_ty: Ty<'tcx>, trait_ref: Option>, - ) -> Result { + ) -> Result { if trait_ref.is_none() { if let ty::Adt(def, substs) = self_ty.sty { return self.print_def_path(def.did, substs); @@ -836,8 +836,8 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> { // This shouldn't ever be needed, but just in case: Ok(vec![match trait_ref { - Some(trait_ref) => LocalInternedString::intern(&format!("{:?}", trait_ref)), - None => LocalInternedString::intern(&format!("<{}>", self_ty)), + Some(trait_ref) => Symbol::intern(&format!("{:?}", trait_ref)), + None => Symbol::intern(&format!("<{}>", self_ty)), }]) } @@ -847,16 +847,16 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> { _disambiguated_data: &DisambiguatedDefPathData, self_ty: Ty<'tcx>, trait_ref: Option>, - ) -> Result { + ) -> Result { let mut path = print_prefix(self)?; // This shouldn't ever be needed, but just in case: path.push(match trait_ref { Some(trait_ref) => { - LocalInternedString::intern(&format!("", trait_ref, + Symbol::intern(&format!("", trait_ref, self_ty)) }, - None => LocalInternedString::intern(&format!("", self_ty)), + None => Symbol::intern(&format!("", self_ty)), }); Ok(path) @@ -866,7 +866,7 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> { self, print_prefix: impl FnOnce(Self) -> Result, disambiguated_data: &DisambiguatedDefPathData, - ) -> Result { + ) -> Result { let mut path = print_prefix(self)?; // Skip `::{{constructor}}` on tuple/unit structs. @@ -875,7 +875,7 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> { _ => {} } - path.push(disambiguated_data.data.as_interned_str().as_str()); + path.push(disambiguated_data.data.as_interned_str().as_symbol()); Ok(path) } @@ -883,7 +883,7 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> { self, print_prefix: impl FnOnce(Self) -> Result, _args: &[Kind<'tcx>], - ) -> Result { + ) -> Result { print_prefix(self) } } diff --git a/src/librustc/lint/internal.rs b/src/librustc/lint/internal.rs index c780262097607..e953c08459963 100644 --- a/src/librustc/lint/internal.rs +++ b/src/librustc/lint/internal.rs @@ -8,6 +8,7 @@ use crate::lint::{ use errors::Applicability; use rustc_data_structures::fx::FxHashMap; use syntax::ast::Ident; +use syntax::symbol::{sym, Symbol}; declare_lint! { pub DEFAULT_HASH_TYPES, @@ -16,14 +17,16 @@ declare_lint! { } pub struct DefaultHashTypes { - map: FxHashMap, + map: FxHashMap, } impl DefaultHashTypes { + // we are allowed to use `HashMap` and `HashSet` as identifiers for implementing the lint itself + #[allow(internal)] pub fn new() -> Self { let mut map = FxHashMap::default(); - map.insert("HashMap".to_string(), "FxHashMap".to_string()); - map.insert("HashSet".to_string(), "FxHashSet".to_string()); + map.insert(sym::HashMap, sym::FxHashMap); + map.insert(sym::HashSet, sym::FxHashSet); Self { map } } } @@ -32,11 +35,10 @@ impl_lint_pass!(DefaultHashTypes => [DEFAULT_HASH_TYPES]); impl EarlyLintPass for DefaultHashTypes { fn check_ident(&mut self, cx: &EarlyContext<'_>, ident: Ident) { - let ident_string = ident.to_string(); - if let Some(replace) = self.map.get(&ident_string) { + if let Some(replace) = self.map.get(&ident.name) { let msg = format!( "Prefer {} over {}, it has better performance", - replace, ident_string + replace, ident ); let mut db = cx.struct_span_lint(DEFAULT_HASH_TYPES, ident.span, &msg); db.span_suggestion( @@ -169,10 +171,10 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for TyTyKind { } fn lint_ty_kind_usage(cx: &LateContext<'_, '_>, segment: &PathSegment) -> bool { - if segment.ident.as_str() == "TyKind" { + if segment.ident.name == sym::TyKind { if let Some(res) = segment.res { if let Some(did) = res.opt_def_id() { - return cx.match_def_path(did, &["rustc", "ty", "sty", "TyKind"]); + return cx.match_def_path(did, TYKIND_PATH); } } } @@ -180,14 +182,18 @@ fn lint_ty_kind_usage(cx: &LateContext<'_, '_>, segment: &PathSegment) -> bool { false } +const TYKIND_PATH: &[Symbol] = &[sym::rustc, sym::ty, sym::sty, sym::TyKind]; +const TY_PATH: &[Symbol] = &[sym::rustc, sym::ty, sym::Ty]; +const TYCTXT_PATH: &[Symbol] = &[sym::rustc, sym::ty, sym::context, sym::TyCtxt]; + fn is_ty_or_ty_ctxt(cx: &LateContext<'_, '_>, ty: &Ty) -> Option { match &ty.node { TyKind::Path(qpath) => { if let QPath::Resolved(_, path) = qpath { let did = path.res.opt_def_id()?; - if cx.match_def_path(did, &["rustc", "ty", "Ty"]) { + if cx.match_def_path(did, TY_PATH) { return Some(format!("Ty{}", gen_args(path.segments.last().unwrap()))); - } else if cx.match_def_path(did, &["rustc", "ty", "context", "TyCtxt"]) { + } else if cx.match_def_path(did, TYCTXT_PATH) { return Some(format!("TyCtxt{}", gen_args(path.segments.last().unwrap()))); } } diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs index 60f87783b3e11..8847e94127be6 100644 --- a/src/libsyntax_pos/symbol.rs +++ b/src/libsyntax_pos/symbol.rs @@ -194,6 +194,7 @@ symbols! { const_raw_ptr_to_usize_cast, const_transmute, contents, + context, convert, copy_closures, core, @@ -282,6 +283,8 @@ symbols! { fundamental, future, Future, + FxHashSet, + FxHashMap, gen_future, generators, generic_associated_types, @@ -291,6 +294,8 @@ symbols! { globs, hash, Hash, + HashSet, + HashMap, hexagon_target_feature, hidden, homogeneous_aggregate, @@ -505,6 +510,7 @@ symbols! { rust_2015_preview, rust_2018_preview, rust_begin_unwind, + rustc, rustc_allocator_nounwind, rustc_allow_const_fn_ptr, rustc_args_required_const, @@ -590,6 +596,7 @@ symbols! { struct_inherit, structural_match, struct_variant, + sty, suggestion, target_feature, target_has_atomic, @@ -618,7 +625,10 @@ symbols! { try_trait, tt, tuple_indexing, + Ty, ty, + TyCtxt, + TyKind, type_alias_enum_variants, type_ascription, type_length_limit,