Rollup merge of #81680 - camsteffen:primty, r=oli-obk
Refactor `PrimitiveTypeTable` for Clippy I removed `PrimitiveTypeTable` and added `PrimTy::ALL` and `PrimTy::from_name` in its place. This allows Clippy to use `PrimTy::from_name` for the `builtin_type_shadow` lint, and a `const` list of primitive types is deleted from Clippy code (the goal). All changes should be a little faster, if anything.
This commit is contained in:
commit
85fb5cdf26
|
@ -2058,6 +2058,28 @@ pub enum PrimTy {
|
|||
}
|
||||
|
||||
impl PrimTy {
|
||||
/// All of the primitive types
|
||||
pub const ALL: [Self; 17] = [
|
||||
// any changes here should also be reflected in `PrimTy::from_name`
|
||||
Self::Int(IntTy::I8),
|
||||
Self::Int(IntTy::I16),
|
||||
Self::Int(IntTy::I32),
|
||||
Self::Int(IntTy::I64),
|
||||
Self::Int(IntTy::I128),
|
||||
Self::Int(IntTy::Isize),
|
||||
Self::Uint(UintTy::U8),
|
||||
Self::Uint(UintTy::U16),
|
||||
Self::Uint(UintTy::U32),
|
||||
Self::Uint(UintTy::U64),
|
||||
Self::Uint(UintTy::U128),
|
||||
Self::Uint(UintTy::Usize),
|
||||
Self::Float(FloatTy::F32),
|
||||
Self::Float(FloatTy::F64),
|
||||
Self::Bool,
|
||||
Self::Char,
|
||||
Self::Str,
|
||||
];
|
||||
|
||||
pub fn name_str(self) -> &'static str {
|
||||
match self {
|
||||
PrimTy::Int(i) => i.name_str(),
|
||||
|
@ -2079,6 +2101,33 @@ impl PrimTy {
|
|||
PrimTy::Char => sym::char,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the matching `PrimTy` for a `Symbol` such as "str" or "i32".
|
||||
/// Returns `None` if no matching type is found.
|
||||
pub fn from_name(name: Symbol) -> Option<Self> {
|
||||
let ty = match name {
|
||||
// any changes here should also be reflected in `PrimTy::ALL`
|
||||
sym::i8 => Self::Int(IntTy::I8),
|
||||
sym::i16 => Self::Int(IntTy::I16),
|
||||
sym::i32 => Self::Int(IntTy::I32),
|
||||
sym::i64 => Self::Int(IntTy::I64),
|
||||
sym::i128 => Self::Int(IntTy::I128),
|
||||
sym::isize => Self::Int(IntTy::Isize),
|
||||
sym::u8 => Self::Uint(UintTy::U8),
|
||||
sym::u16 => Self::Uint(UintTy::U16),
|
||||
sym::u32 => Self::Uint(UintTy::U32),
|
||||
sym::u64 => Self::Uint(UintTy::U64),
|
||||
sym::u128 => Self::Uint(UintTy::U128),
|
||||
sym::usize => Self::Uint(UintTy::Usize),
|
||||
sym::f32 => Self::Float(FloatTy::F32),
|
||||
sym::f64 => Self::Float(FloatTy::F64),
|
||||
sym::bool => Self::Bool,
|
||||
sym::char => Self::Char,
|
||||
sym::str => Self::Str,
|
||||
_ => return None,
|
||||
};
|
||||
Some(ty)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, HashStable_Generic)]
|
||||
|
|
|
@ -9,6 +9,7 @@ use rustc_feature::BUILTIN_ATTRIBUTES;
|
|||
use rustc_hir::def::Namespace::{self, *};
|
||||
use rustc_hir::def::{self, CtorKind, CtorOf, DefKind, NonMacroAttrKind};
|
||||
use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
|
||||
use rustc_hir::PrimTy;
|
||||
use rustc_middle::bug;
|
||||
use rustc_middle::ty::{self, DefIdTree};
|
||||
use rustc_session::Session;
|
||||
|
@ -718,10 +719,9 @@ impl<'a> Resolver<'a> {
|
|||
}
|
||||
}
|
||||
Scope::BuiltinTypes => {
|
||||
let primitive_types = &this.primitive_type_table.primitive_types;
|
||||
suggestions.extend(primitive_types.iter().flat_map(|(name, prim_ty)| {
|
||||
suggestions.extend(PrimTy::ALL.iter().filter_map(|prim_ty| {
|
||||
let res = Res::PrimTy(*prim_ty);
|
||||
filter_fn(res).then_some(TypoSuggestion::from_res(*name, res))
|
||||
filter_fn(res).then_some(TypoSuggestion::from_res(prim_ty.name(), res))
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
|
|
@ -20,7 +20,7 @@ use rustc_errors::DiagnosticId;
|
|||
use rustc_hir::def::Namespace::{self, *};
|
||||
use rustc_hir::def::{self, CtorKind, DefKind, PartialRes, PerNS};
|
||||
use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX};
|
||||
use rustc_hir::TraitCandidate;
|
||||
use rustc_hir::{PrimTy, TraitCandidate};
|
||||
use rustc_middle::{bug, span_bug};
|
||||
use rustc_session::lint;
|
||||
use rustc_span::symbol::{kw, sym, Ident, Symbol};
|
||||
|
@ -1927,7 +1927,7 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
|
|||
self.r.trait_map.insert(id, traits);
|
||||
}
|
||||
|
||||
if self.r.primitive_type_table.primitive_types.contains_key(&path[0].ident.name) {
|
||||
if PrimTy::from_name(path[0].ident.name).is_some() {
|
||||
let mut std_path = Vec::with_capacity(1 + path.len());
|
||||
|
||||
std_path.push(Segment::from_ident(Ident::with_dummy_span(sym::std)));
|
||||
|
@ -2121,13 +2121,9 @@ impl<'a: 'ast, 'b, 'ast> LateResolutionVisitor<'a, 'b, 'ast> {
|
|||
// The same fallback is used when `a` resolves to nothing.
|
||||
PathResult::Module(ModuleOrUniformRoot::Module(_)) | PathResult::Failed { .. }
|
||||
if (ns == TypeNS || path.len() > 1)
|
||||
&& self
|
||||
.r
|
||||
.primitive_type_table
|
||||
.primitive_types
|
||||
.contains_key(&path[0].ident.name) =>
|
||||
&& PrimTy::from_name(path[0].ident.name).is_some() =>
|
||||
{
|
||||
let prim = self.r.primitive_type_table.primitive_types[&path[0].ident.name];
|
||||
let prim = PrimTy::from_name(path[0].ident.name).unwrap();
|
||||
PartialRes::with_unresolved_segments(Res::PrimTy(prim), path.len() - 1)
|
||||
}
|
||||
PathResult::Module(ModuleOrUniformRoot::Module(module)) => {
|
||||
|
|
|
@ -1212,8 +1212,8 @@ impl<'a: 'ast, 'ast> LateResolutionVisitor<'a, '_, 'ast> {
|
|||
// Add primitive types to the mix
|
||||
if filter_fn(Res::PrimTy(PrimTy::Bool)) {
|
||||
names.extend(
|
||||
self.r.primitive_type_table.primitive_types.iter().map(|(name, prim_ty)| {
|
||||
TypoSuggestion::from_res(*name, Res::PrimTy(*prim_ty))
|
||||
PrimTy::ALL.iter().map(|prim_ty| {
|
||||
TypoSuggestion::from_res(prim_ty.name(), Res::PrimTy(*prim_ty))
|
||||
}),
|
||||
)
|
||||
}
|
||||
|
|
|
@ -25,7 +25,7 @@ use rustc_arena::{DroplessArena, TypedArena};
|
|||
use rustc_ast::node_id::NodeMap;
|
||||
use rustc_ast::unwrap_or;
|
||||
use rustc_ast::visit::{self, Visitor};
|
||||
use rustc_ast::{self as ast, FloatTy, IntTy, NodeId, UintTy};
|
||||
use rustc_ast::{self as ast, NodeId};
|
||||
use rustc_ast::{Crate, CRATE_NODE_ID};
|
||||
use rustc_ast::{ItemKind, Path};
|
||||
use rustc_ast_lowering::ResolverAstLowering;
|
||||
|
@ -39,8 +39,7 @@ use rustc_hir::def::Namespace::*;
|
|||
use rustc_hir::def::{self, CtorOf, DefKind, NonMacroAttrKind, PartialRes};
|
||||
use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX};
|
||||
use rustc_hir::definitions::{DefKey, DefPathData, Definitions};
|
||||
use rustc_hir::PrimTy::{self, Bool, Char, Float, Int, Str, Uint};
|
||||
use rustc_hir::TraitCandidate;
|
||||
use rustc_hir::{PrimTy, TraitCandidate};
|
||||
use rustc_index::vec::IndexVec;
|
||||
use rustc_metadata::creader::{CStore, CrateLoader};
|
||||
use rustc_middle::hir::exports::ExportMap;
|
||||
|
@ -834,39 +833,6 @@ impl<'a> NameBinding<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
/// Interns the names of the primitive types.
|
||||
///
|
||||
/// All other types are defined somewhere and possibly imported, but the primitive ones need
|
||||
/// special handling, since they have no place of origin.
|
||||
struct PrimitiveTypeTable {
|
||||
primitive_types: FxHashMap<Symbol, PrimTy>,
|
||||
}
|
||||
|
||||
impl PrimitiveTypeTable {
|
||||
fn new() -> PrimitiveTypeTable {
|
||||
let mut table = FxHashMap::default();
|
||||
|
||||
table.insert(sym::bool, Bool);
|
||||
table.insert(sym::char, Char);
|
||||
table.insert(sym::f32, Float(FloatTy::F32));
|
||||
table.insert(sym::f64, Float(FloatTy::F64));
|
||||
table.insert(sym::isize, Int(IntTy::Isize));
|
||||
table.insert(sym::i8, Int(IntTy::I8));
|
||||
table.insert(sym::i16, Int(IntTy::I16));
|
||||
table.insert(sym::i32, Int(IntTy::I32));
|
||||
table.insert(sym::i64, Int(IntTy::I64));
|
||||
table.insert(sym::i128, Int(IntTy::I128));
|
||||
table.insert(sym::str, Str);
|
||||
table.insert(sym::usize, Uint(UintTy::Usize));
|
||||
table.insert(sym::u8, Uint(UintTy::U8));
|
||||
table.insert(sym::u16, Uint(UintTy::U16));
|
||||
table.insert(sym::u32, Uint(UintTy::U32));
|
||||
table.insert(sym::u64, Uint(UintTy::U64));
|
||||
table.insert(sym::u128, Uint(UintTy::U128));
|
||||
Self { primitive_types: table }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Default, Clone)]
|
||||
pub struct ExternPreludeEntry<'a> {
|
||||
extern_crate_item: Option<&'a NameBinding<'a>>,
|
||||
|
@ -912,9 +878,6 @@ pub struct Resolver<'a> {
|
|||
/// "self-confirming" import resolutions during import validation.
|
||||
unusable_binding: Option<&'a NameBinding<'a>>,
|
||||
|
||||
/// The idents for the primitive types.
|
||||
primitive_type_table: PrimitiveTypeTable,
|
||||
|
||||
/// Resolutions for nodes that have a single resolution.
|
||||
partial_res_map: NodeMap<PartialRes>,
|
||||
/// Resolutions for import nodes, which have multiple resolutions in different namespaces.
|
||||
|
@ -1284,8 +1247,6 @@ impl<'a> Resolver<'a> {
|
|||
last_import_segment: false,
|
||||
unusable_binding: None,
|
||||
|
||||
primitive_type_table: PrimitiveTypeTable::new(),
|
||||
|
||||
partial_res_map: Default::default(),
|
||||
import_res_map: Default::default(),
|
||||
label_res_map: Default::default(),
|
||||
|
@ -1994,9 +1955,9 @@ impl<'a> Resolver<'a> {
|
|||
}
|
||||
|
||||
if ns == TypeNS {
|
||||
if let Some(prim_ty) = self.primitive_type_table.primitive_types.get(&ident.name) {
|
||||
if let Some(prim_ty) = PrimTy::from_name(ident.name) {
|
||||
let binding =
|
||||
(Res::PrimTy(*prim_ty), ty::Visibility::Public, DUMMY_SP, ExpnId::root())
|
||||
(Res::PrimTy(prim_ty), ty::Visibility::Public, DUMMY_SP, ExpnId::root())
|
||||
.to_name_binding(self.arenas);
|
||||
return Some(LexicalScopeBinding::Item(binding));
|
||||
}
|
||||
|
|
|
@ -21,6 +21,7 @@ use rustc_expand::expand::{AstFragment, Invocation, InvocationKind};
|
|||
use rustc_feature::is_builtin_attr_name;
|
||||
use rustc_hir::def::{self, DefKind, NonMacroAttrKind};
|
||||
use rustc_hir::def_id;
|
||||
use rustc_hir::PrimTy;
|
||||
use rustc_middle::middle::stability;
|
||||
use rustc_middle::ty;
|
||||
use rustc_session::lint::builtin::{SOFT_UNSTABLE, UNUSED_MACROS};
|
||||
|
@ -796,12 +797,10 @@ impl<'a> Resolver<'a> {
|
|||
}
|
||||
result
|
||||
}
|
||||
Scope::BuiltinTypes => {
|
||||
match this.primitive_type_table.primitive_types.get(&ident.name).cloned() {
|
||||
Some(prim_ty) => ok(Res::PrimTy(prim_ty), DUMMY_SP, this.arenas),
|
||||
None => Err(Determinacy::Determined),
|
||||
}
|
||||
}
|
||||
Scope::BuiltinTypes => match PrimTy::from_name(ident.name) {
|
||||
Some(prim_ty) => ok(Res::PrimTy(prim_ty), DUMMY_SP, this.arenas),
|
||||
None => Err(Determinacy::Determined),
|
||||
},
|
||||
};
|
||||
|
||||
match result {
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
use crate::utils::{constants, snippet_opt, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
|
||||
use crate::utils::{snippet_opt, span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
|
||||
use rustc_ast::ast::{
|
||||
BindingMode, Expr, ExprKind, GenericParamKind, Generics, Lit, LitFloatType, LitIntType, LitKind, Mutability,
|
||||
NodeId, Pat, PatKind, UnOp,
|
||||
|
@ -6,6 +6,7 @@ use rustc_ast::ast::{
|
|||
use rustc_ast::visit::FnKind;
|
||||
use rustc_data_structures::fx::FxHashMap;
|
||||
use rustc_errors::Applicability;
|
||||
use rustc_hir::PrimTy;
|
||||
use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
|
||||
use rustc_middle::lint::in_external_macro;
|
||||
use rustc_session::{declare_lint_pass, declare_tool_lint};
|
||||
|
@ -264,13 +265,12 @@ impl EarlyLintPass for MiscEarlyLints {
|
|||
fn check_generics(&mut self, cx: &EarlyContext<'_>, gen: &Generics) {
|
||||
for param in &gen.params {
|
||||
if let GenericParamKind::Type { .. } = param.kind {
|
||||
let name = param.ident.as_str();
|
||||
if constants::BUILTIN_TYPES.contains(&&*name) {
|
||||
if let Some(prim_ty) = PrimTy::from_name(param.ident.name) {
|
||||
span_lint(
|
||||
cx,
|
||||
BUILTIN_TYPE_SHADOW,
|
||||
param.ident.span,
|
||||
&format!("this generic shadows the built-in type `{}`", name),
|
||||
&format!("this generic shadows the built-in type `{}`", prim_ty.name()),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -1,13 +0,0 @@
|
|||
//! This module contains some useful constants.
|
||||
|
||||
#![deny(clippy::missing_docs_in_private_items)]
|
||||
|
||||
/// List of the built-in types names.
|
||||
///
|
||||
/// See also [the reference][reference-types] for a list of such types.
|
||||
///
|
||||
/// [reference-types]: https://doc.rust-lang.org/reference/types.html
|
||||
pub const BUILTIN_TYPES: &[&str] = &[
|
||||
"i8", "u8", "i16", "u16", "i32", "u32", "i64", "u64", "i128", "u128", "isize", "usize", "f32", "f64", "bool",
|
||||
"str", "char",
|
||||
];
|
|
@ -8,7 +8,6 @@ pub mod author;
|
|||
pub mod camel_case;
|
||||
pub mod comparisons;
|
||||
pub mod conf;
|
||||
pub mod constants;
|
||||
mod diagnostics;
|
||||
pub mod eager_or_lazy;
|
||||
pub mod higher;
|
||||
|
|
Loading…
Reference in New Issue