Completed
Push — master ( c4d2d4...eae51e )
by Alexander
9s
created

src/ReflectionFile.php (1 issue)

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

1
<?php
2
/**
3
 * Parser Reflection API
4
 *
5
 * @copyright Copyright 2015, Lisachenko Alexander <[email protected]>
6
 *
7
 * This source file is subject to the license that is bundled
8
 * with this source code in the file LICENSE.
9
 */
10
11
namespace Go\ParserReflection;
12
13
14
use Go\ParserReflection\Instrument\PathResolver;
15
use PhpParser\Node;
16
use PhpParser\Node\Stmt\Namespace_;
17
18
/**
19
 * AST-based reflector for the source file
20
 */
21
class ReflectionFile
22
{
23
24
    /**
25
     * Name of the file for reflectino
26
     *
27
     * @var string
28
     */
29
    protected $fileName;
30
31
    /**
32
     * List of namespaces in the file
33
     *
34
     * @var ReflectionFileNamespace[]|array
35
     */
36
    protected $fileNamespaces;
37
38
    /**
39
     * Top-level nodes for the file
40
     *
41
     * @var Node[]
42
     */
43
    private $topLevelNodes;
44
45
    /**
46
     * ReflectionFile constructor.
47
     *
48
     * @param string $fileName Name of the file to reflect
49
     * @param null|array|Node[] $topLevelNodes Optional corresponding list of AST nodes for that file
50
     */
51 3010
    public function __construct($fileName, $topLevelNodes = null)
52
    {
53 3010
        $fileName            = PathResolver::realpath($fileName);
54 3010
        $this->fileName      = $fileName;
0 ignored issues
show
Documentation Bug introduced by
It seems like $fileName can also be of type array or boolean. However, the property $fileName is declared as type string. Maybe add an additional type check?

Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly.

For example, imagine you have a variable $accountId that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the id property of an instance of the Account class. This class holds a proper account, so the id value must no longer be false.

Either this assignment is in error or a type check should be added for that assignment.

class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
Loading history...
55 3010
        $this->topLevelNodes = $topLevelNodes ?: ReflectionEngine::parseFile($fileName);
56 3010
    }
57
58
    /**
59
     * Returns a namespace from the file or false if no such a namespace
60
     *
61
     * @param string $namespaceName
62
     *
63
     * @return bool|ReflectionFileNamespace
64
     */
65 2995
    public function getFileNamespace($namespaceName)
66
    {
67 2995
        if ($this->hasFileNamespace($namespaceName)) {
68 2995
            return $this->fileNamespaces[$namespaceName];
69
        }
70
71 1
        return false;
72
    }
73
74
    /**
75
     * Gets the list of namespaces in the file
76
     *
77
     * @return array|ReflectionFileNamespace[]
78
     */
79 3003
    public function getFileNamespaces()
80
    {
81 3003
        if (!isset($this->fileNamespaces)) {
82 3003
            $this->fileNamespaces = $this->findFileNamespaces();
83
        }
84
85 3003
        return $this->fileNamespaces;
86
    }
87
88
    /**
89
     * Returns the name of current reflected file
90
     *
91
     * @return string
92
     */
93 1
    public function getName()
94
    {
95 1
        return $this->fileName;
96
    }
97
98
    /**
99
     * Returns the presence of namespace in the file
100
     *
101
     * @param string $namespaceName Namespace to check
102
     *
103
     * @return bool
104
     */
105 2996
    public function hasFileNamespace($namespaceName)
106
    {
107 2996
        $namespaces = $this->getFileNamespaces();
108
109 2996
        return isset($namespaces[$namespaceName]);
110
    }
111
112
    /**
113
     * Checks if the current file is in strict mode
114
     *
115
     * @return bool
116
     */
117 4
    public function isStrictMode()
118
    {
119
        // declare statement for the strict_types can be only top-level node
120 4
        $topLevelNode = reset($this->topLevelNodes);
121 4
        if (!$topLevelNode instanceof Node\Stmt\Declare_) {
122 1
            return false;
123
        }
124
125 3
        $declareStatement = reset($topLevelNode->declares);
126 3
        $isStrictTypeKey  = $declareStatement->key === 'strict_types';
127 3
        $isScalarValue    = $declareStatement->value instanceof Node\Scalar\LNumber;
128 3
        $isStrictMode     = $isStrictTypeKey && $isScalarValue && $declareStatement->value->value === 1;
129
130 3
        return $isStrictMode;
131
    }
132
133
    /**
134
     * Searches for file namespaces in the given AST
135
     *
136
     * @return array|ReflectionFileNamespace[]
137
     */
138 3003
    private function findFileNamespaces()
139
    {
140 3003
        $namespaces = array();
141
142
        // namespaces can be only top-level nodes, so we can scan them directly
143 3003
        foreach ($this->topLevelNodes as $topLevelNode) {
144 3003
            if ($topLevelNode instanceof Namespace_) {
145 3003
                $namespaceName = $topLevelNode->name ? $topLevelNode->name->toString() : '';
146
147 3003
                $namespaces[$namespaceName] = new ReflectionFileNamespace(
148 3003
                    $this->fileName,
149
                    $namespaceName,
150
                    $topLevelNode
151
                );
152
            }
153
        }
154
155 3003
        return $namespaces;
156
    }
157
}
158