fix: mark classes extended by anonymous classes as extended so MustBeFinalRule does not flag them

src/Analyser/Analyser.php

@@ -148,7 +148,7 @@ public function analyse(
         $classNodes       = $this->withRecursiveParents($classNodes);
 
         if ($hasExtendedClassAwareRule) {
-            $this->markExtendedClasses($classNodes);
+            $this->markExtendedClasses($classNodes, $extractionResult);
         }
 
         $fileAnalysisProvider = new FileAnalysisProvider($extractionResult->fileAnalyses);
@@ -663,7 +663,7 @@ private function dependenciesForInheritanceDependency(
      *
      * @param list<ClassNode> $classNodes
      */
-    private function markExtendedClasses(array $classNodes): void
+    private function markExtendedClasses(array $classNodes, ExtractionResult $extractionResult): void
     {
         $extended = [];
 
@@ -673,6 +673,14 @@ private function markExtendedClasses(array $classNodes): void
             }
         }
 
+        // Anonymous classes (`new class extends Foo {}`) have no ClassNode of
+        // their own, so the classes they extend are tracked separately.
+        foreach ($extractionResult->anonymousClassNodes as $anonymousClassNode) {
+            if ($anonymousClassNode->extends !== null) {
+                $extended[$anonymousClassNode->extends] = true;
+            }
+        }
+
         foreach ($classNodes as $classNode) {
             // Only classes appear in parentClasses; traits, interfaces, and enums
             // never do, so they are left with the default (not extended).
@@ -836,9 +844,10 @@ private function collectClassNodes(
         ?AnalyserOptions $analyserOptions = null,
         bool $withFileAnalysis = true,
     ): ExtractionResult {
-        $classNodes   = [];
-        $fileAnalyses = [];
-        $filesToParse = [];
+        $classNodes          = [];
+        $fileAnalyses        = [];
+        $anonymousClassNodes = [];
+        $filesToParse        = [];
 
         foreach ($files as $file) {
             if ($withFileAnalysis) {
@@ -856,32 +865,40 @@ private function collectClassNodes(
                     $classNodes[] = $cachedClassNode;
                 }
 
+                foreach ($cachedResult['anonymousClassNodes'] as $cachedAnonymousClassNode) {
+                    $anonymousClassNodes[] = $cachedAnonymousClassNode;
+                }
+
                 $fileAnalyses[$file] = $cachedResult['fileAnalysis'];
 
                 continue;
             }
 
-            $cachedClassNodes = $this->analysisResultCache?->loadClassNodes(
+            $cachedResult = $this->analysisResultCache?->loadClassNodes(
                 $file,
                 $this->classNodeCacheNamespace,
             );
 
-            if ($cachedClassNodes === null) {
+            if ($cachedResult === null) {
                 $filesToParse[] = $file;
                 continue;
             }
 
-            foreach ($cachedClassNodes as $cachedClassNode) {
+            foreach ($cachedResult['classNodes'] as $cachedClassNode) {
                 $classNodes[] = $cachedClassNode;
             }
+
+            foreach ($cachedResult['anonymousClassNodes'] as $cachedAnonymousClassNode) {
+                $anonymousClassNodes[] = $cachedAnonymousClassNode;
+            }
         }
 
         $progressHandler?->start(count($filesToParse));
 
         if ($filesToParse === []) {
             $progressHandler?->finish();
 
-            return new ExtractionResult($classNodes, $fileAnalyses);
+            return new ExtractionResult($classNodes, $fileAnalyses, $anonymousClassNodes);
         }
 
         $options = $analyserOptions ?? AnalyserOptions::parallel();
@@ -911,6 +928,15 @@ private function collectClassNodes(
             }
         }
 
+        $anonymousClassNodesByFile = array_fill_keys($filesToParse, []);
+        foreach ($parsedResult->anonymousClassNodes as $parsedAnonymousClassNode) {
+            $anonymousClassNodes[] = $parsedAnonymousClassNode;
+
+            if (isset($anonymousClassNodesByFile[$parsedAnonymousClassNode->file])) {
+                $anonymousClassNodesByFile[$parsedAnonymousClassNode->file][] = $parsedAnonymousClassNode;
+            }
+        }
+
         foreach ($parsedResult->fileAnalyses as $file => $fileAnalysis) {
             $fileAnalyses[$file] = $fileAnalysis;
         }
@@ -921,12 +947,13 @@ private function collectClassNodes(
                 $this->classNodeCacheNamespace,
                 $fileClassNodes,
                 $fileAnalyses[$fileToParse] ?? null,
+                $anonymousClassNodesByFile[$fileToParse] ?? [],
             );
         }
 
         $progressHandler?->finish();
 
-        return new ExtractionResult($classNodes, $fileAnalyses);
+        return new ExtractionResult($classNodes, $fileAnalyses, $anonymousClassNodes);
     }
 
     /**

src/Analyser/AnonymousClassNode.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Boundwize\StructArmed\Analyser;
+
+/**
+ * An anonymous class declaration (`new class ... {}`). Anonymous classes never
+ * become ClassNodes — they cannot be referenced by name and no rule targets
+ * them directly — but the class they extend is still extended within the
+ * scanned paths, which extended-class-aware rules must take into account.
+ *
+ * The usage example is on MustBeFinalRule, which must skip if target class is extended by an anonymous class.
+ *
+ * Note: Other properties like anonymous class's traits, implements, etc may come
+ * later if needed for future needed rules.
+ */
+final readonly class AnonymousClassNode
+{
+    public function __construct(
+        public string $file,
+        public int $line,
+        public ?string $extends,
+    ) {
+    }
+}

src/Analyser/ClassCollector.php

@@ -76,6 +76,9 @@ final class ClassCollector extends NodeVisitorAbstract
     /** @var list<ClassNode> */
     private array $nodes = [];
 
+    /** @var list<AnonymousClassNode> */
+    private array $anonymousClassNodes = [];
+
     private string $currentFile = '';
 
     /** @var list<string> */
@@ -126,6 +129,12 @@ public function getNodes(): array
         return $this->nodes;
     }
 
+    /** @return list<AnonymousClassNode> */
+    public function getAnonymousClassNodes(): array
+    {
+        return $this->anonymousClassNodes;
+    }
+
     public function enterNode(Node $node): null
     {
         if ($node instanceof Namespace_) {
@@ -174,6 +183,16 @@ public function leaveNode(Node $node): null
         }
 
         if (! $node->name instanceof Identifier) {
+            // Anonymous classes never become ClassNodes, but the class they
+            // extend is still extended within the scanned paths.
+            if ($node instanceof Class_) {
+                $this->anonymousClassNodes[] = new AnonymousClassNode(
+                    file:    $this->currentFile,
+                    line:    $node->getStartLine(),
+                    extends: $node->extends instanceof Name ? $node->extends->toString() : null,
+                );
+            }
+
             return null;
         }
 

src/Analyser/ClassNodeExtractor.php

@@ -53,6 +53,10 @@ public function extract(
             }
         }
 
-        return new ExtractionResult($classCollector->getNodes(), $fileAnalyses);
+        return new ExtractionResult(
+            $classCollector->getNodes(),
+            $fileAnalyses,
+            $classCollector->getAnonymousClassNodes(),
+        );
     }
 }

src/Analyser/ExtractionResult.php

@@ -9,10 +9,12 @@
     /**
      * @param list<ClassNode>             $classNodes
      * @param array<string, FileAnalysis> $fileAnalyses
+     * @param list<AnonymousClassNode>    $anonymousClassNodes
      */
     public function __construct(
         public array $classNodes,
         public array $fileAnalyses,
+        public array $anonymousClassNodes = [],
     ) {
     }
 }

src/Analyser/Parallel/ClassNodeWorker.php

@@ -60,17 +60,19 @@ public static function run(string $inputFile, string $outputFile, mixed $outputS
             );
 
             file_put_contents($outputFile, serialize([
-                'nodes'        => $result->classNodes,
-                'fileAnalyses' => $result->fileAnalyses,
-                'error'        => null,
+                'nodes'               => $result->classNodes,
+                'fileAnalyses'        => $result->fileAnalyses,
+                'anonymousClassNodes' => $result->anonymousClassNodes,
+                'error'               => null,
             ]));
 
             return 0;
         } catch (Throwable $throwable) {
             file_put_contents($outputFile, serialize([
-                'nodes'        => [],
-                'fileAnalyses' => [],
-                'error'        => sprintf('%s: %s', $throwable::class, $throwable->getMessage()),
+                'nodes'               => [],
+                'fileAnalyses'        => [],
+                'anonymousClassNodes' => [],
+                'error'               => sprintf('%s: %s', $throwable::class, $throwable->getMessage()),
             ]));
 
             return 1;

src/Analyser/Parallel/ParallelClassNodeExtractor.php

@@ -4,6 +4,7 @@
 
 namespace Boundwize\StructArmed\Analyser\Parallel;
 
+use Boundwize\StructArmed\Analyser\AnonymousClassNode;
 use Boundwize\StructArmed\Analyser\ClassNode;
 use Boundwize\StructArmed\Analyser\ExtractionResult;
 use Boundwize\StructArmed\Analyser\FileAnalysis;
@@ -128,10 +129,11 @@ public function extract(
             ];
         }
 
-        $nodes        = [];
-        $fileAnalyses = [];
-        $failure      = null;
-        $pending      = $processes;
+        $nodes               = [];
+        $fileAnalyses        = [];
+        $anonymousClassNodes = [];
+        $failure             = null;
+        $pending             = $processes;
 
         while ($pending !== []) {
             $anyActivity = false;
@@ -220,6 +222,24 @@ public function extract(
 
                         $fileAnalyses[$file] = $fileAnalysis;
                     }
+
+                    $workerAnonClassNodes = $result['anonymousClassNodes'] ?? [];
+
+                    if (! is_array($workerAnonClassNodes)) {
+                        throw new RuntimeException(
+                            'Parallel analysis worker returned invalid anonymous class nodes.'
+                        );
+                    }
+
+                    foreach ($workerAnonClassNodes as $workerAnonClassNode) {
+                        if (! $workerAnonClassNode instanceof AnonymousClassNode) {
+                            throw new RuntimeException(
+                                'Parallel analysis worker returned invalid anonymous class nodes.'
+                            );
+                        }
+
+                        $anonymousClassNodes[] = $workerAnonClassNode;
+                    }
                 } catch (RuntimeException $runtimeException) {
                     $failure ??= $runtimeException->getMessage();
                 } finally {
@@ -243,7 +263,7 @@ public function extract(
             throw new RuntimeException($failure);
         }
 
-        return new ExtractionResult($nodes, $fileAnalyses);
+        return new ExtractionResult($nodes, $fileAnalyses, $anonymousClassNodes);
     }
 
     /**