Improving support for anonymous classes

lib/WorseReflection/Bridge/TolerantParser/Reflection/ReflectionClass.php

@@ -5,6 +5,7 @@
 use Microsoft\PhpParser\Node;
 use Microsoft\PhpParser\Node\ClassBaseClause;
 use Microsoft\PhpParser\Node\ClassInterfaceClause;
+use Microsoft\PhpParser\Node\Expression\ObjectCreationExpression;
 use Microsoft\PhpParser\Node\QualifiedName;
 use Microsoft\PhpParser\Node\Statement\ClassDeclaration;
 use Microsoft\PhpParser\TokenKind;
@@ -57,14 +58,15 @@
     public function __construct(
         private ServiceLocator $serviceLocator,
         private TextDocument $sourceCode,
-        private ClassDeclaration $node,
-        private array $visited = []
+        private ClassDeclaration|ObjectCreationExpression $node,
+        private array $visited = [],
+        private bool $anonymous = false
     ) {
     }
 
     public function isAbstract(): bool
     {
         $modifier = $this->node->abstractOrFinalModifier;
 
         /** @phpstan-ignore-next-line */
         if (!$modifier) {
@@ -109,7 +111,7 @@
 
             // we need to account for traits renaming aliases
             if ($reflectionClassLike instanceof ReflectionTrait) {
                 $traitImports = TraitImports::forClassDeclaration($this->node);
                 /** @phpstan-ignore-next-line collection IS compatible */
                 $members = $members->merge($this->resolveTraitMethods($traitImports, $this, $this->traits()));
                 continue;
@@ -250,8 +252,8 @@
     public function memberListPosition(): ByteOffsetRange
     {
         return ByteOffsetRange::fromInts(
             $this->node->classMembers->openBrace->start,
             $this->node->classMembers->openBrace->start + $this->node->classMembers->openBrace->length
         );
     }
 
@@ -260,7 +262,13 @@
         if ($this->name) {
             return $this->name;
         }
-        $this->name = ClassName::fromString((string) $this->node->getNamespacedName());
+
+        if ($this->node instanceof ObjectCreationExpression){
+            $this->name = ClassName::fromString('class@anonymous:'.$this->node->getStartPosition());
+        } else {
+            $this->name = ClassName::fromString((string) $this->node->getNamespacedName());
+        }
+
         return $this->name;
     }
 
@@ -340,7 +348,7 @@
 
     public function isFinal(): bool
     {
         $modifier = $this->node->abstractOrFinalModifier;
 
         /** @phpstan-ignore-next-line */
         if (!$modifier) {

lib/WorseReflection/Bridge/TolerantParser/Reflection/ReflectionMethod.php

@@ -4,6 +4,7 @@
 
 use Microsoft\PhpParser\ClassLike;
 use Microsoft\PhpParser\Node;
+use Microsoft\PhpParser\Node\Expression\ObjectCreationExpression;
 use Microsoft\PhpParser\Node\MethodDeclaration;
 use Microsoft\PhpParser\Node\Statement\CompoundStatementNode;
 use Microsoft\PhpParser\TokenKind;
@@ -60,7 +61,10 @@ public function nameRange(): ByteOffsetRange
 
     public function declaringClass(): ReflectionClassLike
     {
-        $classDeclaration = $this->node->getFirstAncestor(ClassLike::class);
+        $classDeclaration = $this->node->getFirstAncestor(ClassLike::class, ObjectCreationExpression::class);
+        if ($classDeclaration instanceof ObjectCreationExpression) {
+            return $this->class ?? $this->serviceLocator->reflector()->reflectClassLike('class@anonymous:'.$classDeclaration->getStartPosition());
+        }
 
         assert($classDeclaration instanceof NamespacedNameInterface);
         $class = $classDeclaration->getNamespacedName();

lib/WorseReflection/Core/Inference/Resolver/ObjectCreationExpressionResolver.php

@@ -10,8 +10,10 @@
 use Phpactor\WorseReflection\Core\Inference\FunctionArguments;
 use Phpactor\WorseReflection\Core\Inference\GenericMapResolver;
 use Phpactor\WorseReflection\Core\Inference\NodeContext;
+use Phpactor\WorseReflection\Core\Inference\NodeContextFactory;
 use Phpactor\WorseReflection\Core\Inference\Resolver;
 use Phpactor\WorseReflection\Core\Inference\NodeContextResolver;
+use Phpactor\WorseReflection\Core\Inference\Symbol;
 use Phpactor\WorseReflection\Core\Type;
 use Phpactor\WorseReflection\Core\TypeFactory;
 use Phpactor\WorseReflection\Core\Type\ClassStringType;
@@ -27,12 +29,13 @@ public function __construct(private GenericMapResolver $resolver)
     public function resolve(NodeContextResolver $resolver, Frame $frame, Node $node): NodeContext
     {
         assert($node instanceof ObjectCreationExpression);
-        if (false === $node->classTypeDesignator instanceof Node) {
-            throw new CouldNotResolveNode(sprintf('Could not create object from "%s"', get_class($node)));
-        }
 
+        $className = $node->classTypeDesignator;
+        if (false === $className instanceof Node) {
+            return $this->resolveAnonymousClass($resolver, $node);
+        }
 
-        $classContext = $resolver->resolveNode($frame, $node->classTypeDesignator);
+        $classContext = $resolver->resolveNode($frame, $className);
         $classType = $classContext->type();
 
         if ($classType instanceof ClassStringType) {
@@ -74,4 +77,20 @@ private function resolveClassType(NodeContextResolver $resolver, Frame $frame, O
         );
         return new GenericClassType($resolver->reflector(), $classType->name(), $templateMap->toArguments());
     }
+
+    private function resolveAnonymousClass(NodeContextResolver $resolver, Node $node): NodeContext
+    {
+        return NodeContextFactory::create(
+            'testing',
+            $node->getStartPosition(),
+            $node->getEndPosition(),
+            [
+                'symbol_type' => Symbol::CLASS_,
+                'type' => TypeFactory::fromStringWithReflector(
+                    'class@anonymous:'.$node->getStartPosition(),
+                    $resolver->reflector(),
+                )
+            ]
+        );
+    }
 }

lib/WorseReflection/Core/Reflection/Collection/ClassLikeReflectionMemberCollection.php

@@ -7,6 +7,7 @@
 use Microsoft\PhpParser\Node\ClassConstDeclaration;
 use Microsoft\PhpParser\Node\EnumCaseDeclaration;
 use Microsoft\PhpParser\Node\Expression\AssignmentExpression;
+use Microsoft\PhpParser\Node\Expression\ObjectCreationExpression;
 use Microsoft\PhpParser\Node\Expression\Variable;
 use Microsoft\PhpParser\Node\MethodDeclaration;
 use Microsoft\PhpParser\Node\Parameter;
@@ -68,13 +69,13 @@
 
     public static function fromClassMemberDeclarations(
         ServiceLocator $serviceLocator,
-        ClassDeclaration $class,
+        ClassDeclaration|ObjectCreationExpression $class,
         ReflectionClass $reflectionClass
     ): self {
         return self::fromDeclarations(
             $serviceLocator,
             $reflectionClass,
             $class->classMembers->classMemberDeclarations,
         );
     }
 

lib/WorseReflection/Core/Reflection/Collection/ReflectionClassLikeCollection.php

@@ -2,6 +2,7 @@
 
 namespace Phpactor\WorseReflection\Core\Reflection\Collection;
 
+use Microsoft\PhpParser\Node\Expression\ObjectCreationExpression;
 use Microsoft\PhpParser\Node\Statement\ClassDeclaration;
 use Microsoft\PhpParser\Node\Statement\EnumDeclaration;
 use Phpactor\WorseReflection\Bridge\TolerantParser\Reflection\ReflectionEnum;
@@ -30,11 +31,11 @@ public static function fromNode(ServiceLocator $serviceLocator, TextDocument $so
         $items = [];
 
         $nodeCollection = $node->getDescendantNodes(function (Node $node) {
-            return false === $node instanceof ClassLike;
+            return false === $node instanceof ClassLike && false === $node instanceof ObjectCreationExpression;
         });
 
         foreach ($nodeCollection as $child) {
-            if (false === $child instanceof ClassLike) {
+            if (false === $child instanceof ClassLike && !$child instanceof ObjectCreationExpression) {
                 continue;
             }
 
@@ -55,6 +56,12 @@ public static function fromNode(ServiceLocator $serviceLocator, TextDocument $so
 
             if ($child instanceof ClassDeclaration) {
                 $items[(string) $child->getNamespacedName()] = new ReflectionClass($serviceLocator, $source, $child, $visited);
+                continue;
+            }
+
+            if ($child instanceof ObjectCreationExpression) {
+                // TODO: come up with a good way to generate a class name
+                $items['class@anonymous:'.$child->getStartPosition()] = new ReflectionClass($serviceLocator, $source, $child, $visited, anonymous: true);
             }
         }
 

lib/WorseReflection/Core/Reflection/Collection/ReflectionInterfaceCollection.php

@@ -3,6 +3,7 @@
 namespace Phpactor\WorseReflection\Core\Reflection\Collection;
 
 use Microsoft\PhpParser\Node\ClassInterfaceClause;
+use Microsoft\PhpParser\Node\Expression\ObjectCreationExpression;
 use Microsoft\PhpParser\Node\InterfaceBaseClause;
 use Phpactor\WorseReflection\Core\Exception\NotFound;
 use Phpactor\WorseReflection\Core\Reflection\ReflectionInterface;
@@ -25,8 +26,10 @@ public static function fromInterfaceDeclaration(ServiceLocator $serviceLocator,
         return self::fromBaseClause($serviceLocator, $interface->interfaceBaseClause, $visited);
     }
 
-    public static function fromClassDeclaration(ServiceLocator $serviceLocator, ClassDeclaration $class): self
-    {
+    public static function fromClassDeclaration(
+        ServiceLocator $serviceLocator,
+        ClassDeclaration|ObjectCreationExpression $class,
+    ): self {
         return self::fromBaseClause($serviceLocator, $class->classInterfaceClause, []);
     }
 

lib/WorseReflection/Core/Reflection/Collection/ReflectionTraitCollection.php

@@ -2,6 +2,7 @@
 
 namespace Phpactor\WorseReflection\Core\Reflection\Collection;
 
+use Microsoft\PhpParser\Node\Expression\ObjectCreationExpression;
 use Microsoft\PhpParser\Node\Statement\EnumDeclaration;
 use Microsoft\PhpParser\Node\Statement\TraitDeclaration;
 use Phpactor\WorseReflection\Core\Exception\NotFound;
@@ -17,10 +18,12 @@
  */
 class ReflectionTraitCollection extends AbstractReflectionCollection
 {
-    public static function fromClassDeclaration(ServiceLocator $serviceLocator, ClassDeclaration $class): self
-    {
+    public static function fromClassDeclaration(
+        ServiceLocator $serviceLocator,
+        ClassDeclaration|ObjectCreationExpression $class,
+    ): self {
         $items = [];
         foreach ($class->classMembers->classMemberDeclarations as $memberDeclaration) {
             if (false === $memberDeclaration instanceof TraitUseClause) {
                 continue;
             }

lib/WorseReflection/Tests/Unit/Core/Reflector/SourceCode/ContextualSourceCodeReflectorTest.php

@@ -2,6 +2,7 @@
 
 namespace Phpactor\WorseReflection\Tests\Unit\Core\Reflector\SourceCode;
 
+use Generator;
 use PHPUnit\Framework\TestCase;
 use Phpactor\TextDocument\TextDocumentBuilder;
 use Phpactor\WorseReflection\Core\SourceCodeLocator\TemporarySourceLocator;
@@ -19,8 +20,6 @@ class ContextualSourceCodeReflectorTest extends TestCase
 
     private ContextualSourceCodeReflector $reflector;
 
-    private $code;
-
     private TemporarySourceLocator $locator;
 
     public function setUp(): void
@@ -31,8 +30,6 @@ public function setUp(): void
             ReflectorBuilder::create()->build(),
             $this->locator
         );
-
-        $this->code = TextDocumentBuilder::create(self::TEST_SOURCE_CODE)->build();
     }
 
     public function testReflectsClassesIn(): void
@@ -51,4 +48,33 @@ public function testReflectMethodCall(): void
         $call = $this->reflector->reflectMethodCall(TextDocumentBuilder::fromUnknown('<?php class One { function bar() {} } $f = new One();$f->bar();'), 59);
         self::assertInstanceOf(ReflectionMethodCall::class, $call);
     }
+
+    /**
+    * @dataProvider provideReflectAnonymousClass
+    */
+    public function testReflectAnonymousClass(string $sourceCode, int $expectedCount): void
+    {
+        $result = $this->reflector->reflectClassesIn(TextDocumentBuilder::fromUnknown($sourceCode));
+
+        self::assertCount($expectedCount, $result);
+    }
+
+    /**
+     * @return Generator<string,array{string,int}>
+     */
+    public function provideReflectAnonymousClass(): Generator
+    {
+        yield 'one class' => [
+            '<?php $formatter = new class() {};', 1
+        ];
+
+        yield 'one class with implements' => [
+            '<?php $formatter = new class implements Test () {};', 1
+        ];
+
+        yield 'two classes' => [
+            '<?php $billow = new class() {}; $formatter = new class() {};', 2
+        ];
+    }
+
 }

tests/System/Extension/Completion/Application/CompleteTest.php

@@ -295,7 +295,49 @@ class Foobar
                         'short_description' => 'pub $foobar',
                     ],
                 ],
-            ]
+            ],
+
+            'Anonoymous class properties' => [
+                <<<'EOT'
+                    <?php
+
+                    $foobar = new class(){
+                        public string $test;
+                    };
+                    $foobar-><>
+
+                    EOT
+                , [
+                    [
+                        'type' => 'property',
+                        'name' => 'test',
+                        'short_description' => 'pub $test: string',
+                    ],
+                ],
+            ],
+            'Anonoymous class methods' => [
+                <<<'EOT'
+                    <?php
+
+                    $foobar = new class() {
+                        public function doSomething(): bool {}
+                    };
+                    $foobar-><>
+
+                    EOT
+                , [
+                    [
+                        'type' => 'method',
+                        'name' => 'doSomething',
+                        'short_description' => 'pub doSomething(): bool',
+                        'documentation' => '### class@anonymous:17::doSomething
+
+```php
+<?php public function doSomething(): bool
+```'
+                    ],
+                ],
+            ],
         ];
     }
     /**
@@ -304,9 +346,9 @@ class Foobar
     private function complete(string $source): array
     {
         [$source, $offset] = ExtractOffset::fromSource($source);
-        $complete = $this->container()->get('application.complete');
-        assert($complete instanceof Complete);
-        $result = $complete->complete($source, $offset);
+        $result = $this->container()
+            ->expect('application.complete', Complete::class)
+            ->complete($source, $offset);
 
         return $result;
     }