language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-01 14:21:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Invert condition to unindent code

Browse source
This commit is contained in:
Jonas Schievink 2020-09-18 12:32:07 +02:00
parent 086f1c4b30
commit 700a3d5d75
1 changed files with 159 additions and 160 deletions
Download patch file Download diff file Expand all files Collapse all files

319
crates/hir_def/src/nameres/collector.rs
View file

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