Preserve template bound for enum-case, integer-range, constant-float and constant-bool subtypes in TemplateTypeFactory::create()

[phpstan-bot]

Summary

When a template-typed variable was narrowed by a comparison (e.g. Foo::Abc === $foo where $foo is TFoo of Foo::*), PHPStan lost the generic type information: the narrowed value became TFoo of mixed instead of TFoo of Foo::Abc, which then caused spurious argument.type errors such as "expects Foo::Abc|Foo::Bcd, TFoo given".

The root cause is in TemplateTypeFactory::create(), which builds the Template* wrapper for a narrowed/computed bound. It dispatched on the exact bound class via get_class(), so any bound that is a subtype of a handled base type but lacks its own dedicated Template* class fell through to the final TemplateMixedType catch-all — silently widening the bound to mixed.

Changes

• src/Type/Generic/TemplateTypeFactory.php:
  • Reordered the GenericObjectType branch before the ObjectType branch and broadened the latter to accept any ObjectType subtype (notably EnumCaseObjectType), mapping it to TemplateObjectType with the precise bound preserved.
  • Routed IntegerRangeType (subtype of IntegerType) to TemplateIntegerType.
  • Routed ConstantFloatType (subtype of FloatType) to TemplateFloatType.
  • Routed constant booleans (detected via isTrue()/isFalse()) to TemplateBooleanType.
• tests/PHPStan/Type/TypeCombinatorTest.php: updated data set Fixed broken travis config #67, which previously asserted the buggy TemplateMixedType / 'T (class Foo, parameter)' result and carried // should be ... comments; it now expects TemplateBooleanType / 'T of true (class Foo, parameter)'.

Root cause

TemplateTypeFactory::create() is a dispatch table that maps a bound Type to the matching Template* type. Each branch guarded with $boundClass === SomeType::class to avoid catching subtypes that need their own wrapper. But several concrete subtypes have no dedicated wrapper:

• EnumCaseObjectType (← ObjectType)
• IntegerRangeType (← IntegerType)
• ConstantFloatType (← FloatType)
• ConstantBooleanType (← BooleanType)

For these, the strict checks skipped every branch and the function fell through to return new TemplateMixedType(...), discarding the bound. The fix routes each of these subtypes to the appropriate base Template* class (which stores the precise bound), so narrowing a template variable keeps its generic identity and bound.

Test

• tests/PHPStan/Analyser/nsrt/bug-10083.php — a new regression test that mirrors the issue and also covers the analogous families:
  • enum-case narrowing of TFoo of Foo::* in both branches of an if and through a ternary (the reported case),
  • integer-range narrowing of TInt of int (>= 0 && <= 5 → TInt of int<0, 5>),
  • float narrowing of TFloat of 1.0|2.0 (=== 1.0 → TFloat of 1.0).
    All assertions fail before the fix (the bound shows as mixed) and pass after.
• The boolean case is exercised by TypeCombinatorTest::testRemove data set Fixed broken travis config #67 (removing false from a T of bool template now yields T of true).

Fixes phpstan/phpstan#10083