NameStmtPrefixer::getParent() - Code Metrics - humbug/php-scoper - Measure and Improve Code Quality continuously with Scrutinizer

NameStmtPrefixer::getParent() A
last analyzed 2022-10-12 21:08 UTC

↳ Parent: NameStmtPrefixer

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	4
nc	2
nop	1
dl	0
loc	13
ccs	9
cts	9
cp	1
crap	2
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

/*
 * This file is part of the humbug/php-scoper package.
 *
 * Copyright (c) 2017 Théo FIDRY <[email protected]>,
 *                    Pádraic Brady <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Humbug\PhpScoper\PhpParser\NodeVisitor;

use Humbug\PhpScoper\PhpParser\Node\FullyQualifiedFactory;
use Humbug\PhpScoper\PhpParser\NodeVisitor\NamespaceStmt\NamespaceStmtCollection;
use Humbug\PhpScoper\PhpParser\NodeVisitor\UseStmt\UseStmtCollection;
use Humbug\PhpScoper\PhpParser\UseStmtName;
use Humbug\PhpScoper\Symbol\EnrichedReflector;
use PhpParser\Node;
use PhpParser\Node\Expr\ArrowFunction;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Expr\Closure;
use PhpParser\Node\Expr\ConstFetch;
use PhpParser\Node\Expr\FuncCall;
use PhpParser\Node\Expr\Instanceof_;
use PhpParser\Node\Expr\New_;
use PhpParser\Node\Expr\StaticCall;
use PhpParser\Node\Expr\StaticPropertyFetch;
use PhpParser\Node\IntersectionType;
use PhpParser\Node\Name;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\NullableType;
use PhpParser\Node\Param;
use PhpParser\Node\Stmt\Catch_;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Function_;
use PhpParser\Node\Stmt\Interface_;
use PhpParser\Node\Stmt\Property;
use PhpParser\Node\Stmt\TraitUse;
use PhpParser\Node\Stmt\TraitUseAdaptation\Alias;
use PhpParser\Node\Stmt\TraitUseAdaptation\Precedence;
use PhpParser\Node\Stmt\Use_;
use PhpParser\Node\UnionType;
use PhpParser\NodeVisitorAbstract;
use function in_array;
use function strtolower;

/**
 * Prefixes names when appropriate.
 *
 * ```
 * new Foo\Bar();
 * ```.
 *
 * =>
 *
 * ```
 * new \Humbug\Foo\Bar();
 * ```
 *
 * @private
 */
final class NameStmtPrefixer extends NodeVisitorAbstract
{
    private const SUPPORTED_PARENT_NODE_CLASS_NAMES = [
        Alias::class,
        ArrowFunction::class,
        Catch_::class,
        ConstFetch::class,
        Class_::class,
        ClassConstFetch::class,
        ClassMethod::class,
        Closure::class,
        FuncCall::class,
        Function_::class,
        Instanceof_::class,
        Interface_::class,
        New_::class,
        Param::class,
        Precedence::class,
        Property::class,
        StaticCall::class,
        StaticPropertyFetch::class,
        TraitUse::class,
        UnionType::class,
        IntersectionType::class,
    ];

    private string $prefix;
    private NamespaceStmtCollection $namespaceStatements;
    private UseStmtCollection $useStatements;
    private EnrichedReflector $enrichedReflector;

    public function __construct(
        string $prefix,
        NamespaceStmtCollection $namespaceStatements,
        UseStmtCollection $useStatements,
        EnrichedReflector $enrichedReflector
    ) {
        $this->prefix = $prefix;
        $this->namespaceStatements = $namespaceStatements;
        $this->useStatements = $useStatements;
        $this->enrichedReflector = $enrichedReflector;
    }

    public function enterNode(Node $node): Node
    {
        if (!($node instanceof Name)) {
            return $node;
        }

        return $this->prefixName(
            $node,
            self::getParent($node),
        );
    }

    private static function getParent(Node $name): Node
    {
        $parent = ParentNodeAppender::getParent($name);

        // The parent can be a nullable type. For example for "public ?Foo $x"
        // the parent of Name("Foo") will be NullableType.
        // In practice, we do not get any information from NullableType to
        // determine if we can prefix or not our name hence we skip it completely
        if (!($parent instanceof NullableType)) {
            return $parent;
        }

        return self::getParent($parent);
    }

    private function prefixName(Name $resolvedName, Node $parentNode): Node
    {
        if ($resolvedName->isSpecialClassName()
            || !self::isParentNodeSupported($parentNode)
        ) {
            return $resolvedName;
        }

        $originalName = OriginalNameResolver::getOriginalName($resolvedName);

        // Happens when assigning `null` as a default value for example
        if ($parentNode instanceof ConstFetch
            && 'null' === $originalName->toLowerString()
        ) {
            return $originalName;
        }

        $useStatement = $this->useStatements->findStatementForNode(
            $this->namespaceStatements->findNamespaceForNode($resolvedName),
            $resolvedName,
        );

        if ($this->doesNameHasUseStatement(
            $originalName,
            $resolvedName,
            $parentNode,
            $useStatement,
        )) {
            // Do not prefix if there is a matching use statement.
            return $originalName;
        }

        if ($this->isNamePrefixable($resolvedName)) {
            return $resolvedName;
        }

        // Do not prefix if the Name is inside the current namespace
        $currentNamespace = $this->namespaceStatements->getCurrentNamespaceName();

        if (self::doesNameBelongToNamespace(
            $originalName,
            $resolvedName,
            $currentNamespace,
        )
            // At this point if the name belongs to the global namespace, since
            // we are NOT in an excluded namespace, the current namespace will
            // become prefixed hence there is no need for prefixing.
            // This is however not true for exposed constants as the constants
            // cannot be aliases – they are transformed to keep their original
            // FQ name. In other words, they cannot remain untouched/non-FQ
            || $this->doesNameBelongToGlobalNamespace(
                $originalName,
                $resolvedName->toString(),
                $parentNode,
                $currentNamespace,
            )
        ) {
            return $originalName;
        }

        if (!$this->isPrefixableClassName($resolvedName, $parentNode)) {
            return $resolvedName;
        }

        if ($parentNode instanceof ConstFetch) {
            $prefixedName = $this->prefixConstFetchNode($resolvedName);

            if (null !== $prefixedName) {
                return $prefixedName;
            }

            // Continue
        }

        if ($parentNode instanceof FuncCall) {
            $prefixedName = $this->prefixFuncCallNode($originalName, $resolvedName);

            if (null !== $prefixedName) {
                return $prefixedName;
            }

            // Continue
        }

        return FullyQualifiedFactory::concat(
            $this->prefix,
            $resolvedName->toString(),
            $resolvedName->getAttributes(),
        );
    }

    private static function isParentNodeSupported(Node $parentNode): bool
    {
        foreach (self::SUPPORTED_PARENT_NODE_CLASS_NAMES as $supportedClassName) {
            if ($parentNode instanceof $supportedClassName) {
                return true;
            }
        }

        return false;
    }

    private function isNamePrefixable(Name $resolvedName): bool
    {
        if (!$resolvedName->isFullyQualified()) {
            return false;
        }

        $isAlreadyPrefixed = $this->prefix === $resolvedName->getFirst();

        return (
            $isAlreadyPrefixed
            || $this->enrichedReflector->belongsToExcludedNamespace((string) $resolvedName)
        );
    }

    private static function doesNameBelongToNamespace(
        Name $originalName,
        Name $resolvedName,
        ?Name $namespaceName
    ): bool {
        if (
            $namespaceName === null
            || !$resolvedName->isFullyQualified()
            // In case the original name is a FQ, we do not skip the prefixing
            // and keep it as FQ
            || $originalName->isFullyQualified()
        ) {
            return false;
        }

        $originalNameFQParts = [
            ...$namespaceName->parts,
            ...$originalName->parts,
        ];

        return $originalNameFQParts === $resolvedName->parts;
    }

    private function doesNameBelongToGlobalNamespace(
        Name $originalName,
        string $resolvedName,
        Node $parentNode,
        ?Name $namespaceName
    ): bool {
        return null === $namespaceName
            && !$originalName->isFullyQualified()

            // See caller as to why we cannot allow constants to keep their
            // original non FQ names
            && !($parentNode instanceof ConstFetch)

            // If exposed we cannot keep the original non-FQCN UNLESS belongs
            // to the global namespace for the reasons mentioned in the caller
            && (
                !$this->enrichedReflector->isExposedClass($resolvedName)
                || $this->enrichedReflector->isExposedClassFromGlobalNamespace($resolvedName)
            )
            // If excluded we cannot keep the non-FQCN
            && !$this->enrichedReflector->isClassExcluded($resolvedName)

            && (
                !$this->enrichedReflector->isExposedFunction($resolvedName)
                || $this->enrichedReflector->isExposedFunctionFromGlobalNamespace($resolvedName)
            )
            && !$this->enrichedReflector->isFunctionExcluded($resolvedName);
    }

    private function doesNameHasUseStatement(
        Name $originalName,
        Name $resolvedName,
        Node $parentNode,
        ?Name $useStatementName
    ): bool {
        if (null === $useStatementName
            || !$resolvedName->isFullyQualified()
            // In case the original name is a FQ, we do not skip the prefixing
            // and keep it as FQ
            || $originalName->isFullyQualified()
            // TODO: review Isolated Finder support
            || $resolvedName->parts === ['Isolated', 'Symfony', 'Component', 'Finder', 'Finder']
        ) {
            return false;
        }

        $useStmt = new UseStmtName($useStatementName);

        if (!$useStmt->contains($resolvedName)) {
            return false;
        }

        [$useStmtAlias, $useStmtType] = $useStmt->getUseStmtAliasAndType();

        if ($parentNode instanceof ConstFetch) {
            $isExposedConstant = $this->enrichedReflector->isExposedConstant($resolvedName->toString());

            // If a constant is exposed, it can be that letting a non FQ breaks
            // things. For example the exposed namespaced constant could be
            // used via a partial import (in which case it is a regular import not
            // a constant one) which may not be prefixed.
            return ($isExposedConstant && Use_::TYPE_CONSTANT === $useStmtType)
                || !$isExposedConstant;
        }

        if (null === $useStmtAlias) {
            return true;
        }

        // Classes and namespaces usages are case-insensitive
        $caseSensitiveUseStmt = !in_array(
            $useStmtType,
            [Use_::TYPE_UNKNOWN, Use_::TYPE_NORMAL],
            true,
        );

        return $caseSensitiveUseStmt
            ? $originalName->getFirst() === $useStmtAlias
            : strtolower($originalName->getFirst()) === strtolower($useStmtAlias);
    }

    private function isPrefixableClassName(
        Name $resolvedName,
        Node $parentNode
    ): bool {
        $isClassNode = $parentNode instanceof ConstFetch || $parentNode instanceof FuncCall;

        return (
            $isClassNode
            || !$resolvedName->isFullyQualified()
            || !$this->enrichedReflector->isClassExcluded($resolvedName->toString())
        );
    }

    /**
     * @return Name|null Returns the name to use (prefixed or not). Otherwise
     *                   it was not possible to resolve the name and the name
     *                   will end up being prefixed the "regular" way (prefix
     *                   added)
     */
    private function prefixConstFetchNode(Name $resolvedName): ?Name
    {
        $resolvedNameString = $resolvedName->toString();

        if ($resolvedName->isFullyQualified()) {
            return $this->enrichedReflector->isExposedConstant($resolvedNameString)
                ? $resolvedName
                : null;
        }

        // Constants have an auto-loading fallback, so as a rule we cannot
        // prefix them when the name is ambiguous.
        // See https://wiki.php.net/rfc/fallback-to-root-scope-deprecation
        //
        // HOWEVER. However. There is _very_ high chances that if a user
        // explicitly register a constant to be exposed or that the constant
        // is internal that it is the constant in question and not the one
        // relative to the namespace.
        // Indeed it would otherwise mean that the user has for example Acme\FOO
        // and \FOO in the codebase AND decide to expose \FOO.
        // It is not only unlikely but sketchy, hence should not be an issue
        // in practice.

        // We distinguish exposed from internal here as internal are a much safer
        // bet.
        if ($this->enrichedReflector->isConstantInternal($resolvedNameString)) {
            return new FullyQualified(
                $resolvedNameString,
                $resolvedName->getAttributes(),
            );
        }

        if ($this->enrichedReflector->isExposedConstant($resolvedNameString)) {
            return $this->enrichedReflector->isExposedConstantFromGlobalNamespace($resolvedNameString)
                ? $resolvedName
                : new FullyQualified(
                    $resolvedNameString,
                    $resolvedName->getAttributes(),
                );
        }

        return $resolvedName;
    }

    /**
     * @return Name|null Returns the name to use (prefixed or not). Otherwise
     *                   it was not possible to resolve the name and the name
     *                   will end up being prefixed the "regular" way (prefix
     *                   added)
     */
    private function prefixFuncCallNode(Name $originalName, Name $resolvedName): ?Name
    {
        // Functions have a fallback auto-loading so we cannot prefix them when
        // the name is ambiguous
        // See https://wiki.php.net/rfc/fallback-to-root-scope-deprecation
        //
        // See prefixConstFetchNode() for more details as to why we can still
        // take the risk under some circumstances.
        $resolvedNameString = $resolvedName->toString();

        if ($resolvedName->isFullyQualified()) {
            return $this->enrichedReflector->isFunctionExcluded($resolvedNameString)
                ? $resolvedName
                : null;
        }

        if ($this->enrichedReflector->isFunctionInternal($resolvedNameString)) {
            return new FullyQualified(
                $originalName->toString(),
                $originalName->getAttributes(),
            );
        }

        if ($this->enrichedReflector->isExposedFunction($resolvedNameString)) {
            // TODO: should be able to find a case for it
            return $this->enrichedReflector->isExposedFunctionFromGlobalNamespace($resolvedNameString)
                ? $resolvedName
                : null;
        }

        return $resolvedName;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		/*
6		* This file is part of the humbug/php-scoper package.
7		*
8		* Copyright (c) 2017 Théo FIDRY <[email protected]>,
9		* Pádraic Brady <[email protected]>
10		*
11		* For the full copyright and license information, please view the LICENSE
12		* file that was distributed with this source code.
13		*/
14
15		namespace Humbug\PhpScoper\PhpParser\NodeVisitor;
16
17		use Humbug\PhpScoper\PhpParser\Node\FullyQualifiedFactory;
18		use Humbug\PhpScoper\PhpParser\NodeVisitor\NamespaceStmt\NamespaceStmtCollection;
19		use Humbug\PhpScoper\PhpParser\NodeVisitor\UseStmt\UseStmtCollection;
20		use Humbug\PhpScoper\PhpParser\UseStmtName;
21		use Humbug\PhpScoper\Symbol\EnrichedReflector;
22		use PhpParser\Node;
23		use PhpParser\Node\Expr\ArrowFunction;
24		use PhpParser\Node\Expr\ClassConstFetch;
25		use PhpParser\Node\Expr\Closure;
26		use PhpParser\Node\Expr\ConstFetch;
27		use PhpParser\Node\Expr\FuncCall;
28		use PhpParser\Node\Expr\Instanceof_;
29		use PhpParser\Node\Expr\New_;
30		use PhpParser\Node\Expr\StaticCall;
31		use PhpParser\Node\Expr\StaticPropertyFetch;
32		use PhpParser\Node\IntersectionType;
33		use PhpParser\Node\Name;
34		use PhpParser\Node\Name\FullyQualified;
35		use PhpParser\Node\NullableType;
36		use PhpParser\Node\Param;
37		use PhpParser\Node\Stmt\Catch_;
38		use PhpParser\Node\Stmt\Class_;
39		use PhpParser\Node\Stmt\ClassMethod;
40		use PhpParser\Node\Stmt\Function_;
41		use PhpParser\Node\Stmt\Interface_;
42		use PhpParser\Node\Stmt\Property;
43		use PhpParser\Node\Stmt\TraitUse;
44		use PhpParser\Node\Stmt\TraitUseAdaptation\Alias;
45		use PhpParser\Node\Stmt\TraitUseAdaptation\Precedence;
46		use PhpParser\Node\Stmt\Use_;
47		use PhpParser\Node\UnionType;
48		use PhpParser\NodeVisitorAbstract;
49		use function in_array;
50		use function strtolower;
51
52		/**
53		* Prefixes names when appropriate.
54		*
55		* ```
56		* new Foo\Bar();
57		* ```.
58		*
59		* =>
60		*
61		* ```
62		* new \Humbug\Foo\Bar();
63		* ```
64		*
65		* @private
66		*/
67		final class NameStmtPrefixer extends NodeVisitorAbstract
68	549	{
69		private const SUPPORTED_PARENT_NODE_CLASS_NAMES = [
70		Alias::class,
71		ArrowFunction::class,
72		Catch_::class,
73		ConstFetch::class,
74	549	Class_::class,
75	549	ClassConstFetch::class,
76	549	ClassMethod::class,
77	549	Closure::class,
78		FuncCall::class,
79		Function_::class,
80		Instanceof_::class,
81		Interface_::class,
82		New_::class,
83	548	Param::class,
84		Precedence::class,
85	548	Property::class,
86	544	StaticCall::class,
87	548	StaticPropertyFetch::class,
88		TraitUse::class,
89		UnionType::class,
90		IntersectionType::class,
91	544	];
92
93	544	private string $prefix;
94		private NamespaceStmtCollection $namespaceStatements;
95	544	private UseStmtCollection $useStatements;
96	4	private EnrichedReflector $enrichedReflector;
97
98		public function __construct(
99		string $prefix,
100	4	NamespaceStmtCollection $namespaceStatements,
101		UseStmtCollection $useStatements,
102		EnrichedReflector $enrichedReflector
103		) {
104	544	$this->prefix = $prefix;
105	542	$this->namespaceStatements = $namespaceStatements;
106	541	$this->useStatements = $useStatements;
107	540	$this->enrichedReflector = $enrichedReflector;
108	540	}
109	538
110	538	public function enterNode(Node $node): Node
111	538	{
112	538	if (!($node instanceof Name)) {
113	538	return $node;
114	538	}
115	538
116	544	return $this->prefixName(
117		$node,
118		self::getParent($node),
119	537	);
120		}
121
122		private static function getParent(Node $name): Node
123		{
124	405	$parent = ParentNodeAppender::getParent($name);
125	349
126	298	// The parent can be a nullable type. For example for "public ?Foo $x"
127	236	// the parent of Name("Foo") will be NullableType.
128	185	// In practice, we do not get any information from NullableType to
129	133	// determine if we can prefix or not our name hence we skip it completely
130	131	if (!($parent instanceof NullableType)) {
131	120	return $parent;
132		}
133	320
134		return self::getParent($parent);
135	9	}
136
137		private function prefixName(Name $resolvedName, Node $parentNode): Node
138	403	{
139	4	if ($resolvedName->isSpecialClassName()
140		\|\| !self::isParentNodeSupported($parentNode)
141		) {
142	403	return $resolvedName;
143		}
144	403
145		$originalName = OriginalNameResolver::getOriginalName($resolvedName);
146	403
147	403	// Happens when assigning `null` as a default value for example
148		if ($parentNode instanceof ConstFetch
149	23	&& 'null' === $originalName->toLowerString()
150		) {
151		return $originalName;
152		}
153	392
154	257	$useStatement = $this->useStatements->findStatementForNode(
155		$this->namespaceStatements->findNamespaceForNode($resolvedName),
156	61	$resolvedName,
157		);
158
159	355	if ($this->doesNameHasUseStatement(
160	85	$originalName,
161	21	$resolvedName,
162		$parentNode,
163		$useStatement,
164	67	)) {
165	19	// Do not prefix if there is a matching use statement.
166		return $originalName;
167		}
168
169		if ($this->isNamePrefixable($resolvedName)) {
170	48	return $resolvedName;
171	8	}
172
173		// Do not prefix if the Name is inside the current namespace
174	46	$currentNamespace = $this->namespaceStatements->getCurrentNamespaceName();
175
176	11	if (self::doesNameBelongToNamespace(
177		$originalName,
178		$resolvedName,
179		$currentNamespace,
180		)
181		// At this point if the name belongs to the global namespace, since
182		// we are NOT in an excluded namespace, the current namespace will
183		// become prefixed hence there is no need for prefixing.
184	320	// This is however not true for exposed constants as the constants
185	76	// cannot be aliases – they are transformed to keep their original
186	37	// FQ name. In other words, they cannot remain untouched/non-FQ
187		\|\| $this->doesNameBelongToGlobalNamespace(
188		$originalName,
189	54	$resolvedName->toString(),
190	9	$parentNode,
191		$currentNamespace,
192		)
193		) {
194	297	return $originalName;
195	3	}
196
197		if (!$this->isPrefixableClassName($resolvedName, $parentNode)) {
198	297	return $resolvedName;
199	297	}
200	297
201	297	if ($parentNode instanceof ConstFetch) {
202		$prefixedName = $this->prefixConstFetchNode($resolvedName);
203
204		if (null !== $prefixedName) {
205		return $prefixedName;
206		}
207
208		// Continue
209		}
210
211		if ($parentNode instanceof FuncCall) {
212		$prefixedName = $this->prefixFuncCallNode($originalName, $resolvedName);
213
214		if (null !== $prefixedName) {
215		return $prefixedName;
216		}
217
218		// Continue
219		}
220
221		return FullyQualifiedFactory::concat(
222		$this->prefix,
223		$resolvedName->toString(),
224		$resolvedName->getAttributes(),
225		);
226		}
227
228		private static function isParentNodeSupported(Node $parentNode): bool
229		{
230		foreach (self::SUPPORTED_PARENT_NODE_CLASS_NAMES as $supportedClassName) {
231		if ($parentNode instanceof $supportedClassName) {
232		return true;
233		}
234		}
235
236		return false;
237		}
238
239		private function isNamePrefixable(Name $resolvedName): bool
240		{
241		if (!$resolvedName->isFullyQualified()) {
242		return false;
243		}
244
245		$isAlreadyPrefixed = $this->prefix === $resolvedName->getFirst();
246
247		return (
248		$isAlreadyPrefixed
249		\|\| $this->enrichedReflector->belongsToExcludedNamespace((string) $resolvedName)
250		);
251		}
252
253		private static function doesNameBelongToNamespace(
254		Name $originalName,
255		Name $resolvedName,
256		?Name $namespaceName
257		): bool {
258		if (
259		$namespaceName === null
260		\|\| !$resolvedName->isFullyQualified()
261		// In case the original name is a FQ, we do not skip the prefixing
262		// and keep it as FQ
263		\|\| $originalName->isFullyQualified()
264		) {
265		return false;
266		}
267
268		$originalNameFQParts = [
269		...$namespaceName->parts,
270		...$originalName->parts,
271		];
272
273		return $originalNameFQParts === $resolvedName->parts;
274		}
275
276		private function doesNameBelongToGlobalNamespace(
277		Name $originalName,
278		string $resolvedName,
279		Node $parentNode,
280		?Name $namespaceName
281		): bool {
282		return null === $namespaceName
283		&& !$originalName->isFullyQualified()
284
285		// See caller as to why we cannot allow constants to keep their
286		// original non FQ names
287		&& !($parentNode instanceof ConstFetch)
288
289		// If exposed we cannot keep the original non-FQCN UNLESS belongs
290		// to the global namespace for the reasons mentioned in the caller
291		&& (
292		!$this->enrichedReflector->isExposedClass($resolvedName)
293		\|\| $this->enrichedReflector->isExposedClassFromGlobalNamespace($resolvedName)
294		)
295		// If excluded we cannot keep the non-FQCN
296		&& !$this->enrichedReflector->isClassExcluded($resolvedName)
297
298		&& (
299		!$this->enrichedReflector->isExposedFunction($resolvedName)
300		\|\| $this->enrichedReflector->isExposedFunctionFromGlobalNamespace($resolvedName)
301		)
302		&& !$this->enrichedReflector->isFunctionExcluded($resolvedName);
303		}
304
305		private function doesNameHasUseStatement(
306		Name $originalName,
307		Name $resolvedName,
308		Node $parentNode,
309		?Name $useStatementName
310		): bool {
311		if (null === $useStatementName
312		\|\| !$resolvedName->isFullyQualified()
313		// In case the original name is a FQ, we do not skip the prefixing
314		// and keep it as FQ
315		\|\| $originalName->isFullyQualified()
316		// TODO: review Isolated Finder support
317		\|\| $resolvedName->parts === ['Isolated', 'Symfony', 'Component', 'Finder', 'Finder']
318		) {
319		return false;
320		}
321
322		$useStmt = new UseStmtName($useStatementName);
323
324		if (!$useStmt->contains($resolvedName)) {
325		return false;
326		}
327
328		[$useStmtAlias, $useStmtType] = $useStmt->getUseStmtAliasAndType();
329
330		if ($parentNode instanceof ConstFetch) {
331		$isExposedConstant = $this->enrichedReflector->isExposedConstant($resolvedName->toString());
332
333		// If a constant is exposed, it can be that letting a non FQ breaks
334		// things. For example the exposed namespaced constant could be
335		// used via a partial import (in which case it is a regular import not
336		// a constant one) which may not be prefixed.
337		return ($isExposedConstant && Use_::TYPE_CONSTANT === $useStmtType)
338		\|\| !$isExposedConstant;
339		}
340
341		if (null === $useStmtAlias) {
342		return true;
343		}
344
345		// Classes and namespaces usages are case-insensitive
346		$caseSensitiveUseStmt = !in_array(
347		$useStmtType,
348		[Use_::TYPE_UNKNOWN, Use_::TYPE_NORMAL],
349		true,
350		);
351
352		return $caseSensitiveUseStmt
353		? $originalName->getFirst() === $useStmtAlias
354		: strtolower($originalName->getFirst()) === strtolower($useStmtAlias);
355		}
356
357		private function isPrefixableClassName(
358		Name $resolvedName,
359		Node $parentNode
360		): bool {
361		$isClassNode = $parentNode instanceof ConstFetch \|\| $parentNode instanceof FuncCall;
362
363		return (
364		$isClassNode
365		\|\| !$resolvedName->isFullyQualified()
366		\|\| !$this->enrichedReflector->isClassExcluded($resolvedName->toString())
367		);
368		}
369
370		/**
371		* @return Name\|null Returns the name to use (prefixed or not). Otherwise
372		* it was not possible to resolve the name and the name
373		* will end up being prefixed the "regular" way (prefix
374		* added)
375		*/
376		private function prefixConstFetchNode(Name $resolvedName): ?Name
377		{
378		$resolvedNameString = $resolvedName->toString();
379
380		if ($resolvedName->isFullyQualified()) {
381		return $this->enrichedReflector->isExposedConstant($resolvedNameString)
382		? $resolvedName
383		: null;
384		}
385
386		// Constants have an auto-loading fallback, so as a rule we cannot
387		// prefix them when the name is ambiguous.
388		// See https://wiki.php.net/rfc/fallback-to-root-scope-deprecation
389		//
390		// HOWEVER. However. There is _very_ high chances that if a user
391		// explicitly register a constant to be exposed or that the constant
392		// is internal that it is the constant in question and not the one
393		// relative to the namespace.
394		// Indeed it would otherwise mean that the user has for example Acme\FOO
395		// and \FOO in the codebase AND decide to expose \FOO.
396		// It is not only unlikely but sketchy, hence should not be an issue
397		// in practice.
398
399		// We distinguish exposed from internal here as internal are a much safer
400		// bet.
401		if ($this->enrichedReflector->isConstantInternal($resolvedNameString)) {
402		return new FullyQualified(
403		$resolvedNameString,
404		$resolvedName->getAttributes(),
405		);
406		}
407
408		if ($this->enrichedReflector->isExposedConstant($resolvedNameString)) {
409		return $this->enrichedReflector->isExposedConstantFromGlobalNamespace($resolvedNameString)
410		? $resolvedName
411		: new FullyQualified(
412		$resolvedNameString,
413		$resolvedName->getAttributes(),
414		);
415		}
416
417		return $resolvedName;
418		}
419
420		/**
421		* @return Name\|null Returns the name to use (prefixed or not). Otherwise
422		* it was not possible to resolve the name and the name
423		* will end up being prefixed the "regular" way (prefix
424		* added)
425		*/
426		private function prefixFuncCallNode(Name $originalName, Name $resolvedName): ?Name
427		{
428		// Functions have a fallback auto-loading so we cannot prefix them when
429		// the name is ambiguous
430		// See https://wiki.php.net/rfc/fallback-to-root-scope-deprecation
431		//
432		// See prefixConstFetchNode() for more details as to why we can still
433		// take the risk under some circumstances.
434		$resolvedNameString = $resolvedName->toString();
435
436		if ($resolvedName->isFullyQualified()) {
437		return $this->enrichedReflector->isFunctionExcluded($resolvedNameString)
438		? $resolvedName
439		: null;
440		}
441
442		if ($this->enrichedReflector->isFunctionInternal($resolvedNameString)) {
443		return new FullyQualified(
444		$originalName->toString(),
445		$originalName->getAttributes(),
446		);
447		}
448
449		if ($this->enrichedReflector->isExposedFunction($resolvedNameString)) {
450		// TODO: should be able to find a case for it
451		return $this->enrichedReflector->isExposedFunctionFromGlobalNamespace($resolvedNameString)
452		? $resolvedName
453		: null;
454		}
455
456		return $resolvedName;
457		}
458		}
459

humbug / php-scoper

NameStmtPrefixer::getParent() A last analyzed 2022-10-12 21:08 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

NameStmtPrefixer::getParent() A
last analyzed 2022-10-12 21:08 UTC