refactor: leverage HasAttrs for code brevity

crates/hir-def/src/attr.rs

@@ -315,26 +315,14 @@ impl AttrsWithOwner {
                     let src = it.parent().child_source(db);
                     RawAttrs::from_attrs_owner(
                         db.upcast(),
-                        src.with_value(src.value[it.local_id()].as_ref().either(
+                        src.with_value(&src.value[it.local_id()]),
-                            |it| match it {
-                                ast::TypeOrConstParam::Type(it) => it as _,
-                                ast::TypeOrConstParam::Const(it) => it as _,
-                            },
-                            |it| it as _,
-                        )),
                     )
                 }
                 GenericParamId::TypeParamId(it) => {
                     let src = it.parent().child_source(db);
                     RawAttrs::from_attrs_owner(
                         db.upcast(),
-                        src.with_value(src.value[it.local_id()].as_ref().either(
+                        src.with_value(&src.value[it.local_id()]),
-                            |it| match it {
-                                ast::TypeOrConstParam::Type(it) => it as _,
-                                ast::TypeOrConstParam::Const(it) => it as _,
-                            },
-                            |it| it as _,
-                        )),
                     )
                 }
                 GenericParamId::LifetimeParamId(it) => {
@@ -412,28 +400,14 @@ impl AttrsWithOwner {
             },
             AttrDefId::ImplId(id) => id.lookup(db).source(db).map(ast::AnyHasAttrs::new),
             AttrDefId::GenericParamId(id) => match id {
-                GenericParamId::ConstParamId(id) => {
+                GenericParamId::ConstParamId(id) => id
-                    id.parent().child_source(db).map(|source| match &source[id.local_id()] {
+                    .parent()
-                        Either::Left(ast::TypeOrConstParam::Type(id)) => {
+                    .child_source(db)
-                            ast::AnyHasAttrs::new(id.clone())
+                    .map(|source| ast::AnyHasAttrs::new(source[id.local_id()].clone())),
-                        }
+                GenericParamId::TypeParamId(id) => id
-                        Either::Left(ast::TypeOrConstParam::Const(id)) => {
+                    .parent()
-                            ast::AnyHasAttrs::new(id.clone())
+                    .child_source(db)
-                        }
+                    .map(|source| ast::AnyHasAttrs::new(source[id.local_id()].clone())),
-                        Either::Right(id) => ast::AnyHasAttrs::new(id.clone()),
-                    })
-                }
-                GenericParamId::TypeParamId(id) => {
-                    id.parent().child_source(db).map(|source| match &source[id.local_id()] {
-                        Either::Left(ast::TypeOrConstParam::Type(id)) => {
-                            ast::AnyHasAttrs::new(id.clone())
-                        }
-                        Either::Left(ast::TypeOrConstParam::Const(id)) => {
-                            ast::AnyHasAttrs::new(id.clone())
-                        }
-                        Either::Right(id) => ast::AnyHasAttrs::new(id.clone()),
-                    })
-                }
                 GenericParamId::LifetimeParamId(id) => id
                     .parent
                     .child_source(db)

crates/syntax/src/ast.rs

@@ -129,6 +129,13 @@ where
     }
 }
 
+impl<L, R> HasAttrs for Either<L, R>
+where
+    L: HasAttrs,
+    R: HasAttrs,
+{
+}
+
 mod support {
     use super::{AstChildren, AstNode, SyntaxKind, SyntaxNode, SyntaxToken};
 

crates/syntax/src/ast/node_ext.rs

@@ -680,6 +680,36 @@ impl TypeOrConstParam {
     }
 }
 
+impl AstNode for TypeOrConstParam {
+    fn can_cast(kind: SyntaxKind) -> bool
+    where
+        Self: Sized,
+    {
+        matches!(kind, SyntaxKind::TYPE_PARAM | SyntaxKind::CONST_PARAM)
+    }
+
+    fn cast(syntax: SyntaxNode) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        let res = match syntax.kind() {
+            SyntaxKind::TYPE_PARAM => TypeOrConstParam::Type(ast::TypeParam { syntax }),
+            SyntaxKind::CONST_PARAM => TypeOrConstParam::Const(ast::ConstParam { syntax }),
+            _ => return None,
+        };
+        Some(res)
+    }
+
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            TypeOrConstParam::Type(it) => it.syntax(),
+            TypeOrConstParam::Const(it) => it.syntax(),
+        }
+    }
+}
+
+impl HasAttrs for TypeOrConstParam {}
+
 #[derive(Debug, Clone)]
 pub enum TraitOrAlias {
     Trait(ast::Trait),