language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-11-03 21:25:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Merge pull request #20376 from fee1-dead/traitalias

Browse source 
Merge Trait and TraitAlias handling
This commit is contained in:
Lukas Wirth 2025-08-13 08:27:54 +00:00 • committed by GitHub
commit ac9d0f8049
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
78 changed files with 102 additions and 591 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/hir-def/src/attr.rs
View file

@ -554,7 +554,6 @@ impl AttrsWithOwner {
AdtId::UnionId(it) => attrs_from_ast_id_loc(db, it),
},
AttrDefId::TraitId(it) => attrs_from_ast_id_loc(db, it),
AttrDefId::TraitAliasId(it) => attrs_from_ast_id_loc(db, it),
AttrDefId::MacroId(it) => match it {
MacroId::Macro2Id(it) => attrs_from_ast_id_loc(db, it),
MacroId::MacroRulesId(it) => attrs_from_ast_id_loc(db, it),
@ -659,7 +658,6 @@ impl AttrsWithOwner {
AttrDefId::StaticId(id) => any_has_attrs(db, id),
AttrDefId::ConstId(id) => any_has_attrs(db, id),
AttrDefId::TraitId(id) => any_has_attrs(db, id),
AttrDefId::TraitAliasId(id) => any_has_attrs(db, id),
AttrDefId::TypeAliasId(id) => any_has_attrs(db, id),
AttrDefId::MacroId(id) => match id {
MacroId::Macro2Id(id) => any_has_attrs(db, id),

20
crates/hir-def/src/db.rs
View file

@ -15,8 +15,8 @@ use crate::{
EnumVariantId, EnumVariantLoc, ExternBlockId, ExternBlockLoc, ExternCrateId, ExternCrateLoc,
FunctionId, FunctionLoc, GenericDefId, ImplId, ImplLoc, LocalFieldId, Macro2Id, Macro2Loc,
MacroExpander, MacroId, MacroRulesId, MacroRulesLoc, MacroRulesLocFlags, ProcMacroId,
ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc, TraitAliasId, TraitAliasLoc, TraitId,
TraitLoc, TypeAliasId, TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
ProcMacroLoc, StaticId, StaticLoc, StructId, StructLoc, TraitId, TraitLoc, TypeAliasId,
TypeAliasLoc, UnionId, UnionLoc, UseId, UseLoc, VariantId,
attr::{Attrs, AttrsWithOwner},
expr_store::{
Body, BodySourceMap, ExpressionStore, ExpressionStoreSourceMap, scope::ExprScopes,
@ -28,7 +28,7 @@ use crate::{
nameres::crate_def_map,
signatures::{
ConstSignature, EnumSignature, FunctionSignature, ImplSignature, StaticSignature,
StructSignature, TraitAliasSignature, TraitSignature, TypeAliasSignature, UnionSignature,
StructSignature, TraitSignature, TypeAliasSignature, UnionSignature,
},
tt,
visibility::{self, Visibility},
@ -69,9 +69,6 @@ pub trait InternDatabase: RootQueryDb {
#[salsa::interned]
fn intern_trait(&self, loc: TraitLoc) -> TraitId;
#[salsa::interned]
fn intern_trait_alias(&self, loc: TraitAliasLoc) -> TraitAliasId;
#[salsa::interned]
fn intern_type_alias(&self, loc: TypeAliasLoc) -> TypeAliasId;
@ -152,11 +149,6 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
self.function_signature_with_source_map(e).0
}
#[salsa::tracked]
fn trait_alias_signature(&self, e: TraitAliasId) -> Arc<TraitAliasSignature> {
self.trait_alias_signature_with_source_map(e).0
}
#[salsa::tracked]
fn type_alias_signature(&self, e: TypeAliasId) -> Arc<TypeAliasSignature> {
self.type_alias_signature_with_source_map(e).0
@ -210,12 +202,6 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
e: FunctionId,
) -> (Arc<FunctionSignature>, Arc<ExpressionStoreSourceMap>);
#[salsa::invoke(TraitAliasSignature::query)]
fn trait_alias_signature_with_source_map(
&self,
e: TraitAliasId,
) -> (Arc<TraitAliasSignature>, Arc<ExpressionStoreSourceMap>);
#[salsa::invoke(TypeAliasSignature::query)]
fn type_alias_signature_with_source_map(
&self,

5
crates/hir-def/src/dyn_map.rs
View file

@ -33,8 +33,8 @@ pub mod keys {
use crate::{
BlockId, ConstId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId, FieldId, FunctionId,
ImplId, LifetimeParamId, Macro2Id, MacroRulesId, ProcMacroId, StaticId, StructId,
TraitAliasId, TraitId, TypeAliasId, TypeOrConstParamId, UnionId, UseId,
ImplId, LifetimeParamId, Macro2Id, MacroRulesId, ProcMacroId, StaticId, StructId, TraitId,
TypeAliasId, TypeOrConstParamId, UnionId, UseId,
dyn_map::{DynMap, Policy},
};
@ -48,7 +48,6 @@ pub mod keys {
pub const IMPL: Key<ast::Impl, ImplId> = Key::new();
pub const EXTERN_BLOCK: Key<ast::ExternBlock, ExternBlockId> = Key::new();
pub const TRAIT: Key<ast::Trait, TraitId> = Key::new();
pub const TRAIT_ALIAS: Key<ast::TraitAlias, TraitAliasId> = Key::new();
pub const STRUCT: Key<ast::Struct, StructId> = Key::new();
pub const UNION: Key<ast::Union, UnionId> = Key::new();
pub const ENUM: Key<ast::Enum, EnumId> = Key::new();

24
crates/hir-def/src/expr_store/lower.rs
View file

@ -33,7 +33,7 @@ use tt::TextRange;
use crate::{
AdtId, BlockId, BlockLoc, DefWithBodyId, FunctionId, GenericDefId, ImplId, MacroId,
ModuleDefId, ModuleId, TraitAliasId, TraitId, TypeAliasId, UnresolvedMacro,
ModuleDefId, ModuleId, TraitId, TypeAliasId, UnresolvedMacro,
builtin_type::BuiltinUint,
db::DefDatabase,
expr_store::{
@ -252,28 +252,6 @@ pub(crate) fn lower_trait(
(store, source_map, params)
}
pub(crate) fn lower_trait_alias(
db: &dyn DefDatabase,
module: ModuleId,
trait_syntax: InFile<ast::TraitAlias>,
trait_id: TraitAliasId,
) -> (ExpressionStore, ExpressionStoreSourceMap, Arc<GenericParams>) {
let mut expr_collector = ExprCollector::new(db, module, trait_syntax.file_id);
let mut collector = generics::GenericParamsCollector::with_self_param(
&mut expr_collector,
trait_id.into(),
trait_syntax.value.type_bound_list(),
);
collector.lower(
&mut expr_collector,
trait_syntax.value.generic_param_list(),
trait_syntax.value.where_clause(),
);
let params = collector.finish();
let (store, source_map) = expr_collector.store.finish();
(store, source_map, params)
}
pub(crate) fn lower_type_alias(
db: &dyn DefDatabase,
module: ModuleId,

1
crates/hir-def/src/expr_store/pretty.rs
View file

@ -183,7 +183,6 @@ pub fn print_signature(db: &dyn DefDatabase, owner: GenericDefId, edition: Editi
}
GenericDefId::ImplId(id) => format!("unimplemented {id:?}"),
GenericDefId::StaticId(id) => format!("unimplemented {id:?}"),
GenericDefId::TraitAliasId(id) => format!("unimplemented {id:?}"),
GenericDefId::TraitId(id) => format!("unimplemented {id:?}"),
GenericDefId::TypeAliasId(id) => format!("unimplemented {id:?}"),
}

2
crates/hir-def/src/expr_store/tests/signatures.rs
View file

@ -24,7 +24,6 @@ fn lower_and_print(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expe
ModuleDefId::ConstId(id) => id.into(),
ModuleDefId::StaticId(id) => id.into(),
ModuleDefId::TraitId(id) => id.into(),
ModuleDefId::TraitAliasId(id) => id.into(),
ModuleDefId::TypeAliasId(id) => id.into(),
ModuleDefId::EnumVariantId(_) => continue,
ModuleDefId::BuiltinType(_) => continue,
@ -51,7 +50,6 @@ fn lower_and_print(#[rust_analyzer::rust_fixture] ra_fixture: &str, expect: Expe
GenericDefId::ImplId(_id) => (),
GenericDefId::StaticId(_id) => (),
GenericDefId::TraitAliasId(_id) => (),
GenericDefId::TraitId(_id) => (),
GenericDefId::TypeAliasId(_id) => (),
}

11
crates/hir-def/src/hir/generics.rs
View file

@ -203,9 +203,6 @@ impl GenericParams {
}
GenericDefId::ImplId(impl_id) => db.impl_signature(impl_id).generic_params.clone(),
GenericDefId::StaticId(_) => EMPTY.clone(),
GenericDefId::TraitAliasId(trait_alias_id) => {
db.trait_alias_signature(trait_alias_id).generic_params.clone()
}
GenericDefId::TraitId(trait_id) => db.trait_signature(trait_id).generic_params.clone(),
GenericDefId::TypeAliasId(type_alias_id) => {
db.type_alias_signature(type_alias_id).generic_params.clone()
@ -246,10 +243,6 @@ impl GenericParams {
let sig = db.static_signature(id);
(EMPTY.clone(), sig.store.clone())
}
GenericDefId::TraitAliasId(id) => {
let sig = db.trait_alias_signature(id);
(sig.generic_params.clone(), sig.store.clone())
}
GenericDefId::TraitId(id) => {
let sig = db.trait_signature(id);
(sig.generic_params.clone(), sig.store.clone())
@ -294,10 +287,6 @@ impl GenericParams {
let (sig, sm) = db.static_signature_with_source_map(id);
(EMPTY.clone(), sig.store.clone(), sm)
}
GenericDefId::TraitAliasId(id) => {
let (sig, sm) = db.trait_alias_signature_with_source_map(id);
(sig.generic_params.clone(), sig.store.clone(), sm)
}
GenericDefId::TraitId(id) => {
let (sig, sm) = db.trait_signature_with_source_map(id);
(sig.generic_params.clone(), sig.store.clone(), sm)

1
crates/hir-def/src/item_scope.rs
View file

@ -872,7 +872,6 @@ impl PerNs {
PerNs::values(def, v, import.and_then(ImportOrExternCrate::import_or_glob))
}
ModuleDefId::TraitId(_) => PerNs::types(def, v, import),
ModuleDefId::TraitAliasId(_) => PerNs::types(def, v, import),
ModuleDefId::TypeAliasId(_) => PerNs::types(def, v, import),
ModuleDefId::BuiltinType(_) => PerNs::types(def, v, import),
ModuleDefId::MacroId(mac) => PerNs::macros(mac, v, import),

8
crates/hir-def/src/item_tree.rs
View file

@ -276,7 +276,6 @@ enum SmallModItem {
Static(Static),
Struct(Struct),
Trait(Trait),
TraitAlias(TraitAlias),
TypeAlias(TypeAlias),
Union(Union),
}
@ -404,7 +403,6 @@ ModItemId ->
Static in small_data -> ast::Static,
Struct in small_data -> ast::Struct,
Trait in small_data -> ast::Trait,
TraitAlias in small_data -> ast::TraitAlias,
TypeAlias in small_data -> ast::TypeAlias,
Union in small_data -> ast::Union,
Use in big_data -> ast::Use,
@ -583,12 +581,6 @@ pub struct Trait {
pub(crate) visibility: RawVisibilityId,
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct TraitAlias {
pub name: Name,
pub(crate) visibility: RawVisibilityId,
}
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Impl {}

16
crates/hir-def/src/item_tree/lower.rs
View file

@ -23,7 +23,7 @@ use crate::{
BigModItem, Const, Enum, ExternBlock, ExternCrate, FieldsShape, Function, Impl,
ImportAlias, Interned, ItemTree, ItemTreeAstId, Macro2, MacroCall, MacroRules, Mod,
ModItemId, ModKind, ModPath, RawAttrs, RawVisibility, RawVisibilityId, SmallModItem,
Static, Struct, StructKind, Trait, TraitAlias, TypeAlias, Union, Use, UseTree, UseTreeKind,
Static, Struct, StructKind, Trait, TypeAlias, Union, Use, UseTree, UseTreeKind,
VisibilityExplicitness,
},
};
@ -134,7 +134,6 @@ impl<'a> Ctx<'a> {
ast::Item::Const(ast) => self.lower_const(ast).into(),
ast::Item::Module(ast) => self.lower_module(ast)?.into(),
ast::Item::Trait(ast) => self.lower_trait(ast)?.into(),
ast::Item::TraitAlias(ast) => self.lower_trait_alias(ast)?.into(),
ast::Item::Impl(ast) => self.lower_impl(ast).into(),
ast::Item::Use(ast) => self.lower_use(ast)?.into(),
ast::Item::ExternCrate(ast) => self.lower_extern_crate(ast)?.into(),
@ -267,19 +266,6 @@ impl<'a> Ctx<'a> {
Some(ast_id)
}
fn lower_trait_alias(
&mut self,
trait_alias_def: &ast::TraitAlias,
) -> Option<ItemTreeAstId<TraitAlias>> {
let name = trait_alias_def.name()?.as_name();
let visibility = self.lower_visibility(trait_alias_def);
let ast_id = self.source_ast_id_map.ast_id(trait_alias_def);
let alias = TraitAlias { name, visibility };
self.tree.small_data.insert(ast_id.upcast(), SmallModItem::TraitAlias(alias));
Some(ast_id)
}
fn lower_impl(&mut self, impl_def: &ast::Impl) -> ItemTreeAstId<Impl> {
let ast_id = self.source_ast_id_map.ast_id(impl_def);
// Note that trait impls don't get implicit `Self` unlike traits, because here they are a

8
crates/hir-def/src/item_tree/pretty.rs
View file

@ -8,7 +8,7 @@ use crate::{
item_tree::{
Const, DefDatabase, Enum, ExternBlock, ExternCrate, FieldsShape, Function, Impl, ItemTree,
Macro2, MacroCall, MacroRules, Mod, ModItemId, ModKind, RawAttrs, RawVisibilityId, Static,
Struct, Trait, TraitAlias, TypeAlias, Union, Use, UseTree, UseTreeKind,
Struct, Trait, TypeAlias, Union, Use, UseTree, UseTreeKind,
},
visibility::RawVisibility,
};
@ -250,12 +250,6 @@ impl Printer<'_> {
self.print_visibility(*visibility);
w!(self, "trait {} {{ ... }}", name.display(self.db, self.edition));
}
ModItemId::TraitAlias(ast_id) => {
let TraitAlias { name, visibility } = &self.tree[ast_id];
self.print_ast_id(ast_id.erase());
self.print_visibility(*visibility);
wln!(self, "trait {} = ..;", name.display(self.db, self.edition));
}
ModItemId::Impl(ast_id) => {
let Impl {} = &self.tree[ast_id];
self.print_ast_id(ast_id.erase());

14
crates/hir-def/src/lib.rs
View file

@ -318,9 +318,6 @@ impl TraitId {
}
}
pub type TraitAliasLoc = ItemLoc<ast::TraitAlias>;
impl_intern!(TraitAliasId, TraitAliasLoc, intern_trait_alias, lookup_intern_trait_alias);
type TypeAliasLoc = AssocItemLoc<ast::TypeAlias>;
impl_intern!(TypeAliasId, TypeAliasLoc, intern_type_alias, lookup_intern_type_alias);
@ -742,7 +739,6 @@ pub enum ModuleDefId {
ConstId(ConstId),
StaticId(StaticId),
TraitId(TraitId),
TraitAliasId(TraitAliasId),
TypeAliasId(TypeAliasId),
BuiltinType(BuiltinType),
MacroId(MacroId),
@ -756,7 +752,6 @@ impl_from!(
ConstId,
StaticId,
TraitId,
TraitAliasId,
TypeAliasId,
BuiltinType
for ModuleDefId
@ -862,7 +857,6 @@ pub enum GenericDefId {
// More importantly, this completes the set of items that contain type references
// which is to be used by the signature expression store in the future.
StaticId(StaticId),
TraitAliasId(TraitAliasId),
TraitId(TraitId),
TypeAliasId(TypeAliasId),
}
@ -872,7 +866,6 @@ impl_from!(
FunctionId,
ImplId,
StaticId,
TraitAliasId,
TraitId,
TypeAliasId
for GenericDefId
@ -902,7 +895,6 @@ impl GenericDefId {
GenericDefId::AdtId(AdtId::UnionId(it)) => file_id_and_params_of_item_loc(db, it),
GenericDefId::AdtId(AdtId::EnumId(it)) => file_id_and_params_of_item_loc(db, it),
GenericDefId::TraitId(it) => file_id_and_params_of_item_loc(db, it),
GenericDefId::TraitAliasId(it) => file_id_and_params_of_item_loc(db, it),
GenericDefId::ImplId(it) => file_id_and_params_of_item_loc(db, it),
GenericDefId::ConstId(it) => (it.lookup(db).id.file_id, None),
GenericDefId::StaticId(it) => (it.lookup(db).id.file_id, None),
@ -978,7 +970,6 @@ pub enum AttrDefId {
StaticId(StaticId),
ConstId(ConstId),
TraitId(TraitId),
TraitAliasId(TraitAliasId),
TypeAliasId(TypeAliasId),
MacroId(MacroId),
ImplId(ImplId),
@ -997,7 +988,6 @@ impl_from!(
ConstId,
FunctionId,
TraitId,
TraitAliasId,
TypeAliasId,
MacroId(Macro2Id, MacroRulesId, ProcMacroId),
ImplId,
@ -1020,7 +1010,6 @@ impl TryFrom<ModuleDefId> for AttrDefId {
ModuleDefId::StaticId(it) => Ok(it.into()),
ModuleDefId::TraitId(it) => Ok(it.into()),
ModuleDefId::TypeAliasId(it) => Ok(it.into()),
ModuleDefId::TraitAliasId(id) => Ok(id.into()),
ModuleDefId::MacroId(id) => Ok(id.into()),
ModuleDefId::BuiltinType(_) => Err(()),
}
@ -1266,7 +1255,6 @@ impl HasModule for GenericDefId {
GenericDefId::FunctionId(it) => it.module(db),
GenericDefId::AdtId(it) => it.module(db),
GenericDefId::TraitId(it) => it.module(db),
GenericDefId::TraitAliasId(it) => it.module(db),
GenericDefId::TypeAliasId(it) => it.module(db),
GenericDefId::ImplId(it) => it.module(db),
GenericDefId::ConstId(it) => it.module(db),
@ -1286,7 +1274,6 @@ impl HasModule for AttrDefId {
AttrDefId::StaticId(it) => it.module(db),
AttrDefId::ConstId(it) => it.module(db),
AttrDefId::TraitId(it) => it.module(db),
AttrDefId::TraitAliasId(it) => it.module(db),
AttrDefId::TypeAliasId(it) => it.module(db),
AttrDefId::ImplId(it) => it.module(db),
AttrDefId::ExternBlockId(it) => it.module(db),
@ -1316,7 +1303,6 @@ impl ModuleDefId {
ModuleDefId::ConstId(id) => id.module(db),
ModuleDefId::StaticId(id) => id.module(db),
ModuleDefId::TraitId(id) => id.module(db),
ModuleDefId::TraitAliasId(id) => id.module(db),
ModuleDefId::TypeAliasId(id) => id.module(db),
ModuleDefId::MacroId(id) => id.module(db),
ModuleDefId::BuiltinType(_) => return None,

10
crates/hir-def/src/nameres/assoc.rs
View file

@ -51,10 +51,18 @@ impl TraitItems {
tr: TraitId,
) -> (TraitItems, DefDiagnostics) {
let ItemLoc { container: module_id, id: ast_id } = tr.lookup(db);
let ast_id_map = db.ast_id_map(ast_id.file_id);
let source = ast_id.with_value(ast_id_map.get(ast_id.value)).to_node(db);
if source.eq_token().is_some() {
// FIXME(trait-alias) probably needs special handling here
return (
TraitItems { macro_calls: ThinVec::new(), items: Box::default() },
DefDiagnostics::new(vec![]),
);
}
let collector =
AssocItemCollector::new(db, module_id, ItemContainerId::TraitId(tr), ast_id.file_id);
let source = ast_id.with_value(collector.ast_id_map.get(ast_id.value)).to_node(db);
let (items, macro_calls, diagnostics) = collector.collect(source.assoc_item_list());
(TraitItems { macro_calls, items }, DefDiagnostics::new(diagnostics))

16
crates/hir-def/src/nameres/collector.rs
View file

@ -30,7 +30,7 @@ use crate::{
ExternCrateId, ExternCrateLoc, FunctionId, FunctionLoc, ImplLoc, Intern, ItemContainerId,
LocalModuleId, Lookup, Macro2Id, Macro2Loc, MacroExpander, MacroId, MacroRulesId,
MacroRulesLoc, MacroRulesLocFlags, ModuleDefId, ModuleId, ProcMacroId, ProcMacroLoc, StaticLoc,
StructLoc, TraitAliasLoc, TraitLoc, TypeAliasLoc, UnionLoc, UnresolvedMacro, UseId, UseLoc,
StructLoc, TraitLoc, TypeAliasLoc, UnionLoc, UnresolvedMacro, UseId, UseLoc,
attr::Attrs,
db::DefDatabase,
item_scope::{GlobId, ImportId, ImportOrExternCrate, PerNsGlobImports},
@ -1954,20 +1954,6 @@ impl ModCollector<'_, '_> {
false,
);
}
ModItemId::TraitAlias(id) => {
let it = &self.item_tree[id];
let vis = resolve_vis(def_map, local_def_map, &self.item_tree[it.visibility]);
update_def(
self.def_collector,
TraitAliasLoc { container: module, id: InFile::new(self.file_id(), id) }
.intern(db)
.into(),
&it.name,
vis,
false,
);
}
ModItemId::TypeAlias(id) => {
let it = &self.item_tree[id];

13
crates/hir-def/src/resolver.rs
View file

@ -20,7 +20,7 @@ use crate::{
EnumVariantId, ExternBlockId, ExternCrateId, FunctionId, FxIndexMap, GenericDefId,
GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalModuleId, Lookup,
Macro2Id, MacroId, MacroRulesId, ModuleDefId, ModuleId, ProcMacroId, StaticId, StructId,
TraitAliasId, TraitId, TypeAliasId, TypeOrConstParamId, TypeParamId, UseId, VariantId,
TraitId, TypeAliasId, TypeOrConstParamId, TypeParamId, UseId, VariantId,
builtin_type::BuiltinType,
db::DefDatabase,
expr_store::{
@ -105,7 +105,6 @@ pub enum TypeNs {
TypeAliasId(TypeAliasId),
BuiltinType(BuiltinType),
TraitId(TraitId),
TraitAliasId(TraitAliasId),
ModuleId(ModuleId),
}
@ -1150,7 +1149,6 @@ impl<'db> ModuleItemMap<'db> {
let ty = match def.def {
ModuleDefId::AdtId(it) => TypeNs::AdtId(it),
ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
ModuleDefId::TraitAliasId(it) => TypeNs::TraitAliasId(it),
ModuleDefId::TypeAliasId(it) => TypeNs::TypeAliasId(it),
ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
@ -1195,7 +1193,6 @@ fn to_value_ns(per_ns: PerNs) -> Option<(ValueNs, Option<ImportOrGlob>)> {
ModuleDefId::AdtId(AdtId::EnumId(_) | AdtId::UnionId(_))
| ModuleDefId::TraitId(_)
| ModuleDefId::TraitAliasId(_)
| ModuleDefId::TypeAliasId(_)
| ModuleDefId::BuiltinType(_)
| ModuleDefId::MacroId(_)
@ -1214,7 +1211,6 @@ fn to_type_ns(per_ns: PerNs) -> Option<(TypeNs, Option<ImportOrExternCrate>)> {
ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
ModuleDefId::TraitId(it) => TypeNs::TraitId(it),
ModuleDefId::TraitAliasId(it) => TypeNs::TraitAliasId(it),
ModuleDefId::ModuleId(it) => TypeNs::ModuleId(it),
@ -1320,12 +1316,6 @@ impl HasResolver for TraitId {
}
}
impl HasResolver for TraitAliasId {
fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
lookup_resolver(db, self).push_generic_params_scope(db, self.into())
}
}
impl<T: Into<AdtId> + Copy> HasResolver for T {
fn resolver(self, db: &dyn DefDatabase) -> Resolver<'_> {
let def = self.into();
@ -1410,7 +1400,6 @@ impl HasResolver for GenericDefId {
GenericDefId::FunctionId(inner) => inner.resolver(db),
GenericDefId::AdtId(adt) => adt.resolver(db),
GenericDefId::TraitId(inner) => inner.resolver(db),
GenericDefId::TraitAliasId(inner) => inner.resolver(db),
GenericDefId::TypeAliasId(inner) => inner.resolver(db),
GenericDefId::ImplId(inner) => inner.resolver(db),
GenericDefId::ConstId(inner) => inner.resolver(db),

35
crates/hir-def/src/signatures.rs
View file

@ -20,15 +20,13 @@ use triomphe::Arc;
use crate::{
ConstId, EnumId, EnumVariantId, EnumVariantLoc, ExternBlockId, FunctionId, HasModule, ImplId,
ItemContainerId, ModuleId, StaticId, StructId, TraitAliasId, TraitId, TypeAliasId, UnionId,
VariantId,
ItemContainerId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, UnionId, VariantId,
attr::Attrs,
db::DefDatabase,
expr_store::{
ExpressionStore, ExpressionStoreSourceMap,
lower::{
ExprCollector, lower_function, lower_generic_params, lower_trait, lower_trait_alias,
lower_type_alias,
ExprCollector, lower_function, lower_generic_params, lower_trait, lower_type_alias,
},
},
hir::{ExprId, PatId, generics::GenericParams},
@ -404,6 +402,7 @@ bitflags::bitflags! {
const SKIP_BOXED_SLICE_DURING_METHOD_DISPATCH = 1 << 6;
const RUSTC_PAREN_SUGAR = 1 << 7;
const COINDUCTIVE = 1 << 8;
const ALIAS = 1 << 9;
}
}
@ -428,6 +427,9 @@ impl TraitSignature {
if source.value.unsafe_token().is_some() {
flags.insert(TraitFlags::UNSAFE);
}
if source.value.eq_token().is_some() {
flags.insert(TraitFlags::ALIAS);
}
if attrs.by_key(sym::fundamental).exists() {
flags |= TraitFlags::FUNDAMENTAL;
}
@ -469,31 +471,6 @@ impl TraitSignature {
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct TraitAliasSignature {
pub name: Name,
pub generic_params: Arc<GenericParams>,
pub store: Arc<ExpressionStore>,
}
impl TraitAliasSignature {
pub fn query(
db: &dyn DefDatabase,
id: TraitAliasId,
) -> (Arc<Self>, Arc<ExpressionStoreSourceMap>) {
let loc = id.lookup(db);
let source = loc.source(db);
let name = as_name_opt(source.value.name());
let (store, source_map, generic_params) = lower_trait_alias(db, loc.container, source, id);
(
Arc::new(TraitAliasSignature { generic_params, store: Arc::new(store), name }),
Arc::new(source_map),
)
}
}
bitflags! {
#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
pub struct FnFlags: u16 {

9
crates/hir-def/src/src.rs
View file

@ -71,7 +71,7 @@ impl HasChildSource<la_arena::Idx<ast::UseTree>> for UseId {
}
impl HasChildSource<LocalTypeOrConstParamId> for GenericDefId {
type Value = Either<ast::TypeOrConstParam, ast::TraitOrAlias>;
type Value = Either<ast::TypeOrConstParam, ast::Trait>;
fn child_source(
&self,
db: &dyn DefDatabase,
@ -89,12 +89,7 @@ impl HasChildSource<LocalTypeOrConstParamId> for GenericDefId {
GenericDefId::TraitId(id) => {
let trait_ref = id.lookup(db).source(db).value;
let idx = idx_iter.next().unwrap();
params.insert(idx, Either::Right(ast::TraitOrAlias::Trait(trait_ref)));
}
GenericDefId::TraitAliasId(id) => {
let alias = id.lookup(db).source(db).value;
let idx = idx_iter.next().unwrap();
params.insert(idx, Either::Right(ast::TraitOrAlias::TraitAlias(alias)));
params.insert(idx, Either::Right(trait_ref));
}
_ => {}
}

5
crates/hir-ty/src/generics.rs
View file

@ -273,7 +273,7 @@ impl Generics {
pub(crate) fn trait_self_param_idx(db: &dyn DefDatabase, def: GenericDefId) -> Option<usize> {
match def {
GenericDefId::TraitId(_) | GenericDefId::TraitAliasId(_) => {
GenericDefId::TraitId(_) => {
let params = db.generic_params(def);
params.trait_self_param().map(|idx| idx.into_raw().into_u32() as usize)
}
@ -295,8 +295,7 @@ pub(crate) fn parent_generic_def(db: &dyn DefDatabase, def: GenericDefId) -> Opt
GenericDefId::StaticId(_)
| GenericDefId::AdtId(_)
| GenericDefId::TraitId(_)
| GenericDefId::ImplId(_)
| GenericDefId::TraitAliasId(_) => return None,
| GenericDefId::ImplId(_) => return None,
};
match container {

1
crates/hir-ty/src/infer.rs
View file

@ -1790,7 +1790,6 @@ impl<'db> InferenceContext<'db> {
TypeNs::AdtId(AdtId::EnumId(_))
| TypeNs::BuiltinType(_)
| TypeNs::TraitId(_)
| TypeNs::TraitAliasId(_)
| TypeNs::ModuleId(_) => {
// FIXME diagnostic
(self.err_ty(), None)

7
crates/hir-ty/src/lower/path.rs
View file

@ -220,10 +220,6 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
};
return (ty, None);
}
TypeNs::TraitAliasId(_) => {
// FIXME(trait_alias): Implement trait alias.
return (TyKind::Error.intern(Interner), None);
}
TypeNs::GenericParam(param_id) => match self.ctx.type_param_mode {
ParamLoweringMode::Placeholder => {
TyKind::Placeholder(to_placeholder_idx(self.ctx.db, param_id.into()))
@ -311,8 +307,7 @@ impl<'a, 'b> PathLoweringContext<'a, 'b> {
TypeNs::AdtId(_)
| TypeNs::EnumVariantId(_)
| TypeNs::TypeAliasId(_)
| TypeNs::TraitId(_)
| TypeNs::TraitAliasId(_) => {}
| TypeNs::TraitId(_) => {}
}
}

7
crates/hir-ty/src/lower_nextsolver/path.rs
View file

@ -260,10 +260,6 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
};
return (ty, None);
}
TypeNs::TraitAliasId(_) => {
// FIXME(trait_alias): Implement trait alias.
return (Ty::new_error(self.ctx.interner, ErrorGuaranteed), None);
}
TypeNs::GenericParam(param_id) => {
let generics = self.ctx.generics();
let idx = generics.type_or_const_param_idx(param_id.into());
@ -343,8 +339,7 @@ impl<'a, 'b, 'db> PathLoweringContext<'a, 'b, 'db> {
TypeNs::AdtId(_)
| TypeNs::EnumVariantId(_)
| TypeNs::TypeAliasId(_)
| TypeNs::TraitId(_)
| TypeNs::TraitAliasId(_) => {}
| TypeNs::TraitId(_) => {}
}
}

6
crates/hir-ty/src/next_solver/def_id.rs
View file

@ -2,7 +2,7 @@
use hir_def::{
AdtId, ConstId, EnumId, EnumVariantId, FunctionId, GenericDefId, ImplId, StaticId, StructId,
TraitAliasId, TraitId, TypeAliasId, UnionId,
TraitId, TypeAliasId, UnionId,
};
use rustc_type_ir::inherent;
use stdx::impl_from;
@ -24,7 +24,6 @@ pub enum SolverDefId {
FunctionId(FunctionId),
ImplId(ImplId),
StaticId(StaticId),
TraitAliasId(TraitAliasId),
TraitId(TraitId),
TypeAliasId(TypeAliasId),
ForeignId(TypeAliasId),
@ -40,7 +39,6 @@ impl_from!(
FunctionId,
ImplId,
StaticId,
TraitAliasId,
TraitId,
TypeAliasId,
InternedClosureId,
@ -57,7 +55,6 @@ impl From<GenericDefId> for SolverDefId {
GenericDefId::FunctionId(function_id) => SolverDefId::FunctionId(function_id),
GenericDefId::ImplId(impl_id) => SolverDefId::ImplId(impl_id),
GenericDefId::StaticId(static_id) => SolverDefId::StaticId(static_id),
GenericDefId::TraitAliasId(trait_alias_id) => SolverDefId::TraitAliasId(trait_alias_id),
GenericDefId::TraitId(trait_id) => SolverDefId::TraitId(trait_id),
GenericDefId::TypeAliasId(type_alias_id) => SolverDefId::TypeAliasId(type_alias_id),
}
@ -74,7 +71,6 @@ impl TryFrom<SolverDefId> for GenericDefId {
SolverDefId::FunctionId(function_id) => GenericDefId::FunctionId(function_id),
SolverDefId::ImplId(impl_id) => GenericDefId::ImplId(impl_id),
SolverDefId::StaticId(static_id) => GenericDefId::StaticId(static_id),
SolverDefId::TraitAliasId(trait_alias_id) => GenericDefId::TraitAliasId(trait_alias_id),
SolverDefId::TraitId(trait_id) => GenericDefId::TraitId(trait_id),
SolverDefId::TypeAliasId(type_alias_id) => GenericDefId::TypeAliasId(type_alias_id),
SolverDefId::ForeignId(_) => return Err(value),

8
crates/hir-ty/src/next_solver/interner.rs
View file

@ -1172,7 +1172,6 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
| SolverDefId::AdtId(_)
| SolverDefId::TraitId(_)
| SolverDefId::ImplId(_)
| SolverDefId::TraitAliasId(_)
| SolverDefId::Ctor(..)
| SolverDefId::InternedOpaqueTyId(..) => panic!(),
};
@ -1790,7 +1789,12 @@ impl<'db> rustc_type_ir::Interner for DbInterner<'db> {
}
fn trait_is_alias(self, trait_def_id: Self::DefId) -> bool {
matches!(trait_def_id, SolverDefId::TraitAliasId(_))
let trait_ = match trait_def_id {
SolverDefId::TraitId(id) => id,
_ => panic!("Unexpected SolverDefId in trait_is_alias"),
};
let trait_data = self.db().trait_signature(trait_);
trait_data.flags.contains(TraitFlags::ALIAS)
}
fn trait_is_dyn_compatible(self, trait_def_id: Self::DefId) -> bool {

1
crates/hir-ty/src/tests.rs
View file

@ -9,6 +9,7 @@ mod never_type;
mod patterns;
mod regression;
mod simple;
mod trait_aliases;
mod traits;
mod type_alias_impl_traits;

21
crates/hir-ty/src/tests/trait_aliases.rs Normal file
View file

@ -0,0 +1,21 @@
use crate::tests::check_types;
#[test]
fn projection() {
check_types(
r#"
#![feature(trait_alias)]
pub trait A {
type Output;
}
pub trait B = A<Output = u32>;
pub fn a<T: B>(x: T::Output) {
x;
// ^ u32
}
"#,
);
}

5
crates/hir-ty/src/variance.rs
View file

@ -990,7 +990,6 @@ struct FixedPoint<T, U, V>(&'static FixedPoint<(), T, U>, V);
ModuleDefId::AdtId(it) => it.into(),
ModuleDefId::ConstId(it) => it.into(),
ModuleDefId::TraitId(it) => it.into(),
ModuleDefId::TraitAliasId(it) => it.into(),
ModuleDefId::TypeAliasId(it) => it.into(),
_ => return,
})
@ -1021,10 +1020,6 @@ struct FixedPoint<T, U, V>(&'static FixedPoint<(), T, U>, V);
let loc = it.lookup(&db);
loc.source(&db).value.name().unwrap()
}
GenericDefId::TraitAliasId(it) => {
let loc = it.lookup(&db);
loc.source(&db).value.name().unwrap()
}
GenericDefId::TypeAliasId(it) => {
let loc = it.lookup(&db);
loc.source(&db).value.name().unwrap()

8
crates/hir/src/attrs.rs
View file

@ -19,7 +19,7 @@ use hir_ty::{db::HirDatabase, method_resolution};
use crate::{
Adt, AsAssocItem, AssocItem, BuiltinType, Const, ConstParam, DocLinkDef, Enum, ExternCrateDecl,
Field, Function, GenericParam, HasCrate, Impl, LifetimeParam, Macro, Module, ModuleDef, Static,
Struct, Trait, TraitAlias, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
Struct, Trait, Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
};
pub trait HasAttrs {
@ -48,7 +48,6 @@ impl_has_attrs![
(Static, StaticId),
(Const, ConstId),
(Trait, TraitId),
(TraitAlias, TraitAliasId),
(TypeAlias, TypeAliasId),
(Macro, MacroId),
(Function, FunctionId),
@ -137,7 +136,6 @@ fn resolve_doc_path_on_(
AttrDefId::StaticId(it) => it.resolver(db),
AttrDefId::ConstId(it) => it.resolver(db),
AttrDefId::TraitId(it) => it.resolver(db),
AttrDefId::TraitAliasId(it) => it.resolver(db),
AttrDefId::TypeAliasId(it) => it.resolver(db),
AttrDefId::ImplId(it) => it.resolver(db),
AttrDefId::ExternBlockId(it) => it.resolver(db),
@ -216,10 +214,6 @@ fn resolve_assoc_or_field(
DocLinkDef::ModuleDef(def)
});
}
TypeNs::TraitAliasId(_) => {
// XXX: Do these get resolved?
return None;
}
TypeNs::ModuleId(_) => {
return None;
}

21
crates/hir/src/display.rs
View file

@ -23,8 +23,8 @@ use itertools::Itertools;
use crate::{
Adt, AsAssocItem, AssocItem, AssocItemContainer, Const, ConstParam, Crate, Enum,
ExternCrateDecl, Field, Function, GenericParam, HasCrate, HasVisibility, Impl, LifetimeParam,
Macro, Module, SelfParam, Static, Struct, StructKind, Trait, TraitAlias, TraitRef, TupleField,
TyBuilder, Type, TypeAlias, TypeOrConstParam, TypeParam, Union, Variant,
Macro, Module, SelfParam, Static, Struct, StructKind, Trait, TraitRef, TupleField, TyBuilder,
Type, TypeAlias, TypeOrConstParam, TypeParam, Union, Variant,
};
impl HirDisplay for Function {
@ -751,6 +751,7 @@ impl HirDisplay for TraitRef<'_> {
impl HirDisplay for Trait {
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
// FIXME(trait-alias) needs special handling to print the equal sign
write_trait_header(self, f)?;
let def_id = GenericDefId::TraitId(self.id);
let has_where_clause = write_where_clause(def_id, f)?;
@ -802,22 +803,6 @@ fn write_trait_header(trait_: &Trait, f: &mut HirFormatter<'_>) -> Result<(), Hi
Ok(())
}
impl HirDisplay for TraitAlias {
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;
let data = f.db.trait_alias_signature(self.id);
write!(f, "trait {}", data.name.display(f.db, f.edition()))?;
let def_id = GenericDefId::TraitAliasId(self.id);
write_generic_params(def_id, f)?;
f.write_str(" = ")?;
// FIXME: Currently we lower every bounds in a trait alias as a trait bound on `Self` i.e.
// `trait Foo = Bar` is stored and displayed as `trait Foo = where Self: Bar`, which might
// be less readable.
write_where_clause(def_id, f)?;
Ok(())
}
}
impl HirDisplay for TypeAlias {
fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {
write_visibility(self.module(f.db).id, self.visibility(f.db), f)?;

5
crates/hir/src/from_id.rs
View file

@ -37,7 +37,6 @@ from_id![
(hir_def::EnumId, crate::Enum),
(hir_def::TypeAliasId, crate::TypeAlias),
(hir_def::TraitId, crate::Trait),
(hir_def::TraitAliasId, crate::TraitAlias),
(hir_def::StaticId, crate::Static),
(hir_def::ConstId, crate::Const),
(hir_def::FunctionId, crate::Function),
@ -113,7 +112,6 @@ impl From<ModuleDefId> for ModuleDef {
ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
ModuleDefId::TraitAliasId(it) => ModuleDef::TraitAlias(it.into()),
ModuleDefId::TypeAliasId(it) => ModuleDef::TypeAlias(it.into()),
ModuleDefId::BuiltinType(it) => ModuleDef::BuiltinType(it.into()),
ModuleDefId::MacroId(it) => ModuleDef::Macro(it.into()),
@ -131,7 +129,6 @@ impl From<ModuleDef> for ModuleDefId {
ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
ModuleDef::TraitAlias(it) => ModuleDefId::TraitAliasId(it.into()),
ModuleDef::TypeAlias(it) => ModuleDefId::TypeAliasId(it.into()),
ModuleDef::BuiltinType(it) => ModuleDefId::BuiltinType(it.into()),
ModuleDef::Macro(it) => ModuleDefId::MacroId(it.into()),
@ -177,7 +174,6 @@ impl From<GenericDef> for GenericDefId {
GenericDef::Function(it) => GenericDefId::FunctionId(it.id),
GenericDef::Adt(it) => GenericDefId::AdtId(it.into()),
GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
GenericDef::TraitAlias(it) => GenericDefId::TraitAliasId(it.id),
GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
GenericDef::Impl(it) => GenericDefId::ImplId(it.id),
GenericDef::Const(it) => GenericDefId::ConstId(it.id),
@ -192,7 +188,6 @@ impl From<GenericDefId> for GenericDef {
GenericDefId::FunctionId(it) => GenericDef::Function(it.into()),
GenericDefId::AdtId(it) => GenericDef::Adt(it.into()),
GenericDefId::TraitId(it) => GenericDef::Trait(it.into()),
GenericDefId::TraitAliasId(it) => GenericDef::TraitAlias(it.into()),
GenericDefId::TypeAliasId(it) => GenericDef::TypeAlias(it.into()),
GenericDefId::ImplId(it) => GenericDef::Impl(it.into()),
GenericDefId::ConstId(it) => GenericDef::Const(it.into()),

11
crates/hir/src/has_source.rs
View file

@ -14,8 +14,7 @@ use tt::TextRange;
use crate::{
Adt, Callee, Const, Enum, ExternCrateDecl, Field, FieldSource, Function, Impl,
InlineAsmOperand, Label, LifetimeParam, LocalSource, Macro, Module, Param, SelfParam, Static,
Struct, Trait, TraitAlias, TypeAlias, TypeOrConstParam, Union, Variant, VariantDef,
db::HirDatabase,
Struct, Trait, TypeAlias, TypeOrConstParam, Union, Variant, VariantDef, db::HirDatabase,
};
pub trait HasSource {
@ -168,12 +167,6 @@ impl HasSource for Trait {
Some(self.id.lookup(db).source(db))
}
}
impl HasSource for TraitAlias {
type Ast = ast::TraitAlias;
fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
Some(self.id.lookup(db).source(db))
}
}
impl HasSource for TypeAlias {
type Ast = ast::TypeAlias;
fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
@ -202,7 +195,7 @@ impl HasSource for Impl {
}
impl HasSource for TypeOrConstParam {
type Ast = Either<ast::TypeOrConstParam, ast::TraitOrAlias>;
type Ast = Either<ast::TypeOrConstParam, ast::Trait>;
fn source(self, db: &dyn HirDatabase) -> Option<InFile<Self::Ast>> {
let child_source = self.id.parent.child_source(db);
child_source.map(|it| it.get(self.id.local_id).cloned()).transpose()

51
crates/hir/src/lib.rs
View file

@ -52,7 +52,7 @@ use hir_def::{
CrateRootModuleId, DefWithBodyId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId,
FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId,
LocalFieldId, Lookup, MacroExpander, MacroId, ModuleId, StaticId, StructId, SyntheticSyntax,
TraitAliasId, TupleId, TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,
TupleId, TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,
expr_store::{ExpressionStoreDiagnostics, ExpressionStoreSourceMap},
hir::{
BindingAnnotation, BindingId, Expr, ExprId, ExprOrPatId, LabelId, Pat,
@ -333,7 +333,6 @@ pub enum ModuleDef {
Const(Const),
Static(Static),
Trait(Trait),
TraitAlias(TraitAlias),
TypeAlias(TypeAlias),
BuiltinType(BuiltinType),
Macro(Macro),
@ -346,7 +345,6 @@ impl_from!(
Const,
Static,
Trait,
TraitAlias,
TypeAlias,
BuiltinType,
Macro
@ -373,7 +371,6 @@ impl ModuleDef {
ModuleDef::Const(it) => Some(it.module(db)),
ModuleDef::Static(it) => Some(it.module(db)),
ModuleDef::Trait(it) => Some(it.module(db)),
ModuleDef::TraitAlias(it) => Some(it.module(db)),
ModuleDef::TypeAlias(it) => Some(it.module(db)),
ModuleDef::Macro(it) => Some(it.module(db)),
ModuleDef::BuiltinType(_) => None,
@ -402,7 +399,6 @@ impl ModuleDef {
ModuleDef::Const(it) => it.name(db)?,
ModuleDef::Adt(it) => it.name(db),
ModuleDef::Trait(it) => it.name(db),
ModuleDef::TraitAlias(it) => it.name(db),
ModuleDef::Function(it) => it.name(db),
ModuleDef::Variant(it) => it.name(db),
ModuleDef::TypeAlias(it) => it.name(db),
@ -425,7 +421,6 @@ impl ModuleDef {
Adt::Union(it) => it.id.into(),
},
ModuleDef::Trait(it) => it.id.into(),
ModuleDef::TraitAlias(it) => it.id.into(),
ModuleDef::Function(it) => it.id.into(),
ModuleDef::TypeAlias(it) => it.id.into(),
ModuleDef::Module(it) => it.id.into(),
@ -465,7 +460,6 @@ impl ModuleDef {
ModuleDef::Module(_)
| ModuleDef::Adt(_)
| ModuleDef::Trait(_)
| ModuleDef::TraitAlias(_)
| ModuleDef::TypeAlias(_)
| ModuleDef::Macro(_)
| ModuleDef::BuiltinType(_) => None,
@ -478,7 +472,6 @@ impl ModuleDef {
ModuleDef::Function(it) => Some(it.into()),
ModuleDef::Adt(it) => Some(it.into()),
ModuleDef::Trait(it) => Some(it.into()),
ModuleDef::TraitAlias(it) => Some(it.into()),
ModuleDef::TypeAlias(it) => Some(it.into()),
ModuleDef::Module(_)
| ModuleDef::Variant(_)
@ -498,7 +491,6 @@ impl ModuleDef {
ModuleDef::Const(it) => it.attrs(db),
ModuleDef::Static(it) => it.attrs(db),
ModuleDef::Trait(it) => it.attrs(db),
ModuleDef::TraitAlias(it) => it.attrs(db),
ModuleDef::TypeAlias(it) => it.attrs(db),
ModuleDef::Macro(it) => it.attrs(db),
ModuleDef::BuiltinType(_) => return None,
@ -524,7 +516,6 @@ impl HasVisibility for ModuleDef {
ModuleDef::Const(it) => it.visibility(db),
ModuleDef::Static(it) => it.visibility(db),
ModuleDef::Trait(it) => it.visibility(db),
ModuleDef::TraitAlias(it) => it.visibility(db),
ModuleDef::TypeAlias(it) => it.visibility(db),
ModuleDef::Variant(it) => it.visibility(db),
ModuleDef::Macro(it) => it.visibility(db),
@ -3045,29 +3036,6 @@ impl HasVisibility for Trait {
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TraitAlias {
pub(crate) id: TraitAliasId,
}
impl TraitAlias {
pub fn module(self, db: &dyn HirDatabase) -> Module {
Module { id: self.id.lookup(db).container }
}
pub fn name(self, db: &dyn HirDatabase) -> Name {
db.trait_alias_signature(self.id).name.clone()
}
}
impl HasVisibility for TraitAlias {
fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
let loc = self.id.lookup(db);
let source = loc.source(db);
visibility_from_ast(db, self.id, source.map(|src| src.visibility()))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct TypeAlias {
pub(crate) id: TypeAliasId,
@ -3690,7 +3658,6 @@ pub enum GenericDef {
Function(Function),
Adt(Adt),
Trait(Trait),
TraitAlias(TraitAlias),
TypeAlias(TypeAlias),
Impl(Impl),
// consts can have type parameters from their parents (i.e. associated consts of traits)
@ -3701,7 +3668,6 @@ impl_from!(
Function,
Adt(Struct, Enum, Union),
Trait,
TraitAlias,
TypeAlias,
Impl,
Const,
@ -3751,7 +3717,6 @@ impl GenericDef {
GenericDef::Function(it) => it.id.into(),
GenericDef::Adt(it) => it.into(),
GenericDef::Trait(it) => it.id.into(),
GenericDef::TraitAlias(it) => it.id.into(),
GenericDef::TypeAlias(it) => it.id.into(),
GenericDef::Impl(it) => it.id.into(),
GenericDef::Const(it) => it.id.into(),
@ -3776,7 +3741,6 @@ impl GenericDef {
GenericDefId::FunctionId(it) => db.function_signature_with_source_map(it).1,
GenericDefId::ImplId(it) => db.impl_signature_with_source_map(it).1,
GenericDefId::StaticId(_) => return,
GenericDefId::TraitAliasId(it) => db.trait_alias_signature_with_source_map(it).1,
GenericDefId::TraitId(it) => db.trait_signature_with_source_map(it).1,
GenericDefId::TypeAliasId(it) => db.type_alias_signature_with_source_map(it).1,
};
@ -3813,7 +3777,6 @@ impl GenericDef {
GenericDef::Adt(Adt::Enum(_)) => "enum",
GenericDef::Adt(Adt::Union(_)) => "union",
GenericDef::Trait(_) => "trait",
GenericDef::TraitAlias(_) => "trait alias",
GenericDef::TypeAlias(_) => "type alias",
GenericDef::Impl(_) => "impl",
GenericDef::Const(_) => "constant",
@ -6401,12 +6364,6 @@ impl HasCrate for Trait {
}
}
impl HasCrate for TraitAlias {
fn krate(&self, db: &dyn HirDatabase) -> Crate {
self.module(db).krate()
}
}
impl HasCrate for Static {
fn krate(&self, db: &dyn HirDatabase) -> Crate {
self.module(db).krate()
@ -6500,12 +6457,6 @@ impl HasContainer for Trait {
}
}
impl HasContainer for TraitAlias {
fn container(&self, db: &dyn HirDatabase) -> ItemContainer {
ItemContainer::Module(Module { id: self.id.lookup(db).container })
}
}
impl HasContainer for ExternBlock {
fn container(&self, db: &dyn HirDatabase) -> ItemContainer {
ItemContainer::Module(Module { id: self.id.lookup(db).container })

12
crates/hir/src/semantics.rs
View file

@ -46,8 +46,8 @@ use crate::{
Adjust, Adjustment, Adt, AutoBorrow, BindingMode, BuiltinAttr, Callable, Const, ConstParam,
Crate, DefWithBody, DeriveHelper, Enum, Field, Function, GenericSubstitution, HasSource, Impl,
InFile, InlineAsmOperand, ItemInNs, Label, LifetimeParam, Local, Macro, Module, ModuleDef,
Name, OverloadedDeref, ScopeDef, Static, Struct, ToolModule, Trait, TraitAlias, TupleField,
Type, TypeAlias, TypeParam, Union, Variant, VariantDef,
Name, OverloadedDeref, ScopeDef, Static, Struct, ToolModule, Trait, TupleField, Type,
TypeAlias, TypeParam, Union, Variant, VariantDef,
db::HirDatabase,
semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
source_analyzer::{SourceAnalyzer, name_hygiene, resolve_hir_path},
@ -85,8 +85,7 @@ impl PathResolution {
| ModuleDef::Function(_)
| ModuleDef::Module(_)
| ModuleDef::Static(_)
| ModuleDef::Trait(_)
| ModuleDef::TraitAlias(_),
| ModuleDef::Trait(_),
) => None,
PathResolution::Def(ModuleDef::TypeAlias(alias)) => {
Some(TypeNs::TypeAliasId((*alias).into()))
@ -343,10 +342,6 @@ impl<DB: HirDatabase + ?Sized> Semantics<'_, DB> {
self.imp.to_def(s)
}
pub fn to_trait_alias_def(&self, t: &ast::TraitAlias) -> Option<TraitAlias> {
self.imp.to_def(t)
}
pub fn to_trait_def(&self, t: &ast::Trait) -> Option<Trait> {
self.imp.to_def(t)
}
@ -2138,7 +2133,6 @@ to_def_impls![
(crate::Enum, ast::Enum, enum_to_def),
(crate::Union, ast::Union, union_to_def),
(crate::Trait, ast::Trait, trait_to_def),
(crate::TraitAlias, ast::TraitAlias, trait_alias_to_def),
(crate::Impl, ast::Impl, impl_to_def),
(crate::TypeAlias, ast::TypeAlias, type_alias_to_def),
(crate::Const, ast::Const, const_to_def),

3
crates/hir/src/semantics/child_by_source.rs
View file

@ -154,9 +154,6 @@ impl ChildBySource for ItemScope {
}
ModuleDefId::StaticId(id) => insert_item_loc(db, map, file_id, id, keys::STATIC),
ModuleDefId::TraitId(id) => insert_item_loc(db, map, file_id, id, keys::TRAIT),
ModuleDefId::TraitAliasId(id) => {
insert_item_loc(db, map, file_id, id, keys::TRAIT_ALIAS)
}
ModuleDefId::AdtId(adt) => match adt {
AdtId::StructId(id) => insert_item_loc(db, map, file_id, id, keys::STRUCT),
AdtId::UnionId(id) => insert_item_loc(db, map, file_id, id, keys::UNION),

16
crates/hir/src/semantics/source_to_def.rs
View file

@ -89,8 +89,8 @@ use either::Either;
use hir_def::{
AdtId, BlockId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId, ExternBlockId,
ExternCrateId, FieldId, FunctionId, GenericDefId, GenericParamId, ImplId, LifetimeParamId,
Lookup, MacroId, ModuleId, StaticId, StructId, TraitAliasId, TraitId, TypeAliasId, TypeParamId,
UnionId, UseId, VariantId,
Lookup, MacroId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId,
UseId, VariantId,
dyn_map::{
DynMap,
keys::{self, Key},
@ -252,12 +252,6 @@ impl SourceToDefCtx<'_, '_> {
pub(super) fn trait_to_def(&mut self, src: InFile<&ast::Trait>) -> Option<TraitId> {
self.to_def(src, keys::TRAIT)
}
pub(super) fn trait_alias_to_def(
&mut self,
src: InFile<&ast::TraitAlias>,
) -> Option<TraitAliasId> {
self.to_def(src, keys::TRAIT_ALIAS)
}
pub(super) fn impl_to_def(&mut self, src: InFile<&ast::Impl>) -> Option<ImplId> {
self.to_def(src, keys::IMPL)
}
@ -555,9 +549,6 @@ impl SourceToDefCtx<'_, '_> {
}
ast::Item::Enum(it) => this.enum_to_def(InFile::new(file_id, it)).map(Into::into),
ast::Item::Trait(it) => this.trait_to_def(InFile::new(file_id, it)).map(Into::into),
ast::Item::TraitAlias(it) => {
this.trait_alias_to_def(InFile::new(file_id, it)).map(Into::into)
}
ast::Item::TypeAlias(it) => {
this.type_alias_to_def(InFile::new(file_id, it)).map(Into::into)
}
@ -636,9 +627,6 @@ impl SourceToDefCtx<'_, '_> {
ast::Item::TypeAlias(it) => ChildContainer::GenericDefId(
self.type_alias_to_def(container.with_value(it))?.into(),
),
ast::Item::TraitAlias(it) => ChildContainer::GenericDefId(
self.trait_alias_to_def(container.with_value(it))?.into(),
),
ast::Item::Struct(it) => {
let def = self.struct_to_def(container.with_value(it))?;
let is_in_body = it.field_list().is_some_and(|it| {

4
crates/hir/src/source_analyzer.rs
View file

@ -10,7 +10,7 @@ use std::iter::{self, once};
use crate::{
Adt, AssocItem, BindingMode, BuiltinAttr, BuiltinType, Callable, Const, DeriveHelper, Field,
Function, GenericSubstitution, Local, Macro, ModuleDef, Static, Struct, ToolModule, Trait,
TraitAlias, TupleField, Type, TypeAlias, Variant,
TupleField, Type, TypeAlias, Variant,
db::HirDatabase,
semantics::{PathResolution, PathResolutionPerNs},
};
@ -1587,7 +1587,6 @@ fn resolve_hir_path_(
TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
TypeNs::BuiltinType(it) => PathResolution::Def(BuiltinType::from(it).into()),
TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
TypeNs::TraitAliasId(it) => PathResolution::Def(TraitAlias::from(it).into()),
TypeNs::ModuleId(it) => PathResolution::Def(ModuleDef::Module(it.into())),
};
match unresolved {
@ -1737,7 +1736,6 @@ fn resolve_hir_path_qualifier(
TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
TypeNs::BuiltinType(it) => PathResolution::Def(BuiltinType::from(it).into()),
TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
TypeNs::TraitAliasId(it) => PathResolution::Def(TraitAlias::from(it).into()),
TypeNs::ModuleId(it) => PathResolution::Def(ModuleDef::Module(it.into())),
};
match unresolved {

3
crates/hir/src/symbols.rs
View file

@ -148,9 +148,6 @@ impl<'a> SymbolCollector<'a> {
let trait_do_not_complete = this.push_decl(id, name, false, None);
this.collect_from_trait(id, trait_do_not_complete);
}
ModuleDefId::TraitAliasId(id) => {
this.push_decl(id, name, false, None);
}
ModuleDefId::TypeAliasId(id) => {
this.push_decl(id, name, false, None);
}

1
crates/ide-assists/src/handlers/extract_module.rs
View file

@ -613,7 +613,6 @@ impl Module {
| Definition::Const(_)
| Definition::Static(_)
| Definition::Trait(_)
| Definition::TraitAlias(_)
| Definition::TypeAlias(_)
);

4
crates/ide-assists/src/handlers/fix_visibility.rs
View file

@ -136,10 +136,6 @@ fn target_data_for_def(
target_name = Some(t.name(db));
offset_target_and_file_id(db, t)?
}
hir::ModuleDef::TraitAlias(t) => {
target_name = Some(t.name(db));
offset_target_and_file_id(db, t)?
}
hir::ModuleDef::TypeAlias(t) => {
target_name = Some(t.name(db));
offset_target_and_file_id(db, t)?

1
crates/ide-assists/src/handlers/move_bounds.rs
View file

@ -55,7 +55,6 @@ pub(crate) fn move_bounds_to_where_clause(
match parent {
ast::Fn(it) => it.get_or_create_where_clause(),
ast::Trait(it) => it.get_or_create_where_clause(),
ast::TraitAlias(it) => it.get_or_create_where_clause(),
ast::Impl(it) => it.get_or_create_where_clause(),
ast::Enum(it) => it.get_or_create_where_clause(),
ast::Struct(it) => it.get_or_create_where_clause(),

4
crates/ide-completion/src/completions/type.rs
View file

@ -37,9 +37,7 @@ pub(crate) fn complete_type_path(
true
}
// Type things are fine
ScopeDef::ModuleDef(
BuiltinType(_) | Adt(_) | Module(_) | Trait(_) | TraitAlias(_) | TypeAlias(_),
)
ScopeDef::ModuleDef(BuiltinType(_) | Adt(_) | Module(_) | Trait(_) | TypeAlias(_))
| ScopeDef::AdtSelfType(_)
| ScopeDef::Unknown
| ScopeDef::GenericParam(TypeParam(_)) => location.complete_types(),

1
crates/ide-completion/src/context.rs
View file

@ -525,7 +525,6 @@ impl CompletionContext<'_> {
hir::ModuleDef::Const(it) => self.is_visible(it),
hir::ModuleDef::Static(it) => self.is_visible(it),
hir::ModuleDef::Trait(it) => self.is_visible(it),
hir::ModuleDef::TraitAlias(it) => self.is_visible(it),
hir::ModuleDef::TypeAlias(it) => self.is_visible(it),
hir::ModuleDef::Macro(it) => self.is_visible(it),
hir::ModuleDef::BuiltinType(_) => Visible::Yes,

3
crates/ide-completion/src/context/analysis.rs
View file

@ -1037,9 +1037,6 @@ fn classify_name_ref<'db>(
sema.source(trait_)?.value.generic_param_list()
}
}
hir::ModuleDef::TraitAlias(trait_) => {
sema.source(trait_)?.value.generic_param_list()
}
hir::ModuleDef::TypeAlias(ty_) => {
sema.source(ty_)?.value.generic_param_list()
}

1
crates/ide-completion/src/item.rs
View file

@ -399,7 +399,6 @@ impl CompletionItemKind {
SymbolKind::Struct => "st",
SymbolKind::ToolModule => "tm",
SymbolKind::Trait => "tt",
SymbolKind::TraitAlias => "tr",
SymbolKind::TypeAlias => "ta",
SymbolKind::TypeParam => "tp",
SymbolKind::Union => "un",

8
crates/ide-completion/src/render.rs
View file

@ -486,10 +486,7 @@ fn render_resolution_path(
| ScopeDef::Label(_)
| ScopeDef::Unknown
| ScopeDef::ModuleDef(
ModuleDef::Trait(_)
| ModuleDef::TraitAlias(_)
| ModuleDef::Module(_)
| ModuleDef::TypeAlias(_),
ModuleDef::Trait(_) | ModuleDef::Module(_) | ModuleDef::TypeAlias(_),
) => (),
};
@ -542,9 +539,6 @@ fn res_to_kind(resolution: ScopeDef) -> CompletionItemKind {
ScopeDef::ModuleDef(Const(..)) => CompletionItemKind::SymbolKind(SymbolKind::Const),
ScopeDef::ModuleDef(Static(..)) => CompletionItemKind::SymbolKind(SymbolKind::Static),
ScopeDef::ModuleDef(Trait(..)) => CompletionItemKind::SymbolKind(SymbolKind::Trait),
ScopeDef::ModuleDef(TraitAlias(..)) => {
CompletionItemKind::SymbolKind(SymbolKind::TraitAlias)
}
ScopeDef::ModuleDef(TypeAlias(..)) => CompletionItemKind::SymbolKind(SymbolKind::TypeAlias),
ScopeDef::ModuleDef(BuiltinType(..)) => CompletionItemKind::BuiltinType,
ScopeDef::GenericParam(param) => CompletionItemKind::SymbolKind(match param {

1
crates/ide-db/src/active_parameter.rs
View file

@ -125,7 +125,6 @@ pub fn generic_def_for_node(
hir::PathResolution::Def(hir::ModuleDef::Adt(it)) => it.into(),
hir::PathResolution::Def(hir::ModuleDef::Function(it)) => it.into(),
hir::PathResolution::Def(hir::ModuleDef::Trait(it)) => it.into(),
hir::PathResolution::Def(hir::ModuleDef::TraitAlias(it)) => it.into(),
hir::PathResolution::Def(hir::ModuleDef::TypeAlias(it)) => it.into(),
hir::PathResolution::Def(hir::ModuleDef::Variant(it)) => {
variant = Some(it);

15
crates/ide-db/src/defs.rs
View file

@ -16,7 +16,7 @@ use hir::{
ExternCrateDecl, Field, Function, GenericDef, GenericParam, GenericSubstitution, HasContainer,
HasVisibility, HirDisplay, Impl, InlineAsmOperand, ItemContainer, Label, Local, Macro, Module,
ModuleDef, Name, PathResolution, Semantics, Static, StaticLifetime, Struct, ToolModule, Trait,
TraitAlias, TupleField, TypeAlias, Variant, VariantDef, Visibility,
TupleField, TypeAlias, Variant, VariantDef, Visibility,
};
use span::Edition;
use stdx::{format_to, impl_from};
@ -40,7 +40,6 @@ pub enum Definition {
Const(Const),
Static(Static),
Trait(Trait),
TraitAlias(TraitAlias),
TypeAlias(TypeAlias),
SelfType(Impl),
GenericParam(GenericParam),
@ -83,7 +82,6 @@ impl Definition {
Definition::Const(it) => it.module(db),
Definition::Static(it) => it.module(db),
Definition::Trait(it) => it.module(db),
Definition::TraitAlias(it) => it.module(db),
Definition::TypeAlias(it) => it.module(db),
Definition::Variant(it) => it.module(db),
Definition::SelfType(it) => it.module(db),
@ -122,7 +120,6 @@ impl Definition {
Definition::Const(it) => container_to_definition(it.container(db)),
Definition::Static(it) => container_to_definition(it.container(db)),
Definition::Trait(it) => container_to_definition(it.container(db)),
Definition::TraitAlias(it) => container_to_definition(it.container(db)),
Definition::TypeAlias(it) => container_to_definition(it.container(db)),
Definition::Variant(it) => Some(Adt::Enum(it.parent_enum(db)).into()),
Definition::SelfType(it) => Some(it.module(db).into()),
@ -151,7 +148,6 @@ impl Definition {
Definition::Const(it) => it.visibility(db),
Definition::Static(it) => it.visibility(db),
Definition::Trait(it) => it.visibility(db),
Definition::TraitAlias(it) => it.visibility(db),
Definition::TypeAlias(it) => it.visibility(db),
Definition::Variant(it) => it.visibility(db),
Definition::ExternCrateDecl(it) => it.visibility(db),
@ -185,7 +181,6 @@ impl Definition {
Definition::Const(it) => it.name(db)?,
Definition::Static(it) => it.name(db),
Definition::Trait(it) => it.name(db),
Definition::TraitAlias(it) => it.name(db),
Definition::TypeAlias(it) => it.name(db),
Definition::BuiltinType(it) => it.name(),
Definition::TupleField(it) => it.name(),
@ -230,7 +225,6 @@ impl Definition {
Definition::Const(it) => it.docs_with_rangemap(db),
Definition::Static(it) => it.docs_with_rangemap(db),
Definition::Trait(it) => it.docs_with_rangemap(db),
Definition::TraitAlias(it) => it.docs_with_rangemap(db),
Definition::TypeAlias(it) => {
it.docs_with_rangemap(db).or_else(|| {
// docs are missing, try to fall back to the docs of the aliased item.
@ -321,7 +315,6 @@ impl Definition {
Definition::Const(it) => it.display(db, display_target).to_string(),
Definition::Static(it) => it.display(db, display_target).to_string(),
Definition::Trait(it) => it.display(db, display_target).to_string(),
Definition::TraitAlias(it) => it.display(db, display_target).to_string(),
Definition::TypeAlias(it) => it.display(db, display_target).to_string(),
Definition::BuiltinType(it) => {
it.name().display(db, display_target.edition).to_string()
@ -589,7 +582,6 @@ impl<'db> NameClass<'db> {
ast::Item::Module(it) => Definition::Module(sema.to_def(&it)?),
ast::Item::Static(it) => Definition::Static(sema.to_def(&it)?),
ast::Item::Trait(it) => Definition::Trait(sema.to_def(&it)?),
ast::Item::TraitAlias(it) => Definition::TraitAlias(sema.to_def(&it)?),
ast::Item::TypeAlias(it) => Definition::TypeAlias(sema.to_def(&it)?),
ast::Item::Enum(it) => Definition::Adt(hir::Adt::Enum(sema.to_def(&it)?)),
ast::Item::Struct(it) => Definition::Adt(hir::Adt::Struct(sema.to_def(&it)?)),
@ -895,7 +887,7 @@ impl<'db> NameRefClass<'db> {
}
impl_from!(
Field, Module, Function, Adt, Variant, Const, Static, Trait, TraitAlias, TypeAlias, BuiltinType, Local,
Field, Module, Function, Adt, Variant, Const, Static, Trait, TypeAlias, BuiltinType, Local,
GenericParam, Label, Macro, ExternCrateDecl
for Definition
);
@ -975,7 +967,6 @@ impl From<ModuleDef> for Definition {
ModuleDef::Const(it) => Definition::Const(it),
ModuleDef::Static(it) => Definition::Static(it),
ModuleDef::Trait(it) => Definition::Trait(it),
ModuleDef::TraitAlias(it) => Definition::TraitAlias(it),
ModuleDef::TypeAlias(it) => Definition::TypeAlias(it),
ModuleDef::Macro(it) => Definition::Macro(it),
ModuleDef::BuiltinType(it) => Definition::BuiltinType(it),
@ -1017,7 +1008,6 @@ impl From<GenericDef> for Definition {
GenericDef::Function(it) => it.into(),
GenericDef::Adt(it) => it.into(),
GenericDef::Trait(it) => it.into(),
GenericDef::TraitAlias(it) => it.into(),
GenericDef::TypeAlias(it) => it.into(),
GenericDef::Impl(it) => it.into(),
GenericDef::Const(it) => it.into(),
@ -1033,7 +1023,6 @@ impl TryFrom<Definition> for GenericDef {
Definition::Function(it) => Ok(it.into()),
Definition::Adt(it) => Ok(it.into()),
Definition::Trait(it) => Ok(it.into()),
Definition::TraitAlias(it) => Ok(it.into()),
Definition::TypeAlias(it) => Ok(it.into()),
Definition::SelfType(it) => Ok(it.into()),
Definition::Const(it) => Ok(it.into()),

3
crates/ide-db/src/documentation.rs
View file

@ -195,8 +195,7 @@ macro_rules! impl_has_docs {
}
impl_has_docs![
Variant, Field, Static, Const, Trait, TraitAlias, TypeAlias, Macro, Function, Adt, Module,
Impl, Crate,
Variant, Field, Static, Const, Trait, TypeAlias, Macro, Function, Adt, Module, Impl, Crate,
];
macro_rules! impl_has_docs_enum {

2
crates/ide-db/src/imports/import_assets.rs
View file

@ -475,8 +475,6 @@ fn validate_resolvable(
}
// FIXME
ModuleDef::Trait(_) => return None,
// FIXME
ModuleDef::TraitAlias(_) => return None,
ModuleDef::TypeAlias(alias) => alias.ty(db),
ModuleDef::BuiltinType(builtin) => builtin.ty(db),
ModuleDef::Adt(adt) => adt.ty(db),

2
crates/ide-db/src/lib.rs
View file

@ -273,7 +273,6 @@ pub enum SymbolKind {
Struct,
ToolModule,
Trait,
TraitAlias,
TypeAlias,
TypeParam,
Union,
@ -306,7 +305,6 @@ impl From<hir::ModuleDef> for SymbolKind {
hir::ModuleDef::Adt(hir::Adt::Enum(..)) => SymbolKind::Enum,
hir::ModuleDef::Adt(hir::Adt::Union(..)) => SymbolKind::Union,
hir::ModuleDef::Trait(..) => SymbolKind::Trait,
hir::ModuleDef::TraitAlias(..) => SymbolKind::TraitAlias,
hir::ModuleDef::TypeAlias(..) => SymbolKind::TypeAlias,
hir::ModuleDef::BuiltinType(..) => SymbolKind::TypeAlias,
}

1
crates/ide-db/src/rename.rs
View file

@ -163,7 +163,6 @@ impl Definition {
Definition::Const(it) => name_range(it, sema).and_then(syn_ctx_is_root),
Definition::Static(it) => name_range(it, sema).and_then(syn_ctx_is_root),
Definition::Trait(it) => name_range(it, sema).and_then(syn_ctx_is_root),
Definition::TraitAlias(it) => name_range(it, sema).and_then(syn_ctx_is_root),
Definition::TypeAlias(it) => name_range(it, sema).and_then(syn_ctx_is_root),
Definition::Local(it) => {
name_range(it.primary_source(sema.db), sema).and_then(syn_ctx_is_root)

1
crates/ide-db/src/search.rs
View file

@ -352,7 +352,6 @@ impl Definition {
hir::GenericDef::Function(it) => it.source(db).map(|src| src.syntax().cloned()),
hir::GenericDef::Adt(it) => it.source(db).map(|src| src.syntax().cloned()),
hir::GenericDef::Trait(it) => it.source(db).map(|src| src.syntax().cloned()),
hir::GenericDef::TraitAlias(it) => it.source(db).map(|src| src.syntax().cloned()),
hir::GenericDef::TypeAlias(it) => it.source(db).map(|src| src.syntax().cloned()),
hir::GenericDef::Impl(it) => it.source(db).map(|src| src.syntax().cloned()),
hir::GenericDef::Const(it) => it.source(db).map(|src| src.syntax().cloned()),

1
crates/ide-db/src/symbol_index.rs
View file

@ -357,7 +357,6 @@ impl Query {
hir::ModuleDef::Adt(..)
| hir::ModuleDef::TypeAlias(..)
| hir::ModuleDef::BuiltinType(..)
| hir::ModuleDef::TraitAlias(..)
| hir::ModuleDef::Trait(..)
);
if non_type_for_type_only_query || !self.matches_assoc_mode(symbol.is_assoc) {

5
crates/ide/src/doc_links.rs
View file

@ -225,7 +225,6 @@ pub(crate) fn resolve_doc_path_for_def(
Definition::Const(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
Definition::Static(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
Definition::Trait(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
Definition::TraitAlias(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
Definition::TypeAlias(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
Definition::Macro(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
Definition::Field(it) => it.resolve_doc_path(db, link, ns, is_inner_doc),
@ -671,11 +670,9 @@ fn filename_and_frag_for_def(
None => String::from("index.html"),
},
Definition::Trait(t) => {
// FIXME(trait-alias): url should be traitalias. for aliases
format!("trait.{}.html", t.name(db).as_str())
}
Definition::TraitAlias(t) => {
format!("traitalias.{}.html", t.name(db).as_str())
}
Definition::TypeAlias(t) => {
format!("type.{}.html", t.name(db).as_str())
}

5
crates/ide/src/file_structure.rs
View file

@ -162,7 +162,6 @@ fn structure_node(node: &SyntaxNode, config: &FileStructureConfig) -> Option<Str
ast::Enum(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Enum)),
ast::Variant(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Variant)),
ast::Trait(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Trait)),
ast::TraitAlias(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::TraitAlias)),
ast::Module(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Module)),
ast::Macro(it) => decl(it, StructureNodeKind::SymbolKind(SymbolKind::Macro)),
ast::TypeAlias(it) => decl_with_type_ref(&it, it.ty(), StructureNodeKind::SymbolKind(SymbolKind::TypeAlias)),
@ -553,7 +552,7 @@ fn let_statements() {
navigation_range: 251..256,
node_range: 245..262,
kind: SymbolKind(
TraitAlias,
Trait,
),
detail: None,
deprecated: false,
@ -944,7 +943,7 @@ fn let_statements() {
navigation_range: 251..256,
node_range: 245..262,
kind: SymbolKind(
TraitAlias,
Trait,
),
detail: None,
deprecated: false,

7
crates/ide/src/folding_ranges.rs
View file

@ -29,7 +29,6 @@ pub enum FoldKind {
Consts,
Statics,
TypeAliases,
TraitAliases,
ExternCrates,
// endregion: item runs
}
@ -147,11 +146,6 @@ pub(crate) fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
res.push(Fold { range, kind: FoldKind::TypeAliases })
}
},
ast::TraitAlias(alias) => {
if let Some(range) = contiguous_range_for_item_group(alias, &mut visited_nodes) {
res.push(Fold { range, kind: FoldKind::TraitAliases })
}
},
ast::ExternCrate(extern_crate) => {
if let Some(range) = contiguous_range_for_item_group(extern_crate, &mut visited_nodes) {
res.push(Fold { range, kind: FoldKind::ExternCrates })
@ -351,7 +345,6 @@ mod tests {
FoldKind::ReturnType => "returntype",
FoldKind::MatchArm => "matcharm",
FoldKind::Function => "function",
FoldKind::TraitAliases => "traitaliases",
FoldKind::ExternCrates => "externcrates",
};
assert_eq!(kind, &attr.unwrap());

1
crates/ide/src/hover/render.rs
View file

@ -401,7 +401,6 @@ fn definition_owner_name(db: &RootDatabase, def: Definition, edition: Edition) -
Definition::GenericParam(generic_param) => match generic_param.parent() {
hir::GenericDef::Adt(it) => Some(it.name(db)),
hir::GenericDef::Trait(it) => Some(it.name(db)),
hir::GenericDef::TraitAlias(it) => Some(it.name(db)),
hir::GenericDef::TypeAlias(it) => Some(it.name(db)),
hir::GenericDef::Impl(i) => i.self_ty(db).as_adt().map(|adt| adt.name(db)),

1
crates/ide/src/moniker.rs
View file

@ -209,7 +209,6 @@ pub(crate) fn def_to_kind(db: &RootDatabase, def: Definition) -> SymbolInformati
Definition::Const(..) => Constant,
Definition::Static(..) => StaticVariable,
Definition::Trait(..) => Trait,
Definition::TraitAlias(..) => Trait,
Definition::TypeAlias(it) => {
if it.as_assoc_item(db).is_some() {
AssociatedType

1
crates/ide/src/move_item.rs
View file

@ -72,7 +72,6 @@ fn find_ancestors(item: SyntaxElement, direction: Direction, range: TextRange) -
SyntaxKind::MACRO_CALL,
SyntaxKind::TYPE_ALIAS,
SyntaxKind::TRAIT,
SyntaxKind::TRAIT_ALIAS,
SyntaxKind::IMPL,
SyntaxKind::MACRO_DEF,
SyntaxKind::STRUCT,

11
crates/ide/src/navigation_target.rs
View file

@ -226,9 +226,6 @@ impl TryToNav for FileSymbol {
hir::ModuleDef::Trait(it) => {
Some(it.display(db, display_target).to_string())
}
hir::ModuleDef::TraitAlias(it) => {
Some(it.display(db, display_target).to_string())
}
hir::ModuleDef::TypeAlias(it) => {
Some(it.display(db, display_target).to_string())
}
@ -261,7 +258,6 @@ impl TryToNav for Definition {
Definition::Const(it) => it.try_to_nav(db),
Definition::Static(it) => it.try_to_nav(db),
Definition::Trait(it) => it.try_to_nav(db),
Definition::TraitAlias(it) => it.try_to_nav(db),
Definition::TypeAlias(it) => it.try_to_nav(db),
Definition::ExternCrateDecl(it) => it.try_to_nav(db),
Definition::InlineAsmOperand(it) => it.try_to_nav(db),
@ -287,7 +283,6 @@ impl TryToNav for hir::ModuleDef {
hir::ModuleDef::Const(it) => it.try_to_nav(db),
hir::ModuleDef::Static(it) => it.try_to_nav(db),
hir::ModuleDef::Trait(it) => it.try_to_nav(db),
hir::ModuleDef::TraitAlias(it) => it.try_to_nav(db),
hir::ModuleDef::TypeAlias(it) => it.try_to_nav(db),
hir::ModuleDef::Macro(it) => it.try_to_nav(db),
hir::ModuleDef::BuiltinType(_) => None,
@ -366,12 +361,6 @@ impl ToNavFromAst for hir::Trait {
container_name(db, self, self.krate(db).edition(db))
}
}
impl ToNavFromAst for hir::TraitAlias {
const KIND: SymbolKind = SymbolKind::TraitAlias;
fn container_name(self, db: &RootDatabase) -> Option<SmolStr> {
container_name(db, self, self.krate(db).edition(db))
}
}
impl<D> TryToNav for D
where

2
crates/ide/src/references.rs
View file

@ -1783,7 +1783,7 @@ trait Bar$0 = Foo where Self: ;
fn foo<T: Bar>(_: impl Bar, _: &dyn Bar) {}
"#,
expect![[r#"
Bar TraitAlias FileId(0) 13..42 19..22
Bar Trait FileId(0) 13..42 19..22
FileId(0) 53..56
FileId(0) 66..69

1
crates/ide/src/runnables.rs
View file

@ -493,7 +493,6 @@ fn module_def_doctest(db: &RootDatabase, def: Definition) -> Option<Runnable> {
Definition::Const(it) => it.attrs(db),
Definition::Static(it) => it.attrs(db),
Definition::Trait(it) => it.attrs(db),
Definition::TraitAlias(it) => it.attrs(db),
Definition::TypeAlias(it) => it.attrs(db),
Definition::Macro(it) => it.attrs(db),
Definition::SelfType(it) => it.attrs(db),

4
crates/ide/src/signature_help.rs
View file

@ -339,10 +339,6 @@ fn signature_help_for_generics(
res.doc = it.docs(db);
format_to!(res.signature, "trait {}", it.name(db).display(db, edition));
}
hir::GenericDef::TraitAlias(it) => {
res.doc = it.docs(db);
format_to!(res.signature, "trait {}", it.name(db).display(db, edition));
}
hir::GenericDef::TypeAlias(it) => {
res.doc = it.docs(db);
format_to!(res.signature, "type {}", it.name(db).display(db, edition));

2
crates/ide/src/syntax_highlighting/highlight.rs
View file

@ -576,7 +576,6 @@ pub(super) fn highlight_def(
h
}
Definition::Trait(_) => Highlight::new(HlTag::Symbol(SymbolKind::Trait)),
Definition::TraitAlias(_) => Highlight::new(HlTag::Symbol(SymbolKind::TraitAlias)),
Definition::TypeAlias(type_) => {
let mut h = Highlight::new(HlTag::Symbol(SymbolKind::TypeAlias));
@ -780,7 +779,6 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
MACRO_RULES => SymbolKind::Macro,
CONST_PARAM => SymbolKind::ConstParam,
SELF_PARAM => SymbolKind::SelfParam,
TRAIT_ALIAS => SymbolKind::TraitAlias,
ASM_OPERAND_NAMED => SymbolKind::Local,
_ => return default.into(),
};

1
crates/ide/src/syntax_highlighting/inject.rs
View file

@ -311,7 +311,6 @@ fn module_def_to_hl_tag(def: Definition) -> HlTag {
Definition::Const(_) => SymbolKind::Const,
Definition::Static(_) => SymbolKind::Static,
Definition::Trait(_) => SymbolKind::Trait,
Definition::TraitAlias(_) => SymbolKind::TraitAlias,
Definition::TypeAlias(_) => SymbolKind::TypeAlias,
Definition::BuiltinLifetime(_) => SymbolKind::LifetimeParam,
Definition::BuiltinType(_) => return HlTag::BuiltinType,

1
crates/ide/src/syntax_highlighting/tags.rs
View file

@ -160,7 +160,6 @@ impl HlTag {
SymbolKind::Struct => "struct",
SymbolKind::ToolModule => "tool_module",
SymbolKind::Trait => "trait",
SymbolKind::TraitAlias => "trait_alias",
SymbolKind::TypeAlias => "type_alias",
SymbolKind::TypeParam => "type_param",
SymbolKind::Union => "union",

4
crates/ide/src/syntax_highlighting/test_data/highlight_strings.html
View file

@ -78,8 +78,8 @@ pre { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
<span class="brace">}</span>
<span class="keyword">use</span> <span class="unresolved_reference">foo</span><span class="operator">::</span><span class="unresolved_reference">bar</span> <span class="keyword">as</span> <span class="variable declaration">baz</span><span class="semicolon">;</span>
<span class="keyword">trait</span> <span class="trait_alias declaration">Bar</span> <span class="operator">=</span> <span class="unresolved_reference">Baz</span><span class="semicolon">;</span>
<span class="keyword">trait</span> <span class="trait_alias declaration">Foo</span> <span class="operator">=</span> <span class="trait_alias">Bar</span><span class="semicolon">;</span>
<span class="keyword">trait</span> <span class="trait declaration">Bar</span> <span class="operator">=</span> <span class="unresolved_reference">Baz</span><span class="semicolon">;</span>
<span class="keyword">trait</span> <span class="trait declaration">Foo</span> <span class="operator">=</span> <span class="trait">Bar</span><span class="semicolon">;</span>
<span class="keyword">fn</span> <span class="function declaration">main</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
<span class="keyword">let</span> <span class="variable declaration">a</span> <span class="operator">=</span> <span class="char_literal">'</span><span class="escape_sequence">\n</span><span class="char_literal">'</span><span class="semicolon">;</span>

2
crates/parser/src/grammar/items/traits.rs
View file

@ -20,7 +20,7 @@ pub(super) fn trait_(p: &mut Parser<'_>, m: Marker) {
// trait Z<U> = where Self: T<U>;
generic_params::opt_where_clause(p);
p.expect(T![;]);
m.complete(p, TRAIT_ALIAS);
m.complete(p, TRAIT);
return;
}

2
crates/parser/src/syntax_kind/generated.rs
View file

@ -284,7 +284,6 @@ pub enum SyntaxKind {
STRUCT,
TOKEN_TREE,
TRAIT,
TRAIT_ALIAS,
TRY_EXPR,
TUPLE_EXPR,
TUPLE_FIELD,
@ -457,7 +456,6 @@ impl SyntaxKind {
| STRUCT
| TOKEN_TREE
| TRAIT
| TRAIT_ALIAS
| TRY_EXPR
| TUPLE_EXPR
| TUPLE_FIELD

2
crates/parser/test_data/parser/inline/ok/trait_alias.rast
View file

@ -1,5 +1,5 @@
SOURCE_FILE
TRAIT_ALIAS
TRAIT
TRAIT_KW "trait"
WHITESPACE " "
NAME

4
crates/parser/test_data/parser/inline/ok/trait_alias_where_clause.rast
View file

@ -1,5 +1,5 @@
SOURCE_FILE
TRAIT_ALIAS
TRAIT
TRAIT_KW "trait"
WHITESPACE " "
NAME
@ -50,7 +50,7 @@ SOURCE_FILE
IDENT "Copy"
SEMICOLON ";"
WHITESPACE "\n"
TRAIT_ALIAS
TRAIT
TRAIT_KW "trait"
WHITESPACE " "
NAME

5
crates/rust-analyzer/src/lsp/to_proto.rs
View file

@ -61,7 +61,7 @@ pub(crate) fn symbol_kind(symbol_kind: SymbolKind) -> lsp_types::SymbolKind {
SymbolKind::Struct => lsp_types::SymbolKind::STRUCT,
SymbolKind::Enum => lsp_types::SymbolKind::ENUM,
SymbolKind::Variant => lsp_types::SymbolKind::ENUM_MEMBER,
SymbolKind::Trait | SymbolKind::TraitAlias => lsp_types::SymbolKind::INTERFACE,
SymbolKind::Trait => lsp_types::SymbolKind::INTERFACE,
SymbolKind::Macro
| SymbolKind::ProcMacro
| SymbolKind::BuiltinAttr
@ -156,7 +156,6 @@ pub(crate) fn completion_item_kind(
SymbolKind::Static => lsp_types::CompletionItemKind::VALUE,
SymbolKind::Struct => lsp_types::CompletionItemKind::STRUCT,
SymbolKind::Trait => lsp_types::CompletionItemKind::INTERFACE,
SymbolKind::TraitAlias => lsp_types::CompletionItemKind::INTERFACE,
SymbolKind::TypeAlias => lsp_types::CompletionItemKind::STRUCT,
SymbolKind::TypeParam => lsp_types::CompletionItemKind::TYPE_PARAMETER,
SymbolKind::Union => lsp_types::CompletionItemKind::STRUCT,
@ -817,7 +816,6 @@ fn semantic_token_type_and_modifiers(
SymbolKind::Union => types::UNION,
SymbolKind::TypeAlias => types::TYPE_ALIAS,
SymbolKind::Trait => types::INTERFACE,
SymbolKind::TraitAlias => types::INTERFACE,
SymbolKind::Macro => types::MACRO,
SymbolKind::ProcMacro => types::PROC_MACRO,
SymbolKind::BuiltinAttr => types::BUILTIN_ATTRIBUTE,
@ -909,7 +907,6 @@ pub(crate) fn folding_range(
| FoldKind::WhereClause
| FoldKind::ReturnType
| FoldKind::Array
| FoldKind::TraitAliases
| FoldKind::ExternCrates
| FoldKind::MatchArm
| FoldKind::Function => None,

3
crates/span/src/ast_id.rs
View file

@ -485,8 +485,7 @@ register_has_name_ast_id! {
MacroRules = name,
Module = name,
Static = name,
Trait = name,
TraitAlias = name
Trait = name
}
macro_rules! register_assoc_item_ast_id {

8
crates/syntax/rust.ungram
View file

@ -154,7 +154,6 @@ Item =
| Static
| Struct
| Trait
| TraitAlias
| TypeAlias
| Union
| Use
@ -306,11 +305,8 @@ Trait =
Attr* Visibility?
'unsafe'? 'auto'?
'trait' Name GenericParamList?
(':' TypeBoundList?)? WhereClause? AssocItemList
TraitAlias =
Attr* Visibility?
'trait' Name GenericParamList? '=' TypeBoundList? WhereClause? ';'
(((':' TypeBoundList?)? WhereClause? AssocItemList) |
('=' TypeBoundList? WhereClause? ';'))
AssocItemList =
'{' Attr* AssocItem* '}'

3
crates/syntax/src/ast.rs
View file

@ -26,8 +26,7 @@ pub use self::{
generated::{nodes::*, tokens::*},
node_ext::{
AttrKind, FieldKind, Macro, NameLike, NameOrNameRef, PathSegmentKind, SelfParamKind,
SlicePatComponents, StructKind, TraitOrAlias, TypeBoundKind, TypeOrConstParam,
VisibilityKind,
SlicePatComponents, StructKind, TypeBoundKind, TypeOrConstParam, VisibilityKind,
},
operators::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering, RangeOp, UnaryOp},
token_ext::{CommentKind, CommentPlacement, CommentShape, IsString, QuoteOffsets, Radix},

36
crates/syntax/src/ast/edit_in_place.rs
View file

@ -99,38 +99,10 @@ impl GenericParamsOwnerEdit for ast::Trait {
fn get_or_create_where_clause(&self) -> ast::WhereClause {
if self.where_clause().is_none() {
let position = match self.assoc_item_list() {
Some(items) => Position::before(items.syntax()),
None => Position::last_child_of(self.syntax()),
};
create_where_clause(position);
}
self.where_clause().unwrap()
}
}
impl GenericParamsOwnerEdit for ast::TraitAlias {
fn get_or_create_generic_param_list(&self) -> ast::GenericParamList {
match self.generic_param_list() {
Some(it) => it,
None => {
let position = if let Some(name) = self.name() {
Position::after(name.syntax)
} else if let Some(trait_token) = self.trait_token() {
Position::after(trait_token)
} else {
Position::last_child_of(self.syntax())
};
create_generic_param_list(position)
}
}
}
fn get_or_create_where_clause(&self) -> ast::WhereClause {
if self.where_clause().is_none() {
let position = match self.semicolon_token() {
Some(tok) => Position::before(tok),
None => Position::last_child_of(self.syntax()),
let position = match (self.assoc_item_list(), self.semicolon_token()) {
(Some(items), _) => Position::before(items.syntax()),
(_, Some(tok)) => Position::before(tok),
(None, None) => Position::last_child_of(self.syntax()),
};
create_where_clause(position);
}

97
crates/syntax/src/ast/generated/nodes.rs
View file

@ -1614,30 +1614,16 @@ impl Trait {
#[inline]
pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
#[inline]
pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
#[inline]
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
#[inline]
pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) }
#[inline]
pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
#[inline]
pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
}
pub struct TraitAlias {
pub(crate) syntax: SyntaxNode,
}
impl ast::HasAttrs for TraitAlias {}
impl ast::HasDocComments for TraitAlias {}
impl ast::HasGenericParams for TraitAlias {}
impl ast::HasName for TraitAlias {}
impl ast::HasVisibility for TraitAlias {}
impl TraitAlias {
#[inline]
pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) }
#[inline]
pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
#[inline]
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
#[inline]
pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
}
pub struct TryExpr {
pub(crate) syntax: SyntaxNode,
}
@ -2107,7 +2093,6 @@ pub enum Item {
Static(Static),
Struct(Struct),
Trait(Trait),
TraitAlias(TraitAlias),
TypeAlias(TypeAlias),
Union(Union),
Use(Use),
@ -6801,42 +6786,6 @@ impl fmt::Debug for Trait {
f.debug_struct("Trait").field("syntax", &self.syntax).finish()
}
}
impl AstNode for TraitAlias {
#[inline]
fn kind() -> SyntaxKind
where
Self: Sized,
{
TRAIT_ALIAS
}
#[inline]
fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_ALIAS }
#[inline]
fn cast(syntax: SyntaxNode) -> Option<Self> {
if Self::can_cast(syntax.kind()) {
Some(Self { syntax })
} else {
None
}
}
#[inline]
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl hash::Hash for TraitAlias {
fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
}
impl Eq for TraitAlias {}
impl PartialEq for TraitAlias {
fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
}
impl Clone for TraitAlias {
fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
}
impl fmt::Debug for TraitAlias {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("TraitAlias").field("syntax", &self.syntax).finish()
}
}
impl AstNode for TryExpr {
#[inline]
fn kind() -> SyntaxKind
@ -8471,10 +8420,6 @@ impl From<Trait> for Item {
#[inline]
fn from(node: Trait) -> Item { Item::Trait(node) }
}
impl From<TraitAlias> for Item {
#[inline]
fn from(node: TraitAlias) -> Item { Item::TraitAlias(node) }
}
impl From<TypeAlias> for Item {
#[inline]
fn from(node: TypeAlias) -> Item { Item::TypeAlias(node) }
@ -8506,7 +8451,6 @@ impl AstNode for Item {
| STATIC
| STRUCT
| TRAIT
| TRAIT_ALIAS
| TYPE_ALIAS
| UNION
| USE
@ -8529,7 +8473,6 @@ impl AstNode for Item {
STATIC => Item::Static(Static { syntax }),
STRUCT => Item::Struct(Struct { syntax }),
TRAIT => Item::Trait(Trait { syntax }),
TRAIT_ALIAS => Item::TraitAlias(TraitAlias { syntax }),
TYPE_ALIAS => Item::TypeAlias(TypeAlias { syntax }),
UNION => Item::Union(Union { syntax }),
USE => Item::Use(Use { syntax }),
@ -8554,7 +8497,6 @@ impl AstNode for Item {
Item::Static(it) => &it.syntax,
Item::Struct(it) => &it.syntax,
Item::Trait(it) => &it.syntax,
Item::TraitAlias(it) => &it.syntax,
Item::TypeAlias(it) => &it.syntax,
Item::Union(it) => &it.syntax,
Item::Use(it) => &it.syntax,
@ -8984,7 +8926,6 @@ impl AstNode for AnyHasAttrs {
| STMT_LIST
| STRUCT
| TRAIT
| TRAIT_ALIAS
| TRY_EXPR
| TUPLE_EXPR
| TUPLE_FIELD
@ -9257,10 +9198,6 @@ impl From<Trait> for AnyHasAttrs {
#[inline]
fn from(node: Trait) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<TraitAlias> for AnyHasAttrs {
#[inline]
fn from(node: TraitAlias) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
}
impl From<TryExpr> for AnyHasAttrs {
#[inline]
fn from(node: TryExpr) -> AnyHasAttrs { AnyHasAttrs { syntax: node.syntax } }
@ -9330,7 +9267,6 @@ impl AstNode for AnyHasDocComments {
| STATIC
| STRUCT
| TRAIT
| TRAIT_ALIAS
| TUPLE_FIELD
| TYPE_ALIAS
| UNION
@ -9420,10 +9356,6 @@ impl From<Trait> for AnyHasDocComments {
#[inline]
fn from(node: Trait) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<TraitAlias> for AnyHasDocComments {
#[inline]
fn from(node: TraitAlias) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
}
impl From<TupleField> for AnyHasDocComments {
#[inline]
fn from(node: TupleField) -> AnyHasDocComments { AnyHasDocComments { syntax: node.syntax } }
@ -9488,7 +9420,7 @@ impl ast::HasGenericParams for AnyHasGenericParams {}
impl AstNode for AnyHasGenericParams {
#[inline]
fn can_cast(kind: SyntaxKind) -> bool {
matches!(kind, CONST | ENUM | FN | IMPL | STRUCT | TRAIT | TRAIT_ALIAS | TYPE_ALIAS | UNION)
matches!(kind, CONST | ENUM | FN | IMPL | STRUCT | TRAIT | TYPE_ALIAS | UNION)
}
#[inline]
fn cast(syntax: SyntaxNode) -> Option<Self> {
@ -9536,10 +9468,6 @@ impl From<Trait> for AnyHasGenericParams {
#[inline]
fn from(node: Trait) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
}
impl From<TraitAlias> for AnyHasGenericParams {
#[inline]
fn from(node: TraitAlias) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
}
impl From<TypeAlias> for AnyHasGenericParams {
#[inline]
fn from(node: TypeAlias) -> AnyHasGenericParams { AnyHasGenericParams { syntax: node.syntax } }
@ -9646,7 +9574,6 @@ impl AstNode for AnyHasName {
| STATIC
| STRUCT
| TRAIT
| TRAIT_ALIAS
| TYPE_ALIAS
| TYPE_PARAM
| UNION
@ -9739,10 +9666,6 @@ impl From<Trait> for AnyHasName {
#[inline]
fn from(node: Trait) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<TraitAlias> for AnyHasName {
#[inline]
fn from(node: TraitAlias) -> AnyHasName { AnyHasName { syntax: node.syntax } }
}
impl From<TypeAlias> for AnyHasName {
#[inline]
fn from(node: TypeAlias) -> AnyHasName { AnyHasName { syntax: node.syntax } }
@ -9832,7 +9755,6 @@ impl AstNode for AnyHasVisibility {
| STATIC
| STRUCT
| TRAIT
| TRAIT_ALIAS
| TUPLE_FIELD
| TYPE_ALIAS
| UNION
@ -9910,10 +9832,6 @@ impl From<Trait> for AnyHasVisibility {
#[inline]
fn from(node: Trait) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<TraitAlias> for AnyHasVisibility {
#[inline]
fn from(node: TraitAlias) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
}
impl From<TupleField> for AnyHasVisibility {
#[inline]
fn from(node: TupleField) -> AnyHasVisibility { AnyHasVisibility { syntax: node.syntax } }
@ -10639,11 +10557,6 @@ impl std::fmt::Display for Trait {
std::fmt::Display::fmt(self.syntax(), f)
}
}
impl std::fmt::Display for TraitAlias {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Display::fmt(self.syntax(), f)
}
}
impl std::fmt::Display for TryExpr {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Display::fmt(self.syntax(), f)

45
crates/syntax/src/ast/node_ext.rs
View file

@ -880,51 +880,6 @@ impl AstNode for TypeOrConstParam {
impl HasAttrs for TypeOrConstParam {}
#[derive(Debug, Clone)]
pub enum TraitOrAlias {
Trait(ast::Trait),
TraitAlias(ast::TraitAlias),
}
impl TraitOrAlias {
pub fn name(&self) -> Option<ast::Name> {
match self {
TraitOrAlias::Trait(x) => x.name(),
TraitOrAlias::TraitAlias(x) => x.name(),
}
}
}
impl AstNode for TraitOrAlias {
fn can_cast(kind: SyntaxKind) -> bool
where
Self: Sized,
{
matches!(kind, SyntaxKind::TRAIT | SyntaxKind::TRAIT_ALIAS)
}
fn cast(syntax: SyntaxNode) -> Option<Self>
where
Self: Sized,
{
let res = match syntax.kind() {
SyntaxKind::TRAIT => TraitOrAlias::Trait(ast::Trait { syntax }),
SyntaxKind::TRAIT_ALIAS => TraitOrAlias::TraitAlias(ast::TraitAlias { syntax }),
_ => return None,
};
Some(res)
}
fn syntax(&self) -> &SyntaxNode {
match self {
TraitOrAlias::Trait(it) => it.syntax(),
TraitOrAlias::TraitAlias(it) => it.syntax(),
}
}
}
impl HasAttrs for TraitOrAlias {}
pub enum VisibilityKind {
In(ast::Path),
PubCrate,

1
xtask/src/codegen/grammar.rs
View file

@ -1081,7 +1081,6 @@ fn extract_struct_traits(ast: &mut AstSrc) {
"Enum",
"Variant",
"Trait",
"TraitAlias",
"Module",
"Static",
"Const",