use test_utils::tested_by;
use crate::{
- adt::StructKind,
+ adt::{self, StructKind},
body::{Body, BodySourceMap, Expander, PatPtr, SyntheticSyntax},
builtin_type::{BuiltinFloat, BuiltinInt},
db::DefDatabase,
self.body.item_scope.define_def(def);
if let Some(name) = name {
let vis = crate::visibility::Visibility::Public; // FIXME determine correctly
- self.body
- .item_scope
- .push_res(name.as_name(), crate::per_ns::PerNs::from_def(def, vis));
+ let favor_types = match def {
+ ModuleDefId::AdtId(AdtId::StructId(s)) => {
+ self.db.struct_data(s).variant_data.kind() == adt::StructKind::Record
+ }
+ _ => false,
+ };
+ self.body.item_scope.push_res(
+ name.as_name(),
+ crate::per_ns::PerNs::from_def(def, vis, favor_types),
+ );
}
}
}
}
impl PerNs {
- pub(crate) fn from_def(def: ModuleDefId, v: Visibility) -> PerNs {
+ pub(crate) fn from_def(def: ModuleDefId, v: Visibility, favor_types: bool) -> PerNs {
match def {
ModuleDefId::ModuleId(_) => PerNs::types(def, v),
ModuleDefId::FunctionId(_) => PerNs::values(def, v),
ModuleDefId::AdtId(adt) => match adt {
- AdtId::StructId(_) | AdtId::UnionId(_) => PerNs::both(def, def, v),
+ AdtId::UnionId(_) => PerNs::both(def, def, v),
AdtId::EnumId(_) => PerNs::types(def, v),
+ AdtId::StructId(_) => {
+ if favor_types {
+ PerNs::types(def, v)
+ } else {
+ PerNs::both(def, def, v)
+ }
+ }
},
ModuleDefId::EnumVariantId(_) => PerNs::both(def, def, v),
ModuleDefId::ConstId(_) | ModuleDefId::StaticId(_) => PerNs::values(def, v),
let module = ModuleId { krate: self.def_collector.def_map.krate, local_id: res };
let def: ModuleDefId = module.into();
self.def_collector.def_map.modules[self.module_id].scope.define_def(def);
- self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis))], vis);
+ self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis, false))], vis);
res
}
let name = def.name.clone();
let container = ContainerId::ModuleId(module);
let vis = &def.visibility;
+ let mut favor_types = false;
+
let def: ModuleDefId = match def.kind {
raw::DefKind::Function(ast_id) => FunctionLoc {
container: container.into(),
}
.intern(self.def_collector.db)
.into(),
- raw::DefKind::Struct(ast_id) => {
+ raw::DefKind::Struct(ast_id, mode) => {
+ favor_types = mode == raw::StructDefKind::Record;
StructLoc { container, ast_id: AstId::new(self.file_id, ast_id) }
.intern(self.def_collector.db)
.into()
.def_map
.resolve_visibility(self.def_collector.db, self.module_id, vis)
.unwrap_or(Visibility::Public);
- self.def_collector.update(self.module_id, &[(name, PerNs::from_def(def, vis))], vis)
+ self.def_collector.update(
+ self.module_id,
+ &[(name, PerNs::from_def(def, vis, favor_types))],
+ vis,
+ )
}
fn collect_derives(&mut self, attrs: &Attrs, def: &raw::DefData) {
pub(super) visibility: RawVisibility,
}
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub(super) enum StructDefKind {
+ Record,
+ Tuple,
+ Unit,
+}
+
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub(super) enum DefKind {
Function(FileAstId<ast::FnDef>),
- Struct(FileAstId<ast::StructDef>),
+ Struct(FileAstId<ast::StructDef>, StructDefKind),
Union(FileAstId<ast::UnionDef>),
Enum(FileAstId<ast::EnumDef>),
Const(FileAstId<ast::ConstDef>),
pub fn ast_id(&self) -> FileAstId<ast::ModuleItem> {
match self {
DefKind::Function(it) => it.upcast(),
- DefKind::Struct(it) => it.upcast(),
+ DefKind::Struct(it, _) => it.upcast(),
DefKind::Union(it) => it.upcast(),
DefKind::Enum(it) => it.upcast(),
DefKind::Const(it) => it.upcast(),
return;
}
ast::ModuleItem::StructDef(it) => {
+ let kind = match it.kind() {
+ ast::StructKind::Record(_) => StructDefKind::Record,
+ ast::StructKind::Tuple(_) => StructDefKind::Tuple,
+ ast::StructKind::Unit => StructDefKind::Unit,
+ };
let id = self.source_ast_id_map.ast_id(&it);
let name = it.name();
- (DefKind::Struct(id), name)
+ (DefKind::Struct(id, kind), name)
}
ast::ModuleItem::UnionDef(it) => {
let id = self.source_ast_id_map.ast_id(&it);