fix errors after rebase

crates/hir-def/src/signatures.rs

@@ -402,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;
     }
 }
 
@@ -426,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;
         }

crates/hir-ty/src/lower_nextsolver/path.rs

@@ -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(_) => {}
         }
     }
 

crates/hir-ty/src/next_solver/def_id.rs

@@ -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),

crates/hir-ty/src/next_solver/interner.rs

@@ -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 {

crates/ide/src/file_structure.rs

@@ -943,7 +943,7 @@ fn let_statements() {
                         navigation_range: 251..256,
                         node_range: 245..262,
                         kind: SymbolKind(
-                            TraitAlias,
+                            Trait,
                         ),
                         detail: None,
                         deprecated: false,