Expression::constFetch() - Code Metrics - Inspection of "Refactor Expression class" - ovr/phpsa - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#196)

by Enrico

created 2016-10-06 16:05 UTC

Expression::constFetch() A

↳ Parent: Project

Complexity

Conditions	4
Paths	4

Size

Total Lines	17
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	4

Importance

Changes

Metric	Value
cc	4
eloc	7
c	0
b	0
f	0
nc	4
nop	1
dl	0
loc	17
ccs	8
cts	8
cp	1
crap	4
rs	9.2

<?php
/**
 * @author Patsura Dmitry https://github.com/ovr <[email protected]>
 */

namespace PHPSA\Compiler;

use InvalidArgumentException;
use phpDocumentor\Reflection\DocBlockFactory;
use PHPSA\Check;
use PHPSA\CompiledExpression;
use PHPSA\Compiler\Event\ExpressionBeforeCompile;
use PHPSA\Context;
use PhpParser\Node;
use PHPSA\Definition\ClassDefinition;
use PHPSA\Exception\RuntimeException;
use PHPSA\Variable;
use PHPSA\Compiler\Expression\AbstractExpressionCompiler;
use Webiny\Component\EventManager\EventManager;

class Expression

{
    /**
     * @var Context
     */
    protected $context;

    /**
     * @var EventManager
     */
    protected $eventManager;

    /**
     * @param Context $context
     */
    public function __construct(Context $context, EventManager $eventManager)
    {
        $this->context = $context;
        $this->eventManager = $eventManager;
    }

    /**
     * @param $expr
     * @return ExpressionCompilerInterface|AbstractExpressionCompiler
     */
    protected function factory($expr)
    {
        switch (get_class($expr)) {
            /**
             * Call(s)
             */
            case Node\Expr\MethodCall::class:
                return new Expression\MethodCall();
            case Node\Expr\FuncCall::class:
                return new Expression\FunctionCall();
            case Node\Expr\StaticCall::class:
                return new Expression\StaticCall();
            /**
             * Operators
             */
            case Node\Expr\New_::class:
                return new Expression\Operators\NewOp();
            case Node\Expr\Instanceof_::class:
                return new Expression\Operators\InstanceOfOp();
            /**
             * AssignOp
             */
            case Node\Expr\AssignOp\Pow::class:
                return new Expression\AssignOp\Pow();
            case Node\Expr\AssignOp\Plus::class:
                return new Expression\AssignOp\Plus();
            case Node\Expr\AssignOp\Minus::class:
                return new Expression\AssignOp\Minus();
            case Node\Expr\AssignOp\Mul::class:
                return new Expression\AssignOp\Mul();
            case Node\Expr\AssignOp\Div::class:
                return new Expression\AssignOp\Div();
            case Node\Expr\AssignOp\Mod::class:
                return new Expression\AssignOp\Mod();
            case Node\Expr\AssignOp\BitwiseOr::class:
                return new Expression\AssignOp\BitwiseOr();
            case Node\Expr\AssignOp\BitwiseAnd::class:
                return new Expression\AssignOp\BitwiseAnd();
            case Node\Expr\AssignOp\BitwiseXor::class:
                return new Expression\AssignOp\BitwiseXor();
            case Node\Expr\AssignOp\Concat::class:
                return new Expression\AssignOp\Concat();
            case Node\Expr\AssignOp\ShiftLeft::class:
                return new Expression\AssignOp\ShiftLeft();
            case Node\Expr\AssignOp\ShiftRight::class:
                return new Expression\AssignOp\ShiftRight();

            /**
             * BinaryOp
             */
            case Node\Expr\BinaryOp\Identical::class:
                return new Expression\BinaryOp\Identical();
            case Node\Expr\BinaryOp\Concat::class:
                return new Expression\Operators\Concat();
            case Node\Expr\BinaryOp\NotIdentical::class:
                return new Expression\BinaryOp\NotIdentical();
            case Node\Expr\BinaryOp\Equal::class:
                return new Expression\BinaryOp\Equal();
            case Node\Expr\BinaryOp\NotEqual::class:
                return new Expression\BinaryOp\NotEqual();
            case Node\Expr\BinaryOp\Spaceship::class:
                return new Expression\BinaryOp\SpaceShip();
            case Node\Expr\BinaryOp\Coalesce::class:
                return new Expression\BinaryOp\Coalesce();
                
            /**
             * @link http://php.net/manual/en/language.operators.increment.php
             */
            case Node\Expr\PostInc::class:
                return new Expression\Operators\PostInc();
            case Node\Expr\PostDec::class:
                return new Expression\Operators\PostDec();
            case Node\Expr\PreInc::class:
                return new Expression\Operators\PreInc();
            case Node\Expr\PreDec::class:
                return new Expression\Operators\PreDec();
            /**
             * Arithmetical
             */
            case Node\Expr\BinaryOp\Div::class:
                return new Expression\Operators\Arithmetical\Div();
            case Node\Expr\BinaryOp\Plus::class:
                return new Expression\Operators\Arithmetical\Plus();
            case Node\Expr\BinaryOp\Minus::class:
                return new Expression\Operators\Arithmetical\Minus();
            case Node\Expr\BinaryOp\Mul::class:
                return new Expression\Operators\Arithmetical\Mul();
            case Node\Expr\BinaryOp\Mod::class:
                return new Expression\Operators\Arithmetical\Mod();
            case Node\Expr\BinaryOp\Pow::class:
                return new Expression\Operators\Arithmetical\Pow();

            /**
             * Bitwise
             * @link http://php.net/manual/ru/language.operators.bitwise.php
             */
            case Node\Expr\BinaryOp\BitwiseOr::class:
                return new Expression\Operators\Bitwise\BitwiseOr();
            case Node\Expr\BinaryOp\BitwiseXor::class:
                return new Expression\Operators\Bitwise\BitwiseXor();
            case Node\Expr\BinaryOp\BitwiseAnd::class:
                return new Expression\Operators\Bitwise\BitwiseAnd();
            case Node\Expr\BinaryOp\ShiftRight::class:
                return new Expression\Operators\Bitwise\ShiftRight();
            case Node\Expr\BinaryOp\ShiftLeft::class:
                return new Expression\Operators\Bitwise\ShiftLeft();
            case Node\Expr\BitwiseNot::class:
                return new Expression\Operators\Bitwise\BitwiseNot();
            /**
             * Logical
             */
            case Node\Expr\BinaryOp\BooleanOr::class:
                return new Expression\Operators\Logical\BooleanOr();
            case Node\Expr\BinaryOp\BooleanAnd::class:
                return new Expression\Operators\Logical\BooleanAnd();
            case Node\Expr\BooleanNot::class:
                return new Expression\Operators\Logical\BooleanNot();
            case Node\Expr\BinaryOp\LogicalAnd::class:
                return new Expression\Operators\Logical\LogicalAnd();
            case Node\Expr\BinaryOp\LogicalOr::class:
                return new Expression\Operators\Logical\LogicalOr();
            case Node\Expr\BinaryOp\LogicalXor::class:
                return new Expression\Operators\Logical\LogicalXor();

            /**
             * Comparison
             */
            case Node\Expr\BinaryOp\Greater::class:
                return new Expression\Operators\Comparison\Greater();
            case Node\Expr\BinaryOp\GreaterOrEqual::class:
                return new Expression\Operators\Comparison\GreaterOrEqual();
            case Node\Expr\BinaryOp\Smaller::class:
                return new Expression\Operators\Comparison\Smaller();
            case Node\Expr\BinaryOp\SmallerOrEqual::class:
                return new Expression\Operators\Comparison\SmallerOrEqual();

            /**
             * Casts
             */
            case Node\Expr\Cast\Array_::class:
                return new Expression\Casts\ArrayCast();
            case Node\Expr\Cast\Bool_::class:
                return new Expression\Casts\BoolCast();
            case Node\Expr\Cast\Int_::class:
                return new Expression\Casts\IntCast();
            case Node\Expr\Cast\Double::class:
                return new Expression\Casts\DoubleCast();
            case Node\Expr\Cast\Object_::class:
                return new Expression\Casts\ObjectCast();
            case Node\Expr\Cast\String_::class:
                return new Expression\Casts\StringCast();
            case Node\Expr\Cast\Unset_::class:
                return new Expression\Casts\UnsetCast();


            /**
             * Other
             */
            case Node\Expr\Array_::class:
                return new Expression\ArrayOp();
            case Node\Expr\Assign::class:
                return new Expression\Assign();
            case Node\Expr\AssignRef::class:
                return new Expression\AssignRef();
            case Node\Expr\Closure::class:
                return new Expression\Closure();
            case Node\Expr\ConstFetch::class:
                return new Expression\ConstFetch();
            case Node\Expr\ClassConstFetch::class:
                return new Expression\ClassConstFetch();
            case Node\Expr\PropertyFetch::class:
                return new Expression\PropertyFetch();
            case Node\Expr\UnaryMinus::class:
                return new Expression\Operators\UnaryMinus();
            case Node\Expr\UnaryPlus::class:
                return new Expression\Operators\UnaryPlus();
            case Node\Expr\Exit_::class:
                return new Expression\ExitOp();
            case Node\Expr\Isset_::class:
                return new Expression\IssetOp();
            case Node\Expr\Print_::class:
                return new Expression\PrintOp();
            case Node\Expr\Empty_::class:
                return new Expression\EmptyOp();
            case Node\Expr\Eval_::class:
                return new Expression\EvalOp();
            case Node\Expr\ErrorSuppress::class:
                return new Expression\ErrorSuppress();
            case Node\Expr\Clone_::class:
                return new Expression\CloneOp();
            case Node\Expr\Ternary::class:
                return new Expression\Ternary();
            case Node\Expr\Variable::class:
                return new Expression\Variable();
        }

        return false;
    }

    /**
     * @param object|string $expr
     * @throws InvalidArgumentException when $expr is not string/object/null
     * @throws RuntimeException when compiler class does not return a CompiledExpression
     * @return CompiledExpression
     */
    public function compile($expr)

    {
        if (is_string($expr)) {
            return new CompiledExpression(CompiledExpression::STRING, $expr);
        }

        if (is_null($expr)) {
            return new CompiledExpression(CompiledExpression::NULL);
        }

        if (!is_object($expr)) {
            throw new InvalidArgumentException('$expr must be string/object/null');
        }

        $this->eventManager->fire(
            ExpressionBeforeCompile::EVENT_NAME,
            new ExpressionBeforeCompile(
                $expr,
                $this->context
            )
        );

        $className = get_class($expr);
        switch ($className) {
            case Node\Arg::class:
                /**
                 * @todo Better compile
                 */
                return $this->compile($expr->value);
            case Node\Stmt\Property::class:
                return $this->passProperty($expr);

            /**
             * Expressions
             */
            case Node\Name::class:
                return $this->getNodeName($expr);
            case Node\Name\FullyQualified::class:
                return $this->getFullyQualifiedNodeName($expr);

            /**
             * Simple Scalar(s)
             */
            case \PHPSA\Node\Scalar\Nil::class:
                return new CompiledExpression(CompiledExpression::NULL);
            case Node\Scalar\LNumber::class:
                return new CompiledExpression(CompiledExpression::INTEGER, $expr->value);
            case Node\Scalar\DNumber::class:
                return new CompiledExpression(CompiledExpression::DOUBLE, $expr->value);
            case Node\Scalar\String_::class:
                return new CompiledExpression(CompiledExpression::STRING, $expr->value);
            case \PHPSA\Node\Scalar\Boolean::class:
                return new CompiledExpression(CompiledExpression::BOOLEAN, $expr->value);
            case \PHPSA\Node\Scalar\Fake::class:
                return new CompiledExpression($expr->type, $expr->value);
        }

        $expressionCompiler = $this->factory($expr);
        if (!$expressionCompiler) {
            $this->context->debug("Expression compiler is not implemented for {$className}");
            return new CompiledExpression(CompiledExpression::UNIMPLEMENTED);
        }

        $result = $expressionCompiler->pass($expr, $this->context);
        if (!$result instanceof CompiledExpression) {
            throw new RuntimeException('Please return CompiledExpression from ' . get_class($expressionCompiler));
        }

        return $result;
    }

    /**
     * @todo Implement - needs to be a new analyzer for var docblock
     *
     * @param Node\Stmt\Property $st
     * @return CompiledExpression
     */
    public function passProperty(Node\Stmt\Property $st)

    {
        $docBlock = $st->getDocComment();
        if (!$docBlock) {
            return new CompiledExpression();
        }

        $phpdoc = DocBlockFactory::createInstance()->create($docBlock->getText());

        $varTags = $phpdoc->getTagsByName('var');
        if ($varTags) {

            /** @var \phpDocumentor\Reflection\DocBlock\Tag\VarTag $varTag */
            $varTag = current($varTags);

            $typeResolver = new \phpDocumentor\Reflection\TypeResolver();

            try {
                $type = $typeResolver->resolve($varTag->getType());
            } catch (\InvalidArgumentException $e) {
                return new CompiledExpression();
            }

            if ($type) {
                switch (get_class($type)) {
                    case \phpDocumentor\Reflection\Types\Object_::class:
                        return new CompiledExpression(
                            CompiledExpression::OBJECT
                        );
                    case \phpDocumentor\Reflection\Types\Integer::class:
                        return new CompiledExpression(
                            CompiledExpression::INTEGER
                        );
                    case \phpDocumentor\Reflection\Types\String_::class:
                        return new CompiledExpression(
                            CompiledExpression::STRING
                        );
                    case \phpDocumentor\Reflection\Types\Float_::class:
                        return new CompiledExpression(
                            CompiledExpression::DOUBLE
                        );
                    case \phpDocumentor\Reflection\Types\Null_::class:
                        return new CompiledExpression(
                            CompiledExpression::NULL
                        );
                    case \phpDocumentor\Reflection\Types\Boolean::class:
                        return new CompiledExpression(
                            CompiledExpression::BOOLEAN
                        );
                }
            }
        }

        return new CompiledExpression();
    }

    /**
     * @param Node\Expr\Variable $expr
     * @param mixed $value
     * @param int $type
     * @return CompiledExpression
     */
    public function declareVariable(Node\Expr\Variable $expr, $value = null, $type = CompiledExpression::UNKNOWN)
    {
        $variable = $this->context->getSymbol($expr->name);
        if (!$variable) {
            $variable = new Variable($expr->name, $value, $type, $this->context->getCurrentBranch());
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $this->context->addVariable($variable);
        }

        return new CompiledExpression($variable->getType(), $variable->getValue(), $variable);
    }

    /**
     * @param Node\Name\FullyQualified $expr
     * @return CompiledExpression
     */
    public function getFullyQualifiedNodeName(Node\Name\FullyQualified $expr)
    {
        $this->context->debug('Unimplemented FullyQualified', $expr);

        return new CompiledExpression;
    }

    /**
     * @param Node\Name $expr
     * @return CompiledExpression
     */
    public function getNodeName(Node\Name $expr)
    {
        $nodeString = $expr->toString();
        if ($nodeString === 'null') {
            return new CompiledExpression(CompiledExpression::NULL);
        }

        if (in_array($nodeString, ['parent'], true)) {
            /** @var ClassDefinition $scope */
            $scope = $this->context->scope;
            assert($scope instanceof ClassDefinition);

            if ($scope->getExtendsClass()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
                $definition = $scope->getExtendsClassDefinition();
                if ($definition) {
                    return new CompiledExpression(CompiledExpression::OBJECT, $definition);
                }
            } else {
                $this->context->notice(
                    'no-parent',
                    'Cannot access parent:: when current class scope has no parent',
                    $expr
                );
            }
        }

        if (in_array($nodeString, ['self', 'static'], true)) {
            return CompiledExpression::fromZvalValue($this->context->scope);
        }

        if (defined($nodeString)) {
            return CompiledExpression::fromZvalValue(constant($expr));
        }

        return new CompiledExpression(CompiledExpression::STRING, $expr->toString());
    }
}


1		<?php
2		/**
3		* @author Patsura Dmitry https://github.com/ovr <[email protected]>
4		*/
5
6		namespace PHPSA\Compiler;
7
8		use InvalidArgumentException;
9		use phpDocumentor\Reflection\DocBlockFactory;
10		use PHPSA\Check;
11		use PHPSA\CompiledExpression;
12		use PHPSA\Compiler\Event\ExpressionBeforeCompile;
13		use PHPSA\Context;
14		use PhpParser\Node;
15		use PHPSA\Definition\ClassDefinition;
16		use PHPSA\Exception\RuntimeException;
17		use PHPSA\Variable;
18		use PHPSA\Compiler\Expression\AbstractExpressionCompiler;
19		use Webiny\Component\EventManager\EventManager;
20
21		class Expression
		0 ignored issues – show Complexity introduced 2016-02-06 15:22 UTC by Report Bug Copy Issue Report This class has a complexity of 114 which exceeds the configured maximum of 50. The class complexity is the sum of the complexity of all methods. A very high value is usually an indication that your class does not follow the single reponsibility principle and does more than one job. Some resources for further reading: Single Reponsibility Principle Open/Closed Principle You can also find more detailed suggestions for refactoring in the “Code” section of your repository. Loading history...
22		{
23		/**
24		* @var Context
25		*/
26		protected $context;
27
28		/**
29		* @var EventManager
30		*/
31		protected $eventManager;
32
33		/**
34		* @param Context $context
35		*/
36	849	public function __construct(Context $context, EventManager $eventManager)
37		{
38	849	$this->context = $context;
39	849	$this->eventManager = $eventManager;
40	849	}
41
42		/**
43		* @param $expr
44		* @return ExpressionCompilerInterface\|AbstractExpressionCompiler
45		*/
46	839	protected function factory($expr)
47		{
48	839	switch (get_class($expr)) {
49		/**
50		* Call(s)
51		*/
52	839	case Node\Expr\MethodCall::class:
53		return new Expression\MethodCall();
54	839	case Node\Expr\FuncCall::class:
55	10	return new Expression\FunctionCall();
56	835	case Node\Expr\StaticCall::class:
57	1	return new Expression\StaticCall();
58		/**
59		* Operators
60		*/
61	834	case Node\Expr\New_::class:
62	2	return new Expression\Operators\NewOp();
63	834	case Node\Expr\Instanceof_::class:
64		return new Expression\Operators\InstanceOfOp();
65		/**
66		* AssignOp
67		*/
68	834	case Node\Expr\AssignOp\Pow::class:
69	21	return new Expression\AssignOp\Pow();
70	813	case Node\Expr\AssignOp\Plus::class:
71	17	return new Expression\AssignOp\Plus();
72	796	case Node\Expr\AssignOp\Minus::class:
73	20	return new Expression\AssignOp\Minus();
74	776	case Node\Expr\AssignOp\Mul::class:
75	20	return new Expression\AssignOp\Mul();
76	756	case Node\Expr\AssignOp\Div::class:
77	18	return new Expression\AssignOp\Div();
78	738	case Node\Expr\AssignOp\Mod::class:
79	11	return new Expression\AssignOp\Mod();
80	727	case Node\Expr\AssignOp\BitwiseOr::class:
81	12	return new Expression\AssignOp\BitwiseOr();
82	715	case Node\Expr\AssignOp\BitwiseAnd::class:
83	12	return new Expression\AssignOp\BitwiseAnd();
84	703	case Node\Expr\AssignOp\BitwiseXor::class:
85	12	return new Expression\AssignOp\BitwiseXor();
86	691	case Node\Expr\AssignOp\Concat::class:
87	14	return new Expression\AssignOp\Concat();
88	677	case Node\Expr\AssignOp\ShiftLeft::class:
89	12	return new Expression\AssignOp\ShiftLeft();
90	665	case Node\Expr\AssignOp\ShiftRight::class:
91	12	return new Expression\AssignOp\ShiftRight();
92
93		/**
94		* BinaryOp
95		*/
96	653	case Node\Expr\BinaryOp\Identical::class:
97	28	return new Expression\BinaryOp\Identical();
98	625	case Node\Expr\BinaryOp\Concat::class:
99	15	return new Expression\Operators\Concat();
100	611	case Node\Expr\BinaryOp\NotIdentical::class:
101	14	return new Expression\BinaryOp\NotIdentical();
102	597	case Node\Expr\BinaryOp\Equal::class:
103	42	return new Expression\BinaryOp\Equal();
104	568	case Node\Expr\BinaryOp\NotEqual::class:
105	17	return new Expression\BinaryOp\NotEqual();
106	551	case Node\Expr\BinaryOp\Spaceship::class:
107	11	return new Expression\BinaryOp\SpaceShip();
108	542	case Node\Expr\BinaryOp\Coalesce::class:
109	3	return new Expression\BinaryOp\Coalesce();
110
111		/**
112		* @link http://php.net/manual/en/language.operators.increment.php
113		*/
114	540	case Node\Expr\PostInc::class:
115	8	return new Expression\Operators\PostInc();
116	532	case Node\Expr\PostDec::class:
117	8	return new Expression\Operators\PostDec();
118	524	case Node\Expr\PreInc::class:
119	8	return new Expression\Operators\PreInc();
120	516	case Node\Expr\PreDec::class:
121	8	return new Expression\Operators\PreDec();
122		/**
123		* Arithmetical
124		*/
125	508	case Node\Expr\BinaryOp\Div::class:
126	37	return new Expression\Operators\Arithmetical\Div();
127	471	case Node\Expr\BinaryOp\Plus::class:
128	45	return new Expression\Operators\Arithmetical\Plus();
129	430	case Node\Expr\BinaryOp\Minus::class:
130	24	return new Expression\Operators\Arithmetical\Minus();
131	406	case Node\Expr\BinaryOp\Mul::class:
132	35	return new Expression\Operators\Arithmetical\Mul();
133	371	case Node\Expr\BinaryOp\Mod::class:
134	35	return new Expression\Operators\Arithmetical\Mod();
135	336	case Node\Expr\BinaryOp\Pow::class:
136	21	return new Expression\Operators\Arithmetical\Pow();
137
138		/**
139		* Bitwise
140		* @link http://php.net/manual/ru/language.operators.bitwise.php
141		*/
142	315	case Node\Expr\BinaryOp\BitwiseOr::class:
143	12	return new Expression\Operators\Bitwise\BitwiseOr();
144	303	case Node\Expr\BinaryOp\BitwiseXor::class:
145	12	return new Expression\Operators\Bitwise\BitwiseXor();
146	291	case Node\Expr\BinaryOp\BitwiseAnd::class:
147	12	return new Expression\Operators\Bitwise\BitwiseAnd();
148	279	case Node\Expr\BinaryOp\ShiftRight::class:
149	12	return new Expression\Operators\Bitwise\ShiftRight();
150	267	case Node\Expr\BinaryOp\ShiftLeft::class:
151	12	return new Expression\Operators\Bitwise\ShiftLeft();
152	255	case Node\Expr\BitwiseNot::class:
153	5	return new Expression\Operators\Bitwise\BitwiseNot();
154		/**
155		* Logical
156		*/
157	250	case Node\Expr\BinaryOp\BooleanOr::class:
158	17	return new Expression\Operators\Logical\BooleanOr();
159	235	case Node\Expr\BinaryOp\BooleanAnd::class:
160	15	return new Expression\Operators\Logical\BooleanAnd();
161	222	case Node\Expr\BooleanNot::class:
162	9	return new Expression\Operators\Logical\BooleanNot();
163	214	case Node\Expr\BinaryOp\LogicalAnd::class:
164	15	return new Expression\Operators\Logical\LogicalAnd();
165	201	case Node\Expr\BinaryOp\LogicalOr::class:
166	17	return new Expression\Operators\Logical\LogicalOr();
167	186	case Node\Expr\BinaryOp\LogicalXor::class:
168	17	return new Expression\Operators\Logical\LogicalXor();
169
170		/**
171		* Comparison
172		*/
173	171	case Node\Expr\BinaryOp\Greater::class:
174	12	return new Expression\Operators\Comparison\Greater();
175	159	case Node\Expr\BinaryOp\GreaterOrEqual::class:
176	12	return new Expression\Operators\Comparison\GreaterOrEqual();
177	147	case Node\Expr\BinaryOp\Smaller::class:
178	12	return new Expression\Operators\Comparison\Smaller();
179	135	case Node\Expr\BinaryOp\SmallerOrEqual::class:
180	12	return new Expression\Operators\Comparison\SmallerOrEqual();
181
182		/**
183		* Casts
184		*/
185	123	case Node\Expr\Cast\Array_::class:
186	3	return new Expression\Casts\ArrayCast();
187	122	case Node\Expr\Cast\Bool_::class:
188	8	return new Expression\Casts\BoolCast();
189	116	case Node\Expr\Cast\Int_::class:
190	8	return new Expression\Casts\IntCast();
191	110	case Node\Expr\Cast\Double::class:
192	8	return new Expression\Casts\DoubleCast();
193	104	case Node\Expr\Cast\Object_::class:
194	2	return new Expression\Casts\ObjectCast();
195	103	case Node\Expr\Cast\String_::class:
196	7	return new Expression\Casts\StringCast();
197	97	case Node\Expr\Cast\Unset_::class:
198	2	return new Expression\Casts\UnsetCast();
199
200
201		/**
202		* Other
203		*/
204	96	case Node\Expr\Array_::class:
205	36	return new Expression\ArrayOp();
206	68	case Node\Expr\Assign::class:
207	29	return new Expression\Assign();
208	50	case Node\Expr\AssignRef::class:
209	1	return new Expression\AssignRef();
210	50	case Node\Expr\Closure::class:
211		return new Expression\Closure();
212	50	case Node\Expr\ConstFetch::class:
213	7	return new Expression\ConstFetch();
214	47	case Node\Expr\ClassConstFetch::class:
215		return new Expression\ClassConstFetch();
216	47	case Node\Expr\PropertyFetch::class:
217		return new Expression\PropertyFetch();
218	47	case Node\Expr\UnaryMinus::class:
219	9	return new Expression\Operators\UnaryMinus();
220	38	case Node\Expr\UnaryPlus::class:
221	9	return new Expression\Operators\UnaryPlus();
222	29	case Node\Expr\Exit_::class:
223	1	return new Expression\ExitOp();
224	28	case Node\Expr\Isset_::class:
225	3	return new Expression\IssetOp();
226	25	case Node\Expr\Print_::class:
227	2	return new Expression\PrintOp();
228	24	case Node\Expr\Empty_::class:
229	5	return new Expression\EmptyOp();
230	19	case Node\Expr\Eval_::class:
231	2	return new Expression\EvalOp();
232	17	case Node\Expr\ErrorSuppress::class:
233	2	return new Expression\ErrorSuppress();
234	15	case Node\Expr\Clone_::class:
235	1	return new Expression\CloneOp();
236	14	case Node\Expr\Ternary::class:
237	2	return new Expression\Ternary();
238	12	case Node\Expr\Variable::class:
239	12	return new Expression\Variable();
240		}
241
242		return false;
243		}
244
245		/**
246		* @param object\|string $expr
247		* @throws InvalidArgumentException when $expr is not string/object/null
248		* @throws RuntimeException when compiler class does not return a CompiledExpression
249		* @return CompiledExpression
250		*/
251	849	public function compile($expr)
		0 ignored issues – show Complexity introduced 2016-02-06 15:22 UTC by Report Bug Copy Issue Report This operation has 320 execution paths which exceeds the configured maximum of 200. A high number of execution paths generally suggests many nested conditional statements and make the code less readible. This can usually be fixed by splitting the method into several smaller methods. You can also find more information in the “Code” section of your repository. Loading history...
252		{
253	849	if (is_string($expr)) {
254	16	return new CompiledExpression(CompiledExpression::STRING, $expr);
255		}
256
257	849	if (is_null($expr)) {
258	8	return new CompiledExpression(CompiledExpression::NULL);
259		}
260
261	849	if (!is_object($expr)) {
262		throw new InvalidArgumentException('$expr must be string/object/null');
263		}
264
265	849	$this->eventManager->fire(
266	849	ExpressionBeforeCompile::EVENT_NAME,
267	849	new ExpressionBeforeCompile(
268	849	$expr,
269	849	$this->context
270	849	)
271	849	);
272
273	849	$className = get_class($expr);
274		switch ($className) {
275	849	case Node\Arg::class:
276		/**
277		* @todo Better compile
278		*/
279	2	return $this->compile($expr->value);
280	849	case Node\Stmt\Property::class:
281		return $this->passProperty($expr);
282
283		/**
284		* Expressions
285		*/
286	849	case Node\Name::class:
287	27	return $this->getNodeName($expr);
288	849	case Node\Name\FullyQualified::class:
289		return $this->getFullyQualifiedNodeName($expr);
290
291		/**
292		* Simple Scalar(s)
293		*/
294	849	case \PHPSA\Node\Scalar\Nil::class:
295	25	return new CompiledExpression(CompiledExpression::NULL);
296	848	case Node\Scalar\LNumber::class:
297	512	return new CompiledExpression(CompiledExpression::INTEGER, $expr->value);
298	843	case Node\Scalar\DNumber::class:
299	212	return new CompiledExpression(CompiledExpression::DOUBLE, $expr->value);
300	842	case Node\Scalar\String_::class:
301	50	return new CompiledExpression(CompiledExpression::STRING, $expr->value);
302	841	case \PHPSA\Node\Scalar\Boolean::class:
303	241	return new CompiledExpression(CompiledExpression::BOOLEAN, $expr->value);
304	839	case \PHPSA\Node\Scalar\Fake::class:
305	79	return new CompiledExpression($expr->type, $expr->value);
306		}
307
308	839	$expressionCompiler = $this->factory($expr);
309	839	if (!$expressionCompiler) {
310		$this->context->debug("Expression compiler is not implemented for {$className}");
311		return new CompiledExpression(CompiledExpression::UNIMPLEMENTED);
312		}
313
314	839	$result = $expressionCompiler->pass($expr, $this->context);
315	839	if (!$result instanceof CompiledExpression) {
316		throw new RuntimeException('Please return CompiledExpression from ' . get_class($expressionCompiler));
317		}
318
319	839	return $result;
320		}
321
322		/**
323		* @todo Implement - needs to be a new analyzer for var docblock
324		*
325		* @param Node\Stmt\Property $st
326		* @return CompiledExpression
327		*/
328		public function passProperty(Node\Stmt\Property $st)
		0 ignored issues – show Comprehensibility introduced 2016-02-06 15:22 UTC by Report Bug Copy Issue Report Avoid variables with short names like $st. Configured minimum length is 3. Short variable names may make your code harder to understand. Variable names should be self-descriptive. This check looks for variable names who are shorter than a configured minimum. Loading history...
329		{
330		$docBlock = $st->getDocComment();
331		if (!$docBlock) {
332		return new CompiledExpression();
333		}
334
335		$phpdoc = DocBlockFactory::createInstance()->create($docBlock->getText());
336
337		$varTags = $phpdoc->getTagsByName('var');
338		if ($varTags) {
		0 ignored issues – show Bug Best Practice introduced 2016-05-08 22:00 UTC by Report Bug Copy Issue Report The expression `$varTags` of type `phpDocumentor\Reflection\DocBlock\Tag[]` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
339		/** @var \phpDocumentor\Reflection\DocBlock\Tag\VarTag $varTag */
340		$varTag = current($varTags);
341
342		$typeResolver = new \phpDocumentor\Reflection\TypeResolver();
343
344		try {
345		$type = $typeResolver->resolve($varTag->getType());
346		} catch (\InvalidArgumentException $e) {
347		return new CompiledExpression();
348		}
349
350		if ($type) {
351		switch (get_class($type)) {
352		case \phpDocumentor\Reflection\Types\Object_::class:
353		return new CompiledExpression(
354		CompiledExpression::OBJECT
355		);
356		case \phpDocumentor\Reflection\Types\Integer::class:
357		return new CompiledExpression(
358		CompiledExpression::INTEGER
359		);
360		case \phpDocumentor\Reflection\Types\String_::class:
361		return new CompiledExpression(
362		CompiledExpression::STRING
363		);
364		case \phpDocumentor\Reflection\Types\Float_::class:
365		return new CompiledExpression(
366		CompiledExpression::DOUBLE
367		);
368		case \phpDocumentor\Reflection\Types\Null_::class:
369		return new CompiledExpression(
370		CompiledExpression::NULL
371		);
372		case \phpDocumentor\Reflection\Types\Boolean::class:
373		return new CompiledExpression(
374		CompiledExpression::BOOLEAN
375		);
376		}
377		}
378		}
379
380		return new CompiledExpression();
381		}
382
383		/**
384		* @param Node\Expr\Variable $expr
385		* @param mixed $value
386		* @param int $type
387		* @return CompiledExpression
388		*/
389	1	public function declareVariable(Node\Expr\Variable $expr, $value = null, $type = CompiledExpression::UNKNOWN)
390		{
391	1	$variable = $this->context->getSymbol($expr->name);
392	1	if (!$variable) {
393	1	$variable = new Variable($expr->name, $value, $type, $this->context->getCurrentBranch());
		0 ignored issues – show Bug introduced 2016-10-03 13:50 UTC by Report Bug Copy Issue Report It seems like `$expr->name` can also be of type `object<PhpParser\Node\Expr>`; however, `PHPSA\Variable::__construct()` does only seem to accept `string`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
394	1	$this->context->addVariable($variable);
395	1	}
396
397	1	return new CompiledExpression($variable->getType(), $variable->getValue(), $variable);
398		}
399
400		/**
401		* @param Node\Name\FullyQualified $expr
402		* @return CompiledExpression
403		*/
404		public function getFullyQualifiedNodeName(Node\Name\FullyQualified $expr)
405		{
406		$this->context->debug('Unimplemented FullyQualified', $expr);
407
408		return new CompiledExpression;
409		}
410
411		/**
412		* @param Node\Name $expr
413		* @return CompiledExpression
414		*/
415	27	public function getNodeName(Node\Name $expr)
416		{
417	27	$nodeString = $expr->toString();
418	27	if ($nodeString === 'null') {
419	1	return new CompiledExpression(CompiledExpression::NULL);
420		}
421
422	27	if (in_array($nodeString, ['parent'], true)) {
423		/** @var ClassDefinition $scope */
424		$scope = $this->context->scope;
425		assert($scope instanceof ClassDefinition);
426
427		if ($scope->getExtendsClass()) {
		0 ignored issues – show Bug Best Practice introduced 2016-01-18 21:09 UTC by Report Bug Copy Issue Report The expression `$scope->getExtendsClass()` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
428		$definition = $scope->getExtendsClassDefinition();
429		if ($definition) {
430		return new CompiledExpression(CompiledExpression::OBJECT, $definition);
431		}
432		} else {
433		$this->context->notice(
434		'no-parent',
435		'Cannot access parent:: when current class scope has no parent',
436		$expr
437		);
438		}
439		}
440
441	27	if (in_array($nodeString, ['self', 'static'], true)) {
442	1	return CompiledExpression::fromZvalValue($this->context->scope);
443		}
444
445	26	if (defined($nodeString)) {
446	7	return CompiledExpression::fromZvalValue(constant($expr));
447		}
448
449	23	return new CompiledExpression(CompiledExpression::STRING, $expr->toString());
450		}
451		}
452

ovr / phpsa

Pull Request — master (#196)

Expression::constFetch() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like