Fix a panic in ast::TypeBound::kind()

Author: ChayimFriedman2

src/tools/rust-analyzer/crates/hir-def/src/expr_store/lower.rs

@@ -949,7 +949,8 @@ impl<'db> ExprCollector<'db> {
         node: ast::TypeBound,
         impl_trait_lower_fn: ImplTraitLowerFn<'_>,
     ) -> TypeBound {
-        match node.kind() {
+        let Some(kind) = node.kind() else { return TypeBound::Error };
+        match kind {
             ast::TypeBoundKind::PathType(binder, path_type) => {
                 let binder = match binder.and_then(|it| it.generic_param_list()) {
                     Some(gpl) => gpl

src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/signatures.rs

@@ -197,3 +197,15 @@ fn allowed3(baz: impl Baz<Assoc = Qux<impl Foo>>) {}
         "#]],
     );
 }
+
+#[test]
+fn regression_21138() {
+    lower_and_print(
+        r#"
+fn foo(v: for<'a> Trait1 + Trait2) {}
+    "#,
+        expect![[r#"
+            fn foo(dyn for<'a> Trait1 + Trait2) {...}
+        "#]],
+    );
+}

src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs

@@ -813,13 +813,16 @@ pub enum TypeBoundKind {
 }
 
 impl ast::TypeBound {
-    pub fn kind(&self) -> TypeBoundKind {
+    pub fn kind(&self) -> Option<TypeBoundKind> {
         if let Some(path_type) = support::children(self.syntax()).next() {
-            TypeBoundKind::PathType(self.for_binder(), path_type)
+            Some(TypeBoundKind::PathType(self.for_binder(), path_type))
+        } else if let Some(for_binder) = support::children::<ast::ForType>(&self.syntax).next() {
+            let Some(ast::Type::PathType(path_type)) = for_binder.ty() else { return None };
+            Some(TypeBoundKind::PathType(for_binder.for_binder(), path_type))
         } else if let Some(args) = self.use_bound_generic_args() {
-            TypeBoundKind::Use(args)
+            Some(TypeBoundKind::Use(args))
         } else if let Some(lifetime) = self.lifetime() {
-            TypeBoundKind::Lifetime(lifetime)
+            Some(TypeBoundKind::Lifetime(lifetime))
         } else {
             unreachable!()
         }