//! This module contains the implementation details of the HIR for ADTs, i.e. //! structs and enums (and unions). use std::sync::Arc; use ra_syntax::{ SyntaxNode, ast::{self, NameOwner, StructFlavor, AstNode} }; use crate::{ DefId, DefLoc, Name, AsName, Struct, Enum, EnumVariant, Module, HirFileId, HirDatabase, DefKind, SourceItemId, type_ref::TypeRef, ids::ItemLoc, }; impl Struct { pub(crate) fn from_ast( db: &impl HirDatabase, module: Module, file_id: HirFileId, ast: &ast::StructDef, ) -> Struct { let loc = ItemLoc::from_ast(db, module, file_id, ast); let id = db.as_ref().structs.loc2id(&loc); Struct { id } } pub(crate) fn variant_data(&self, db: &impl HirDatabase) -> Arc { db.struct_data((*self).into()).variant_data.clone() } } impl Enum { pub(crate) fn from_ast( db: &impl HirDatabase, module: Module, file_id: HirFileId, ast: &ast::EnumDef, ) -> Enum { let loc = ItemLoc::from_ast(db, module, file_id, ast); let id = db.as_ref().enums.loc2id(&loc); Enum { id } } } #[derive(Debug, Clone, PartialEq, Eq)] pub struct StructData { pub(crate) name: Option, pub(crate) variant_data: Arc, } impl StructData { fn new(struct_def: &ast::StructDef) -> StructData { let name = struct_def.name().map(|n| n.as_name()); let variant_data = VariantData::new(struct_def.flavor()); let variant_data = Arc::new(variant_data); StructData { name, variant_data } } pub(crate) fn struct_data_query(db: &impl HirDatabase, struct_: Struct) -> Arc { let (_, struct_def) = struct_.source(db); Arc::new(StructData::new(&*struct_def)) } } fn get_def_id( db: &impl HirDatabase, module: Module, file_id: HirFileId, node: &SyntaxNode, expected_kind: DefKind, ) -> DefId { let file_items = db.file_items(file_id); let item_id = file_items.id_of(file_id, node); let source_item_id = SourceItemId { file_id, item_id: Some(item_id), }; let loc = DefLoc { module, kind: expected_kind, source_item_id, }; loc.id(db) } #[derive(Debug, Clone, PartialEq, Eq)] pub struct EnumData { pub(crate) name: Option, pub(crate) variants: Vec<(Name, EnumVariant)>, } impl EnumData { fn new(enum_def: &ast::EnumDef, variants: Vec<(Name, EnumVariant)>) -> Self { let name = enum_def.name().map(|n| n.as_name()); EnumData { name, variants } } pub(crate) fn enum_data_query(db: &impl HirDatabase, e: Enum) -> Arc { let (file_id, enum_def) = e.source(db); let module = e.module(db); let variants = if let Some(vl) = enum_def.variant_list() { vl.variants() .filter_map(|variant_def| { let name = variant_def.name().map(|n| n.as_name()); name.map(|n| { let def_id = get_def_id( db, module, file_id, variant_def.syntax(), DefKind::EnumVariant, ); (n, EnumVariant::new(def_id)) }) }) .collect() } else { Vec::new() }; Arc::new(EnumData::new(&*enum_def, variants)) } } #[derive(Debug, Clone, PartialEq, Eq)] pub struct EnumVariantData { pub(crate) name: Option, pub(crate) variant_data: Arc, pub(crate) parent_enum: Enum, } impl EnumVariantData { fn new(variant_def: &ast::EnumVariant, parent_enum: Enum) -> EnumVariantData { let name = variant_def.name().map(|n| n.as_name()); let variant_data = VariantData::new(variant_def.flavor()); let variant_data = Arc::new(variant_data); EnumVariantData { name, variant_data, parent_enum, } } pub(crate) fn enum_variant_data_query( db: &impl HirDatabase, def_id: DefId, ) -> Arc { let def_loc = def_id.loc(db); assert!(def_loc.kind == DefKind::EnumVariant); let syntax = db.file_item(def_loc.source_item_id); let variant_def = ast::EnumVariant::cast(&syntax) .expect("enum variant def should point to EnumVariant node"); let enum_def = variant_def.parent_enum(); let e = Enum::from_ast(db, def_loc.module, def_loc.source_item_id.file_id, enum_def); Arc::new(EnumVariantData::new(variant_def, e)) } } /// A single field of an enum variant or struct #[derive(Debug, Clone, PartialEq, Eq)] pub struct StructField { pub(crate) name: Name, pub(crate) type_ref: TypeRef, } /// Fields of an enum variant or struct #[derive(Debug, Clone, PartialEq, Eq)] pub enum VariantData { Struct(Vec), Tuple(Vec), Unit, } impl VariantData { pub fn fields(&self) -> &[StructField] { match self { VariantData::Struct(fields) | VariantData::Tuple(fields) => fields, _ => &[], } } pub fn is_struct(&self) -> bool { match self { VariantData::Struct(..) => true, _ => false, } } pub fn is_tuple(&self) -> bool { match self { VariantData::Tuple(..) => true, _ => false, } } pub fn is_unit(&self) -> bool { match self { VariantData::Unit => true, _ => false, } } } impl VariantData { fn new(flavor: StructFlavor) -> Self { match flavor { StructFlavor::Tuple(fl) => { let fields = fl .fields() .enumerate() .map(|(i, fd)| StructField { name: Name::tuple_field_name(i), type_ref: TypeRef::from_ast_opt(fd.type_ref()), }) .collect(); VariantData::Tuple(fields) } StructFlavor::Named(fl) => { let fields = fl .fields() .map(|fd| StructField { name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing), type_ref: TypeRef::from_ast_opt(fd.type_ref()), }) .collect(); VariantData::Struct(fields) } StructFlavor::Unit => VariantData::Unit, } } pub(crate) fn get_field_type_ref(&self, field_name: &Name) -> Option<&TypeRef> { self.fields() .iter() .find(|f| f.name == *field_name) .map(|f| &f.type_ref) } }