Assign - Code Metrics - Inspection of "[ArrayIllegalOffsetType] Dont use class name as ty..." - ovr/phpsa - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8bad52...c13fe7 )

by Дмитрий

created 2017-01-15 14:18 UTC

Assign A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	11

Test Coverage

Coverage

90.28%

Importance

Changes

Metric	Value
dl	0
loc	110
ccs	65
cts	72
cp	0.9028
rs	10
c	0
b	0
f	0
wmc	17
lcom	0
cbo	11

2 Methods

Rating	Name	Duplication	Size	Complexity
C	compile()	0	66	14
B	compileVariableDeclaration()	0	30	3

<?php

namespace PHPSA\Compiler\Expression;

use PHPSA\CompiledExpression;
use PHPSA\Context;
use PhpParser\Node;
use PHPSA\Definition\ClassDefinition;

class Assign extends AbstractExpressionCompiler
{
    protected $name = 'PhpParser\Node\Expr\Assign';

    /**
     * $a = 3;
     *
     * @param \PhpParser\Node\Expr\Assign $expr
     * @param Context $context
     * @return CompiledExpression
     */
    protected function compile($expr, Context $context)

    {
        $compiler = $context->getExpressionCompiler();

        $compiledExpression = $compiler->compile($expr->expr);

        if ($expr->var instanceof Node\Expr\List_) {
            $isCorrectType = $compiledExpression->isArray();

            foreach ($expr->var->items as $var) {
                if ($var === null) {
                    continue;
                }
                if (!$var->value instanceof Node\Expr\Variable) {
                    continue;
                }

                if ($var->value->name instanceof Node\Expr\Variable) {
                    $this->compileVariableDeclaration($compiler->compile($var->value->name), new CompiledExpression(), $context);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
                    continue;
                }

                $symbol = $context->getSymbol($var->value->name);
                if (!$symbol) {
                    $symbol = new \PHPSA\Variable(
                        $var->value->name,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
                        null,
                        CompiledExpression::UNKNOWN,
                        $context->getCurrentBranch()
                    );
                    $context->addVariable($symbol);
                }

                if (!$isCorrectType) {
                    $symbol->modify(CompiledExpression::NULL, null);
                }

                $symbol->incSets();
            }

            return new CompiledExpression();
        }

        if ($expr->var instanceof Node\Expr\Variable) {
            $this->compileVariableDeclaration($compiler->compile($expr->var->name), $compiledExpression, $context);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}

            return $compiledExpression;
        }

        if ($expr->var instanceof Node\Expr\PropertyFetch) {
            $compiledExpression = $compiler->compile($expr->var->var);
            if ($compiledExpression->getType() == CompiledExpression::OBJECT) {
                $objectDefinition = $compiledExpression->getValue();
                if ($objectDefinition instanceof ClassDefinition) {
                    if (is_string($expr->var->name)) {
                        if ($objectDefinition->hasProperty($expr->var->name)) {
                            return $compiler->compile($objectDefinition->getProperty($expr->var->name));
                        }
                    }
                }
            }
        }

        $context->debug('Unknown how to pass symbol', $expr);
        return new CompiledExpression();
    }


    protected function compileVariableDeclaration(CompiledExpression $variableName, CompiledExpression $value, Context $context)
    {
        switch ($variableName->getType()) {
            case CompiledExpression::STRING:
                break;
            default:
                $context->debug('Unexpected type of Variable name after compile');
                return new CompiledExpression();
        }

        $symbol = $context->getSymbol($variableName->getValue());
        if ($symbol) {
            $symbol->modify($value->getType(), $value->getValue());
            $context->modifyReferencedVariables(
                $symbol,
                $value->getType(),
                $value->getValue()
            );
        } else {
            $symbol = new \PHPSA\Variable(
                $variableName->getValue(),
                $value->getValue(),
                $value->getType(),
                $context->getCurrentBranch()
            );
            $context->addVariable($symbol);
        }

        $symbol->incSets();
    }
}


1		<?php
2
3		namespace PHPSA\Compiler\Expression;
4
5		use PHPSA\CompiledExpression;
6		use PHPSA\Context;
7		use PhpParser\Node;
8		use PHPSA\Definition\ClassDefinition;
9
10		class Assign extends AbstractExpressionCompiler
11		{
12		protected $name = 'PhpParser\Node\Expr\Assign';
13
14		/**
15		* $a = 3;
16		*
17		* @param \PhpParser\Node\Expr\Assign $expr
18		* @param Context $context
19		* @return CompiledExpression
20		*/
21	43	protected function compile($expr, Context $context)
		0 ignored issues – show Complexity introduced 2016-10-06 16:12 UTC by Report Bug Copy Issue Report This operation has 408 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...
22		{
23	43	$compiler = $context->getExpressionCompiler();
24
25	43	$compiledExpression = $compiler->compile($expr->expr);
26
27	43	if ($expr->var instanceof Node\Expr\List_) {
28	1	$isCorrectType = $compiledExpression->isArray();
29
30	1	foreach ($expr->var->items as $var) {
31	1	if ($var === null) {
32	1	continue;
33		}
34	1	if (!$var->value instanceof Node\Expr\Variable) {
35		continue;
36		}
37
38	1	if ($var->value->name instanceof Node\Expr\Variable) {
39	1	$this->compileVariableDeclaration($compiler->compile($var->value->name), new CompiledExpression(), $context);
		0 ignored issues – show Bug introduced 2016-12-15 10:01 UTC by Report Bug Copy Issue Report It seems like `$compiler->compile($var->value->name)` can be `null`; however, `compileVariableDeclaration()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
40	1	continue;
41		}
42
43	1	$symbol = $context->getSymbol($var->value->name);
44	1	if (!$symbol) {
45	1	$symbol = new \PHPSA\Variable(
46	1	$var->value->name,
		0 ignored issues – show Bug introduced 2016-12-15 10:01 UTC by Report Bug Copy Issue Report It seems like `$var->value->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...
47	1	null,
48	1	CompiledExpression::UNKNOWN,
49	1	$context->getCurrentBranch()
50	1	);
51	1	$context->addVariable($symbol);
52	1	}
53
54	1	if (!$isCorrectType) {
55		$symbol->modify(CompiledExpression::NULL, null);
56		}
57
58	1	$symbol->incSets();
59	1	}
60
61	1	return new CompiledExpression();
62		}
63
64	43	if ($expr->var instanceof Node\Expr\Variable) {
65	43	$this->compileVariableDeclaration($compiler->compile($expr->var->name), $compiledExpression, $context);
		0 ignored issues – show Bug introduced 2016-10-13 13:04 UTC by Report Bug Copy Issue Report It seems like `$compiler->compile($expr->var->name)` can be `null`; however, `compileVariableDeclaration()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null / function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history... Bug introduced 2016-10-13 13:04 UTC by Report Bug Copy Issue Report It seems like `$compiledExpression` defined by `$compiler->compile($expr->expr)` on line `25` can be `null`; however, `PHPSA\Compiler\Expressio...leVariableDeclaration()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /* @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
66
67	43	return $compiledExpression;
68		}
69
70	2	if ($expr->var instanceof Node\Expr\PropertyFetch) {
71	2	$compiledExpression = $compiler->compile($expr->var->var);
72	2	if ($compiledExpression->getType() == CompiledExpression::OBJECT) {
73	2	$objectDefinition = $compiledExpression->getValue();
74	2	if ($objectDefinition instanceof ClassDefinition) {
75	2	if (is_string($expr->var->name)) {
76	2	if ($objectDefinition->hasProperty($expr->var->name)) {
77		return $compiler->compile($objectDefinition->getProperty($expr->var->name));
78		}
79	2	}
80	2	}
81	2	}
82	2	}
83
84	2	$context->debug('Unknown how to pass symbol', $expr);
85	2	return new CompiledExpression();
86		}
87
88
89	43	protected function compileVariableDeclaration(CompiledExpression $variableName, CompiledExpression $value, Context $context)
90		{
91	43	switch ($variableName->getType()) {
92	43	case CompiledExpression::STRING:
93	43	break;
94		default:
95		$context->debug('Unexpected type of Variable name after compile');
96		return new CompiledExpression();
97	43	}
98
99	43	$symbol = $context->getSymbol($variableName->getValue());
100	43	if ($symbol) {
101	5	$symbol->modify($value->getType(), $value->getValue());
102	5	$context->modifyReferencedVariables(
103	5	$symbol,
104	5	$value->getType(),
105	5	$value->getValue()
106	5	);
107	5	} else {
108	42	$symbol = new \PHPSA\Variable(
109	42	$variableName->getValue(),
110	42	$value->getValue(),
111	42	$value->getType(),
112	42	$context->getCurrentBranch()
113	42	);
114	42	$context->addVariable($symbol);
115		}
116
117	43	$symbol->incSets();
118	43	}
119		}
120

ovr / phpsa

Push — master ( 8bad52...c13fe7 )

Assign A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

2 Methods

Duplication Side-by-Side

Filter issues like