Call RestrictedMethodUsageExtension for __toString methods in (string) cast

Author: ondrejmirtes

conf/config.neon

@@ -227,6 +227,7 @@ rules:
 	- PHPStan\Rules\RestrictedUsage\RestrictedStaticMethodUsageRule
 	- PHPStan\Rules\RestrictedUsage\RestrictedStaticMethodCallableUsageRule
 	- PHPStan\Rules\RestrictedUsage\RestrictedStaticPropertyUsageRule
+	- PHPStan\Rules\RestrictedUsage\RestrictedUsageOfDeprecatedStringCastRule
 
 conditionalTags:
 	PHPStan\Rules\Exceptions\MissingCheckedExceptionInFunctionThrowsRule:

src/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRule.php

@@ -0,0 +1,70 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\RestrictedUsage;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\Cast;
+use PHPStan\Analyser\Scope;
+use PHPStan\DependencyInjection\Container;
+use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * @implements Rule<Cast\String_>
+ */
+final class RestrictedUsageOfDeprecatedStringCastRule implements Rule
+{
+
+	public function __construct(
+		private Container $container,
+		private ReflectionProvider $reflectionProvider,
+	)
+	{
+	}
+
+	public function getNodeType(): string
+	{
+		return Cast\String_::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		/** @var RestrictedMethodUsageExtension[] $extensions */
+		$extensions = $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG);
+		if ($extensions === []) {
+			return [];
+		}
+
+		$exprType = $scope->getType($node->expr);
+		$referencedClasses = $exprType->getObjectClassNames();
+
+		$errors = [];
+
+		foreach ($referencedClasses as $referencedClass) {
+			if (!$this->reflectionProvider->hasClass($referencedClass)) {
+				continue;
+			}
+
+			$classReflection = $this->reflectionProvider->getClass($referencedClass);
+			if (!$classReflection->hasNativeMethod('__toString')) {
+				continue;
+			}
+
+			$methodReflection = $classReflection->getNativeMethod('__toString');
+			foreach ($extensions as $extension) {
+				$restrictedUsage = $extension->isRestrictedMethodUsage($methodReflection, $scope);
+				if ($restrictedUsage === null) {
+					continue;
+				}
+
+				$errors[] = RuleErrorBuilder::message($restrictedUsage->errorMessage)
+					->identifier($restrictedUsage->identifier)
+					->build();
+			}
+		}
+
+		return $errors;
+	}
+
+}

tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php

@@ -0,0 +1,40 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\RestrictedUsage;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<RestrictedUsageOfDeprecatedStringCastRule>
+ */
+class RestrictedUsageOfDeprecatedStringCastRuleTest extends RuleTestCase
+{
+
+	protected function getRule(): Rule
+	{
+		return new RestrictedUsageOfDeprecatedStringCastRule(
+			self::getContainer(),
+			$this->createReflectionProvider(),
+		);
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/restricted-to-string.php'], [
+			[
+				'Cannot call __toString',
+				11,
+			],
+		]);
+	}
+
+	public static function getAdditionalConfigFiles(): array
+	{
+		return [
+			__DIR__ . '/restricted-usage.neon',
+			...parent::getAdditionalConfigFiles(),
+		];
+	}
+
+}

tests/PHPStan/Rules/RestrictedUsage/data/MethodExtension.php

@@ -6,6 +6,7 @@
 use PHPStan\Reflection\ExtendedMethodReflection;
 use PHPStan\Rules\RestrictedUsage\RestrictedMethodUsageExtension;
 use PHPStan\Rules\RestrictedUsage\RestrictedUsage;
+use function sprintf;
 
 class MethodExtension implements RestrictedMethodUsageExtension
 {
@@ -15,11 +16,11 @@ public function isRestrictedMethodUsage(
 		Scope $scope
 	): ?RestrictedUsage
 	{
-		if ($methodReflection->getName() !== 'doFoo') {
+		if ($methodReflection->getName() !== 'doFoo' && $methodReflection->getName() !== '__toString') {
 			return null;
 		}
 
-		return RestrictedUsage::create('Cannot call doFoo', 'restrictedUsage.doFoo');
+		return RestrictedUsage::create(sprintf('Cannot call %s', $methodReflection->getName()), 'restrictedUsage.doFoo');
 	}
 
 }

tests/PHPStan/Rules/RestrictedUsage/data/restricted-to-string.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace RestrictedUsage;
+
+class FooToString
+{
+
+	public function doTest(Nonexistent $c): void
+	{
+		(string) $c;
+		(string) $this;
+	}
+
+	public function __toString()
+	{
+		return 'foo';
+	}
+
+	public function doTest2(FooWithoutToString $f)
+	{
+		(string) $f;
+	}
+
+}
+
+class FooWithoutToString
+{
+
+}