mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use known names instead of string literals

Browse Source
This commit is contained in:
Lukas Wirth 2021-12-09 18:13:15 +01:00
parent 067d87e8a9
commit f9c59d3752
3 changed files with 43 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
crates/hir_expand/src/name.rs
View File

@ -334,6 +334,13 @@ pub mod known {
gt, gt,
le, le,
lt, lt,
// lang items
not,
neg,
future_trait,
owned_box,
index,
partial_ord
); );
// self/Self cannot be used as an identifier // self/Self cannot be used as an identifier

18
crates/hir_ty/src/infer.rs
View File

@ -28,11 +28,10 @@ use hir_def::{
AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, FunctionId, HasModule, Lookup, AdtId, AssocItemId, DefWithBodyId, EnumVariantId, FieldId, FunctionId, HasModule, Lookup,
TraitId, TypeAliasId, VariantId, TraitId, TypeAliasId, VariantId,
}; };
use hir_expand::name::name; use hir_expand::name::{name, Name};
use la_arena::ArenaMap; use la_arena::ArenaMap;
use rustc_hash::FxHashMap; use rustc_hash::FxHashMap;
use stdx::impl_from; use stdx::impl_from;
use syntax::SmolStr;
use crate::{ use crate::{
db::HirDatabase, fold_tys, infer::coerce::CoerceMany, lower::ImplTraitLoweringMode, db::HirDatabase, fold_tys, infer::coerce::CoerceMany, lower::ImplTraitLoweringMode,
@ -719,10 +718,9 @@ impl<'a> InferenceContext<'a> {
self.infer_expr_coerce(self.body.body_expr, &Expectation::has_type(self.return_ty.clone())); self.infer_expr_coerce(self.body.body_expr, &Expectation::has_type(self.return_ty.clone()));
} }
fn resolve_lang_item(&self, name: &str) -> Option<LangItemTarget> { fn resolve_lang_item(&self, name: Name) -> Option<LangItemTarget> {
let krate = self.resolver.krate()?; let krate = self.resolver.krate()?;
let name = SmolStr::new_inline(name); self.db.lang_item(krate, name.to_smol_str())
self.db.lang_item(krate, name)
} }
fn resolve_into_iter_item(&self) -> Option<TypeAliasId> { fn resolve_into_iter_item(&self) -> Option<TypeAliasId> {
@ -743,22 +741,22 @@ impl<'a> InferenceContext<'a> {
} }
fn resolve_ops_neg_output(&self) -> Option<TypeAliasId> { fn resolve_ops_neg_output(&self) -> Option<TypeAliasId> {
let trait_ = self.resolve_lang_item("neg")?.as_trait()?; let trait_ = self.resolve_lang_item(name![neg])?.as_trait()?;
self.db.trait_data(trait_).associated_type_by_name(&name![Output]) self.db.trait_data(trait_).associated_type_by_name(&name![Output])
} }
fn resolve_ops_not_output(&self) -> Option<TypeAliasId> { fn resolve_ops_not_output(&self) -> Option<TypeAliasId> {
let trait_ = self.resolve_lang_item("not")?.as_trait()?; let trait_ = self.resolve_lang_item(name![not])?.as_trait()?;
self.db.trait_data(trait_).associated_type_by_name(&name![Output]) self.db.trait_data(trait_).associated_type_by_name(&name![Output])
} }
fn resolve_future_future_output(&self) -> Option<TypeAliasId> { fn resolve_future_future_output(&self) -> Option<TypeAliasId> {
let trait_ = self.resolve_lang_item("future_trait")?.as_trait()?; let trait_ = self.resolve_lang_item(name![future_trait])?.as_trait()?;
self.db.trait_data(trait_).associated_type_by_name(&name![Output]) self.db.trait_data(trait_).associated_type_by_name(&name![Output])
} }
fn resolve_boxed_box(&self) -> Option<AdtId> { fn resolve_boxed_box(&self) -> Option<AdtId> {
let struct_ = self.resolve_lang_item("owned_box")?.as_struct()?; let struct_ = self.resolve_lang_item(name![owned_box])?.as_struct()?;
Some(struct_.into()) Some(struct_.into())
} }
@ -799,7 +797,7 @@ impl<'a> InferenceContext<'a> {
} }
fn resolve_ops_index(&self) -> Option<TraitId> { fn resolve_ops_index(&self) -> Option<TraitId> {
self.resolve_lang_item("index")?.as_trait() self.resolve_lang_item(name![index])?.as_trait()
} }
fn resolve_ops_index_output(&self) -> Option<TypeAliasId> { fn resolve_ops_index_output(&self) -> Option<TypeAliasId> {

54
crates/hir_ty/src/infer/expr.rs
View File

@ -1276,41 +1276,43 @@ impl<'a> InferenceContext<'a> {
let (name, lang_item) = match op { let (name, lang_item) = match op {
BinaryOp::LogicOp(_) => return None, BinaryOp::LogicOp(_) => return None,
BinaryOp::ArithOp(aop) => match aop { BinaryOp::ArithOp(aop) => match aop {
ArithOp::Add => (name!(add), "add"), ArithOp::Add => (name!(add), name!(add)),
ArithOp::Mul => (name!(mul), "mul"), ArithOp::Mul => (name!(mul), name!(mul)),
ArithOp::Sub => (name!(sub), "sub"), ArithOp::Sub => (name!(sub), name!(sub)),
ArithOp::Div => (name!(div), "div"), ArithOp::Div => (name!(div), name!(div)),
ArithOp::Rem => (name!(rem), "rem"), ArithOp::Rem => (name!(rem), name!(rem)),
ArithOp::Shl => (name!(shl), "shl"), ArithOp::Shl => (name!(shl), name!(shl)),
ArithOp::Shr => (name!(shr), "shr"), ArithOp::Shr => (name!(shr), name!(shr)),
ArithOp::BitXor => (name!(bitxor), "bitxor"), ArithOp::BitXor => (name!(bitxor), name!(bitxor)),
ArithOp::BitOr => (name!(bitor), "bitor"), ArithOp::BitOr => (name!(bitor), name!(bitor)),
ArithOp::BitAnd => (name!(bitand), "bitand"), ArithOp::BitAnd => (name!(bitand), name!(bitand)),
}, },
BinaryOp::Assignment { op: Some(aop) } => match aop { BinaryOp::Assignment { op: Some(aop) } => match aop {
ArithOp::Add => (name!(add_assign), "add_assign"), ArithOp::Add => (name!(add_assign), name!(add_assign)),
ArithOp::Mul => (name!(mul_assign), "mul_assign"), ArithOp::Mul => (name!(mul_assign), name!(mul_assign)),
ArithOp::Sub => (name!(sub_assign), "sub_assign"), ArithOp::Sub => (name!(sub_assign), name!(sub_assign)),
ArithOp::Div => (name!(div_assign), "div_assign"), ArithOp::Div => (name!(div_assign), name!(div_assign)),
ArithOp::Rem => (name!(rem_assign), "rem_assign"), ArithOp::Rem => (name!(rem_assign), name!(rem_assign)),
ArithOp::Shl => (name!(shl_assign), "shl_assign"), ArithOp::Shl => (name!(shl_assign), name!(shl_assign)),
ArithOp::Shr => (name!(shr_assign), "shr_assign"), ArithOp::Shr => (name!(shr_assign), name!(shr_assign)),
ArithOp::BitXor => (name!(bitxor_assign), "bitxor_assign"), ArithOp::BitXor => (name!(bitxor_assign), name!(bitxor_assign)),
ArithOp::BitOr => (name!(bitor_assign), "bitor_assign"), ArithOp::BitOr => (name!(bitor_assign), name!(bitor_assign)),
ArithOp::BitAnd => (name!(bitand_assign), "bitand_assign"), ArithOp::BitAnd => (name!(bitand_assign), name!(bitand_assign)),
}, },
BinaryOp::CmpOp(cop) => match cop { BinaryOp::CmpOp(cop) => match cop {
CmpOp::Eq { negated: false } => (name!(eq), "eq"), CmpOp::Eq { negated: false } => (name!(eq), name!(eq)),
CmpOp::Eq { negated: true } => (name!(ne), "eq"), CmpOp::Eq { negated: true } => (name!(ne), name!(eq)),
CmpOp::Ord { ordering: Ordering::Less, strict: false } => { CmpOp::Ord { ordering: Ordering::Less, strict: false } => {
(name!(le), "partial_ord") (name!(le), name!(partial_ord))
}
CmpOp::Ord { ordering: Ordering::Less, strict: true } => {
(name!(lt), name!(partial_ord))
} }
CmpOp::Ord { ordering: Ordering::Less, strict: true } => (name!(lt), "partial_ord"),
CmpOp::Ord { ordering: Ordering::Greater, strict: false } => { CmpOp::Ord { ordering: Ordering::Greater, strict: false } => {
(name!(ge), "partial_ord") (name!(ge), name!(partial_ord))
} }
CmpOp::Ord { ordering: Ordering::Greater, strict: true } => { CmpOp::Ord { ordering: Ordering::Greater, strict: true } => {
(name!(gt), "partial_ord") (name!(gt), name!(partial_ord))
} }
}, },
BinaryOp::Assignment { op: None } => return None, BinaryOp::Assignment { op: None } => return None,