Refactor code style for consistency in SpecialTypeResolver; update cache clear command in CI workflow

Author: rcalicdan

.github/workflows/ci.yml

@@ -33,7 +33,7 @@ jobs:
           dependency-versions: lowest
 
       - name: Clear TypePHP Cache
-        run: ./vendor/bin/typephp cache:clear
+        run: php bin/typephp cache:clear
 
       - name: Run Test Suite (Pest) with Live Debug
         run: ./vendor/bin/pest tests/TypeChecking/ArraysAndShapes/ClassConstKeyShapeTest.php --ci

src/Resolver/SpecialTypeResolver.php

@@ -91,7 +91,7 @@ public static function resolve(TypeNode $node, \ReflectionClass|\ReflectionFunct
 
         if ($node instanceof GenericTypeNode) {
             $genericType = self::resolve($node->type, $ref, $thisObj);
-            $innerTypes = array_map(fn($t) => self::resolve($t, $ref, $thisObj), $node->genericTypes);
+            $innerTypes = array_map(fn ($t) => self::resolve($t, $ref, $thisObj), $node->genericTypes);
 
             return new GenericTypeNode(
                 $genericType instanceof IdentifierTypeNode ? $genericType : $node->type,
@@ -145,11 +145,11 @@ public static function resolve(TypeNode $node, \ReflectionClass|\ReflectionFunct
         }
 
         if ($node instanceof UnionTypeNode) {
-            return new UnionTypeNode(array_map(fn($t) => self::resolve($t, $ref, $thisObj), $node->types));
+            return new UnionTypeNode(array_map(fn ($t) => self::resolve($t, $ref, $thisObj), $node->types));
         }
 
         if ($node instanceof IntersectionTypeNode) {
-            return new IntersectionTypeNode(array_map(fn($t) => self::resolve($t, $ref, $thisObj), $node->types));
+            return new IntersectionTypeNode(array_map(fn ($t) => self::resolve($t, $ref, $thisObj), $node->types));
         }
 
         return $node;
@@ -181,7 +181,7 @@ public static function resolveForFile(TypeNode $node, string $file): TypeNode
 
         if ($node instanceof GenericTypeNode) {
             $genericType = self::resolveForFile($node->type, $file);
-            $innerTypes = array_map(fn($t) => self::resolveForFile($t, $file), $node->genericTypes);
+            $innerTypes = array_map(fn ($t) => self::resolveForFile($t, $file), $node->genericTypes);
 
             return new GenericTypeNode(
                 $genericType instanceof IdentifierTypeNode ? $genericType : $node->type,
@@ -235,11 +235,11 @@ public static function resolveForFile(TypeNode $node, string $file): TypeNode
         }
 
         if ($node instanceof UnionTypeNode) {
-            return new UnionTypeNode(array_map(fn($t) => self::resolveForFile($t, $file), $node->types));
+            return new UnionTypeNode(array_map(fn ($t) => self::resolveForFile($t, $file), $node->types));
         }
 
         if ($node instanceof IntersectionTypeNode) {
-            return new IntersectionTypeNode(array_map(fn($t) => self::resolveForFile($t, $file), $node->types));
+            return new IntersectionTypeNode(array_map(fn ($t) => self::resolveForFile($t, $file), $node->types));
         }
 
         return clone $node;
@@ -361,32 +361,13 @@ private static function resolveArrayShape(ArrayShapeNode $node, \ReflectionClass
             $className = null;
             $constName = null;
 
-            // --- LIVE CI DEBUG LOGGING ---
-            $debugClass = $keyName !== null ? get_class($keyName) : 'null';
-            $debugVal = $keyName !== null && method_exists($keyName, '__toString') ? (string) $keyName : 'unknown';
-            fwrite(\STDERR, "\n[DEBUG] ArrayShapeItem KeyType: {$debugClass} | Value: {$debugVal}\n");
-
-            if ($keyName instanceof IdentifierTypeNode) {
-                fwrite(\STDERR, "[DEBUG] IdentifierName: {$keyName->name}\n");
-            }
-            // -----------------------------
-
             if ($keyName instanceof ConstFetchNode && $keyName->className !== '') {
                 $className = $keyName->className;
                 $constName = $keyName->name;
             } elseif ($keyName instanceof IdentifierTypeNode && str_contains($keyName->name, '::')) {
-                // Fallback for phpstan/phpdoc-parser v1.x/v2.0 which parses constants as Identifiers
                 [$className, $constName] = explode('::', $keyName->name, 2);
             }
 
-            // --- MORE DEBUG LOGGING ---
-            if ($className !== null && $constName !== null) {
-                fwrite(\STDERR, "[DEBUG] Split into Class: {$className} | Const: {$constName}\n");
-            } else {
-                fwrite(\STDERR, "[DEBUG] Did NOT split into Class and Const.\n");
-            }
-            // --------------------------
-
             if ($className !== null && $constName !== null) {
                 $lowerClassName = strtolower($className);
                 $declaringClass = $ref instanceof \ReflectionMethod ? $ref->getDeclaringClass()->getName() : null;
@@ -400,14 +381,9 @@ private static function resolveArrayShape(ArrayShapeNode $node, \ReflectionClass
                     $resolvedClass = self::resolveFqcn($className, $ref);
                 }
 
-                fwrite(\STDERR, "[DEBUG] Resolved Target Class for Reflection: {$resolvedClass}\n");
-
                 $resolvedKeyNode = self::resolveConstantKeyValue($resolvedClass, $constName);
                 if ($resolvedKeyNode !== null) {
-                    fwrite(\STDERR, "[DEBUG] Successfully Reflected Constant! New Value: {$resolvedKeyNode->value}\n");
                     $keyName = $resolvedKeyNode;
-                } else {
-                    fwrite(\STDERR, "[DEBUG] FAILED to Reflect Constant!\n");
                 }
             }