Expression::__construct() - Code Metrics - Inspection of "Codeclimate plugin" - ovr/phpsa - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#210)

by Дмитрий

created 2016-10-08 06:19 UTC

Expression::__construct() A

↳ Parent: Expression

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	2
dl	0
loc	5
ccs	4
cts	4
cp	1
crap	1
rs	9.4285
c	0
b	0
f	0

<?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\StaticPropertyFetch::class:
                return new Expression\StaticPropertyFetch();
            case Node\Expr\ArrayDimFetch::class:
                return new Expression\ArrayDimFetch();
            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\ShellExec::class:
                return new Expression\ShellExec();
            case Node\Expr\ErrorSuppress::class:
                return new Expression\ErrorSuppress();
            case Node\Expr\Include_::class:
                return new Expression\IncludeOp();
            case Node\Expr\Clone_::class:
                return new Expression\CloneOp();
            case Node\Expr\Ternary::class:
                return new Expression\Ternary();
            case Node\Expr\Yield_::class:
                return new Expression\YieldOp();
            case Node\Expr\YieldFrom::class:
                return new Expression\YieldFrom();
            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 120 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	845	public function __construct(Context $context, EventManager $eventManager)
37		{
38	845	$this->context = $context;
39	845	$this->eventManager = $eventManager;
40	845	}
41
42		/**
43		* @param $expr
44		* @return ExpressionCompilerInterface\|AbstractExpressionCompiler
45		*/
46	817	protected function factory($expr)
47		{
48	817	switch (get_class($expr)) {
49		/**
50		* Call(s)
51		*/
52	817	case Node\Expr\MethodCall::class:
53		return new Expression\MethodCall();
54	817	case Node\Expr\FuncCall::class:
55	10	return new Expression\FunctionCall();
56	809	case Node\Expr\StaticCall::class:
57		return new Expression\StaticCall();
58		/**
59		* Operators
60		*/
61	809	case Node\Expr\New_::class:
62	2	return new Expression\Operators\NewOp();
63	807	case Node\Expr\Instanceof_::class:
64		return new Expression\Operators\InstanceOfOp();
65		/**
66		* AssignOp
67		*/
68	807	case Node\Expr\AssignOp\Pow::class:
69	21	return new Expression\AssignOp\Pow();
70	786	case Node\Expr\AssignOp\Plus::class:
71	17	return new Expression\AssignOp\Plus();
72	769	case Node\Expr\AssignOp\Minus::class:
73	20	return new Expression\AssignOp\Minus();
74	749	case Node\Expr\AssignOp\Mul::class:
75	20	return new Expression\AssignOp\Mul();
76	729	case Node\Expr\AssignOp\Div::class:
77	18	return new Expression\AssignOp\Div();
78	711	case Node\Expr\AssignOp\Mod::class:
79	11	return new Expression\AssignOp\Mod();
80	700	case Node\Expr\AssignOp\BitwiseOr::class:
81	12	return new Expression\AssignOp\BitwiseOr();
82	688	case Node\Expr\AssignOp\BitwiseAnd::class:
83	12	return new Expression\AssignOp\BitwiseAnd();
84	676	case Node\Expr\AssignOp\BitwiseXor::class:
85	12	return new Expression\AssignOp\BitwiseXor();
86	664	case Node\Expr\AssignOp\Concat::class:
87	14	return new Expression\AssignOp\Concat();
88	650	case Node\Expr\AssignOp\ShiftLeft::class:
89	12	return new Expression\AssignOp\ShiftLeft();
90	638	case Node\Expr\AssignOp\ShiftRight::class:
91	12	return new Expression\AssignOp\ShiftRight();
92
93		/**
94		* BinaryOp
95		*/
96	626	case Node\Expr\BinaryOp\Identical::class:
97	28	return new Expression\BinaryOp\Identical();
98	598	case Node\Expr\BinaryOp\Concat::class:
99	15	return new Expression\Operators\Concat();
100	583	case Node\Expr\BinaryOp\NotIdentical::class:
101	14	return new Expression\BinaryOp\NotIdentical();
102	569	case Node\Expr\BinaryOp\Equal::class:
103	41	return new Expression\BinaryOp\Equal();
104	530	case Node\Expr\BinaryOp\NotEqual::class:
105	17	return new Expression\BinaryOp\NotEqual();
106	513	case Node\Expr\BinaryOp\Spaceship::class:
107	11	return new Expression\BinaryOp\SpaceShip();
108	502	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	499	case Node\Expr\PostInc::class:
115	8	return new Expression\Operators\PostInc();
116	491	case Node\Expr\PostDec::class:
117	8	return new Expression\Operators\PostDec();
118	483	case Node\Expr\PreInc::class:
119	8	return new Expression\Operators\PreInc();
120	475	case Node\Expr\PreDec::class:
121	8	return new Expression\Operators\PreDec();
122		/**
123		* Arithmetical
124		*/
125	467	case Node\Expr\BinaryOp\Div::class:
126	37	return new Expression\Operators\Arithmetical\Div();
127	430	case Node\Expr\BinaryOp\Plus::class:
128	45	return new Expression\Operators\Arithmetical\Plus();
129	385	case Node\Expr\BinaryOp\Minus::class:
130	24	return new Expression\Operators\Arithmetical\Minus();
131	361	case Node\Expr\BinaryOp\Mul::class:
132	35	return new Expression\Operators\Arithmetical\Mul();
133	326	case Node\Expr\BinaryOp\Mod::class:
134	35	return new Expression\Operators\Arithmetical\Mod();
135	291	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	270	case Node\Expr\BinaryOp\BitwiseOr::class:
143	12	return new Expression\Operators\Bitwise\BitwiseOr();
144	258	case Node\Expr\BinaryOp\BitwiseXor::class:
145	12	return new Expression\Operators\Bitwise\BitwiseXor();
146	246	case Node\Expr\BinaryOp\BitwiseAnd::class:
147	12	return new Expression\Operators\Bitwise\BitwiseAnd();
148	234	case Node\Expr\BinaryOp\ShiftRight::class:
149	12	return new Expression\Operators\Bitwise\ShiftRight();
150	222	case Node\Expr\BinaryOp\ShiftLeft::class:
151	12	return new Expression\Operators\Bitwise\ShiftLeft();
152	210	case Node\Expr\BitwiseNot::class:
153	5	return new Expression\Operators\Bitwise\BitwiseNot();
154		/**
155		* Logical
156		*/
157	205	case Node\Expr\BinaryOp\BooleanOr::class:
158	17	return new Expression\Operators\Logical\BooleanOr();
159	188	case Node\Expr\BinaryOp\BooleanAnd::class:
160	15	return new Expression\Operators\Logical\BooleanAnd();
161	173	case Node\Expr\BooleanNot::class:
162	9	return new Expression\Operators\Logical\BooleanNot();
163	164	case Node\Expr\BinaryOp\LogicalAnd::class:
164	15	return new Expression\Operators\Logical\LogicalAnd();
165	149	case Node\Expr\BinaryOp\LogicalOr::class:
166	17	return new Expression\Operators\Logical\LogicalOr();
167	132	case Node\Expr\BinaryOp\LogicalXor::class:
168	17	return new Expression\Operators\Logical\LogicalXor();
169
170		/**
171		* Comparison
172		*/
173	115	case Node\Expr\BinaryOp\Greater::class:
174	12	return new Expression\Operators\Comparison\Greater();
175	103	case Node\Expr\BinaryOp\GreaterOrEqual::class:
176	12	return new Expression\Operators\Comparison\GreaterOrEqual();
177	91	case Node\Expr\BinaryOp\Smaller::class:
178	12	return new Expression\Operators\Comparison\Smaller();
179	79	case Node\Expr\BinaryOp\SmallerOrEqual::class:
180	12	return new Expression\Operators\Comparison\SmallerOrEqual();
181
182		/**
183		* Casts
184		*/
185	67	case Node\Expr\Cast\Array_::class:
186	3	return new Expression\Casts\ArrayCast();
187	65	case Node\Expr\Cast\Bool_::class:
188	8	return new Expression\Casts\BoolCast();
189	58	case Node\Expr\Cast\Int_::class:
190	8	return new Expression\Casts\IntCast();
191	51	case Node\Expr\Cast\Double::class:
192	8	return new Expression\Casts\DoubleCast();
193	44	case Node\Expr\Cast\Object_::class:
194	2	return new Expression\Casts\ObjectCast();
195	43	case Node\Expr\Cast\String_::class:
196	7	return new Expression\Casts\StringCast();
197	37	case Node\Expr\Cast\Unset_::class:
198	2	return new Expression\Casts\UnsetCast();
199
200
201		/**
202		* Other
203		*/
204	35	case Node\Expr\Array_::class:
205		return new Expression\ArrayOp();
206	35	case Node\Expr\Assign::class:
207	9	return new Expression\Assign();
208	26	case Node\Expr\AssignRef::class:
209	9	return new Expression\AssignRef();
210	17	case Node\Expr\Closure::class:
211	1	return new Expression\Closure();
212	16	case Node\Expr\ConstFetch::class:
213	3	return new Expression\ConstFetch();
214	13	case Node\Expr\ClassConstFetch::class:
215	2	return new Expression\ClassConstFetch();
216	12	case Node\Expr\PropertyFetch::class:
217	5	return new Expression\PropertyFetch();
218	7	case Node\Expr\StaticPropertyFetch::class:
219	2	return new Expression\StaticPropertyFetch();
220	5	case Node\Expr\ArrayDimFetch::class:
221	2	return new Expression\ArrayDimFetch();
222	3	case Node\Expr\UnaryMinus::class:
223	1	return new Expression\Operators\UnaryMinus();
224	2	case Node\Expr\UnaryPlus::class:
225	2	return new Expression\Operators\UnaryPlus();
226		case Node\Expr\Exit_::class:
227		return new Expression\ExitOp();
228		case Node\Expr\Isset_::class:
229		return new Expression\IssetOp();
230		case Node\Expr\Print_::class:
231		return new Expression\PrintOp();
232		case Node\Expr\Empty_::class:
233		return new Expression\EmptyOp();
234		case Node\Expr\Eval_::class:
235		return new Expression\EvalOp();
236		case Node\Expr\ShellExec::class:
237	845	return new Expression\ShellExec();
238		case Node\Expr\ErrorSuppress::class:
239	845	return new Expression\ErrorSuppress();
240	14	case Node\Expr\Include_::class:
241		return new Expression\IncludeOp();
242		case Node\Expr\Clone_::class:
243	845	return new Expression\CloneOp();
244	8	case Node\Expr\Ternary::class:
245		return new Expression\Ternary();
246		case Node\Expr\Yield_::class:
247	845	return new Expression\YieldOp();
248		case Node\Expr\YieldFrom::class:
249		return new Expression\YieldFrom();
250		case Node\Expr\Variable::class:
251	845	return new Expression\Variable();
252	845	}
253	845
254	845	return false;
255	845	}
256	845
257	845	/**
258		* @param object\|string $expr
259	845	* @throws InvalidArgumentException when $expr is not string/object/null
260		* @throws RuntimeException when compiler class does not return a CompiledExpression
261	845	* @return CompiledExpression
262		*/
263		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...
264		{
265	2	if (is_string($expr)) {
266	845	return new CompiledExpression(CompiledExpression::STRING, $expr);
267		}
268	845
269		if (is_null($expr)) {
270	845	return new CompiledExpression(CompiledExpression::NULL);
271		}
272	845
273	27	if (!is_object($expr)) {
274	845	throw new InvalidArgumentException('$expr must be string/object/null');
275	1	}
276	845
277	11	$this->eventManager->fire(
278		ExpressionBeforeCompile::EVENT_NAME,
279		new ExpressionBeforeCompile(
280		$expr,
281		$this->context
282	845	)
283	36	);
284	844
285	6	$className = get_class($expr);
286	844	switch ($className) {
287	24	case Node\Arg::class:
288	844	/**
289		* @todo Better compile
290		*/
291		return $this->compile($expr->value);
292		case Node\Stmt\Property::class:
293		return $this->passProperty($expr);
294	844
295	25	/**
296	843	* Expressions
297	509	*/
298	825	case Node\Name::class:
299	212	return $this->getNodeName($expr);
300	824	case Node\Name\FullyQualified::class:
301	50	return $this->getFullyQualifiedNodeName($expr);
302	819
303	241	/**
304	817	* Simple Scalar(s)
305	79	*/
306		case \PHPSA\Node\Scalar\Nil::class:
307		return new CompiledExpression(CompiledExpression::NULL);
308	817	case Node\Scalar\LNumber::class:
309	817	return new CompiledExpression(CompiledExpression::INTEGER, $expr->value);
310		case Node\Scalar\DNumber::class:
311		return new CompiledExpression(CompiledExpression::DOUBLE, $expr->value);
312		case Node\Scalar\String_::class:
313		return new CompiledExpression(CompiledExpression::STRING, $expr->value);
314	817	case \PHPSA\Node\Scalar\Boolean::class:
315	817	return new CompiledExpression(CompiledExpression::BOOLEAN, $expr->value);
316		case \PHPSA\Node\Scalar\Fake::class:
317		return new CompiledExpression($expr->type, $expr->value);
318		}
319	817
320		$expressionCompiler = $this->factory($expr);
321		if (!$expressionCompiler) {
322		$this->context->debug("Expression compiler is not implemented for {$className}");
323		return new CompiledExpression(CompiledExpression::UNIMPLEMENTED);
324		}
325
326		$result = $expressionCompiler->pass($expr, $this->context);
327		if (!$result instanceof CompiledExpression) {
328		throw new RuntimeException('Please return CompiledExpression from ' . get_class($expressionCompiler));
329		}
330
331		return $result;
332		}
333
334		/**
335		* @todo Implement - needs to be a new analyzer for var docblock
336		*
337		* @param Node\Stmt\Property $st
338		* @return CompiledExpression
339		*/
340		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...
341		{
342		$docBlock = $st->getDocComment();
343		if (!$docBlock) {
344		return new CompiledExpression();
345		}
346
347		$phpdoc = DocBlockFactory::createInstance()->create($docBlock->getText());
348
349		$varTags = $phpdoc->getTagsByName('var');
350		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...
351		/** @var \phpDocumentor\Reflection\DocBlock\Tag\VarTag $varTag */
352		$varTag = current($varTags);
353
354		$typeResolver = new \phpDocumentor\Reflection\TypeResolver();
355
356		try {
357		$type = $typeResolver->resolve($varTag->getType());
358		} catch (\InvalidArgumentException $e) {
359		return new CompiledExpression();
360		}
361
362		if ($type) {
363		switch (get_class($type)) {
364		case \phpDocumentor\Reflection\Types\Object_::class:
365		return new CompiledExpression(
366		CompiledExpression::OBJECT
367		);
368		case \phpDocumentor\Reflection\Types\Integer::class:
369		return new CompiledExpression(
370		CompiledExpression::INTEGER
371		);
372		case \phpDocumentor\Reflection\Types\String_::class:
373		return new CompiledExpression(
374		CompiledExpression::STRING
375		);
376		case \phpDocumentor\Reflection\Types\Float_::class:
377		return new CompiledExpression(
378		CompiledExpression::DOUBLE
379		);
380		case \phpDocumentor\Reflection\Types\Null_::class:
381		return new CompiledExpression(
382		CompiledExpression::NULL
383		);
384		case \phpDocumentor\Reflection\Types\Boolean::class:
385		return new CompiledExpression(
386		CompiledExpression::BOOLEAN
387		);
388		}
389		}
390		}
391
392		return new CompiledExpression();
393		}
394
395	1	/**
396		* @param Node\Expr\Variable $expr
397	1	* @param mixed $value
398	1	* @param int $type
399	1	* @return CompiledExpression
400	1	*/
401	1	public function declareVariable(Node\Expr\Variable $expr, $value = null, $type = CompiledExpression::UNKNOWN)
402		{
403	1	$variable = $this->context->getSymbol($expr->name);
404		if (!$variable) {
405		$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...
406		$this->context->addVariable($variable);
407		}
408
409		return new CompiledExpression($variable->getType(), $variable->getValue(), $variable);
410		}
411
412		/**
413		* @param Node\Name\FullyQualified $expr
414		* @return CompiledExpression
415		*/
416		public function getFullyQualifiedNodeName(Node\Name\FullyQualified $expr)
417		{
418		$this->context->debug('Unimplemented FullyQualified', $expr);
419
420		return new CompiledExpression;
421	24	}
422
423	24	/**
424	24	* @param Node\Name $expr
425	1	* @return CompiledExpression
426		*/
427		public function getNodeName(Node\Name $expr)
428	23	{
429		$nodeString = $expr->toString();
430		if ($nodeString === 'null') {
431		return new CompiledExpression(CompiledExpression::NULL);
432		}
433
434		if (in_array($nodeString, ['parent'], true)) {
435		/** @var ClassDefinition $scope */
436		$scope = $this->context->scope;
437		assert($scope instanceof ClassDefinition);
438
439		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...
440		$definition = $scope->getExtendsClassDefinition();
441		if ($definition) {
442		return new CompiledExpression(CompiledExpression::OBJECT, $definition);
443		}
444		} else {
445		$this->context->notice(
446		'no-parent',
447	23	'Cannot access parent:: when current class scope has no parent',
448		$expr
449		);
450		}
451	23	}
452	1
453		if (in_array($nodeString, ['self', 'static'], true)) {
454		return CompiledExpression::fromZvalValue($this->context->scope);
455	23	}
456
457		if (defined($nodeString)) {
458		return CompiledExpression::fromZvalValue(constant($expr));
459		}
460
461		return new CompiledExpression(CompiledExpression::STRING, $expr->toString());
462		}
463		}
464

ovr / phpsa

Pull Request — master (#210)

Expression::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like