phpstan
diff --git a/‎src/Rules/Symfony/ContainerInterfacePrivateServiceRule.php
Copy file name to clipboardExpand all lines: src/Rules/Symfony/ContainerInterfacePrivateServiceRule.php
+113-9Lines changed: 113 additions & 9 deletions b/‎src/Rules/Symfony/ContainerInterfacePrivateServiceRule.php
Copy file name to clipboardExpand all lines: src/Rules/Symfony/ContainerInterfacePrivateServiceRule.php
+113-9Lines changed: 113 additions & 9 deletions
@@ -5,12 +5,20 @@
 use PhpParser\Node;
 use PhpParser\Node\Expr\MethodCall;
 use PHPStan\Analyser\Scope;
+use PHPStan\BetterReflection\Reflection\Adapter\FakeReflectionAttribute;
+use PHPStan\BetterReflection\Reflection\Adapter\ReflectionAttribute;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\Php\PhpPropertyReflection;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Symfony\ServiceDefinition;
 use PHPStan\Symfony\ServiceMap;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
+use Symfony\Component\DependencyInjection\Attribute\AutowireLocator;
+use function class_exists;
+use function get_class;
 use function sprintf;
 
 /**
@@ -66,15 +74,29 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		$serviceId = $this->serviceMap::getServiceIdFromNode($node->getArgs()[0]->value, $scope);
-		if ($serviceId !== null) {
-			$service = $this->serviceMap->getService($serviceId);
-			if ($service !== null && !$service->isPublic()) {
-				return [
-					RuleErrorBuilder::message(sprintf('Service "%s" is private.', $serviceId))
-						->identifier('symfonyContainer.privateService')
-						->build(),
-				];
-			}
+		if ($serviceId === null) {
+			return [];
+		}
+
+		$service = $this->serviceMap->getService($serviceId);
+		if (!$service instanceof ServiceDefinition) {
+			return [];
+		}
+
+		$isContainerInterfaceType = $isContainerType->yes() || $isPsrContainerType->yes();
+		if (
+			$isContainerInterfaceType &&
+			$this->isAutowireLocator($node, $scope, $service)
+		) {
+			return [];
+		}
+
+		if (!$service->isPublic()) {
+			return [
+				RuleErrorBuilder::message(sprintf('Service "%s" is private.', $serviceId))
+					->identifier('symfonyContainer.privateService')
+					->build(),
+			];
 		}
 
 		return [];
@@ -92,4 +114,86 @@ private function isServiceSubscriber(Type $containerType, Scope $scope): Trinary
 		return $isContainerServiceSubscriber->or($serviceSubscriberInterfaceType->isSuperTypeOf($containedClassType));
 	}
 
+	private function isAutowireLocator(Node $node, Scope $scope, ServiceDefinition $service): bool
+	{
+		if (!class_exists('Symfony\\Component\\DependencyInjection\\Attribute\\AutowireLocator')) {
+			return false;
+		}
+
+		if (
+			!$node instanceof MethodCall
+		) {
+			return false;
+		}
+
+		$nodeParentProperty = $node->var;
+
+		if (!$nodeParentProperty instanceof Node\Expr\PropertyFetch) {
+			return false;
+		}
+
+		$nodeParentPropertyName = $nodeParentProperty->name;
+
+		if (!$nodeParentPropertyName instanceof Node\Identifier) {
+			return false;
+		}
+
+		$containerInterfacePropertyName = $nodeParentPropertyName->name;
+		$scopeClassReflection = $scope->getClassReflection();
+
+		if (!$scopeClassReflection instanceof ClassReflection) {
+			return false;
+		}
+
+		$containerInterfacePropertyReflection = $scopeClassReflection
+			->getProperty($containerInterfacePropertyName, $scope);
+
+		if (!$containerInterfacePropertyReflection instanceof PhpPropertyReflection) {
+			return false;
+		}
+
+		$classPropertyReflection = $containerInterfacePropertyReflection->getNativeReflection();
+		$autowireLocatorAttributes = $classPropertyReflection->getAttributes(AutowireLocator::class);
+
+		return $this->isAutowireLocatorService($autowireLocatorAttributes, $service);
+	}
+
+	/**
+	 * @param  array<int, FakeReflectionAttribute|ReflectionAttribute>  $autowireLocatorAttributes
+	 */
+	private function isAutowireLocatorService(array $autowireLocatorAttributes, ServiceDefinition $service): bool
+	{
+		foreach ($autowireLocatorAttributes as $autowireLocatorAttribute) {
+			foreach ($autowireLocatorAttribute->getArgumentsExpressions() as $autowireLocatorServices) {
+				if (!$autowireLocatorServices instanceof Node\Expr\Array_) {
+					continue;
+				}
+
+				foreach ($autowireLocatorServices->items as $autowireLocatorServiceNode) {
+					/** @var Node\Expr\ArrayItem $autowireLocatorServiceNode */
+					$autowireLocatorServiceExpr = $autowireLocatorServiceNode->value;
+
+					switch (get_class($autowireLocatorServiceExpr)) {
+						case Node\Scalar\String_::class:
+							$autowireLocatorServiceClass = $autowireLocatorServiceExpr->value;
+							break;
+						case Node\Expr\ClassConstFetch::class:
+							$autowireLocatorServiceClass = $autowireLocatorServiceExpr->class instanceof Node\Name
+								? $autowireLocatorServiceExpr->class->toString()
+								: null;
+							break;
+						default:
+							$autowireLocatorServiceClass = null;
+					}
+
+					if ($service->getId() === $autowireLocatorServiceClass) {
+						return true;
+					}
+				}
+			}
+		}
+
+		return false;
+	}
+
 }