UsedSymbolCollector::recordTraitUsage() - Code Metrics - Inspection of "WIP add tests for use trait adaptation" - maglnet/ComposerRequireChecker - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#45)

by Matthias

created 2017-11-15 20:58 UTC

UsedSymbolCollector::recordTraitUsage() B

↳ Parent: UsedSymbolCollector

Complexity

Conditions	5
Paths	6

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	5.0342

Importance

Changes

Metric	Value
dl	0
loc	15
ccs	8
cts	9
cp	0.8889
rs	8.8571
c	0
b	0
f	0
cc	5
eloc	8
nc	6
nop	1
crap	5.0342

<?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) {
            if (null !== $adaptation->trait) {
                $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	23	public function __construct()
16		{
17	23	}
18
19		/**
20		* @return string[]
21		*/
22	23	public function getCollectedSymbols(): array
23		{
24	23	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	23	public function enterNode(Node $node)
41		{
42	23	$this->recordExtendsUsage($node);
43	23	$this->recordImplementsUsage($node);
44	23	$this->recordClassExpressionUsage($node);
45	23	$this->recordCatchUsage($node);
46	23	$this->recordFunctionCallUsage($node);
47	23	$this->recordFunctionParameterTypesUsage($node);
48	23	$this->recordFunctionReturnTypeUsage($node);
49	23	$this->recordConstantFetchUsage($node);
50	23	$this->recordTraitUsage($node);
51
52	23	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	23	private function recordExtendsUsage(Node $node)
56		{
57	23	if ($node instanceof Node\Stmt\Class_) {
58	4	array_map([$this, 'recordUsageOf'], array_filter([$node->extends]));
59		}
60
61	23	if ($node instanceof Node\Stmt\Interface_) {
62	2	array_map([$this, 'recordUsageOf'], array_filter($node->extends));
63		}
64	23	}
65
66	23	private function recordImplementsUsage(Node $node)
67		{
68	23	if ($node instanceof Node\Stmt\Class_) {
69	4	array_map([$this, 'recordUsageOf'], $node->implements);
70		}
71	23	}
72
73	23	private function recordClassExpressionUsage(Node $node)
74		{
75	23	if (($node instanceof Node\Expr\StaticCall
76	22	\|\| $node instanceof Node\Expr\StaticPropertyFetch
77	21	\|\| $node instanceof Node\Expr\ClassConstFetch
78	20	\|\| $node instanceof Node\Expr\New_
79	23	\|\| $node instanceof Node\Expr\Instanceof_
80		)
81	23	&& ($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	23	&& $nodeClass instanceof Node\Name
83		) {
84	6	$this->recordUsageOf($nodeClass);
85		}
86	23	}
87
88	23	private function recordCatchUsage(Node $node)
89		{
90	23	if ($node instanceof Node\Stmt\Catch_) {
91	2	foreach ($node->types as $type) {
92	2	$this->recordUsageOf($type);
93		}
94		}
95	23	}
96
97	23	private function recordFunctionCallUsage(Node $node)
98		{
99	23	if ($node instanceof Node\Expr\FuncCall
100	23	&& ($nodeName = $node->name)
101	23	&& $nodeName instanceof Node\Name
102		) {
103	2	$this->recordUsageOf($nodeName);
104		}
105	23	}
106
107	23	private function recordFunctionParameterTypesUsage(Node $node)
108		{
109	23	if ($node instanceof Node\Stmt\Function_
110	23	\|\| $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	23	}
122
123	23	private function recordFunctionReturnTypeUsage(Node $node)
124		{
125	23	if ($node instanceof Node\Stmt\Function_
126	23	\|\| $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	23	}
136
137	23	private function recordConstantFetchUsage(Node $node)
138		{
139	23	if ($node instanceof Node\Expr\ConstFetch) {
140	2	$this->recordUsageOf($node->name);
141		}
142	23	}
143
144	23	private function recordTraitUsage(Node $node)
145		{
146	23	if (!$node instanceof Node\Stmt\TraitUse) {
147	21	return;
148		}
149
150	2	array_map([$this, 'recordUsageOf'], $node->traits);
151
152	2	foreach ($node->adaptations as $adaptation) {
153	1	if (null !== $adaptation->trait) {
154		$this->recordUsageOf($adaptation->trait);
155		}
156
157	1	if ($adaptation instanceof Node\Stmt\TraitUseAdaptation\Precedence) {
158	1	array_map([$this, 'recordUsageOf'], $adaptation->insteadof);
159		}
160		}
161	2	}
162
163		/**
164		* @param Node\Name $symbol
165		*
166		* @return void
167		*/
168	19	private function recordUsageOf(Node\Name $symbol)
169		{
170	19	$this->collectedSymbols[(string)$symbol] = $symbol;
171	19	}
172
173		/**
174		* @param Node\Name $symbol
175		*
176		* @return void
177		*/
178	5	private function recordUsageOfByString(string $symbol)
179		{
180	5	$this->collectedSymbols[$symbol] = $symbol;
181	5	}
182		}
183

maglnet / ComposerRequireChecker

Pull Request — master (#45)

UsedSymbolCollector::recordTraitUsage() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like