27 files changed, 132 insertions, 148 deletions

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<StructField> {
+    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
         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<StructField> {
+    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
         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<StructField> {
+    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
         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<StructField> {
+    pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
         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<VariantDef> for VariantId {
     }
 }
 
-impl From<StructField> for StructFieldId {
-    fn from(def: StructField) -> Self {
-        StructFieldId { parent: def.parent.into(), local_id: def.id }
+impl From<Field> for FieldId {
+    fn from(def: Field) -> Self {
+        FieldId { parent: def.parent.into(), local_id: def.id }
     }
 }
 
-impl From<StructFieldId> for StructField {
-    fn from(def: StructFieldId) -> Self {
-        StructField { parent: def.parent.into(), id: def.local_id }
+impl From<FieldId> for Field {
+    fn from(def: FieldId) -> Self {
+        Field { parent: def.parent.into(), id: def.local_id }
     }
 }
 
@@ -200,7 +200,7 @@ impl From<AttrDef> 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<FieldSource> {
         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<StructField> {
+    pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<Field> {
         self.analyze(field.syntax()).resolve_field(self.db, field)
     }
 
-    pub fn resolve_record_field(
-        &self,
-        field: &ast::RecordField,
-    ) -> Option<(StructField, Option<Local>)> {
+    pub fn resolve_record_field(&self, field: &ast::RecordField) -> Option<(Field, Option<Local>)> {
         self.analyze(field.syntax()).resolve_record_field(self.db, field)
     }
 
-    pub fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option<StructField> {
+    pub fn resolve_record_field_pat(&self, field: &ast::RecordFieldPat) -> Option<Field> {
         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<ast::RecordFieldDef>,
-    ) -> Option<StructFieldId> {
+    ) -> Option<FieldId> {
         self.to_def(src, keys::RECORD_FIELD)
     }
     pub(super) fn tuple_field_to_def(
         &mut self,
         src: InFile<ast::TupleFieldDef>,
-    ) -> Option<StructFieldId> {
+    ) -> Option<FieldId> {
         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<StructField> {
+    ) -> Option<Field> {
         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<Local>)> {
+    ) -> Option<(Field, Option<Local>)> {
         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<StructField> {
+    ) -> Option<Field> {
         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<Vec<(StructField, Type)>> {
+    ) -> Option<Vec<(Field, Type)>> {
         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<Vec<(StructField, Type)>> {
+    ) -> Option<Vec<(Field, Type)>> {
         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<LocalStructFieldId>,
-    ) -> Vec<(StructField, Type)> {
+        missing_fields: Vec<LocalFieldId>,
+    ) -> 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<StructFieldData>),
-    Tuple(Arena<StructFieldData>),
+    Record(Arena<FieldData>),
+    Tuple(Arena<FieldData>),
     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<StructFieldData> {
-        const EMPTY: &Arena<StructFieldData> = &Arena::new();
+    pub fn fields(&self) -> &Arena<FieldData> {
+        const EMPTY: &Arena<FieldData> = &Arena::new();
         match &self {
             VariantData::Record(fields) | VariantData::Tuple(fields) => fields,
             _ => EMPTY,
         }
     }
 
-    pub fn field(&self, name: &Name) -> Option<LocalStructFieldId> {
+    pub fn field(&self, name: &Name) -> Option<LocalFieldId> {
         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<ast::TupleFieldDef, ast::RecordFieldDef>;
 
     fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
@@ -195,7 +195,7 @@ pub enum StructKind {
 fn lower_struct(
     db: &dyn DefDatabase,
     expander: &mut CfgExpander,
-    trace: &mut Trace<StructFieldData, Either<ast::TupleFieldDef, ast::RecordFieldDef>>,
+    trace: &mut Trace<FieldData, Either<ast::TupleFieldDef, ast::RecordFieldDef>>,
     ast: &InFile<ast::StructKind>,
 ) -> 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<ast::UnionDef, UnionId> = Key::new();
 pub const ENUM: Key<ast::EnumDef, EnumId> = Key::new();
 
 pub const ENUM_VARIANT: Key<ast::EnumVariant, EnumVariantId> = Key::new();
-pub const TUPLE_FIELD: Key<ast::TupleFieldDef, StructFieldId> = Key::new();
-pub const RECORD_FIELD: Key<ast::RecordFieldDef, StructFieldId> = Key::new();
+pub const TUPLE_FIELD: Key<ast::TupleFieldDef, FieldId> = Key::new();
+pub const RECORD_FIELD: Key<ast::RecordFieldDef, FieldId> = Key::new();
 pub const TYPE_PARAM: Key<ast::TypeParam, TypeParamId> = Key::new();
 
 pub const MACRO: Key<ast::MacroCall, MacroDefId> = 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<adt::EnumVariantData>;
 
 #[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<adt::StructFieldData>;
+pub type LocalFieldId = Idx<adt::FieldData>;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ConstId(salsa::InternId);
@@ -299,7 +299,7 @@ impl From<AssocItemId> 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<dyn DefDatabase> {
     fn impl_trait(&self, def: ImplId) -> Option<Binders<TraitRef>>;
 
     #[salsa::invoke(crate::lower::field_types_query)]
-    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalStructFieldId, Binders<Ty>>>;
+    fn field_types(&self, var: VariantId) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>>;
 
     #[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<LocalStructFieldId>,
+        missed_fields: Vec<LocalFieldId>,
     ) {
         // 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<LocalStructFieldId>,
+        missed_fields: Vec<LocalFieldId>,
     ) {
         // 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<LocalStructFieldId>, /*exhaustive*/ bool)> {
+) -> Option<(VariantId, Vec<LocalFieldId>, /*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<LocalStructFieldId> = variant_data
+    let missed_fields: Vec<LocalFieldId> = 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<LocalStructFieldId>, /*exhaustive*/ bool)> {
+) -> Option<(VariantId, Vec<LocalFieldId>, /*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<LocalStructFieldId> = variant_data
+    let missed_fields: Vec<LocalFieldId> = 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<ExprId, FunctionId>,
     /// For each field access expr, records the field it resolves to.
-    field_resolutions: FxHashMap<ExprId, StructFieldId>,
+    field_resolutions: FxHashMap<ExprId, FieldId>,
     /// For each field in record literal, records the field it resolves to.
-    record_field_resolutions: FxHashMap<ExprId, StructFieldId>,
-    record_field_pat_resolutions: FxHashMap<PatId, StructFieldId>,
+    record_field_resolutions: FxHashMap<ExprId, FieldId>,
+    record_field_pat_resolutions: FxHashMap<PatId, FieldId>,
     /// For each struct literal, records the variant it resolves to.
     variant_resolutions: FxHashMap<ExprOrPatId, VariantId>,
     /// For each associated item record what it resolves to
@@ -142,13 +142,13 @@ impl InferenceResult {
     pub fn method_resolution(&self, expr: ExprId) -> Option<FunctionId> {
         self.method_resolutions.get(&expr).copied()
     }
-    pub fn field_resolution(&self, expr: ExprId) -> Option<StructFieldId> {
+    pub fn field_resolution(&self, expr: ExprId) -> Option<FieldId> {
         self.field_resolutions.get(&expr).copied()
     }
-    pub fn record_field_resolution(&self, expr: ExprId) -> Option<StructFieldId> {
+    pub fn record_field_resolution(&self, expr: ExprId) -> Option<FieldId> {
         self.record_field_resolutions.get(&expr).copied()
     }
-    pub fn record_field_pat_resolution(&self, pat: PatId) -> Option<StructFieldId> {
+    pub fn record_field_pat_resolution(&self, pat: PatId) -> Option<FieldId> {
         self.record_field_pat_resolutions.get(&pat).copied()
     }
     pub fn variant_resolution_for_expr(&self, id: ExprId) -> Option<VariantId> {
@@ -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<ArenaMap<LocalStructFieldId, Binders<Ty>>> {
+) -> Arc<ArenaMap<LocalFieldId, Binders<Ty>>> {
     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<NavigationTarget> {
         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<String> {
     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<Strin
             let src = it.source(db);
             hover_text(src.value.doc_comment_text(), Some(macro_label(&src.value)), mod_path)
         }
-        Definition::StructField(it) => {
+        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<ReferenceAccess> {
     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<Module> {
         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<Name> {
         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<RootDatabase>, 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<ReferenceAccess> {
     // Only Locals and Fields have accesses for now.
     match def {
-        Definition::Local(_) | Definition::StructField(_) => {}
+        Definition::Local(_) | Definition::Field(_) => {}
         _ => return None,
     };