ForbidFetchOnMixedRule: check even class const fetches (#150)

Author: janedbal

README.md

@@ -464,7 +464,7 @@ implode('', [MyEnum::MyCase]); // denied, would fail on implicit toString conver
 
 
 ### forbidFetchOnMixed
-- Denies property fetch on unknown type.
+- Denies constant/property fetch on unknown type.
 - Any property fetch assumes the caller is an object with such property and therefore, the typehint/phpdoc should be fixed.
 - Similar to `forbidMethodCallOnMixed`
 - Makes sense only on PHPStan level 8 or below, gets autodisabled on level 9

src/Rule/ForbidFetchOnMixedRule.php

@@ -5,12 +5,14 @@
 use LogicException;
 use PhpParser\Node;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\ClassConstFetch;
 use PhpParser\Node\Expr\PropertyFetch;
 use PhpParser\Node\Expr\StaticPropertyFetch;
 use PhpParser\Node\Identifier;
 use PhpParser\PrettyPrinter\Standard;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Type\Type;
 use PHPStan\Type\TypeUtils;
 use function get_class;
 use function sprintf;
@@ -45,15 +47,15 @@ public function processNode(Node $node, Scope $scope): array
             return []; // already checked by native PHPStan
         }
 
-        if ($node instanceof PropertyFetch || $node instanceof StaticPropertyFetch) {
+        if ($node instanceof PropertyFetch || $node instanceof StaticPropertyFetch || $node instanceof ClassConstFetch) {
             return $this->processFetch($node, $scope);
         }
 
         return [];
     }
 
     /**
-     * @param PropertyFetch|StaticPropertyFetch $node
+     * @param PropertyFetch|StaticPropertyFetch|ClassConstFetch $node
      * @return list<string>
      */
     private function processFetch(Node $node, Scope $scope): array
@@ -68,17 +70,24 @@ private function processFetch(Node $node, Scope $scope): array
 
         $callerType = TypeUtils::toBenevolentUnion($scope->getType($caller));
 
-        if ($callerType->getObjectTypeOrClassStringObjectType()->getObjectClassNames() === []) {
+        if (
+            $callerType->getObjectTypeOrClassStringObjectType()->getObjectClassNames() === []
+            && !$this->isObjectClassFetch($callerType, $node)
+        ) {
             $name = $node->name;
-            $property = $name instanceof Identifier
+            $propertyOrConstant = $name instanceof Identifier
                 ? $this->printer->prettyPrint([$name])
                 : $this->printer->prettyPrintExpr($name);
+            $element = $node instanceof ClassConstFetch
+                ? 'Constant'
+                : 'Property';
 
             return [
                 sprintf(
-                    'Property fetch %s%s is prohibited on unknown type (%s)',
+                    '%s fetch %s%s is prohibited on unknown type (%s)',
+                    $element,
                     $this->getFetchToken($node),
-                    $property,
+                    $propertyOrConstant,
                     $this->printer->prettyPrintExpr($caller),
                 ),
             ];
@@ -88,11 +97,12 @@ private function processFetch(Node $node, Scope $scope): array
     }
 
     /**
-     * @param PropertyFetch|StaticPropertyFetch $node
+     * @param PropertyFetch|StaticPropertyFetch|ClassConstFetch $node
      */
     private function getFetchToken(Node $node): string
     {
         switch (get_class($node)) {
+            case ClassConstFetch::class:
             case StaticPropertyFetch::class:
                 return '::';
 
@@ -104,4 +114,28 @@ private function getFetchToken(Node $node): string
         }
     }
 
+    /**
+     * Detect object::class
+     *
+     * @param PropertyFetch|StaticPropertyFetch|ClassConstFetch $node
+     */
+    private function isObjectClassFetch(Type $callerType, Node $node): bool
+    {
+        $isObjectWithoutClassName = $callerType->isObject()->yes() && $callerType->getObjectClassNames() === [];
+
+        if (!$isObjectWithoutClassName) {
+            return false;
+        }
+
+        if (!$node instanceof ClassConstFetch) {
+            return false;
+        }
+
+        if (!$node->name instanceof Identifier) {
+            return false;
+        }
+
+        return $node->name->name === 'class';
+    }
+
 }

tests/Rule/data/ForbidFetchOnMixedRuleTest/code.php

@@ -5,34 +5,50 @@
 use ReflectionClass;
 
 class Foo {
+    public const CONST = 1;
+
     public ?int $property = null;
     public static ?int $staticProperty = null;
 }
 
-$fn = function (mixed $mixed, $unknown, string $string, array $array, ReflectionClass $reflection, ?Foo $fooOrNull) {
+$fn = function (mixed $mixed, $unknown, string $string, array $array, ReflectionClass $reflection, ?Foo $fooOrNull, object $object) {
     (new Foo)->property;
     Foo::$staticProperty;
+    Foo::CONST;
+    Foo::class;
 
     /** @var class-string $classString */
     $classString = '';
     $classString::$staticProperty; // error: Property fetch ::$staticProperty is prohibited on unknown type ($classString)
+    $classString::CONST; // error: Constant fetch ::CONST is prohibited on unknown type ($classString)
 
     /** @var class-string<Foo> $classString2 */
     $classString2 = '';
     $classString2::$staticProperty;
+    $classString2::CONST;
 
     $string::$staticProperty; // error: Property fetch ::$staticProperty is prohibited on unknown type ($string)
 
     $mixed->fetch1; // error: Property fetch ->fetch1 is prohibited on unknown type ($mixed)
     $mixed::$fetch1; // error: Property fetch ::$fetch1 is prohibited on unknown type ($mixed)
+    $mixed::CONST; // error: Constant fetch ::CONST is prohibited on unknown type ($mixed)
+    $mixed::class; // error: Constant fetch ::class is prohibited on unknown type ($mixed)
     $unknown->fetch2; // error: Property fetch ->fetch2 is prohibited on unknown type ($unknown)
     $unknown::$fetch2; // error: Property fetch ::$fetch2 is prohibited on unknown type ($unknown)
     $array[0]->fetch3; // error: Property fetch ->fetch3 is prohibited on unknown type ($array[0])
 
     $fooOrNull->property;
     $fooOrNull?->property;
+    $fooOrNull::$staticProperty;
+    $fooOrNull::CONST;
+    $fooOrNull::class;
+
+    $object::class;
+    $object::CONST; // error: Constant fetch ::CONST is prohibited on unknown type ($object)
 
     $reflection->newInstance()->property; // error: Property fetch ->property is prohibited on unknown type ($reflection->newInstance())
+    $reflection->newInstance()::CONST; // error: Constant fetch ::CONST is prohibited on unknown type ($reflection->newInstance())
     /** @var ReflectionClass<Foo> $reflection */
     $reflection->newInstance()->property;
+    $reflection->newInstance()::CONST;
 };