Avoid repeated source parsing when trying to analyse docblock types

.travis.yml

@@ -79,6 +79,13 @@ jobs:
         - travis_retry composer require --dev --prefer-dist --prefer-stable phpstan/phpstan:^0.8.3
       script: vendor/bin/phpstan analyse -l 5 -c phpstan.neon src
 
+    - stage: Run benchmarks
+      php: 7.1
+      env: DEPENDENCIES=""
+      before_script:
+        - travis_retry composer require --dev --prefer-dist --prefer-stable phpbench/phpbench:^0.13.0
+      script: ./vendor/bin/phpbench run --progress=dots --iterations=1
+
     - stage: Upload Coverage
       php: 7.1
       env: DEPENDENCIES=""

README.md

@@ -72,6 +72,9 @@ $classInfo = ReflectionClass::createFromName('Foo\Bar\MyClass');
  * `Roave\BetterReflection\Util\FindReflectionOnLine::buildDefaultFinder()` was dropped, please use the newly
    introduced `Roave\BetterReflection\BetterReflection#findReflectionOnLine()` instead
  * `Roave\BetterReflection\Reflection\Exception\PropertyNotPublic` was dropped, all properties are accessible now 
+ * `Roave\BetterReflection\Reflection\ReflectionMethod::createFromNode()` has additional mandatory constructor arguments
+ * `Roave\BetterReflection\Reflection\ReflectionParameter::createFromNode()` has additional mandatory constructor arguments
+ * `Roave\BetterReflection\Reflection\ReflectionProperty::createFromNode()` has additional mandatory constructor arguments
 
 ## More documentation
 

composer.json

@@ -19,7 +19,8 @@
     },
     "autoload-dev": {
         "psr-4": {
-            "Roave\\BetterReflectionTest\\": "test/unit"
+            "Roave\\BetterReflectionTest\\": "test/unit",
+            "Roave\\BetterReflectionBenchmark\\": "test/benchmark"
         }
     },
     "suggest": {

phpbench.json

@@ -0,0 +1,4 @@
+{
+    "bootstrap": "vendor/autoload.php",
+    "path": "test/benchmark"
+}

src/Reflection/ReflectionClass.php

@@ -12,6 +12,7 @@
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Interface_ as InterfaceNode;
 use PhpParser\Node\Stmt\Namespace_ as NamespaceNode;
+use PhpParser\Node\Stmt\Namespace_;
 use PhpParser\Node\Stmt\Property as PropertyNode;
 use PhpParser\Node\Stmt\Trait_ as TraitNode;
 use PhpParser\Node\Stmt\TraitUse;
@@ -43,7 +44,7 @@ class ReflectionClass implements Reflection, CoreReflector
     private $reflector;
 
     /**
-     * @var NamespaceNode
+     * @var NamespaceNode|null
      */
     private $declaringNamespace;
 
@@ -335,15 +336,27 @@ function (ReflectionClass $ancestor) : array {
                 ...\array_map(
                     function (ReflectionClass $trait) : array {
                         return \array_map(function (ReflectionMethod $method) use ($trait) : ReflectionMethod {
-                            return ReflectionMethod::createFromNode($this->reflector, $method->getAst(), $trait, $this);
+                            return ReflectionMethod::createFromNode(
+                                $this->reflector,
+                                $method->getAst(),
+                                $this->declaringNamespace,
+                                $trait,
+                                $this
+                            );
                         }, $trait->getMethods());
                     },
                     $this->getTraits()
                 )
             ),
             \array_map(
                 function (ClassMethod $methodNode) : ReflectionMethod {
-                    return ReflectionMethod::createFromNode($this->reflector, $methodNode, $this, $this);
+                    return ReflectionMethod::createFromNode(
+                        $this->reflector,
+                        $methodNode,
+                        $this->declaringNamespace,
+                        $this,
+                        $this
+                    );
                 },
                 $this->node->getMethods()
             )
@@ -415,7 +428,13 @@ public function getImmediateMethods(?int $filter = null) : array
         /** @var \ReflectionMethod[] $methods */
         $methods = \array_map(
             function (ClassMethod $methodNode) : ReflectionMethod {
-                return ReflectionMethod::createFromNode($this->reflector, $methodNode, $this, $this);
+                return ReflectionMethod::createFromNode(
+                    $this->reflector,
+                    $methodNode,
+                    $this->declaringNamespace,
+                    $this,
+                    $this
+                );
             },
             $this->node->getMethods()
         );
@@ -649,7 +668,13 @@ public function getImmediateProperties(?int $filter = null) : array
             $properties = [];
             foreach ($this->node->stmts as $stmt) {
                 if ($stmt instanceof PropertyNode) {
-                    $prop                         = ReflectionProperty::createFromNode($this->reflector, $stmt, $this, $this);
+                    $prop                         = ReflectionProperty::createFromNode(
+                        $this->reflector,
+                        $stmt,
+                        $this->declaringNamespace,
+                        $this,
+                        $this
+                    );
                     $properties[$prop->getName()] = $prop;
                 }
             }
@@ -703,8 +728,14 @@ function (ReflectionProperty $property) : bool {
                     ),
                     ...\array_map(
                         function (ReflectionClass $trait) use ($filter) {
-                            return \array_map(function (ReflectionProperty $property) : ReflectionProperty {
-                                return ReflectionProperty::createFromNode($this->reflector, $property->getAst(), $property->getDeclaringClass(), $this);
+                            return \array_map(function (ReflectionProperty $property) use ($trait) : ReflectionProperty {
+                                return ReflectionProperty::createFromNode(
+                                    $this->reflector,
+                                    $property->getAst(),
+                                    $trait->declaringNamespace,
+                                    $property->getDeclaringClass(),
+                                    $this
+                                );
                             }, $trait->getProperties($filter));
                         },
                         $this->getTraits()
@@ -1362,6 +1393,11 @@ public function getAst() : ClassLikeNode
         return $this->node;
     }
 
+    public function getDeclaringNamespaceAst() : ?Namespace_
+    {
+        return $this->declaringNamespace;
+    }
+
     /**
      * Set whether this class is final or not
      *

src/Reflection/ReflectionFunctionAbstract.php

@@ -216,14 +216,17 @@ function (ReflectionParameter $p) : bool {
     public function getParameters() : array
     {
         $parameters = [];
+
         foreach ($this->node->params as $paramIndex => $paramNode) {
             $parameters[] = ReflectionParameter::createFromNode(
                 $this->reflector,
                 $paramNode,
+                $this->declaringNamespace,
                 $this,
                 $paramIndex
             );
         }
+
         return $parameters;
     }
 
@@ -432,7 +435,7 @@ public function returnsReference() : bool
      */
     public function getDocBlockReturnTypes() : array
     {
-        return  (new FindReturnType())->__invoke($this);
+        return  (new FindReturnType())->__invoke($this, $this->declaringNamespace);
     }
 
     /**

src/Reflection/ReflectionMethod.php

@@ -4,6 +4,7 @@
 namespace Roave\BetterReflection\Reflection;
 
 use PhpParser\Node\Stmt\ClassMethod as MethodNode;
+use PhpParser\Node\Stmt\Namespace_;
 use ReflectionMethod as CoreReflectionMethod;
 use Roave\BetterReflection\Reflector\Reflector;
 use RuntimeException;
@@ -23,22 +24,22 @@ class ReflectionMethod extends ReflectionFunctionAbstract
     /**
      * @param Reflector $reflector
      * @param MethodNode $node Node has to be processed by the PhpParser\NodeVisitor\NameResolver
+     * @param Namespace_|null $namespace
      * @param ReflectionClass $declaringClass
      * @param ReflectionClass $implementingClass
      */
     public static function createFromNode(
         Reflector $reflector,
         MethodNode $node,
+        ?Namespace_ $namespace,
         ReflectionClass $declaringClass,
         ReflectionClass $implementingClass
     ) : self {
         $method                    = new self();
         $method->declaringClass    = $declaringClass;
         $method->implementingClass = $implementingClass;
 
-        // Compat with core reflection means we should NOT pass namespace info
-        // for ReflectionMethod
-        $method->populateFunctionAbstract($reflector, $node, $declaringClass->getLocatedSource(), null);
+        $method->populateFunctionAbstract($reflector, $node, $declaringClass->getLocatedSource(), $namespace);
 
         return $method;
     }
@@ -182,6 +183,11 @@ private function getMethodNode() : MethodNode
         return $this->getNode();
     }
 
+    public function inNamespace() : bool
+    {
+        return false;
+    }
+
     /**
      * Is the method abstract.
      *

src/Reflection/ReflectionObject.php

@@ -8,6 +8,7 @@
 use PhpParser\Builder\Property as PropertyNodeBuilder;
 use PhpParser\Node\Stmt\ClassLike as ClassLikeNode;
 use PhpParser\Node\Stmt\Namespace_ as NamespaceNode;
+use PhpParser\Node\Stmt\Namespace_;
 use PhpParser\Node\Stmt\Property as PropertyNode;
 use ReflectionObject as CoreReflectionObject;
 use ReflectionProperty as CoreReflectionProperty;
@@ -139,14 +140,20 @@ private function getRuntimeProperties(?int $filter = null) : array
         // the runtime-declared properties  :/
         $reflectionProperties = (new CoreReflectionObject($this->object))->getProperties();
         $runtimeProperties    = [];
+
         foreach ($reflectionProperties as $property) {
             if ($this->reflectionClass->hasProperty($property->getName())) {
                 continue;
             }
 
+            $reflectionProperty = $this->reflectionClass->getProperty($property->getName());
+
             $runtimeProperty = ReflectionProperty::createFromNode(
                 $this->reflector,
                 $this->createPropertyNodeFromReflection($property, $this->object),
+                $reflectionProperty
+                    ? $reflectionProperty->getDeclaringClass()->getDeclaringNamespaceAst()
+                    : null,
                 $this,
                 $this,
                 false
@@ -156,6 +163,7 @@ private function getRuntimeProperties(?int $filter = null) : array
                 $runtimeProperties[$runtimeProperty->getName()] = $runtimeProperty;
             }
         }
+
         return $runtimeProperties;
     }
 
@@ -627,6 +635,14 @@ public function getAst() : ClassLikeNode
         return $this->reflectionClass->getAst();
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function getDeclaringNamespaceAst() : ?Namespace_
+    {
+        return $this->reflectionClass->getDeclaringNamespaceAst();
+    }
+
     /**
      * {@inheritdoc}
      */

src/Reflection/ReflectionParameter.php

@@ -11,6 +11,7 @@
 use PhpParser\Node;
 use PhpParser\Node\NullableType;
 use PhpParser\Node\Param as ParamNode;
+use PhpParser\Node\Stmt\Namespace_;
 use Reflector as CoreReflector;
 use Roave\BetterReflection\NodeCompiler\CompileNodeToValue;
 use Roave\BetterReflection\NodeCompiler\CompilerContext;
@@ -32,6 +33,11 @@ class ReflectionParameter implements CoreReflector
      */
     private $node;
 
+    /**
+     * @var Namespace_|null
+     */
+    private $declaringNamespace;
+
     /**
      * @var ReflectionFunctionAbstract
      */
@@ -187,23 +193,28 @@ public function __toString() : string
     }
 
     /**
-     * @param Reflector $reflector
-     * @param ParamNode $node Node has to be processed by the PhpParser\NodeVisitor\NameResolver
+     * @param Reflector                  $reflector
+     * @param ParamNode                  $node               Node has to be processed by the PhpParser\NodeVisitor\NameResolver
+     * @param Namespace_|null            $declaringNamespace namespace of the declaring function/method
      * @param ReflectionFunctionAbstract $function
-     * @param int $parameterIndex
+     * @param int                        $parameterIndex
+     *
      * @return ReflectionParameter
      */
     public static function createFromNode(
         Reflector $reflector,
         ParamNode $node,
+        ?Namespace_ $declaringNamespace,
         ReflectionFunctionAbstract $function,
         int $parameterIndex
     ) : self {
-        $param                 = new self();
-        $param->reflector      = $reflector;
-        $param->node           = $node;
-        $param->function       = $function;
-        $param->parameterIndex = $parameterIndex;
+        $param                     = new self();
+        $param->reflector          = $reflector;
+        $param->node               = $node;
+        $param->declaringNamespace = $declaringNamespace;
+        $param->function           = $function;
+        $param->parameterIndex     = $parameterIndex;
+
         return $param;
     }
 
@@ -402,7 +413,7 @@ public function getDocBlockTypeStrings() : array
      */
     public function getDocBlockTypes() : array
     {
-        return  (new FindParameterType())->__invoke($this->function, $this->node);
+        return  (new FindParameterType())->__invoke($this->function, $this->declaringNamespace, $this->node);
     }
 
     /**