Refactor CI workflow for PHP 8.2 and streamline test execution; add debug logging in SpecialTypeResolver

Author: rcalicdan

.github/workflows/ci.yml

@@ -13,14 +13,8 @@ permissions:
 
 jobs:
   test:
-    name: PHP ${{ matrix.php }} (${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        php: ['8.2', '8.3', '8.4', '8.5']
+    name: PHP 8.2 Debug (ubuntu-latest)
+    runs-on: ubuntu-latest
 
     steps:
       - name: Checkout Code
@@ -29,18 +23,17 @@ jobs:
       - name: Setup PHP
         uses: shivammathur/setup-php@v2
         with:
-          php-version: ${{ matrix.php }}
+          php-version: '8.2'
           extensions: dom, mbstring, zip, libxml, json, tokenizer, fileinfo
           coverage: none
 
       - name: Install Dependencies
         uses: ramsey/composer-install@v3
         with:
-          dependency-versions: ${{ matrix.php == '8.2' && 'lowest' || 'highest' }}
+          dependency-versions: lowest
 
-      - name: Run Static Analysis (PHPStan)
-        run: ./vendor/bin/phpstan analyse --no-progress
-        if: matrix.os == 'ubuntu-latest' && matrix.php == '8.3'
+      - name: Clear TypePHP Cache
+        run: ./vendor/bin/typephp cache:clear
 
-      - name: Run Test Suite (Pest)
-        run: ./vendor/bin/pest --ci
+      - 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,13 +361,32 @@ 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;
@@ -381,9 +400,14 @@ 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");
                 }
             }