UsedSymbolCollector::__construct() - Code Metrics - Inspection of "Merge pull request #33 from maglnet/feature/psr-co..." - maglnet/ComposerRequireChecker - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( ff5911...a1b140 )

by Matthias

created 2017-11-04 13:22 UTC

UsedSymbolCollector::__construct() A

↳ Parent: UsedSymbolCollector

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	0

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Importance

Changes

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

<?php

namespace ComposerRequireChecker\NodeVisitor;

use PhpParser\Node;
use PhpParser\NodeVisitorAbstract;

final class UsedSymbolCollector extends NodeVisitorAbstract
{
    /**
     * @var mixed[]
     */
    private $collectedSymbols = [];

    public function __construct()
    {
    }

    /**
     * @return string[]
     */
    public function getCollectedSymbols(): array
    {
        return array_keys($this->collectedSymbols);
    }

    /**
     * {@inheritDoc}
     */
    public function beforeTraverse(array $nodes)
    {
        $this->collectedSymbols = [];

        return parent::beforeTraverse($nodes);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    /**
     * {@inheritDoc}
     */
    public function enterNode(Node $node)
    {
        $this->recordExtendsUsage($node);
        $this->recordImplementsUsage($node);
        $this->recordClassExpressionUsage($node);
        $this->recordCatchUsage($node);
        $this->recordFunctionCallUsage($node);
        $this->recordFunctionParameterTypesUsage($node);
        $this->recordFunctionReturnTypeUsage($node);
        $this->recordConstantFetchUsage($node);
        $this->recordTraitUsage($node);

        return parent::enterNode($node);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
    }

    private function recordExtendsUsage(Node $node)
    {
        if ($node instanceof Node\Stmt\Class_) {
            array_map([$this, 'recordUsageOf'], array_filter([$node->extends]));
        }

        if ($node instanceof Node\Stmt\Interface_) {
            array_map([$this, 'recordUsageOf'], array_filter($node->extends));
        }
    }

    private function recordImplementsUsage(Node $node)
    {
        if ($node instanceof Node\Stmt\Class_) {
            array_map([$this, 'recordUsageOf'], $node->implements);
        }
    }

    private function recordClassExpressionUsage(Node $node)
    {
        if (($node instanceof Node\Expr\StaticCall
                || $node instanceof Node\Expr\StaticPropertyFetch
                || $node instanceof Node\Expr\ClassConstFetch
                || $node instanceof Node\Expr\New_
                || $node instanceof Node\Expr\Instanceof_
            )
            && ($nodeClass = $node->class)
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
            && $nodeClass instanceof Node\Name
        ) {
            $this->recordUsageOf($nodeClass);
        }
    }

    private function recordCatchUsage(Node $node)
    {
        if ($node instanceof Node\Stmt\Catch_) {
            foreach ($node->types as $type) {
                $this->recordUsageOf($type);
            }
        }
    }

    private function recordFunctionCallUsage(Node $node)
    {
        if ($node instanceof Node\Expr\FuncCall
            && ($nodeName = $node->name)
            && $nodeName instanceof Node\Name
        ) {
            $this->recordUsageOf($nodeName);
        }
    }

    private function recordFunctionParameterTypesUsage(Node $node)
    {
        if ($node instanceof Node\Stmt\Function_
            || $node instanceof Node\Stmt\ClassMethod
        ) {
            foreach ($node->getParams() as $param) {
                if ($param->type instanceof Node\Name) {
                    $this->recordUsageOf($param->type);
                }
                if (is_string($param->type)) {
                    $this->recordUsageOfByString($param->type);
                }
            }
        }
    }

    private function recordFunctionReturnTypeUsage(Node $node)
    {
        if ($node instanceof Node\Stmt\Function_
            || $node instanceof Node\Stmt\ClassMethod
        ) {
            if ($node->getReturnType() instanceof Node\Name) {
                $this->recordUsageOf($node->getReturnType());
            }
            if (is_string($node->getReturnType())) {
                $this->recordUsageOfByString($node->getReturnType());
            }
        }
    }

    private function recordConstantFetchUsage(Node $node)
    {
        if ($node instanceof Node\Expr\ConstFetch) {
            $this->recordUsageOf($node->name);
        }
    }

    private function recordTraitUsage(Node $node)
    {
        if (!$node instanceof Node\Stmt\TraitUse) {
            return;
        }

        array_map([$this, 'recordUsageOf'], $node->traits);

        foreach ($node->adaptations as $adaptation) {
            $this->recordUsageOf($adaptation->trait);

            if ($adaptation instanceof Node\Stmt\TraitUseAdaptation\Precedence) {
                array_map([$this, 'recordUsageOf'], $adaptation->insteadof);
            }
        }
    }

    /**
     * @param Node\Name $symbol
     *
     * @return void
     */
    private function recordUsageOf(Node\Name $symbol)
    {
        $this->collectedSymbols[(string)$symbol] = $symbol;
    }

    /**
     * @param Node\Name $symbol
     *
     * @return void
     */
    private function recordUsageOfByString(string $symbol)
    {
        $this->collectedSymbols[$symbol] = $symbol;
    }
}


1		<?php
2
3		namespace ComposerRequireChecker\NodeVisitor;
4
5		use PhpParser\Node;
6		use PhpParser\NodeVisitorAbstract;
7
8		final class UsedSymbolCollector extends NodeVisitorAbstract
9		{
10		/**
11		* @var mixed[]
12		*/
13		private $collectedSymbols = [];
14
15	22	public function __construct()
16		{
17	22	}
18
19		/**
20		* @return string[]
21		*/
22	22	public function getCollectedSymbols(): array
23		{
24	22	return array_keys($this->collectedSymbols);
25		}
26
27		/**
28		* {@inheritDoc}
29		*/
30	2	public function beforeTraverse(array $nodes)
31		{
32	2	$this->collectedSymbols = [];
33
34	2	return parent::beforeTraverse($nodes);
		0 ignored issues – show Bug introduced 2017-11-04 12:54 UTC by Report Bug Copy Issue Report Are you sure the usage of `parent::beforeTraverse($nodes)` targeting `PhpParser\NodeVisitorAbstract::beforeTraverse()` seems to always return null. This check looks for function or method calls that always return null and whose return value is used. class A { function getObject() { return null; } } $a = new A(); if ($a->getObject()) { The method `getObject()` can return nothing but null, so it makes no sense to use the return value. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
35		}
36
37		/**
38		* {@inheritDoc}
39		*/
40	22	public function enterNode(Node $node)
41		{
42	22	$this->recordExtendsUsage($node);
43	22	$this->recordImplementsUsage($node);
44	22	$this->recordClassExpressionUsage($node);
45	22	$this->recordCatchUsage($node);
46	22	$this->recordFunctionCallUsage($node);
47	22	$this->recordFunctionParameterTypesUsage($node);
48	22	$this->recordFunctionReturnTypeUsage($node);
49	22	$this->recordConstantFetchUsage($node);
50	22	$this->recordTraitUsage($node);
51
52	22	return parent::enterNode($node);
		0 ignored issues – show Bug introduced 2017-11-04 12:54 UTC by Report Bug Copy Issue Report Are you sure the usage of `parent::enterNode($node)` targeting `PhpParser\NodeVisitorAbstract::enterNode()` seems to always return null. This check looks for function or method calls that always return null and whose return value is used. class A { function getObject() { return null; } } $a = new A(); if ($a->getObject()) { The method `getObject()` can return nothing but null, so it makes no sense to use the return value. The reason is most likely that a function or method is imcomplete or has been reduced for debug purposes. Loading history...
53		}
54
55	22	private function recordExtendsUsage(Node $node)
56		{
57	22	if ($node instanceof Node\Stmt\Class_) {
58	4	array_map([$this, 'recordUsageOf'], array_filter([$node->extends]));
59		}
60
61	22	if ($node instanceof Node\Stmt\Interface_) {
62	2	array_map([$this, 'recordUsageOf'], array_filter($node->extends));
63		}
64	22	}
65
66	22	private function recordImplementsUsage(Node $node)
67		{
68	22	if ($node instanceof Node\Stmt\Class_) {
69	4	array_map([$this, 'recordUsageOf'], $node->implements);
70		}
71	22	}
72
73	22	private function recordClassExpressionUsage(Node $node)
74		{
75	22	if (($node instanceof Node\Expr\StaticCall
76	21	\|\| $node instanceof Node\Expr\StaticPropertyFetch
77	20	\|\| $node instanceof Node\Expr\ClassConstFetch
78	19	\|\| $node instanceof Node\Expr\New_
79	22	\|\| $node instanceof Node\Expr\Instanceof_
80		)
81	22	&& ($nodeClass = $node->class)
		0 ignored issues – show Documentation Bug introduced 2017-11-04 12:54 UTC by Report Bug Copy Issue Report It seems like `$node->class` can also be of type `PhpParser\Node\Stmt\Class_`. However, the property `$class` is declared as type `PhpParser\Node\Name\|PhpParser\Node\Expr`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
82	22	&& $nodeClass instanceof Node\Name
83		) {
84	6	$this->recordUsageOf($nodeClass);
85		}
86	22	}
87
88	22	private function recordCatchUsage(Node $node)
89		{
90	22	if ($node instanceof Node\Stmt\Catch_) {
91	2	foreach ($node->types as $type) {
92	2	$this->recordUsageOf($type);
93		}
94		}
95	22	}
96
97	22	private function recordFunctionCallUsage(Node $node)
98		{
99	22	if ($node instanceof Node\Expr\FuncCall
100	22	&& ($nodeName = $node->name)
101	22	&& $nodeName instanceof Node\Name
102		) {
103	2	$this->recordUsageOf($nodeName);
104		}
105	22	}
106
107	22	private function recordFunctionParameterTypesUsage(Node $node)
108		{
109	22	if ($node instanceof Node\Stmt\Function_
110	22	\|\| $node instanceof Node\Stmt\ClassMethod
111		) {
112	9	foreach ($node->getParams() as $param) {
113	5	if ($param->type instanceof Node\Name) {
114	3	$this->recordUsageOf($param->type);
115		}
116	5	if (is_string($param->type)) {
117	5	$this->recordUsageOfByString($param->type);
118		}
119		}
120		}
121	22	}
122
123	22	private function recordFunctionReturnTypeUsage(Node $node)
124		{
125	22	if ($node instanceof Node\Stmt\Function_
126	22	\|\| $node instanceof Node\Stmt\ClassMethod
127		) {
128	9	if ($node->getReturnType() instanceof Node\Name) {
129	3	$this->recordUsageOf($node->getReturnType());
130		}
131	9	if (is_string($node->getReturnType())) {
132	3	$this->recordUsageOfByString($node->getReturnType());
133		}
134		}
135	22	}
136
137	22	private function recordConstantFetchUsage(Node $node)
138		{
139	22	if ($node instanceof Node\Expr\ConstFetch) {
140	2	$this->recordUsageOf($node->name);
141		}
142	22	}
143
144	22	private function recordTraitUsage(Node $node)
145		{
146	22	if (!$node instanceof Node\Stmt\TraitUse) {
147	21	return;
148		}
149
150	1	array_map([$this, 'recordUsageOf'], $node->traits);
151
152	1	foreach ($node->adaptations as $adaptation) {
153		$this->recordUsageOf($adaptation->trait);
154
155		if ($adaptation instanceof Node\Stmt\TraitUseAdaptation\Precedence) {
156		array_map([$this, 'recordUsageOf'], $adaptation->insteadof);
157		}
158		}
159	1	}
160
161		/**
162		* @param Node\Name $symbol
163		*
164		* @return void
165		*/
166	18	private function recordUsageOf(Node\Name $symbol)
167		{
168	18	$this->collectedSymbols[(string)$symbol] = $symbol;
169	18	}
170
171		/**
172		* @param Node\Name $symbol
173		*
174		* @return void
175		*/
176	5	private function recordUsageOfByString(string $symbol)
177		{
178	5	$this->collectedSymbols[$symbol] = $symbol;
179	5	}
180		}
181

maglnet / ComposerRequireChecker

Push — master ( ff5911...a1b140 )

UsedSymbolCollector::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like