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,
}
#[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)]
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()
}
}
}
-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;
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()
}
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()
}
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()
}
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),
}
}
- 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();
.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))
})
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum AttrDef {
Module(Module),
- StructField(StructField),
+ Field(Field),
Adt(Adt),
Function(Function),
EnumVariant(EnumVariant),
impl_froms!(
AttrDef: Module,
- StructField,
+ Field,
Adt(Struct, Enum, Union),
EnumVariant,
Static,
//! 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 {
}
}
-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 }
}
}
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()),
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;
}
}
-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);
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},
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)]
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)
}
// 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()
(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
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;
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(
},
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::{
};
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;
&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())
}
&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() {
&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())
&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()?;
&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()?;
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))
})
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!
#[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,
}
}
- 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 })
}
}
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>> {
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 {
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())),
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())),
};
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(),
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 {
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)
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,
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,
};
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();
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);
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum AttrDefId {
ModuleId(ModuleId),
- StructFieldId(StructFieldId),
+ FieldId(FieldId),
AdtId(AdtId),
FunctionId(FunctionId),
EnumVariantId(EnumVariantId),
impl_froms!(
AttrDefId: ModuleId,
- StructFieldId,
+ FieldId,
AdtId(StructId, EnumId, UnionId),
EnumVariantId,
StaticId,
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;
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;
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> {
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());
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());
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,
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) })
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,
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) })
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;
/// 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
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> {
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);
}
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;
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,
.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()
expr::{BindingAnnotation, Pat, PatId, RecordFieldPat},
path::Path,
type_ref::Mutability,
- StructFieldId,
+ FieldId,
};
use hir_expand::name::Name;
use test_utils::tested_by;
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);
}
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;
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()),
};
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);
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)),
}
}
-impl ToNav for hir::StructField {
+impl ToNav for hir::Field {
fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
let src = self.source(db);
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) {
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) => {
fn decl_access(def: &Definition, syntax: &SyntaxNode, range: TextRange) -> Option<ReferenceAccess> {
match def {
- Definition::Local(_) | Definition::StructField(_) => {}
+ Definition::Local(_) | Definition::Field(_) => {}
_ => return None,
};
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())
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,
// 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::{
#[derive(Debug, PartialEq, Eq)]
pub enum Definition {
Macro(MacroDef),
- StructField(StructField),
+ Field(Field),
ModuleDef(ModuleDef),
SelfType(ImplDef),
Local(Local),
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)),
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,
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),
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)?;
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)));
}
}
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 },
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));
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum ReferenceKind {
- StructFieldShorthandForField,
- StructFieldShorthandForLocal,
+ FieldShorthandForField,
+ FieldShorthandForLocal,
StructLiteral,
Other,
}
}
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),
}),
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,
};