Scrutinizer fixes

src/ReflectionClass.php

@@ -125,4 +125,18 @@ protected function __initialize()
     {
         parent::__construct($this->getName());
     }
+
+    /**
+     * Create a ReflectionClass for a given class name.
+     *
+     * @param string $className
+     *     The name of the class to create a reflection for.
+     *
+     * @return ReflectionClass
+     *     The apropriate reflection object.
+     */
+    protected function createReflectionForClass($className)
+    {
+        return class_exists($className, false) ? new parent($className) : new static($className);
+    }
 }

src/ReflectionFile.php

@@ -50,6 +50,14 @@ class ReflectionFile
      */
     public function __construct($fileName, $topLevelNodes = null)
     {
+        if (!is_string($fileName)) {
+            throw new \InvalidArgumentException(
+                sprintf(
+                    '$fileName must be a string, but a %s was passed',
+                    gettype($fileName)
+                )
+            );
+        }
         $fileName            = PathResolver::realpath($fileName);
         $this->fileName      = $fileName;
         $this->topLevelNodes = $topLevelNodes ?: ReflectionEngine::parseFile($fileName);

src/ReflectionFileNamespace.php

@@ -83,6 +83,14 @@ class ReflectionFileNamespace
      */
     public function __construct($fileName, $namespaceName, Namespace_ $namespaceNode = null)
     {
+        if (!is_string($fileName)) {
+            throw new \InvalidArgumentException(
+                sprintf(
+                    '$fileName must be a string, but a %s was passed',
+                    gettype($fileName)
+                )
+            );
+        }
         $fileName = PathResolver::realpath($fileName);
         if (!$namespaceNode) {
             $namespaceNode = ReflectionEngine::parseFileNamespace($fileName, $namespaceName);

src/ReflectionMethod.php

@@ -80,7 +80,8 @@ public function ___debugInfo()
      */
     public function __toString()
     {
-        $hasReturnType    = $this->hasReturnType();
+        $returnType       = $this->getReturnType();
+        $hasReturnType    = ($returnType !== null); // Internally same as: $this->hasReturnType();
         $paramsNeeded     = $hasReturnType || $this->getNumberOfParameters() > 0;
         $paramFormat      = $paramsNeeded ? "\n\n  - Parameters [%d] {%s\n  }" : '';
         $returnFormat     = $hasReturnType ? "\n  - Return [ %s ]" : '';
@@ -107,14 +108,22 @@ public function __toString()
             $this->isFinal() ? ' final' : '',
             $this->isStatic() ? ' static' : '',
             $this->isAbstract() ? ' abstract' : '',
-            join(' ', \Reflection::getModifierNames($this->getModifiers() & 1792)),
+            join(
+                ' ',
+                \Reflection::getModifierNames(
+                    $this->getModifiers() &
+                        (self::IS_PUBLIC | self::IS_PROTECTED | self::IS_PRIVATE)
+                )
+            ),
             $this->getName(),
             $this->getFileName(),
             $this->getStartLine(),
             $this->getEndLine(),
             count($methodParameters),
             $paramString,
-            $hasReturnType ? ReflectionType::convertToDisplayType($this->getReturnType()) : ''
+            (   $returnType ?
+                ReflectionType::convertToDisplayType($returnType) :
+                'UNUSED: Prevents convertToDisplayType() being called.')
         );
     }
 

src/ReflectionType.php

@@ -85,7 +85,7 @@ public static function convertToDisplayType(\ReflectionType $type)
             'int'  => 'integer',
             'bool' => 'boolean'
         ];
-        $displayType = $type->type;
+        $displayType = (string) $type;
         if (isset($typeMap[$displayType])) {
             $displayType = $typeMap[$displayType];
         }

src/Traits/ReflectionClassLikeTrait.php

@@ -322,6 +322,7 @@ public function getInterfaces()
 
     /**
      * {@inheritdoc}
+     * @param string $name
      */
     public function getMethod($name)
     {
@@ -442,7 +443,7 @@ public function getParentClass()
             $extendsNode = $hasExtends ? $this->classLikeNode->$extendsField : null;
             if ($extendsNode instanceof FullyQualified) {
                 $extendsName = $extendsNode->toString();
-                $parentClass = class_exists($extendsName, false) ? new parent($extendsName) : new static($extendsName);
+                $parentClass = $this->createReflectionForClass($extendsName);
             }
             $this->parentClass = $parentClass;
         }
@@ -592,6 +593,7 @@ public function hasConstant($name)
 
     /**
      * {@inheritdoc}
+     * @param string $name
      */
     public function hasMethod($name)
     {
@@ -622,6 +624,7 @@ public function hasProperty($name)
 
     /**
      * {@inheritDoc}
+     * @param string $interfaceName
      */
     public function implementsInterface($interfaceName)
     {
@@ -698,7 +701,6 @@ public function isInstance($object)
         }
 
         $className = $this->getName();
-
         return $className === get_class($object) || is_subclass_of($object, $className);
     }
 
@@ -954,4 +956,15 @@ private function collectSelfConstants()
             }
         }
     }
+
+    /**
+     * Create a ReflectionClass for a given class name.
+     *
+     * @param string $className
+     *     The name of the class to create a reflection for.
+     *
+     * @return ReflectionClass
+     *     The apropriate reflection object.
+     */
+    abstract protected function createReflectionForClass($className);
 }

src/Traits/ReflectionFunctionLikeTrait.php

@@ -220,6 +220,15 @@ public function getStartLine()
      */
     public function getStaticVariables()
     {
+        // In nikic/PHP-Parser < 2.0.0 the default behavior is cloning
+        //     nodes when traversing them. Passing FALSE to the constructor
+        //     prevents this.
+        // In nikic/PHP-Parser >= 2.0.0 and < 3.0.0 the default behavior was
+        //     changed to not clone nodes, but the parameter was retained as
+        //     an option.
+        // In nikic/PHP-Parser >= 3.0.0 the option to clone nodes was removed
+        //     as a constructor parameter, so Scrutinizer will pick this up as
+        //     an issue. It is retained for legacy compatibility.
         $nodeTraverser      = new NodeTraverser(false);
         $variablesCollector = new StaticVariablesCollector($this);
         $nodeTraverser->addVisitor($variablesCollector);
@@ -274,6 +283,15 @@ public function isDeprecated()
      */
     public function isGenerator()
     {
+        // In nikic/PHP-Parser < 2.0.0 the default behavior is cloning
+        //     nodes when traversing them. Passing FALSE to the constructor
+        //     prevents this.
+        // In nikic/PHP-Parser >= 2.0.0 and < 3.0.0 the default behavior was
+        //     changed to not clone nodes, but the parameter was retained as
+        //     an option.
+        // In nikic/PHP-Parser >= 3.0.0 the option to clone nodes was removed
+        //     as a constructor parameter, so Scrutinizer will pick this up as
+        //     an issue. It is retained for legacy compatibility.
         $nodeTraverser = new NodeTraverser(false);
         $nodeDetector  = new GeneratorDetector();
         $nodeTraverser->addVisitor($nodeDetector);

src/ValueResolver/NodeExpressionResolver.php

@@ -112,8 +112,7 @@ protected function resolve(Node $node)
         try {
             ++$this->nodeLevel;
 
-            $nodeType   = $node->getType();
-            $methodName = 'resolve' . str_replace('_', '', $nodeType);
+            $methodName = $this->getDispatchMethodFor($node);
             if (method_exists($this, $methodName)) {
                 $value = $this->$methodName($node);
             }
@@ -142,7 +141,7 @@ protected function resolveScalarString(Scalar\String_ $node)
     protected function resolveScalarMagicConstMethod()
     {
         if ($this->context instanceof \ReflectionMethod) {
-            $fullName = $this->context->getDeclaringClass()->getName() . '::' . $this->context->getShortName();
+            $fullName = $this->context->getDeclaringClass()->name . '::' . $this->context->getShortName();
 
             return $fullName;
         }
@@ -175,12 +174,12 @@ protected function resolveScalarMagicConstNamespace()
     protected function resolveScalarMagicConstClass()
     {
         if ($this->context instanceof \ReflectionClass) {
-            return $this->context->getName();
+            return $this->context->name;
         }
         if (method_exists($this->context, 'getDeclaringClass')) {
             $declaringClass = $this->context->getDeclaringClass();
             if ($declaringClass instanceof \ReflectionClass) {
-                return $declaringClass->getName();
+                return $declaringClass->name;
             }
         }
 
@@ -213,7 +212,7 @@ protected function resolveScalarMagicConstLine(MagicConst\Line $node)
     protected function resolveScalarMagicConstTrait()
     {
         if ($this->context instanceof \ReflectionClass && $this->context->isTrait()) {
-            return $this->context->getName();
+            return $this->context->name;
         }
 
         return '';
@@ -224,8 +223,6 @@ protected function resolveExprConstFetch(Expr\ConstFetch $node)
         $constantValue = null;
         $isResolved    = false;
 
-        /** @var ReflectionFileNamespace|null $fileNamespace */
-        $fileNamespace = null;
         $isFQNConstant = $node->name instanceof Node\Name\FullyQualified;
         $constantName  = $node->name->toString();
 
@@ -256,7 +253,22 @@ protected function resolveExprConstFetch(Expr\ConstFetch $node)
 
     protected function resolveExprClassConstFetch(Expr\ClassConstFetch $node)
     {
-        $refClass     = $this->fetchReflectionClass($node->class);
+        $classToReflect = $node->class;
+        if (!($classToReflect instanceof Node\Name)) {
+            $classToReflect = $this->resolve($classToReflect) ?: $classToReflect;
+            if (!is_string($classToReflect)) {
+                $reason = 'Unable';
+                if ($classToReflect instanceof Expr) {
+                    $methodName = $this->getDispatchMethodFor($classToReflect);
+                    $reason = "Method " . __CLASS__ . "::{$methodName}() not found trying";
+                }
+                throw new ReflectionException("$reason to resolve class constant.");
+            }
+            // Strings evaluated as class names are always treated as fully
+            // qualified.
+            $classToReflect = new Node\Name\FullyQualified(ltrim($classToReflect, '\\'));
+        }
+        $refClass = $this->fetchReflectionClass($classToReflect);
         $constantName = $node->name;
 
         // special handling of ::class constants
@@ -265,7 +277,7 @@ protected function resolveExprClassConstFetch(Expr\ClassConstFetch $node)
         }
 
         $this->isConstant = true;
-        $this->constantName = (string)$node->class . '::' . $constantName;
+        $this->constantName = (string)$classToReflect . '::' . $constantName;
 
         return $refClass->getConstant($constantName);
     }
@@ -430,6 +442,12 @@ protected function resolveExprBinaryOpLogicalXor(Expr\BinaryOp\LogicalXor $node)
         return $this->resolve($node->left) xor $this->resolve($node->right);
     }
 
+    private function getDispatchMethodFor(Node $node)
+    {
+        $nodeType = $node->getType();
+        return 'resolve' . str_replace('_', '', $nodeType);
+    }
+
     /**
      * Utility method to fetch reflection class instance by name
      *

src/bootstrap.php

@@ -12,10 +12,9 @@
 use Go\ParserReflection\ReflectionEngine;
 
 /**
- * This file is used for automatic configuration of Go\ParserReflection\ReflectionEngine class
+ * This file is used for automatic configuration of
+ * Go\ParserReflection\ReflectionEngine class
  */
 ReflectionEngine::init(new ComposerLocator());
-// Polifyll for PHP<7.0
-if (!class_exists(ReflectionType::class, false)) {
-    class ReflectionType {}
-}
+
+require(__DIR__ . '/polyfill.php');

src/polyfill.php

@@ -0,0 +1,34 @@
+<?php
+/**
+ * Parser Reflection API
+ *
+ * @copyright Copyright 2015, Lisachenko Alexander <[email protected]>
+ *
+ * This source file is subject to the license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * This file is for ployfilling classes not defined in all supported
+ * versions of PHP, (i.e. PHP < 7).
+ */
+if (!class_exists(ReflectionType::class, false)) {
+    /* Dummy polyfill class */
+    class ReflectionType
+    {
+        public function allowsNull()
+        {
+            return true;
+        }
+
+        public function isBuiltin()
+        {
+            return false;
+        }
+
+        public function __toString()
+        {
+            return '';
+        }
+    }
+}

tests/ReflectionFileNamespaceTest.php

@@ -26,6 +26,24 @@ protected function setUp()
         include_once $fileName;
     }
 
+    /**
+     * @expectedException        InvalidArgumentException
+     * @expectedExceptionMessage $fileName must be a string, but a array was passed
+     */
+    public function testBadFilenameTypeArray()
+    {
+        new ReflectionFileNamespace([1, 3, 5, 7], 'BogusNamespace');
+    }
+
+    /**
+     * @expectedException        InvalidArgumentException
+     * @expectedExceptionMessage $fileName must be a string, but a object was passed
+     */
+    public function testBadFilenameTypeObject()
+    {
+        new ReflectionFileNamespace(new \DateTime(), 'BogusNamespace');
+    }
+
     public function testGetClass()
     {
         $refClass = $this->parsedRefFileNamespace->getClass('Unknown');

tests/ReflectionFileTest.php

@@ -21,6 +21,24 @@ protected function setUp()
         $this->parsedRefFile = $reflectionFile;
     }
 
+    /**
+     * @expectedException        InvalidArgumentException
+     * @expectedExceptionMessage $fileName must be a string, but a array was passed
+     */
+    public function testBadFilenameTypeArray()
+    {
+        new ReflectionFile([1, 3, 5, 7]);
+    }
+
+    /**
+     * @expectedException        InvalidArgumentException
+     * @expectedExceptionMessage $fileName must be a string, but a object was passed
+     */
+    public function testBadFilenameTypeObject()
+    {
+        new ReflectionFile(new \DateTime());
+    }
+
     public function testGetName()
     {
         $fileName     = $this->parsedRefFile->getName();