Done. Here's what I changed to address the reviewer's concern:

Problem: The previous fix used new ObjectType($className) which strips generic type parameters — e.g., ReflectionClass<*> would become plain ReflectionClass, and TemplateObjectType would lose its template information.

Fix: Instead of iterating over $typeWithMethod->getObjectClassNames() and reconstructing plain ObjectTypes, the code now:

1. Splits the type into its constituent parts: $typeWithMethod instanceof UnionType ? $typeWithMethod->getTypes() : [$typeWithMethod]
2. For each inner type, gets class names via $innerType->getObjectClassNames()
3. Gets method reflection from the original inner type ($innerType->getMethod(...)) which preserves GenericObjectType, TemplateObjectType, etc.
4. Still iterates over class names for extension lookup (since extensions are registered per class name)

Both make tests and make phpstan pass cleanly.

Done. Here's a summary of the changes:

What changed:

1. Reverted MethodCallReturnTypeHelper.php back to its original state — no more union type inner type iteration or per-class method reflection.

2. Simplified ReflectionGetAttributesMethodReturnTypeExtension::isMethodSupported() — removed the $methodReflection->getDeclaringClass()->getName() === $this->className check, leaving only the method name check (getName() === 'getAttributes'). This is safe because the getClass() method + extension registry already ensures each extension instance is only invoked for the correct class hierarchy.

3. Added @phpstan-ignore method.notFound on ClassReflection.php:1573 — the getArgumentsExpressions() method exists on BetterReflection's ReflectionAttribute adapter but not on native PHP's ReflectionAttribute. Removing the declaring class check causes the extension to fire on PHPStan's self-analysis (where BetterReflection overrides getAttributes() with declaring class PHPStan\BetterReflection\Reflection\Adapter\ReflectionClass instead of ReflectionClass), exposing this pre-existing type mismatch.

Why this works: The declaring class check was redundant because DynamicReturnTypeExtensionRegistry::getDynamicExtensionsForType() already walks the class hierarchy when looking up extensions. The check was also the root cause of the union type bug — UnionTypeMethodReflection::getDeclaringClass() returns only the first member's declaring class, so extensions registered for other union members were never matched.

I processed this review but have nothing to report.

Done. Here's what I changed to address the reviewer's feedback:

Problem: The previous approach used !str_contains($methodReflection->getDeclaringClass()->getName(), '\\') in isMethodSupported() as a hack to skip BetterReflection adapter classes. The reviewer suggested improving getTypeFromMethodCall() instead.

Fix:

1. Simplified isMethodSupported() — now only checks getName() === 'getAttributes', no declaring class filtering
2. Added resolveReflectionAttributeClassName() — inspects the method's declared return type to determine which ReflectionAttribute class to use in the GenericObjectType:
   • For native reflection classes: return type is ReflectionAttribute[] → resolves to ReflectionAttribute
   • For BetterReflection adapters: return type is list<BRAdapter\ReflectionAttribute|FakeReflectionAttribute> → resolves to BRAdapter\ReflectionAttribute (which extends native ReflectionAttribute), preserving methods like getArgumentsExpressions()

This approach uses ObjectType::isSuperTypeOf() to find the correct class from the iterable value type, which is type-system-native and handles the class hierarchy properly.

Done. Here's what I changed to address the reviewer's feedback:

Change: When resolveReflectionAttributeClassNames finds multiple classes that extend ReflectionAttribute, instead of falling back to the base ReflectionAttribute::class, the code now returns all matching class names and creates a union of GenericObjectType for each one using TypeCombinator::union().

For example, if a method returns array<Attribute1|Attribute2> where both extend ReflectionAttribute, the result will be list<ReflectionAttribute<I>|ReflectionAttribute2<I>> (a union of generic types) rather than just list<ReflectionAttribute<I>>.

The single-match case still works the same — TypeCombinator::union() with one type just returns that type.

Both make tests and make phpstan pass cleanly.

Done. The change renames resolveReflectionAttributeClassNames to resolveReflectionAttributeType and has it return the Type directly (GenericObjectType for single match, UnionType via TypeCombinator::union for multiple matches) instead of returning class name strings. This avoids the unnecessary TypeCombinator::union call in the common single-match case. Both make tests and make phpstan pass cleanly.

Done. The fix uses early exit (continue with negated condition) in the foreach loop at line 60 of ReflectionGetAttributesMethodReturnTypeExtension.php to reduce nesting, addressing the SlevomatCodingStandard.ControlStructures.EarlyExit.EarlyExitNotUsed coding standard violation. Both make tests and make phpstan pass cleanly.

WDYT @janedbal ?

lgtm - when/how did this break with 2.1.47+ ?

Previously ReflectionClass|ReflectionMethod was handled by the returnTypeDynamicExtension this way.

• Find a match for ReflectionClass get the return type
• Find no match for ReflectionMethod ignore
• Return the result

In 2.1.47, we fix the fact that since ReflectionMethod was ignored we should still add the return type of ReflectionMethod.

Now we solve the issue by fixing the ReflectiongetAttributesMethod to correctly match ReflectionMethod too. And since all type are handled we don't use the default return type anymore.

thank you