Humbug\PhpScoper\PhpParser\NodeVisitor\StringScalarPrefixer::shouldPrefixScalar()

Complexity

Conditions	34
Paths	34

Size

Total Lines

112

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	34.2822

Importance

Changes

0

<?php
    private function shouldPrefixScalar(Node $node, bool &$isSpecialFunction): bool
    {
        if (false === ($node instanceof String_ && AppendParentNode::hasParent($node) && is_string($node->value))
            || 1 !== preg_match('/^((\\\\)?[\p{L}_]+)|((\\\\)?(?:[\p{L}_]+\\\\+)+[\p{L}_]+)$/u', $node->value)
        ) {
            return false;
        }

        /** @var String_ $node */
        $parentNode = AppendParentNode::getParent($node);

        // The string scalar either has a class form or a simple string which can either be a symbol from the global
        // namespace or a completely unrelated string.

        if ($parentNode instanceof Arg
            && null !== $functionNode = AppendParentNode::findParent($parentNode)
        ) {
            $functionNode = AppendParentNode::getParent($parentNode);

            if ($functionNode instanceof FuncCall) {
                $functionName = is_stringable($functionNode->name) ? (string) $functionNode->name : null;

                if (false === strpos((string) $node->value, '\\')
                    && null !== $functionName
                    && in_array($functionName, self::SPECIAL_FUNCTION_NAMES, true)
                ) {
                    $isSpecialFunction = true;

                    return
                        (
                            'function_exists' === $functionName
                            && false === $this->reflector->isFunctionInternal($node->value)
                        )
                        || (
                            'function_exists' !== $functionName
                            && false === $this->reflector->isClassInternal($node->value)
                            && false === $this->whitelist->isClassWhitelisted($node->value)
                        )
                    ;
                }

                return $functionNode->name instanceof Name && false === $functionNode->hasAttribute('whitelist_class_alias');
            }

            return $functionNode instanceof MethodCall || $functionNode instanceof StaticCall;
        }

        if (false === ($parentNode instanceof ArrayItem)) {
            return $parentNode instanceof Assign
                || $parentNode instanceof Param
                || $parentNode instanceof Const_
                || $parentNode instanceof PropertyProperty
            ;
        }

        // ArrayItem can lead to two results: either the string is used for `spl_autoload_register()`, e.g.
        // `spl_autoload_register(['Swift', 'autoload'])` in which case the string `'Swift'` is guaranteed to be class
        // name, or something else in which case a string like `'Swift'` can be anything and cannot be prefixed.

        if (substr_count($node->value, '\\') + 1 > 1) {
            return true;
        }

        $arrayItemNode = $parentNode;

        if (false === AppendParentNode::hasParent($parentNode)) {
            return false;
        }

        $parentNode = AppendParentNode::getParent($parentNode);

        if (false === ($parentNode instanceof Array_) || false === AppendParentNode::hasParent($parentNode)) {
            return false;
        }

        /** @var Array_ $arrayNode */
        $arrayNode = $parentNode;
        $parentNode = AppendParentNode::getParent($parentNode);

        if (false === ($parentNode instanceof Arg)
            || null === $functionNode = AppendParentNode::findParent($parentNode)
        ) {
            return false;
        }

        $functionNode = AppendParentNode::getParent($parentNode);

        if (false === ($functionNode instanceof FuncCall)) {
            return false;
        }

        /** @var FuncCall $functionNode */
        if (is_stringable($functionNode->name)) {
            $functionName = (string) $functionNode->name;
        } else {
            return false;
        }

        if ('spl_autoload_register' === $functionName
            && array_key_exists(0, $arrayNode->items)
            && $arrayItemNode === $arrayNode->items[0]
        ) {
            $isSpecialFunction = true;

            return
                false === $this->whitelist->isClassWhitelisted($node->value)
                && false === $this->reflector->isClassInternal($node->value)
            ;
        }

        return false;
    }