Add implicit throw point for dynamic instantiation of non-final classes without constructors

[phpstan-bot]

Summary

When using new $class() where $class is typed as class-string<Interface>, class-string<AbstractClass>, or class-string<NonFinalClass> and the referenced type has no constructor, PHPStan incorrectly reported:

• "Dead catch - Exception is never thrown in the try block"
• "Function returns void but does not have any side effects"

This happened because the dynamic instantiation analysis recursively processed new TypeName() which found no constructor, and therefore generated no throw points or impure points. At runtime, the actual class could be any concrete implementation with a constructor that throws.

Changes

• Added implicit throw point and uncertain impure point in src/Analyser/ExprHandler/NewHandler.php for the dynamic class name branch when:
  • The resolved class has no constructor
  • The class is not final (so the actual runtime class could be a subclass)
  • implicitThrows is enabled (consistent with constructor throw point handling)
• Updated tests/PHPStan/Rules/Exceptions/CatchWithUnthrownExceptionRuleTest.php:
  • Removed the assertion for bug-4806 line 119 which was asserting the buggy behavior
  • Added new testBug6574 test method
• Added tests/PHPStan/Rules/Exceptions/data/bug-6574.php with test cases for:
  • Interface without constructor (primary reported case)
  • Interface with constructor (already worked correctly)
  • Abstract class without constructor
  • Abstract class with constructor (already worked correctly)
  • Non-final class without constructor
  • Final class without constructor (correctly reports dead catch)
• Added tests/PHPStan/Rules/Pure/data/bug-6574.php and test method in PureFunctionRuleTest.php to verify the "no side effects" false positive is also fixed

Root cause

In NewHandler::processExpr, the dynamic class name branch (else case) resolves new $class() to a single class name and recursively processes new ClassName(). The recursive call goes through processConstructorReflection which returns no throw/impure points when the class has no constructor. The subsequent throw point logic at lines 199-206 also doesn't fire because $classReflection is not null (the class IS found in reflection) but $constructorReflection IS null (no constructor). This leaves the expression with zero throw points and zero impure points.

The fix adds the missing throw/impure points specifically in the dynamic branch, recognizing that for non-final classes, the actual runtime class could have a constructor. Final classes without constructors correctly remain side-effect-free since they cannot be subclassed.

Test

• CatchWithUnthrownExceptionRuleTest::testBug6574 - regression test covering interface, abstract class, non-final class (all without constructor, all should NOT report dead catch), and final class (should correctly report dead catch)
• PureFunctionRuleTest::testBug6574 - regression test verifying that functions using new $class() with interface/abstract class-string types are not falsely flagged as having no side effects

Fixes phpstan/phpstan#6574

[VincentLanglet]

rather than removing the error make the class final

[phpstan-bot]

Pushed. Here's what was done to address the review:

1. bug-4806.php: Made HasNoConstructor class final and restored the dead catch assertion at line 119 (instead of removing the assertion as before). A final class with no constructor correctly has no throw points.

2. bug-6574.php: Added two new test types — ThrowsVoidInterface (interface with @throws void constructor) and AbstractThrowsVoid (abstract class with @throws void constructor) — plus test functions that verify dead catch is correctly reported for both. When a constructor explicitly declares @throws void, even non-final classes should report dead catch since the contract guarantees no exceptions.

All 12,079 tests pass and make phpstan reports no errors.

[VincentLanglet]

Shouldn't the logic be placed

• in processConstructorReflection for the impure point
• in the next if for throwPoints

[phpstan-bot]

Done. The review has been addressed:

1. Impure point moved into processConstructorReflection — added a bool $isDynamic = false parameter and an elseif ($isDynamic && !$classReflection->isFinal()) branch in the existing if/elseif chain. The flag is needed because processConstructorReflection is also called from the Name branch (literal new Foo()), where a non-final class without a constructor is genuinely pure and can't throw.

2. Throw point moved into the shared if/elseif chain at lines 204-209, guarded by !$expr->class instanceof Name && !$expr->class instanceof Node\Stmt\Class_ to ensure it only fires for dynamic instantiation.

3. Standalone block removed from the else branch.

All 12,079 tests pass and make phpstan reports no errors.

[staabm]

remove the default value of the $isDynamic parameter

[phpstan-bot]

Removed the default value from the $isDynamic parameter on processConstructorReflection and passed false explicitly at the Name branch call site (line 96). All 12,079 tests pass and make phpstan is clean.