mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge #6030

Browse Source 
6030: Small proc macro cleanup r=jonas-schievink a=jonas-schievink

git got really confused, but all I did in the first commit was unindent a few lines

Co-authored-by: Jonas Schievink <jonas.schievink@ferrous-systems.com>
This commit is contained in:
bors[bot] 2020-09-18 13:40:45 +00:00 committed by GitHub
commit 5e1500ec74
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 167 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
crates/hir/src/code_model.rs
View File

@ -908,12 +908,12 @@ pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
/// Indicate it is a proc-macro
pub fn is_proc_macro(&self) -> bool {
matches!(self.id.kind, MacroDefKind::CustomDerive(_))
matches!(self.id.kind, MacroDefKind::ProcMacro(_))
}
/// Indicate it is a derive macro
pub fn is_derive_macro(&self) -> bool {
matches!(self.id.kind, MacroDefKind::CustomDerive(_) | MacroDefKind::BuiltInDerive(_))
matches!(self.id.kind, MacroDefKind::ProcMacro(_) | MacroDefKind::BuiltInDerive(_))
}
}

321
crates/hir_def/src/nameres/collector.rs
View File

@ -273,7 +273,7 @@ fn collect_proc_macro(&mut self) {
let macro_id = MacroDefId {
ast_id: None,
krate: Some(krate),
kind: MacroDefKind::CustomDerive(expander),
kind: MacroDefKind::ProcMacro(expander),
local_inner: false,
};
@ -874,184 +874,183 @@ fn collect(&mut self, items: &[ModItem]) {
for &item in items {
let attrs = self.item_tree.attrs(item.into());
if self.is_cfg_enabled(attrs) {
let module =
ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
let container = ContainerId::ModuleId(module);
if !self.is_cfg_enabled(attrs) {
continue;
}
let module =
ModuleId { krate: self.def_collector.def_map.krate, local_id: self.module_id };
let container = ContainerId::ModuleId(module);
let mut def = None;
match item {
ModItem::Mod(m) => self.collect_module(&self.item_tree[m], attrs),
ModItem::Import(import_id) => {
self.def_collector.unresolved_imports.push(ImportDirective {
module_id: self.module_id,
import: Import::from_use(
&self.item_tree,
InFile::new(self.file_id, import_id),
),
status: PartialResolvedImport::Unresolved,
})
}
ModItem::ExternCrate(import_id) => {
self.def_collector.unresolved_imports.push(ImportDirective {
module_id: self.module_id,
import: Import::from_extern_crate(
&self.item_tree,
InFile::new(self.file_id, import_id),
),
status: PartialResolvedImport::Unresolved,
})
}
ModItem::MacroCall(mac) => self.collect_macro(&self.item_tree[mac]),
ModItem::Impl(imp) => {
let module = ModuleId {
krate: self.def_collector.def_map.krate,
local_id: self.module_id,
};
let container = ContainerId::ModuleId(module);
let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
.intern(self.def_collector.db);
self.def_collector.def_map.modules[self.module_id]
.scope
.define_impl(impl_id)
}
ModItem::Function(id) => {
let func = &self.item_tree[id];
def = Some(DefData {
id: FunctionLoc {
container: container.into(),
id: ItemTreeId::new(self.file_id, id),
}
.intern(self.def_collector.db)
.into(),
name: &func.name,
visibility: &self.item_tree[func.visibility],
has_constructor: false,
});
}
ModItem::Struct(id) => {
let it = &self.item_tree[id];
// FIXME: check attrs to see if this is an attribute macro invocation;
// in which case we don't add the invocation, just a single attribute
// macro invocation
self.collect_derives(attrs, it.ast_id.upcast());
def = Some(DefData {
id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: it.kind != StructDefKind::Record,
});
}
ModItem::Union(id) => {
let it = &self.item_tree[id];
// FIXME: check attrs to see if this is an attribute macro invocation;
// in which case we don't add the invocation, just a single attribute
// macro invocation
self.collect_derives(attrs, it.ast_id.upcast());
def = Some(DefData {
id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
}
ModItem::Enum(id) => {
let it = &self.item_tree[id];
// FIXME: check attrs to see if this is an attribute macro invocation;
// in which case we don't add the invocation, just a single attribute
// macro invocation
self.collect_derives(attrs, it.ast_id.upcast());
def = Some(DefData {
id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
}
ModItem::Const(id) => {
let it = &self.item_tree[id];
if let Some(name) = &it.name {
def = Some(DefData {
id: ConstLoc {
container: container.into(),
id: ItemTreeId::new(self.file_id, id),
}
.intern(self.def_collector.db)
.into(),
name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
let mut def = None;
match item {
ModItem::Mod(m) => self.collect_module(&self.item_tree[m], attrs),
ModItem::Import(import_id) => {
self.def_collector.unresolved_imports.push(ImportDirective {
module_id: self.module_id,
import: Import::from_use(
&self.item_tree,
InFile::new(self.file_id, import_id),
),
status: PartialResolvedImport::Unresolved,
})
}
ModItem::ExternCrate(import_id) => {
self.def_collector.unresolved_imports.push(ImportDirective {
module_id: self.module_id,
import: Import::from_extern_crate(
&self.item_tree,
InFile::new(self.file_id, import_id),
),
status: PartialResolvedImport::Unresolved,
})
}
ModItem::MacroCall(mac) => self.collect_macro(&self.item_tree[mac]),
ModItem::Impl(imp) => {
let module = ModuleId {
krate: self.def_collector.def_map.krate,
local_id: self.module_id,
};
let container = ContainerId::ModuleId(module);
let impl_id = ImplLoc { container, id: ItemTreeId::new(self.file_id, imp) }
.intern(self.def_collector.db);
self.def_collector.def_map.modules[self.module_id].scope.define_impl(impl_id)
}
ModItem::Function(id) => {
let func = &self.item_tree[id];
def = Some(DefData {
id: FunctionLoc {
container: container.into(),
id: ItemTreeId::new(self.file_id, id),
}
}
ModItem::Static(id) => {
let it = &self.item_tree[id];
.intern(self.def_collector.db)
.into(),
name: &func.name,
visibility: &self.item_tree[func.visibility],
has_constructor: false,
});
}
ModItem::Struct(id) => {
let it = &self.item_tree[id];
def = Some(DefData {
id: StaticLoc { container, id: ItemTreeId::new(self.file_id, id) }
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
}
ModItem::Trait(id) => {
let it = &self.item_tree[id];
// FIXME: check attrs to see if this is an attribute macro invocation;
// in which case we don't add the invocation, just a single attribute
// macro invocation
self.collect_derives(attrs, it.ast_id.upcast());
def = Some(DefData {
id: TraitLoc { container, id: ItemTreeId::new(self.file_id, id) }
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
}
ModItem::TypeAlias(id) => {
let it = &self.item_tree[id];
def = Some(DefData {
id: StructLoc { container, id: ItemTreeId::new(self.file_id, id) }
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: it.kind != StructDefKind::Record,
});
}
ModItem::Union(id) => {
let it = &self.item_tree[id];
// FIXME: check attrs to see if this is an attribute macro invocation;
// in which case we don't add the invocation, just a single attribute
// macro invocation
self.collect_derives(attrs, it.ast_id.upcast());
def = Some(DefData {
id: UnionLoc { container, id: ItemTreeId::new(self.file_id, id) }
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
}
ModItem::Enum(id) => {
let it = &self.item_tree[id];
// FIXME: check attrs to see if this is an attribute macro invocation;
// in which case we don't add the invocation, just a single attribute
// macro invocation
self.collect_derives(attrs, it.ast_id.upcast());
def = Some(DefData {
id: EnumLoc { container, id: ItemTreeId::new(self.file_id, id) }
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
}
ModItem::Const(id) => {
let it = &self.item_tree[id];
if let Some(name) = &it.name {
def = Some(DefData {
id: TypeAliasLoc {
id: ConstLoc {
container: container.into(),
id: ItemTreeId::new(self.file_id, id),
}
.intern(self.def_collector.db)
.into(),
name: &it.name,
name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
}
}
ModItem::Static(id) => {
let it = &self.item_tree[id];
if let Some(DefData { id, name, visibility, has_constructor }) = def {
self.def_collector.def_map.modules[self.module_id].scope.define_def(id);
let vis = self
.def_collector
.def_map
.resolve_visibility(self.def_collector.db, self.module_id, visibility)
.unwrap_or(Visibility::Public);
self.def_collector.update(
self.module_id,
&[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor))],
vis,
ImportType::Named,
)
def = Some(DefData {
id: StaticLoc { container, id: ItemTreeId::new(self.file_id, id) }
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
}
ModItem::Trait(id) => {
let it = &self.item_tree[id];
def = Some(DefData {
id: TraitLoc { container, id: ItemTreeId::new(self.file_id, id) }
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
}
ModItem::TypeAlias(id) => {
let it = &self.item_tree[id];
def = Some(DefData {
id: TypeAliasLoc {
container: container.into(),
id: ItemTreeId::new(self.file_id, id),
}
.intern(self.def_collector.db)
.into(),
name: &it.name,
visibility: &self.item_tree[it.visibility],
has_constructor: false,
});
}
}
if let Some(DefData { id, name, visibility, has_constructor }) = def {
self.def_collector.def_map.modules[self.module_id].scope.define_def(id);
let vis = self
.def_collector
.def_map
.resolve_visibility(self.def_collector.db, self.module_id, visibility)
.unwrap_or(Visibility::Public);
self.def_collector.update(
self.module_id,
&[(Some(name.clone()), PerNs::from_def(id, vis, has_constructor))],
vis,
ImportType::Named,
)
}
}
}

4
crates/hir_expand/src/db.rs
View File

@ -143,7 +143,7 @@ pub(crate) fn macro_def(
Some(Arc::new((TokenExpander::BuiltinDerive(expander), mbe::TokenMap::default())))
}
MacroDefKind::BuiltInEager(_) => None,
MacroDefKind::CustomDerive(expander) => {
MacroDefKind::ProcMacro(expander) => {
Some(Arc::new((TokenExpander::ProcMacro(expander), mbe::TokenMap::default())))
}
}
@ -249,7 +249,7 @@ pub(crate) fn expand_proc_macro(
};
let expander = match loc.def.kind {
MacroDefKind::CustomDerive(expander) => expander,
MacroDefKind::ProcMacro(expander) => expander,
_ => unreachable!(),
};

2
crates/hir_expand/src/eager.rs
View File

@ -129,7 +129,7 @@ fn eager_macro_recur(
MacroDefKind::Declarative
| MacroDefKind::BuiltIn(_)
| MacroDefKind::BuiltInDerive(_)
| MacroDefKind::CustomDerive(_) => {
| MacroDefKind::ProcMacro(_) => {
let expanded = lazy_expand(db, &def, curr.with_value(child.clone()), krate)?;
// replace macro inside
eager_macro_recur(db, expanded, krate, macro_resolver)?

2
crates/hir_expand/src/hygiene.rs
View File

@ -33,7 +33,7 @@ pub fn new(db: &dyn AstDatabase, file_id: HirFileId) -> Hygiene {
MacroDefKind::BuiltIn(_) => (None, false),
MacroDefKind::BuiltInDerive(_) => (None, false),
MacroDefKind::BuiltInEager(_) => (None, false),
MacroDefKind::CustomDerive(_) => (None, false),
MacroDefKind::ProcMacro(_) => (None, false),
}
}
MacroCallId::EagerMacro(_id) => (None, false),

2
crates/hir_expand/src/lib.rs
View File

@ -246,7 +246,7 @@ pub enum MacroDefKind {
// FIXME: maybe just Builtin and rename BuiltinFnLikeExpander to BuiltinExpander
BuiltInDerive(BuiltinDeriveExpander),
BuiltInEager(EagerExpander),
CustomDerive(ProcMacroExpander),
ProcMacro(ProcMacroExpander),
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]