VisitorOfIExpression::VisitT() - Code Metrics - Inspection of "Clean up assorted Scrutinizer complaints" - c-harris/ODataMetadata - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#44)

by Alex

created 2020-07-04 04:49 UTC

VisitorOfIExpression::VisitT() F

↳ Parent: VisitorOfIExpression

Complexity

Conditions	29
Paths	56

Size

Total Lines	252
Code Lines	193

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	0

Metric	Value
cc	29
eloc	193
c	2
b	1
f	0
nc	56
nop	3
dl	0
loc	252
rs	3.3333

How to fix Long Method Complexity

<?php

declare(strict_types=1);


namespace AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator;

use AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator;
use AlgoWeb\ODataMetadata\Enums\ExpressionKind;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IApplyExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IAssertTypeExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IBinaryConstantExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IBooleanConstantExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\ICollectionExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IDateTimeConstantExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IDateTimeOffsetConstantExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IDecimalConstantExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IEntitySetReferenceExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IEnumMemberReferenceExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IFloatingConstantExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IFunctionReferenceExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IGuidConstantExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IIfExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IIntegerConstantExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IIsTypeExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\ILabeledExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\ILabeledExpressionReferenceExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\INullExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IParameterReferenceExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IPathExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IPropertyReferenceExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IRecordExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IStringConstantExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\ITimeConstantExpression;
use AlgoWeb\ODataMetadata\Interfaces\Expressions\IValueTermReferenceExpression;

class VisitorOfIExpression extends VisitorOfT
{
    protected function VisitT($expression, array &$followup, array &$references): ?iterable
    {
        assert($expression instanceof IExpression);
        // Trying to reduce amount of noise in errors - if this expression is bad, then most likely it will have an unacceptable kind, no need to report it.
        $expressionKindError = null;
        if (!InterfaceValidator::IsCheckableBad($expression)) {
            switch ($expression->getExpressionKind()) {
                case ExpressionKind::IntegerConstant():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IIntegerConstantExpression::class
                    );
                    break;

                case ExpressionKind::StringConstant():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IStringConstantExpression::class
                    );
                    break;

                case ExpressionKind::BinaryConstant():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IBinaryConstantExpression::class
                    );
                    break;

                case ExpressionKind::BooleanConstant():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IBooleanConstantExpression::class
                    );
                    break;

                case ExpressionKind::DateTimeConstant():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IDateTimeConstantExpression::class
                    );
                    break;

                case ExpressionKind::DateTimeOffsetConstant():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IDateTimeOffsetConstantExpression::class
                    );
                    break;

                case ExpressionKind::TimeConstant():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        ITimeConstantExpression::class
                    );
                    break;

                case ExpressionKind::DecimalConstant():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IDecimalConstantExpression::class
                    );
                    break;

                case ExpressionKind::FloatingConstant():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IFloatingConstantExpression::class
                    );
                    break;

                case ExpressionKind::GuidConstant():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IGuidConstantExpression::class
                    );
                    break;

                case ExpressionKind::Null():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        INullExpression::class
                    );
                    break;

                case ExpressionKind::Record():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IRecordExpression::class
                    );
                    break;

                case ExpressionKind::Collection():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        ICollectionExpression::class
                    );
                    break;

                case ExpressionKind::Path():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IPathExpression::class
                    );
                    break;

                case ExpressionKind::ParameterReference():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IParameterReferenceExpression::class
                    );
                    break;

                case ExpressionKind::FunctionReference():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IFunctionReferenceExpression::class
                    );
                    break;

                case ExpressionKind::PropertyReference():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IPropertyReferenceExpression::class
                    );
                    break;

                case ExpressionKind::ValueTermReference():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IValueTermReferenceExpression::class
                    );
                    break;

                case ExpressionKind::EntitySetReference():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IEntitySetReferenceExpression::class
                    );
                    break;

                case ExpressionKind::EnumMemberReference():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IEnumMemberReferenceExpression::class
                    );
                    break;

                case ExpressionKind::If():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IIfExpression::class
                    );
                    break;

                case ExpressionKind::AssertType():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IAssertTypeExpression::class
                    );
                    break;

                case ExpressionKind::IsType():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IIsTypeExpression::class
                    );
                    break;

                case ExpressionKind::FunctionApplication():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        IApplyExpression::class
                    );
                    break;

                case ExpressionKind::Labeled():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        ILabeledExpression::class
                    );
                    break;

                case ExpressionKind::LabeledExpressionReference():
                    $expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
                        $expression,
                        $expression->getExpressionKind(),
                        'ExpressionKind',
                        ILabeledExpressionReferenceExpression::class
                    );
                    break;

                default:
                    $expressionKindError = InterfaceValidator::CreateInterfaceKindValueUnexpectedError(
                        $expression,
                        $expression->getExpressionKind()->getKey(),
                        'ExpressionKind'
                    );
                    break;
            }
        }

        return null !== $expressionKindError ? [ $expressionKindError ] : null;

    }

    public function forType(): string
    {
        return IExpression::class;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5
6			namespace AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator;
7
8			use AlgoWeb\ODataMetadata\Edm\Validation\Internal\InterfaceValidator;
9			use AlgoWeb\ODataMetadata\Enums\ExpressionKind;
10			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IApplyExpression;
11			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IAssertTypeExpression;
12			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IBinaryConstantExpression;
13			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IBooleanConstantExpression;
14			use AlgoWeb\ODataMetadata\Interfaces\Expressions\ICollectionExpression;
15			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IDateTimeConstantExpression;
16			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IDateTimeOffsetConstantExpression;
17			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IDecimalConstantExpression;
18			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IEntitySetReferenceExpression;
19			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IEnumMemberReferenceExpression;
20			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IExpression;
21			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IFloatingConstantExpression;
22			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IFunctionReferenceExpression;
23			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IGuidConstantExpression;
24			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IIfExpression;
25			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IIntegerConstantExpression;
26			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IIsTypeExpression;
27			use AlgoWeb\ODataMetadata\Interfaces\Expressions\ILabeledExpression;
28			use AlgoWeb\ODataMetadata\Interfaces\Expressions\ILabeledExpressionReferenceExpression;
29			use AlgoWeb\ODataMetadata\Interfaces\Expressions\INullExpression;
30			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IParameterReferenceExpression;
31			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IPathExpression;
32			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IPropertyReferenceExpression;
33			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IRecordExpression;
34			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IStringConstantExpression;
35			use AlgoWeb\ODataMetadata\Interfaces\Expressions\ITimeConstantExpression;
36			use AlgoWeb\ODataMetadata\Interfaces\Expressions\IValueTermReferenceExpression;
37
38			class VisitorOfIExpression extends VisitorOfT
39			{
40			protected function VisitT($expression, array &$followup, array &$references): ?iterable
41			{
42			assert($expression instanceof IExpression);
43			// Trying to reduce amount of noise in errors - if this expression is bad, then most likely it will have an unacceptable kind, no need to report it.
44			$expressionKindError = null;
45			if (!InterfaceValidator::IsCheckableBad($expression)) {
46			switch ($expression->getExpressionKind()) {
47			case ExpressionKind::IntegerConstant():
48			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
49			$expression,
50			$expression->getExpressionKind(),
51			'ExpressionKind',
52			IIntegerConstantExpression::class
53			);
54			break;
55
56			case ExpressionKind::StringConstant():
57			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
58			$expression,
59			$expression->getExpressionKind(),
60			'ExpressionKind',
61			IStringConstantExpression::class
62			);
63			break;
64
65			case ExpressionKind::BinaryConstant():
66			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
67			$expression,
68			$expression->getExpressionKind(),
69			'ExpressionKind',
70			IBinaryConstantExpression::class
71			);
72			break;
73
74			case ExpressionKind::BooleanConstant():
75			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
76			$expression,
77			$expression->getExpressionKind(),
78			'ExpressionKind',
79			IBooleanConstantExpression::class
80			);
81			break;
82
83			case ExpressionKind::DateTimeConstant():
84			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
85			$expression,
86			$expression->getExpressionKind(),
87			'ExpressionKind',
88			IDateTimeConstantExpression::class
89			);
90			break;
91
92			case ExpressionKind::DateTimeOffsetConstant():
93			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
94			$expression,
95			$expression->getExpressionKind(),
96			'ExpressionKind',
97			IDateTimeOffsetConstantExpression::class
98			);
99			break;
100
101			case ExpressionKind::TimeConstant():
102			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
103			$expression,
104			$expression->getExpressionKind(),
105			'ExpressionKind',
106			ITimeConstantExpression::class
107			);
108			break;
109
110			case ExpressionKind::DecimalConstant():
111			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
112			$expression,
113			$expression->getExpressionKind(),
114			'ExpressionKind',
115			IDecimalConstantExpression::class
116			);
117			break;
118
119			case ExpressionKind::FloatingConstant():
120			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
121			$expression,
122			$expression->getExpressionKind(),
123			'ExpressionKind',
124			IFloatingConstantExpression::class
125			);
126			break;
127
128			case ExpressionKind::GuidConstant():
129			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
130			$expression,
131			$expression->getExpressionKind(),
132			'ExpressionKind',
133			IGuidConstantExpression::class
134			);
135			break;
136
137			case ExpressionKind::Null():
138			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
139			$expression,
140			$expression->getExpressionKind(),
141			'ExpressionKind',
142			INullExpression::class
143			);
144			break;
145
146			case ExpressionKind::Record():
147			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
148			$expression,
149			$expression->getExpressionKind(),
150			'ExpressionKind',
151			IRecordExpression::class
152			);
153			break;
154
155			case ExpressionKind::Collection():
156			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
157			$expression,
158			$expression->getExpressionKind(),
159			'ExpressionKind',
160			ICollectionExpression::class
161			);
162			break;
163
164			case ExpressionKind::Path():
165			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
166			$expression,
167			$expression->getExpressionKind(),
168			'ExpressionKind',
169			IPathExpression::class
170			);
171			break;
172
173			case ExpressionKind::ParameterReference():
174			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
175			$expression,
176			$expression->getExpressionKind(),
177			'ExpressionKind',
178			IParameterReferenceExpression::class
179			);
180			break;
181
182			case ExpressionKind::FunctionReference():
183			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
184			$expression,
185			$expression->getExpressionKind(),
186			'ExpressionKind',
187			IFunctionReferenceExpression::class
188			);
189			break;
190
191			case ExpressionKind::PropertyReference():
192			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
193			$expression,
194			$expression->getExpressionKind(),
195			'ExpressionKind',
196			IPropertyReferenceExpression::class
197			);
198			break;
199
200			case ExpressionKind::ValueTermReference():
201			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
202			$expression,
203			$expression->getExpressionKind(),
204			'ExpressionKind',
205			IValueTermReferenceExpression::class
206			);
207			break;
208
209			case ExpressionKind::EntitySetReference():
210			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
211			$expression,
212			$expression->getExpressionKind(),
213			'ExpressionKind',
214			IEntitySetReferenceExpression::class
215			);
216			break;
217
218			case ExpressionKind::EnumMemberReference():
219			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
220			$expression,
221			$expression->getExpressionKind(),
222			'ExpressionKind',
223			IEnumMemberReferenceExpression::class
224			);
225			break;
226
227			case ExpressionKind::If():
228			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
229			$expression,
230			$expression->getExpressionKind(),
231			'ExpressionKind',
232			IIfExpression::class
233			);
234			break;
235
236			case ExpressionKind::AssertType():
237			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
238			$expression,
239			$expression->getExpressionKind(),
240			'ExpressionKind',
241			IAssertTypeExpression::class
242			);
243			break;
244
245			case ExpressionKind::IsType():
246			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
247			$expression,
248			$expression->getExpressionKind(),
249			'ExpressionKind',
250			IIsTypeExpression::class
251			);
252			break;
253
254			case ExpressionKind::FunctionApplication():
255			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
256			$expression,
257			$expression->getExpressionKind(),
258			'ExpressionKind',
259			IApplyExpression::class
260			);
261			break;
262
263			case ExpressionKind::Labeled():
264			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
265			$expression,
266			$expression->getExpressionKind(),
267			'ExpressionKind',
268			ILabeledExpression::class
269			);
270			break;
271
272			case ExpressionKind::LabeledExpressionReference():
273			$expressionKindError = InterfaceValidator::CheckForInterfaceKindValueMismatchError(
274			$expression,
275			$expression->getExpressionKind(),
276			'ExpressionKind',
277			ILabeledExpressionReferenceExpression::class
278			);
279			break;
280
281			default:
282			$expressionKindError = InterfaceValidator::CreateInterfaceKindValueUnexpectedError(
283			$expression,
284			$expression->getExpressionKind()->getKey(),
285			'ExpressionKind'
286			);
287			break;
288			}
289			}
290
291			return null !== $expressionKindError ? [ $expressionKindError ] : null;
			0 ignored issues – show Bug Best Practice introduced 2020-06-30 18:31 UTC by Report Bug Copy Issue Report The expression `return null !== $express...essionKindError) : null` could return the type `array<integer,AlgoWeb\OD...dm\Validation\EdmError>` which is incompatible with the type-hinted return `iterable\|null`. Consider adding an additional type-check to rule them out. Loading history...
292			}
293
294			public function forType(): string
295			{
296			return IExpression::class;
297			}
298			}
299

c-harris / ODataMetadata

Pull Request — master (#44)

VisitorOfIExpression::VisitT() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like