added Container::getComponent() and $container['…'] return type narrowing

Author: dg

CLAUDE.md

@@ -20,7 +20,7 @@ vendor/bin/tester tests/SomeTest.phpt -s   # Run a single test
 - **`src/Tester/TypeAssert.php`** — Reusable type inference testing helper for Nette Tester (used by other Nette packages)
 - **`extension.neon`** — Entry point, includes `extension-php.neon` and `extension-nette.neon`, auto-included by `phpstan/extension-installer`
 - **`extension-php.neon`** — Generic PHP-level extensions (RemoveFailingReturnType, ClosureTypeCheckIgnore)
-- **`extension-nette.neon`** — All Nette package extensions (schema, tester, utils), separated by comments
+- **`extension-nette.neon`** — All Nette package extensions (component-model, schema, tester, utils), separated by comments
 - **`phpstan.neon`** — Self-analysis config (level 8, analyses `src/` and `tests/`)
 
 ### How extensions are registered
@@ -39,7 +39,7 @@ Each extension class is registered as a service in NEON with the appropriate tag
 
 ### Namespace conventions
 
-Extensions for specific Nette packages use dedicated namespaces: `Nette\PHPStan\Schema\` for nette/schema, `Nette\PHPStan\Utils\` for nette/utils, future packages follow the same pattern (`Nette\PHPStan\Forms\`, `Nette\PHPStan\Application\`, etc.). Generic PHP-level extensions use `Nette\PHPStan\Php\`.
+Extensions for specific Nette packages use dedicated namespaces: `Nette\PHPStan\ComponentModel\` for nette/component-model, `Nette\PHPStan\Schema\` for nette/schema, `Nette\PHPStan\Utils\` for nette/utils, future packages follow the same pattern (`Nette\PHPStan\Forms\`, `Nette\PHPStan\Application\`, etc.). Generic PHP-level extensions use `Nette\PHPStan\Php\`.
 
 ### ExpectArrayReturnTypeExtension
 
@@ -69,6 +69,10 @@ Extensions for specific Nette packages use dedicated namespaces: `Nette\PHPStan\
 
 `ArraysInvokeTypeExtension` (`DynamicStaticMethodReturnTypeExtension`) narrows return types of `Arrays::invoke()` and `Arrays::invokeMethod()` from `array`. For `invoke()`, it extracts the callable return type from the iterable value type and forwards `...$args` via `ParametersAcceptorSelector::selectFromArgs()` to resolve the correct overload. For `invokeMethod()`, it resolves constant method names on the object type, gets method reflection, and forwards remaining args. Handles `callable(): void` by converting void to null. Falls back to declared return type when callbacks are not callable, method names are not constant strings, or methods don't exist on the object type. Config: `extension-nette.neon`.
 
+### GetComponentReturnTypeExtension
+
+`GetComponentReturnTypeExtension` (`DynamicMethodReturnTypeExtension`) narrows return types of `Container::getComponent()` and `Container::offsetGet()` (i.e. `$this['xxx']`). When the component name is a constant string, it looks for a `createComponent<Name>()` factory method on the caller type and returns its return type — e.g. `$this->getComponent('poll')` returns `PollControl` if `createComponentPoll(): PollControl` exists. Falls back to the declared return type when no factory method is found. Config: `extension-nette.neon`.
+
 ### AssertTypeNarrowingExtension
 
 `AssertTypeNarrowingExtension` (`StaticMethodTypeSpecifyingExtension` + `TypeSpecifierAwareExtension`) narrows variable types after `Tester\Assert` assertion calls. Each assertion method is mapped to an equivalent PHP expression that PHPStan already understands, then delegated to `TypeSpecifier::specifyTypesInCondition()`. Supported methods: `null`, `notNull`, `true`, `false`, `truthy`, `falsey`, `same`, `notSame`, and `type` (with built-in type strings like `'string'`, `'int'`, etc. and class/interface names). Config: `extension-nette.neon`.

composer.json

@@ -16,8 +16,10 @@
 		"phpstan/phpstan": "^2.1.40"
 	},
 	"require-dev": {
-		"nette/tester": "^2.6",
-		"nette/schema": "^1.3"
+		"nette/component-model": "^3.1",
+		"nette/forms": "^3.2",
+		"nette/schema": "^1.3",
+		"nette/tester": "^2.6"
 	},
 	"autoload": {
 		"psr-4": {

extension-nette.neon

@@ -6,8 +6,14 @@ parameters:
 		- Nette\Security\SimpleIdentity
 		- Nette\Utils\Html
 
-# nette/schema
+
 services:
+	# nette/component-model
+	-
+		create: Nette\PHPStan\ComponentModel\GetComponentReturnTypeExtension
+		tags: [phpstan.broker.dynamicMethodReturnTypeExtension]
+
+	# nette/schema
 	-
 		create: Nette\PHPStan\Schema\ExpectArrayReturnTypeExtension
 		tags: [phpstan.broker.dynamicStaticMethodReturnTypeExtension]

readme.md

@@ -41,7 +41,7 @@ includes:
 
  <!---->
 
-**Precise return types** — narrows return types of `Strings::match()`, `matchAll()`, `split()`, `Helpers::falseToNull()`, `Expect::array()`, `Arrays::invoke()`, and `Arrays::invokeMethod()` based on the arguments you pass.
+**Precise return types** — narrows return types of `Strings::match()`, `matchAll()`, `split()`, `Helpers::falseToNull()`, `Expect::array()`, `Arrays::invoke()`, and `Arrays::invokeMethod()` based on the arguments you pass. Also narrows `Container::getComponent()` and `$container['...']` to match the corresponding `createComponent*()` factory return type.
 
 **Removes `|false` and `|null` from PHP functions** — many native functions like `getcwd`, `json_encode`, `preg_split`, `preg_replace`, and [many more](extension-php.neon) include `false` or `null` in their return type even though these error values are unrealistic on modern systems.
 

src/ComponentModel/GetComponentReturnTypeExtension.php

@@ -0,0 +1,70 @@
+<?php declare(strict_types=1);
+
+namespace Nette\PHPStan\ComponentModel;
+
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\MethodReflection;
+use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use function count, in_array, ucfirst;
+
+
+/**
+ * Narrows return types of Container::getComponent() and Container::offsetGet()
+ * based on the corresponding createComponent<Name>() factory method.
+ */
+class GetComponentReturnTypeExtension implements DynamicMethodReturnTypeExtension
+{
+	public function getClass(): string
+	{
+		return 'Nette\ComponentModel\Container';
+	}
+
+
+	public function isMethodSupported(MethodReflection $methodReflection): bool
+	{
+		return in_array($methodReflection->getName(), ['getComponent', 'offsetGet'], true);
+	}
+
+
+	public function getTypeFromMethodCall(
+		MethodReflection $methodReflection,
+		MethodCall $methodCall,
+		Scope $scope,
+	): ?Type
+	{
+		$args = $methodCall->getArgs();
+		if ($args === []) {
+			return null;
+		}
+
+		$nameType = $scope->getType($args[0]->value);
+		$constantStrings = $nameType->getConstantStrings();
+		if (count($constantStrings) !== 1) {
+			return null;
+		}
+
+		$componentName = $constantStrings[0]->getValue();
+		$factoryMethodName = 'createComponent' . ucfirst($componentName);
+
+		$callerType = $scope->getType($methodCall->var);
+		if (!$callerType->hasMethod($factoryMethodName)->yes()) {
+			return null;
+		}
+
+		$factoryMethod = $callerType->getMethod($factoryMethodName, $scope);
+		$returnType = $factoryMethod->getVariants()[0]->getReturnType();
+
+		// Respect $throw parameter for getComponent()
+		if ($methodReflection->getName() === 'getComponent' && count($args) >= 2) {
+			$throwType = $scope->getType($args[1]->value);
+			if (!$throwType->isTrue()->yes()) {
+				$returnType = TypeCombinator::addNull($returnType);
+			}
+		}
+
+		return $returnType;
+	}
+}

tests/ComponentModel/get-component-return-type.php

@@ -0,0 +1,60 @@
+<?php declare(strict_types=1);
+
+use Nette\ComponentModel\Container;
+use function PHPStan\Testing\assertType;
+
+
+class PollControl extends Container implements \ArrayAccess
+{
+	use \Nette\ComponentModel\ArrayAccess;
+}
+
+class CalendarControl extends Container implements \ArrayAccess
+{
+	use \Nette\ComponentModel\ArrayAccess;
+}
+
+class TestPresenter extends Container implements \ArrayAccess
+{
+	use \Nette\ComponentModel\ArrayAccess;
+
+	protected function createComponentPoll(): PollControl
+	{
+		return new PollControl;
+	}
+
+
+	protected function createComponentCalendar(): CalendarControl
+	{
+		return new CalendarControl;
+	}
+
+
+	public function test(): void
+	{
+		assertType('PollControl', $this->getComponent('poll'));
+		assertType('CalendarControl', $this->getComponent('calendar'));
+		assertType('PollControl', $this['poll']);
+		assertType('CalendarControl', $this['calendar']);
+
+		// $throw = false → nullable
+		assertType('PollControl|null', $this->getComponent('poll', false));
+		assertType('CalendarControl|null', $this->getComponent('calendar', false));
+	}
+}
+
+
+// no factory method → falls back to declared return type
+class EmptyPresenter extends Container implements \ArrayAccess
+{
+	use \Nette\ComponentModel\ArrayAccess;
+
+	public function test(): void
+	{
+		assertType('Nette\ComponentModel\IComponent', $this->getComponent('unknown'));
+		assertType('Nette\ComponentModel\IComponent', $this['unknown']);
+
+		// $throw = false → nullable (falls back to declared conditional return type)
+		assertType('Nette\ComponentModel\IComponent|null', $this->getComponent('unknown', false));
+	}
+}

tests/extensions.phpt

@@ -9,6 +9,9 @@ TypeAssert::assertTypes(__DIR__ . '/Php/failing-return-type.php');
 TypeAssert::assertNoErrors(__DIR__ . '/Php/arrow-function-void.php', [__DIR__ . '/Php/arrow-function-void.neon']);
 TypeAssert::assertNoErrors(__DIR__ . '/Php/closure-type-check.php');
 
+// ComponentModel
+TypeAssert::assertTypes(__DIR__ . '/ComponentModel/get-component-return-type.php');
+
 // Schema
 TypeAssert::assertTypes(__DIR__ . '/Schema/expect-array-return-type.php');