From 970dbf871795650ecf49b7198d53bdcad9c612af Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sat, 25 Apr 2020 14:23:34 +0200 Subject: Rename StructField -> Field --- crates/ra_hir/src/code_model.rs | 34 +++++++++++++------------- crates/ra_hir/src/from_id.rs | 22 ++++++++--------- crates/ra_hir/src/has_source.rs | 6 ++--- crates/ra_hir/src/lib.rs | 4 +-- crates/ra_hir/src/semantics.rs | 27 +++++++------------- crates/ra_hir/src/semantics/source_to_def.rs | 8 +++--- crates/ra_hir/src/source_analyzer.rs | 22 ++++++++--------- crates/ra_hir_def/src/adt.rs | 22 ++++++++--------- crates/ra_hir_def/src/attr.rs | 2 +- crates/ra_hir_def/src/child_by_source.rs | 6 ++--- crates/ra_hir_def/src/docs.rs | 2 +- crates/ra_hir_def/src/keys.rs | 6 ++--- crates/ra_hir_def/src/lib.rs | 10 ++++---- crates/ra_hir_ty/src/db.rs | 4 +-- crates/ra_hir_ty/src/expr.rs | 14 +++++------ crates/ra_hir_ty/src/infer.rs | 16 ++++++------ crates/ra_hir_ty/src/infer/expr.rs | 8 +++--- crates/ra_hir_ty/src/infer/pat.rs | 4 +-- crates/ra_hir_ty/src/lower.rs | 6 ++--- crates/ra_ide/src/completion/presentation.rs | 7 +----- crates/ra_ide/src/display/navigation_target.rs | 4 +-- crates/ra_ide/src/hover.rs | 4 +-- crates/ra_ide/src/references.rs | 2 +- crates/ra_ide/src/references/rename.rs | 4 +-- crates/ra_ide/src/syntax_highlighting.rs | 2 +- crates/ra_ide_db/src/defs.rs | 22 ++++++++--------- crates/ra_ide_db/src/search.rs | 12 ++++----- 27 files changed, 132 insertions(+), 148 deletions(-) (limited to 'crates') diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index 43f932e20..3f645a1dd 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -13,8 +13,8 @@ use hir_def::{ resolver::{HasResolver, Resolver}, type_ref::{Mutability, TypeRef}, AdtId, AssocContainerId, ConstId, DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule, - ImplId, LocalEnumVariantId, LocalModuleId, LocalStructFieldId, Lookup, ModuleId, StaticId, - StructId, TraitId, TypeAliasId, TypeParamId, UnionId, + ImplId, LocalEnumVariantId, LocalFieldId, LocalModuleId, Lookup, ModuleId, StaticId, StructId, + TraitId, TypeAliasId, TypeParamId, UnionId, }; use hir_expand::{ diagnostics::DiagnosticSink, @@ -294,9 +294,9 @@ impl Module { } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub struct StructField { +pub struct Field { pub(crate) parent: VariantDef, - pub(crate) id: LocalStructFieldId, + pub(crate) id: LocalFieldId, } #[derive(Debug, PartialEq, Eq)] @@ -305,7 +305,7 @@ pub enum FieldSource { Pos(ast::TupleFieldDef), } -impl StructField { +impl Field { pub fn name(&self, db: &dyn HirDatabase) -> Name { self.parent.variant_data(db).fields()[self.id].name.clone() } @@ -331,7 +331,7 @@ impl StructField { } } -impl HasVisibility for StructField { +impl HasVisibility for Field { fn visibility(&self, db: &dyn HirDatabase) -> Visibility { let variant_data = self.parent.variant_data(db); let visibility = &variant_data.fields()[self.id].visibility; @@ -358,12 +358,12 @@ impl Struct { db.struct_data(self.id).name.clone() } - pub fn fields(self, db: &dyn HirDatabase) -> Vec { + pub fn fields(self, db: &dyn HirDatabase) -> Vec { db.struct_data(self.id) .variant_data .fields() .iter() - .map(|(id, _)| StructField { parent: self.into(), id }) + .map(|(id, _)| Field { parent: self.into(), id }) .collect() } @@ -394,12 +394,12 @@ impl Union { Type::from_def(db, self.id.lookup(db.upcast()).container.module(db.upcast()).krate, self.id) } - pub fn fields(self, db: &dyn HirDatabase) -> Vec { + pub fn fields(self, db: &dyn HirDatabase) -> Vec { db.union_data(self.id) .variant_data .fields() .iter() - .map(|(id, _)| StructField { parent: self.into(), id }) + .map(|(id, _)| Field { parent: self.into(), id }) .collect() } @@ -457,11 +457,11 @@ impl EnumVariant { db.enum_data(self.parent.id).variants[self.id].name.clone() } - pub fn fields(self, db: &dyn HirDatabase) -> Vec { + pub fn fields(self, db: &dyn HirDatabase) -> Vec { self.variant_data(db) .fields() .iter() - .map(|(id, _)| StructField { parent: self.into(), id }) + .map(|(id, _)| Field { parent: self.into(), id }) .collect() } @@ -527,7 +527,7 @@ pub enum VariantDef { impl_froms!(VariantDef: Struct, Union, EnumVariant); impl VariantDef { - pub fn fields(self, db: &dyn HirDatabase) -> Vec { + pub fn fields(self, db: &dyn HirDatabase) -> Vec { match self { VariantDef::Struct(it) => it.fields(db), VariantDef::Union(it) => it.fields(db), @@ -1148,7 +1148,7 @@ impl Type { } } - pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(StructField, Type)> { + pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> { if let Ty::Apply(a_ty) = &self.ty.value { if let TypeCtor::Adt(AdtId::StructId(s)) = a_ty.ctor { let var_def = s.into(); @@ -1156,7 +1156,7 @@ impl Type { .field_types(var_def) .iter() .map(|(local_id, ty)| { - let def = StructField { parent: var_def.into(), id: local_id }; + let def = Field { parent: var_def.into(), id: local_id }; let ty = ty.clone().subst(&a_ty.parameters); (def, self.derived(ty)) }) @@ -1352,7 +1352,7 @@ impl ScopeDef { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum AttrDef { Module(Module), - StructField(StructField), + Field(Field), Adt(Adt), Function(Function), EnumVariant(EnumVariant), @@ -1365,7 +1365,7 @@ pub enum AttrDef { impl_froms!( AttrDef: Module, - StructField, + Field, Adt(Struct, Enum, Union), EnumVariant, Static, diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs index 62fb52e72..679ae8121 100644 --- a/crates/ra_hir/src/from_id.rs +++ b/crates/ra_hir/src/from_id.rs @@ -4,13 +4,13 @@ //! are splitting the hir. use hir_def::{ - expr::PatId, AdtId, AssocItemId, AttrDefId, DefWithBodyId, EnumVariantId, GenericDefId, - ModuleDefId, StructFieldId, VariantId, + expr::PatId, AdtId, AssocItemId, AttrDefId, DefWithBodyId, EnumVariantId, FieldId, + GenericDefId, ModuleDefId, VariantId, }; use crate::{ - code_model::ItemInNs, Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, GenericDef, Local, - MacroDef, ModuleDef, StructField, VariantDef, + code_model::ItemInNs, Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, Field, GenericDef, + Local, MacroDef, ModuleDef, VariantDef, }; macro_rules! from_id { @@ -184,15 +184,15 @@ impl From for VariantId { } } -impl From for StructFieldId { - fn from(def: StructField) -> Self { - StructFieldId { parent: def.parent.into(), local_id: def.id } +impl From for FieldId { + fn from(def: Field) -> Self { + FieldId { parent: def.parent.into(), local_id: def.id } } } -impl From for StructField { - fn from(def: StructFieldId) -> Self { - StructField { parent: def.parent.into(), id: def.local_id } +impl From for Field { + fn from(def: FieldId) -> Self { + Field { parent: def.parent.into(), id: def.local_id } } } @@ -200,7 +200,7 @@ impl From for AttrDefId { fn from(def: AttrDef) -> Self { match def { AttrDef::Module(it) => AttrDefId::ModuleId(it.id), - AttrDef::StructField(it) => AttrDefId::StructFieldId(it.into()), + AttrDef::Field(it) => AttrDefId::FieldId(it.into()), AttrDef::Adt(it) => AttrDefId::AdtId(it.into()), AttrDef::Function(it) => AttrDefId::FunctionId(it.id), AttrDef::EnumVariant(it) => AttrDefId::EnumVariantId(it.into()), diff --git a/crates/ra_hir/src/has_source.rs b/crates/ra_hir/src/has_source.rs index 129764e0a..63b8fd369 100644 --- a/crates/ra_hir/src/has_source.rs +++ b/crates/ra_hir/src/has_source.rs @@ -9,8 +9,8 @@ use hir_def::{ use ra_syntax::ast; use crate::{ - db::HirDatabase, Const, Enum, EnumVariant, FieldSource, Function, ImplDef, MacroDef, Module, - Static, Struct, StructField, Trait, TypeAlias, TypeParam, Union, + db::HirDatabase, Const, Enum, EnumVariant, Field, FieldSource, Function, ImplDef, MacroDef, + Module, Static, Struct, Trait, TypeAlias, TypeParam, Union, }; pub use hir_expand::InFile; @@ -37,7 +37,7 @@ impl Module { } } -impl HasSource for StructField { +impl HasSource for Field { type Ast = FieldSource; fn source(self, db: &dyn HirDatabase) -> InFile { let var = VariantId::from(self.parent); diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index 5af7e5d6d..312ef3814 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -52,9 +52,9 @@ mod has_source; pub use crate::{ code_model::{ Adt, AsAssocItem, AssocItem, AssocItemContainer, AttrDef, Const, Crate, CrateDependency, - DefWithBody, Docs, Enum, EnumVariant, FieldSource, Function, GenericDef, HasAttrs, + DefWithBody, Docs, Enum, EnumVariant, Field, FieldSource, Function, GenericDef, HasAttrs, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, ScopeDef, Static, Struct, - StructField, Trait, Type, TypeAlias, TypeParam, Union, VariantDef, Visibility, + Trait, Type, TypeAlias, TypeParam, Union, VariantDef, Visibility, }, has_source::HasSource, semantics::{original_range, PathResolution, Semantics, SemanticsScope}, diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs index e09cf3185..86bfb416c 100644 --- a/crates/ra_hir/src/semantics.rs +++ b/crates/ra_hir/src/semantics.rs @@ -23,8 +23,8 @@ use crate::{ diagnostics::Diagnostic, semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx}, source_analyzer::{resolve_hir_path, SourceAnalyzer}, - AssocItem, Function, HirFileId, ImplDef, InFile, Local, MacroDef, Module, ModuleDef, Name, - Origin, Path, ScopeDef, StructField, Trait, Type, TypeParam, + AssocItem, Field, Function, HirFileId, ImplDef, InFile, Local, MacroDef, Module, ModuleDef, + Name, Origin, Path, ScopeDef, Trait, Type, TypeParam, }; #[derive(Debug, Clone, PartialEq, Eq)] @@ -184,18 +184,15 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> { self.analyze(call.syntax()).resolve_method_call(self.db, call) } - pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option { + pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option { self.analyze(field.syntax()).resolve_field(self.db, field) } - pub fn resolve_record_field( - &self, - field: &ast::RecordField, - ) -> Option<(StructField, Option)> { + pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<(Field, Option)> { self.analyze(field.syntax()).resolve_record_field(self.db, field) } - pub fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option { + pub fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option { self.analyze(field.syntax()).resolve_record_field_pat(self.db, field) } @@ -216,19 +213,13 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> { // FIXME: use this instead? // pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option; - pub fn record_literal_missing_fields( - &self, - literal: &ast::RecordLit, - ) -> Vec<(StructField, Type)> { + pub fn record_literal_missing_fields(&self, literal: &ast::RecordLit) -> Vec<(Field, Type)> { self.analyze(literal.syntax()) .record_literal_missing_fields(self.db, literal) .unwrap_or_default() } - pub fn record_pattern_missing_fields( - &self, - pattern: &ast::RecordPat, - ) -> Vec<(StructField, Type)> { + pub fn record_pattern_missing_fields(&self, pattern: &ast::RecordPat) -> Vec<(Field, Type)> { self.analyze(pattern.syntax()) .record_pattern_missing_fields(self.db, pattern) .unwrap_or_default() @@ -359,8 +350,8 @@ to_def_impls![ (crate::Const, ast::ConstDef, const_to_def), (crate::Static, ast::StaticDef, static_to_def), (crate::Function, ast::FnDef, fn_to_def), - (crate::StructField, ast::RecordFieldDef, record_field_to_def), - (crate::StructField, ast::TupleFieldDef, tuple_field_to_def), + (crate::Field, ast::RecordFieldDef, record_field_to_def), + (crate::Field, ast::TupleFieldDef, tuple_field_to_def), (crate::EnumVariant, ast::EnumVariant, enum_variant_to_def), (crate::TypeParam, ast::TypeParam, type_param_to_def), (crate::MacroDef, ast::MacroCall, macro_call_to_def), // this one is dubious, not all calls are macros diff --git a/crates/ra_hir/src/semantics/source_to_def.rs b/crates/ra_hir/src/semantics/source_to_def.rs index 66724919b..6f3b5b2da 100644 --- a/crates/ra_hir/src/semantics/source_to_def.rs +++ b/crates/ra_hir/src/semantics/source_to_def.rs @@ -5,8 +5,8 @@ use hir_def::{ dyn_map::DynMap, expr::PatId, keys::{self, Key}, - ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, ModuleId, - StaticId, StructFieldId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId, VariantId, + ConstId, DefWithBodyId, EnumId, EnumVariantId, FieldId, FunctionId, GenericDefId, ImplId, + ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId, VariantId, }; use hir_expand::{name::AsName, AstId, MacroDefKind}; use ra_db::FileId; @@ -97,13 +97,13 @@ impl SourceToDefCtx<'_, '_> { pub(super) fn record_field_to_def( &mut self, src: InFile, - ) -> Option { + ) -> Option { self.to_def(src, keys::RECORD_FIELD) } pub(super) fn tuple_field_to_def( &mut self, src: InFile, - ) -> Option { + ) -> Option { self.to_def(src, keys::TUPLE_FIELD) } pub(super) fn enum_variant_to_def( diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs index 59a3a17d2..74d64c97d 100644 --- a/crates/ra_hir/src/source_analyzer.rs +++ b/crates/ra_hir/src/source_analyzer.rs @@ -14,7 +14,7 @@ use hir_def::{ }, expr::{ExprId, Pat, PatId}, resolver::{resolver_for_scope, Resolver, TypeNs, ValueNs}, - AsMacroCall, DefWithBodyId, LocalStructFieldId, StructFieldId, VariantId, + AsMacroCall, DefWithBodyId, FieldId, LocalFieldId, VariantId, }; use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile}; use hir_ty::{ @@ -27,8 +27,8 @@ use ra_syntax::{ }; use crate::{ - db::HirDatabase, semantics::PathResolution, Adt, Const, EnumVariant, Function, Local, MacroDef, - ModPath, ModuleDef, Path, PathKind, Static, Struct, StructField, Trait, Type, TypeAlias, + db::HirDatabase, semantics::PathResolution, Adt, Const, EnumVariant, Field, Function, Local, + MacroDef, ModPath, ModuleDef, Path, PathKind, Static, Struct, Trait, Type, TypeAlias, TypeParam, }; use ra_db::CrateId; @@ -140,7 +140,7 @@ impl SourceAnalyzer { &self, db: &dyn HirDatabase, field: &ast::FieldExpr, - ) -> Option { + ) -> Option { let expr_id = self.expr_id(db, &field.clone().into())?; self.infer.as_ref()?.field_resolution(expr_id).map(|it| it.into()) } @@ -149,7 +149,7 @@ impl SourceAnalyzer { &self, db: &dyn HirDatabase, field: &ast::RecordField, - ) -> Option<(StructField, Option)> { + ) -> Option<(Field, Option)> { let expr = field.expr()?; let expr_id = self.expr_id(db, &expr)?; let local = if field.name_ref().is_some() { @@ -172,7 +172,7 @@ impl SourceAnalyzer { &self, _db: &dyn HirDatabase, field: &ast::RecordFieldPat, - ) -> Option { + ) -> Option { let pat_id = self.pat_id(&field.pat()?)?; let struct_field = self.infer.as_ref()?.record_field_pat_resolution(pat_id)?; Some(struct_field.into()) @@ -232,7 +232,7 @@ impl SourceAnalyzer { &self, db: &dyn HirDatabase, literal: &ast::RecordLit, - ) -> Option> { + ) -> Option> { let krate = self.resolver.krate()?; let body = self.body.as_ref()?; let infer = self.infer.as_ref()?; @@ -253,7 +253,7 @@ impl SourceAnalyzer { &self, db: &dyn HirDatabase, pattern: &ast::RecordPat, - ) -> Option> { + ) -> Option> { let krate = self.resolver.krate()?; let body = self.body.as_ref()?; let infer = self.infer.as_ref()?; @@ -276,14 +276,14 @@ impl SourceAnalyzer { krate: CrateId, substs: &Substs, variant: VariantId, - missing_fields: Vec, - ) -> Vec<(StructField, Type)> { + missing_fields: Vec, + ) -> Vec<(Field, Type)> { let field_types = db.field_types(variant); missing_fields .into_iter() .map(|local_id| { - let field = StructFieldId { parent: variant, local_id }; + let field = FieldId { parent: variant, local_id }; let ty = field_types[local_id].clone().subst(substs); (field.into(), Type::new_with_resolver_inner(db, krate, &self.resolver, ty)) }) diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs index 7c0d93691..753becc3d 100644 --- a/crates/ra_hir_def/src/adt.rs +++ b/crates/ra_hir_def/src/adt.rs @@ -14,7 +14,7 @@ use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner, VisibilityOwner}; use crate::{ body::CfgExpander, db::DefDatabase, src::HasChildSource, src::HasSource, trace::Trace, type_ref::TypeRef, visibility::RawVisibility, EnumId, HasModule, LocalEnumVariantId, - LocalStructFieldId, Lookup, ModuleId, StructId, UnionId, VariantId, + LocalFieldId, Lookup, ModuleId, StructId, UnionId, VariantId, }; /// Note that we use `StructData` for unions as well! @@ -38,14 +38,14 @@ pub struct EnumVariantData { #[derive(Debug, Clone, PartialEq, Eq)] pub enum VariantData { - Record(Arena), - Tuple(Arena), + Record(Arena), + Tuple(Arena), Unit, } /// A single field of an enum variant or struct #[derive(Debug, Clone, PartialEq, Eq)] -pub struct StructFieldData { +pub struct FieldData { pub name: Name, pub type_ref: TypeRef, pub visibility: RawVisibility, @@ -133,15 +133,15 @@ impl VariantData { } } - pub fn fields(&self) -> &Arena { - const EMPTY: &Arena = &Arena::new(); + pub fn fields(&self) -> &Arena { + const EMPTY: &Arena = &Arena::new(); match &self { VariantData::Record(fields) | VariantData::Tuple(fields) => fields, _ => EMPTY, } } - pub fn field(&self, name: &Name) -> Option { + pub fn field(&self, name: &Name) -> Option { self.fields().iter().find_map(|(id, data)| if &data.name == name { Some(id) } else { None }) } @@ -155,7 +155,7 @@ impl VariantData { } impl HasChildSource for VariantId { - type ChildId = LocalStructFieldId; + type ChildId = LocalFieldId; type Value = Either; fn child_source(&self, db: &dyn DefDatabase) -> InFile> { @@ -195,7 +195,7 @@ pub enum StructKind { fn lower_struct( db: &dyn DefDatabase, expander: &mut CfgExpander, - trace: &mut Trace>, + trace: &mut Trace>, ast: &InFile, ) -> StructKind { match &ast.value { @@ -208,7 +208,7 @@ fn lower_struct( trace.alloc( || Either::Left(fd.clone()), - || StructFieldData { + || FieldData { name: Name::new_tuple_field(i), type_ref: TypeRef::from_ast_opt(fd.type_ref()), visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())), @@ -226,7 +226,7 @@ fn lower_struct( trace.alloc( || Either::Right(fd.clone()), - || StructFieldData { + || FieldData { name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing), type_ref: TypeRef::from_ast_opt(fd.ascribed_type()), visibility: RawVisibility::from_ast(db, ast.with_value(fd.visibility())), diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs index 2f2e3e5ba..714a66b02 100644 --- a/crates/ra_hir_def/src/attr.rs +++ b/crates/ra_hir_def/src/attr.rs @@ -43,7 +43,7 @@ impl Attrs { }; Attrs::from_attrs_owner(db, src.as_ref().map(|it| it as &dyn AttrsOwner)) } - AttrDefId::StructFieldId(it) => { + AttrDefId::FieldId(it) => { let src = it.parent.child_source(db); match &src.value[it.local_id] { Either::Left(_tuple) => Attrs::default(), diff --git a/crates/ra_hir_def/src/child_by_source.rs b/crates/ra_hir_def/src/child_by_source.rs index 7009f21d1..a885ec96d 100644 --- a/crates/ra_hir_def/src/child_by_source.rs +++ b/crates/ra_hir_def/src/child_by_source.rs @@ -12,8 +12,8 @@ use crate::{ item_scope::ItemScope, keys, src::{HasChildSource, HasSource}, - AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, ImplId, Lookup, ModuleDefId, - ModuleId, StructFieldId, TraitId, VariantId, + AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, FieldId, ImplId, Lookup, ModuleDefId, + ModuleId, TraitId, VariantId, }; pub trait ChildBySource { @@ -140,7 +140,7 @@ impl ChildBySource for VariantId { let arena_map = self.child_source(db); let arena_map = arena_map.as_ref(); for (local_id, source) in arena_map.value.iter() { - let id = StructFieldId { parent: *self, local_id }; + let id = FieldId { parent: *self, local_id }; match source { Either::Left(source) => { res[keys::TUPLE_FIELD].insert(arena_map.with_value(source.clone()), id) diff --git a/crates/ra_hir_def/src/docs.rs b/crates/ra_hir_def/src/docs.rs index 0539a77d4..b221ae1ce 100644 --- a/crates/ra_hir_def/src/docs.rs +++ b/crates/ra_hir_def/src/docs.rs @@ -43,7 +43,7 @@ impl Documentation { let src = def_map[module.local_id].declaration_source(db)?; docs_from_ast(&src.value) } - AttrDefId::StructFieldId(it) => { + AttrDefId::FieldId(it) => { let src = it.parent.child_source(db); match &src.value[it.local_id] { Either::Left(_tuple) => None, diff --git a/crates/ra_hir_def/src/keys.rs b/crates/ra_hir_def/src/keys.rs index 8cd70eb9a..a7349a21d 100644 --- a/crates/ra_hir_def/src/keys.rs +++ b/crates/ra_hir_def/src/keys.rs @@ -8,7 +8,7 @@ use rustc_hash::FxHashMap; use crate::{ dyn_map::{DynMap, Policy}, - ConstId, EnumId, EnumVariantId, FunctionId, ImplId, StaticId, StructFieldId, StructId, TraitId, + ConstId, EnumId, EnumVariantId, FieldId, FunctionId, ImplId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId, }; @@ -25,8 +25,8 @@ pub const UNION: Key = Key::new(); pub const ENUM: Key = Key::new(); pub const ENUM_VARIANT: Key = Key::new(); -pub const TUPLE_FIELD: Key = Key::new(); -pub const RECORD_FIELD: Key = Key::new(); +pub const TUPLE_FIELD: Key = Key::new(); +pub const RECORD_FIELD: Key = Key::new(); pub const TYPE_PARAM: Key = Key::new(); pub const MACRO: Key = Key::new(); diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs index 2d27bbdf8..518772e8a 100644 --- a/crates/ra_hir_def/src/lib.rs +++ b/crates/ra_hir_def/src/lib.rs @@ -133,12 +133,12 @@ pub struct EnumVariantId { pub type LocalEnumVariantId = Idx; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub struct StructFieldId { +pub struct FieldId { pub parent: VariantId, - pub local_id: LocalStructFieldId, + pub local_id: LocalFieldId, } -pub type LocalStructFieldId = Idx; +pub type LocalFieldId = Idx; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct ConstId(salsa::InternId); @@ -299,7 +299,7 @@ impl From for GenericDefId { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum AttrDefId { ModuleId(ModuleId), - StructFieldId(StructFieldId), + FieldId(FieldId), AdtId(AdtId), FunctionId(FunctionId), EnumVariantId(EnumVariantId), @@ -313,7 +313,7 @@ pub enum AttrDefId { impl_froms!( AttrDefId: ModuleId, - StructFieldId, + FieldId, AdtId(StructId, EnumId, UnionId), EnumVariantId, StaticId, diff --git a/crates/ra_hir_ty/src/db.rs b/crates/ra_hir_ty/src/db.rs index 9e5dfeab3..fdb49560b 100644 --- a/crates/ra_hir_ty/src/db.rs +++ b/crates/ra_hir_ty/src/db.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use hir_def::{ - db::DefDatabase, DefWithBodyId, GenericDefId, ImplId, LocalStructFieldId, TraitId, TypeParamId, + db::DefDatabase, DefWithBodyId, GenericDefId, ImplId, LocalFieldId, TraitId, TypeParamId, VariantId, }; use ra_arena::map::ArenaMap; @@ -43,7 +43,7 @@ pub trait HirDatabase: DefDatabase + Upcast { fn impl_trait(&self, def: ImplId) -> Option>; #[salsa::invoke(crate::lower::field_types_query)] - fn field_types(&self, var: VariantId) -> Arc>>; + fn field_types(&self, var: VariantId) -> Arc>>; #[salsa::invoke(crate::callable_item_sig)] fn callable_item_signature(&self, def: CallableDef) -> PolyFnSig; diff --git a/crates/ra_hir_ty/src/expr.rs b/crates/ra_hir_ty/src/expr.rs index fd59f4320..f04968e14 100644 --- a/crates/ra_hir_ty/src/expr.rs +++ b/crates/ra_hir_ty/src/expr.rs @@ -24,7 +24,7 @@ pub use hir_def::{ ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp, MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, UnaryOp, }, - LocalStructFieldId, VariantId, + LocalFieldId, VariantId, }; pub struct ExprValidator<'a, 'b: 'a> { @@ -83,7 +83,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> { id: ExprId, db: &dyn HirDatabase, variant_def: VariantId, - missed_fields: Vec, + missed_fields: Vec, ) { // XXX: only look at source_map if we do have missing fields let (_, source_map) = db.body_with_source_map(self.func.into()); @@ -112,7 +112,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> { id: PatId, db: &dyn HirDatabase, variant_def: VariantId, - missed_fields: Vec, + missed_fields: Vec, ) { // XXX: only look at source_map if we do have missing fields let (_, source_map) = db.body_with_source_map(self.func.into()); @@ -256,7 +256,7 @@ pub fn record_literal_missing_fields( infer: &InferenceResult, id: ExprId, expr: &Expr, -) -> Option<(VariantId, Vec, /*exhaustive*/ bool)> { +) -> Option<(VariantId, Vec, /*exhaustive*/ bool)> { let (fields, exhausitve) = match expr { Expr::RecordLit { path: _, fields, spread } => (fields, spread.is_none()), _ => return None, @@ -270,7 +270,7 @@ pub fn record_literal_missing_fields( let variant_data = variant_data(db.upcast(), variant_def); let specified_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect(); - let missed_fields: Vec = variant_data + let missed_fields: Vec = variant_data .fields() .iter() .filter_map(|(f, d)| if specified_fields.contains(&d.name) { None } else { Some(f) }) @@ -286,7 +286,7 @@ pub fn record_pattern_missing_fields( infer: &InferenceResult, id: PatId, pat: &Pat, -) -> Option<(VariantId, Vec, /*exhaustive*/ bool)> { +) -> Option<(VariantId, Vec, /*exhaustive*/ bool)> { let (fields, exhaustive) = match pat { Pat::Record { path: _, args, ellipsis } => (args, !ellipsis), _ => return None, @@ -300,7 +300,7 @@ pub fn record_pattern_missing_fields( let variant_data = variant_data(db.upcast(), variant_def); let specified_fields: FxHashSet<_> = fields.iter().map(|f| &f.name).collect(); - let missed_fields: Vec = variant_data + let missed_fields: Vec = variant_data .fields() .iter() .filter_map(|(f, d)| if specified_fields.contains(&d.name) { None } else { Some(f) }) diff --git a/crates/ra_hir_ty/src/infer.rs b/crates/ra_hir_ty/src/infer.rs index dfb6a435f..6a53be621 100644 --- a/crates/ra_hir_ty/src/infer.rs +++ b/crates/ra_hir_ty/src/infer.rs @@ -28,7 +28,7 @@ use hir_def::{ path::{path, Path}, resolver::{HasResolver, Resolver, TypeNs}, type_ref::{Mutability, TypeRef}, - AdtId, AssocItemId, DefWithBodyId, FunctionId, StructFieldId, TraitId, TypeAliasId, VariantId, + AdtId, AssocItemId, DefWithBodyId, FieldId, FunctionId, TraitId, TypeAliasId, VariantId, }; use hir_expand::{diagnostics::DiagnosticSink, name::name}; use ra_arena::map::ArenaMap; @@ -124,10 +124,10 @@ pub struct InferenceResult { /// For each method call expr, records the function it resolves to. method_resolutions: FxHashMap, /// For each field access expr, records the field it resolves to. - field_resolutions: FxHashMap, + field_resolutions: FxHashMap, /// For each field in record literal, records the field it resolves to. - record_field_resolutions: FxHashMap, - record_field_pat_resolutions: FxHashMap, + record_field_resolutions: FxHashMap, + record_field_pat_resolutions: FxHashMap, /// For each struct literal, records the variant it resolves to. variant_resolutions: FxHashMap, /// For each associated item record what it resolves to @@ -142,13 +142,13 @@ impl InferenceResult { pub fn method_resolution(&self, expr: ExprId) -> Option { self.method_resolutions.get(&expr).copied() } - pub fn field_resolution(&self, expr: ExprId) -> Option { + pub fn field_resolution(&self, expr: ExprId) -> Option { self.field_resolutions.get(&expr).copied() } - pub fn record_field_resolution(&self, expr: ExprId) -> Option { + pub fn record_field_resolution(&self, expr: ExprId) -> Option { self.record_field_resolutions.get(&expr).copied() } - pub fn record_field_pat_resolution(&self, pat: PatId) -> Option { + pub fn record_field_pat_resolution(&self, pat: PatId) -> Option { self.record_field_pat_resolutions.get(&pat).copied() } pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option { @@ -249,7 +249,7 @@ impl<'a> InferenceContext<'a> { self.result.method_resolutions.insert(expr, func); } - fn write_field_resolution(&mut self, expr: ExprId, field: StructFieldId) { + fn write_field_resolution(&mut self, expr: ExprId, field: FieldId) { self.result.field_resolutions.insert(expr, field); } diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs index 1fdb235a0..83f946eee 100644 --- a/crates/ra_hir_ty/src/infer/expr.rs +++ b/crates/ra_hir_ty/src/infer/expr.rs @@ -8,7 +8,7 @@ use hir_def::{ expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp}, path::{GenericArg, GenericArgs}, resolver::resolver_for_expr, - AdtId, AssocContainerId, Lookup, StructFieldId, + AdtId, AssocContainerId, FieldId, Lookup, }; use hir_expand::name::Name; use ra_syntax::ast::RangeOp; @@ -216,9 +216,7 @@ impl<'a> InferenceContext<'a> { for (field_idx, field) in fields.iter().enumerate() { let field_def = variant_data.as_ref().and_then(|it| match it.field(&field.name) { - Some(local_id) => { - Some(StructFieldId { parent: def_id.unwrap(), local_id }) - } + Some(local_id) => Some(FieldId { parent: def_id.unwrap(), local_id }), None => { self.push_diagnostic(InferenceDiagnostic::NoSuchField { expr: tgt_expr, @@ -257,7 +255,7 @@ impl<'a> InferenceContext<'a> { .and_then(|idx| a_ty.parameters.0.get(idx).cloned()), TypeCtor::Adt(AdtId::StructId(s)) => { self.db.struct_data(s).variant_data.field(name).map(|local_id| { - let field = StructFieldId { parent: s.into(), local_id }; + let field = FieldId { parent: s.into(), local_id }; self.write_field_resolution(tgt_expr, field); self.db.field_types(s.into())[field.local_id] .clone() diff --git a/crates/ra_hir_ty/src/infer/pat.rs b/crates/ra_hir_ty/src/infer/pat.rs index 7c2ad4384..54ec870df 100644 --- a/crates/ra_hir_ty/src/infer/pat.rs +++ b/crates/ra_hir_ty/src/infer/pat.rs @@ -7,7 +7,7 @@ use hir_def::{ expr::{BindingAnnotation, Pat, PatId, RecordFieldPat}, path::Path, type_ref::Mutability, - StructFieldId, + FieldId, }; use hir_expand::name::Name; use test_utils::tested_by; @@ -69,7 +69,7 @@ impl<'a> InferenceContext<'a> { for subpat in subpats { let matching_field = var_data.as_ref().and_then(|it| it.field(&subpat.name)); if let Some(local_id) = matching_field { - let field_def = StructFieldId { parent: def.unwrap(), local_id }; + let field_def = FieldId { parent: def.unwrap(), local_id }; self.result.record_field_pat_resolutions.insert(subpat.pat, field_def); } diff --git a/crates/ra_hir_ty/src/lower.rs b/crates/ra_hir_ty/src/lower.rs index c2812e178..b57214296 100644 --- a/crates/ra_hir_ty/src/lower.rs +++ b/crates/ra_hir_ty/src/lower.rs @@ -18,8 +18,8 @@ use hir_def::{ resolver::{HasResolver, Resolver, TypeNs}, type_ref::{TypeBound, TypeRef}, AdtId, AssocContainerId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, HasModule, - ImplId, LocalStructFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, - UnionId, VariantId, + ImplId, LocalFieldId, Lookup, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId, + VariantId, }; use ra_arena::map::ArenaMap; use ra_db::CrateId; @@ -682,7 +682,7 @@ pub fn callable_item_sig(db: &dyn HirDatabase, def: CallableDef) -> PolyFnSig { pub(crate) fn field_types_query( db: &dyn HirDatabase, variant_id: VariantId, -) -> Arc>> { +) -> Arc>> { let var_data = variant_data(db.upcast(), variant_id); let (resolver, def): (_, GenericDefId) = match variant_id { VariantId::StructId(it) => (it.resolver(db.upcast()), it.into()), diff --git a/crates/ra_ide/src/completion/presentation.rs b/crates/ra_ide/src/completion/presentation.rs index 9f9f06bf0..7633cd7fd 100644 --- a/crates/ra_ide/src/completion/presentation.rs +++ b/crates/ra_ide/src/completion/presentation.rs @@ -15,12 +15,7 @@ use crate::{ }; impl Completions { - pub(crate) fn add_field( - &mut self, - ctx: &CompletionContext, - field: hir::StructField, - ty: &Type, - ) { + pub(crate) fn add_field(&mut self, ctx: &CompletionContext, field: hir::Field, ty: &Type) { let is_deprecated = is_deprecated(field, ctx.db); let ty = ty.display(ctx.db).to_string(); let name = field.name(ctx.db); diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs index 67bc9c31b..914a8b471 100644 --- a/crates/ra_ide/src/display/navigation_target.rs +++ b/crates/ra_ide/src/display/navigation_target.rs @@ -189,7 +189,7 @@ impl TryToNav for Definition { fn try_to_nav(&self, db: &RootDatabase) -> Option { match self { Definition::Macro(it) => Some(it.to_nav(db)), - Definition::StructField(it) => Some(it.to_nav(db)), + Definition::Field(it) => Some(it.to_nav(db)), Definition::ModuleDef(it) => it.try_to_nav(db), Definition::SelfType(it) => Some(it.to_nav(db)), Definition::Local(it) => Some(it.to_nav(db)), @@ -286,7 +286,7 @@ impl ToNav for hir::ImplDef { } } -impl ToNav for hir::StructField { +impl ToNav for hir::Field { fn to_nav(&self, db: &RootDatabase) -> NavigationTarget { let src = self.source(db); diff --git a/crates/ra_ide/src/hover.rs b/crates/ra_ide/src/hover.rs index fcc2ab7fb..58c799eca 100644 --- a/crates/ra_ide/src/hover.rs +++ b/crates/ra_ide/src/hover.rs @@ -76,7 +76,7 @@ fn hover_text( fn definition_owner_name(db: &RootDatabase, def: &Definition) -> Option { match def { - Definition::StructField(f) => Some(f.parent_def(db).name(db)), + Definition::Field(f) => Some(f.parent_def(db).name(db)), Definition::Local(l) => l.parent(db).name(db), Definition::ModuleDef(md) => match md { ModuleDef::Function(f) => match f.as_assoc_item(db)?.container(db) { @@ -116,7 +116,7 @@ fn hover_text_from_name_kind(db: &RootDatabase, def: Definition) -> Option { + Definition::Field(it) => { let src = it.source(db); match src.value { FieldSource::Named(it) => { diff --git a/crates/ra_ide/src/references.rs b/crates/ra_ide/src/references.rs index a3970bf83..555ccf295 100644 --- a/crates/ra_ide/src/references.rs +++ b/crates/ra_ide/src/references.rs @@ -144,7 +144,7 @@ fn find_name( fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Option { match def { - Definition::Local(_) | Definition::StructField(_) => {} + Definition::Local(_) | Definition::Field(_) => {} _ => return None, }; diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs index a8f320e2f..fd17bc9f2 100644 --- a/crates/ra_ide/src/references/rename.rs +++ b/crates/ra_ide/src/references/rename.rs @@ -51,12 +51,12 @@ fn source_edit_from_reference(reference: Reference, new_name: &str) -> SourceFil let mut replacement_text = String::new(); let file_id = reference.file_range.file_id; let range = match reference.kind { - ReferenceKind::StructFieldShorthandForField => { + ReferenceKind::FieldShorthandForField => { replacement_text.push_str(new_name); replacement_text.push_str(": "); TextRange::new(reference.file_range.range.start(), reference.file_range.range.start()) } - ReferenceKind::StructFieldShorthandForLocal => { + ReferenceKind::FieldShorthandForLocal => { replacement_text.push_str(": "); replacement_text.push_str(new_name); TextRange::new(reference.file_range.range.end(), reference.file_range.range.end()) diff --git a/crates/ra_ide/src/syntax_highlighting.rs b/crates/ra_ide/src/syntax_highlighting.rs index 6f02614a6..be0f8c827 100644 --- a/crates/ra_ide/src/syntax_highlighting.rs +++ b/crates/ra_ide/src/syntax_highlighting.rs @@ -422,7 +422,7 @@ fn highlight_element( fn highlight_name(db: &RootDatabase, def: Definition) -> Highlight { match def { Definition::Macro(_) => HighlightTag::Macro, - Definition::StructField(_) => HighlightTag::Field, + Definition::Field(_) => HighlightTag::Field, Definition::ModuleDef(def) => match def { hir::ModuleDef::Module(_) => HighlightTag::Module, hir::ModuleDef::Function(_) => HighlightTag::Function, diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs index 785613b82..7cd2384e9 100644 --- a/crates/ra_ide_db/src/defs.rs +++ b/crates/ra_ide_db/src/defs.rs @@ -6,8 +6,8 @@ // FIXME: this badly needs rename/rewrite (matklad, 2020-02-06). use hir::{ - HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution, Semantics, - StructField, TypeParam, Visibility, + Field, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, Name, PathResolution, + Semantics, TypeParam, Visibility, }; use ra_prof::profile; use ra_syntax::{ @@ -22,7 +22,7 @@ use crate::RootDatabase; #[derive(Debug, PartialEq, Eq)] pub enum Definition { Macro(MacroDef), - StructField(StructField), + Field(Field), ModuleDef(ModuleDef), SelfType(ImplDef), Local(Local), @@ -33,7 +33,7 @@ impl Definition { pub fn module(&self, db: &RootDatabase) -> Option { match self { Definition::Macro(it) => it.module(db), - Definition::StructField(it) => Some(it.parent_def(db).module(db)), + Definition::Field(it) => Some(it.parent_def(db).module(db)), Definition::ModuleDef(it) => it.module(db), Definition::SelfType(it) => Some(it.module(db)), Definition::Local(it) => Some(it.module(db)), @@ -46,7 +46,7 @@ impl Definition { match self { Definition::Macro(_) => None, - Definition::StructField(sf) => Some(sf.visibility(db)), + Definition::Field(sf) => Some(sf.visibility(db)), Definition::ModuleDef(def) => module?.visibility_of(db, def), Definition::SelfType(_) => None, Definition::Local(_) => None, @@ -57,7 +57,7 @@ impl Definition { pub fn name(&self, db: &RootDatabase) -> Option { let name = match self { Definition::Macro(it) => it.name(db)?, - Definition::StructField(it) => it.name(db), + Definition::Field(it) => it.name(db), Definition::ModuleDef(def) => match def { hir::ModuleDef::Module(it) => it.name(db)?, hir::ModuleDef::Function(it) => it.name(db), @@ -124,8 +124,8 @@ fn classify_name_inner(sema: &Semantics, name: &ast::Name) -> Opti Some(Definition::Local(local)) }, ast::RecordFieldDef(it) => { - let field: hir::StructField = sema.to_def(&it)?; - Some(Definition::StructField(field)) + let field: hir::Field = sema.to_def(&it)?; + Some(Definition::Field(field)) }, ast::Module(it) => { let def = sema.to_def(&it)?; @@ -213,7 +213,7 @@ pub fn classify_name_ref( if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) { tested_by!(goto_def_for_fields; force); if let Some(field) = sema.resolve_field(&field_expr) { - return Some(NameRefClass::Definition(Definition::StructField(field))); + return Some(NameRefClass::Definition(Definition::Field(field))); } } @@ -221,7 +221,7 @@ pub fn classify_name_ref( tested_by!(goto_def_for_record_fields; force); tested_by!(goto_def_for_field_init_shorthand; force); if let Some((field, local)) = sema.resolve_record_field(&record_field) { - let field = Definition::StructField(field); + let field = Definition::Field(field); let res = match local { None => NameRefClass::Definition(field), Some(local) => NameRefClass::FieldShorthand { field, local }, @@ -233,7 +233,7 @@ pub fn classify_name_ref( if let Some(record_field_pat) = ast::RecordFieldPat::cast(parent.clone()) { tested_by!(goto_def_for_record_field_pats; force); if let Some(field) = sema.resolve_record_field_pat(&record_field_pat) { - let field = Definition::StructField(field); + let field = Definition::Field(field); return Some(NameRefClass::Definition(field)); } } diff --git a/crates/ra_ide_db/src/search.rs b/crates/ra_ide_db/src/search.rs index 596f957b8..b464959fc 100644 --- a/crates/ra_ide_db/src/search.rs +++ b/crates/ra_ide_db/src/search.rs @@ -28,8 +28,8 @@ pub struct Reference { #[derive(Debug, Clone, PartialEq)] pub enum ReferenceKind { - StructFieldShorthandForField, - StructFieldShorthandForLocal, + FieldShorthandForField, + FieldShorthandForLocal, StructLiteral, Other, } @@ -242,14 +242,14 @@ impl Definition { } Some(NameRefClass::FieldShorthand { local, field }) => { match self { - Definition::StructField(_) if &field == self => refs.push(Reference { + Definition::Field(_) if &field == self => refs.push(Reference { file_range: sema.original_range(name_ref.syntax()), - kind: ReferenceKind::StructFieldShorthandForField, + kind: ReferenceKind::FieldShorthandForField, access: reference_access(&field, &name_ref), }), Definition::Local(l) if &local == l => refs.push(Reference { file_range: sema.original_range(name_ref.syntax()), - kind: ReferenceKind::StructFieldShorthandForLocal, + kind: ReferenceKind::FieldShorthandForLocal, access: reference_access(&Definition::Local(local), &name_ref), }), @@ -267,7 +267,7 @@ impl Definition { fn reference_access(def: &Definition, name_ref: &ast::NameRef) -> Option { // Only Locals and Fields have accesses for now. match def { - Definition::Local(_) | Definition::StructField(_) => {} + Definition::Local(_) | Definition::Field(_) => {} _ => return None, }; -- cgit v1.2.3