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
|
|||
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 |
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 theid
property of an instance of theAccount
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.