add callable template default type support

src/DocBlock/TypeExpression.php

@@ -78,6 +78,10 @@ final class TypeExpression
                                     \h+(?i)(?<callable_template_inner_b_kw>of|as)(?-i)\h+
                                     (?<callable_template_inner_b_types>(?&types_inner))
                                 |)
+                                (?<callable_template_inner_d>
+                                    \h*=\h*
+                                    (?<callable_template_inner_d_types>(?&types_inner))
+                                |)
                             )
                             (?:
                                 \h*,\h*
@@ -514,6 +518,14 @@ private function parseCallableTemplateInnerTypes(int $startIndex, string $value)
                 ];
             }
 
+            if ('' !== $matches['callable_template_inner_d'][0]) {
+                $this->innerTypeExpressions[] = [
+                    'start_index' => $startIndex + $index + $matches['callable_template_inner_d_types'][1]
+                        - \strlen($addedPrefix),
+                    'expression' => $this->inner($matches['callable_template_inner_d_types'][0]),
+                ];
+            }
+
             $index += $consumedValueLength + $consumedCommaLength;
         }
     }

tests/DocBlock/TypeExpressionTest.php

@@ -219,6 +219,10 @@ public static function provideGetTypesCases(): iterable
 
         yield ['Closure< T1 of Foo, T2 AS Foo >(T1): T2'];
 
+        yield ['Closure<T = Foo>(T): T'];
+
+        yield ['Closure<T1=int, T2 of Foo = Foo2>(T1): T2'];
+
         yield ['Closure<Closure_can_be_regular_class>'];
 
         yield ['Closure(int $a)'];
@@ -835,11 +839,16 @@ public static function provideSortTypesCases(): iterable
             'Closure<B, A>(x|y, A|B|U<o|p>): (B|X|Y)',
         ];
 
-        yield 'generic Closure with narrowed template' => [
+        yield 'generic Closure with bound template' => [
             'Closure<B of J|I, C, A of V|U, D of object>(B|A): array{B, A, B, C, D}',
             'Closure<B of I|J, C, A of U|V, D of object>(A|B): array{B, A, B, C, D}',
         ];
 
+        yield 'generic Closure with template with default' => [
+            'Closure<T = B&A>(T): void',
+            'Closure<T = A&B>(T): void',
+        ];
+
         yield 'nullable generic' => [
             '?array<Foo|Bar>',
             '?array<Bar|Foo>',