FallbackReferenceResolver::resolve() - Code Metrics - Inspection of "Merge pull request #2 from kejwmen/new-parser-test..." - Majkl578/doctrine-annotations - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — new-parser-ast-metadata ( 6127e0...5a4a16 )

by Michael

created 2018-10-23 01:42 UTC

FallbackReferenceResolver::resolve() B

↳ Parent: FallbackReferenceResolver

Complexity

Conditions	8
Paths	9

Size

Total Lines	36
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	8.2518

Importance

Changes

Metric	Value
eloc	18
dl	0
loc	36
rs	8.4444
c	0
b	0
f	0
ccs	16
cts	19
cp	0.8421
cc	8
nc	9
nop	2
crap	8.2518

<?php

declare(strict_types=1);

namespace Doctrine\Annotations\Parser\Reference;

use Doctrine\Annotations\Parser\Ast\Reference;
use Doctrine\Annotations\Parser\Scope;
use ReflectionClass;
use ReflectionFunction;
use ReflectionFunctionAbstract;
use ReflectionMethod;
use ReflectionProperty;
use Reflector;
use function assert;
use function explode;
use function strpos;
use function strtolower;

/**
 * @internal
 */
final class FallbackReferenceResolver implements ReferenceResolver
{
    public function resolve(Reference $reference, Scope $scope) : string
    {
        $identifier = $reference->getIdentifier();
        $imports    = $scope->getImports();

        if ($reference->isFullyQualified()) {
            return $identifier;
        }

        $identifierLower = strtolower($identifier);

        if (isset($imports[$identifierLower])) {
            return $imports[$identifierLower];
        }

        if (strpos($identifierLower, '\\') !== false) {
            $namespacePart = explode('\\', $identifierLower, 2)[0];

            if (isset($imports[$namespacePart])) {
                return $imports[$namespacePart] . '\\' . explode('\\', $identifier, 2)[1];
            }
        }

        $subject = $scope->getSubject();

        if (! $subject instanceof ReflectionClass && ! $subject instanceof ReflectionFunctionAbstract) {
            return $identifier;
        }

        $namespace = $this->getSubjectNamespaceName($scope->getSubject());

        if ($namespace === '') {
            return $identifier;
        }

        return $namespace . '\\' . $identifier;
    }

    private function getSubjectNamespaceName(Reflector $subject) : string
    {
        if ($subject instanceof ReflectionClass || $subject instanceof ReflectionFunction) {
            return $subject->getNamespaceName();
        }

        if ($subject instanceof ReflectionProperty || $subject instanceof ReflectionMethod) {
            return $subject->getDeclaringClass()->getNamespaceName();
        }

        assert(false, 'Unsupported Reflector');
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\Annotations\Parser\Reference;
6
7		use Doctrine\Annotations\Parser\Ast\Reference;
8		use Doctrine\Annotations\Parser\Scope;
9		use ReflectionClass;
10		use ReflectionFunction;
11		use ReflectionFunctionAbstract;
12		use ReflectionMethod;
13		use ReflectionProperty;
14		use Reflector;
15		use function assert;
16		use function explode;
17		use function strpos;
18		use function strtolower;
19
20		/**
21		* @internal
22		*/
23		final class FallbackReferenceResolver implements ReferenceResolver
24		{
25	19	public function resolve(Reference $reference, Scope $scope) : string
26		{
27	19	$identifier = $reference->getIdentifier();
28	19	$imports = $scope->getImports();
29
30	19	if ($reference->isFullyQualified()) {
31	7	return $identifier;
32		}
33
34	12	$identifierLower = strtolower($identifier);
35
36	12	if (isset($imports[$identifierLower])) {
37	2	return $imports[$identifierLower];
38		}
39
40	10	if (strpos($identifierLower, '\\') !== false) {
41		$namespacePart = explode('\\', $identifierLower, 2)[0];
42
43		if (isset($imports[$namespacePart])) {
44		return $imports[$namespacePart] . '\\' . explode('\\', $identifier, 2)[1];
45		}
46		}
47
48	10	$subject = $scope->getSubject();
49
50	10	if (! $subject instanceof ReflectionClass && ! $subject instanceof ReflectionFunctionAbstract) {
51	1	return $identifier;
52		}
53
54	9	$namespace = $this->getSubjectNamespaceName($scope->getSubject());
55
56	9	if ($namespace === '') {
57	4	return $identifier;
58		}
59
60	5	return $namespace . '\\' . $identifier;
61		}
62
63	9	private function getSubjectNamespaceName(Reflector $subject) : string
64		{
65	9	if ($subject instanceof ReflectionClass \|\| $subject instanceof ReflectionFunction) {
66	9	return $subject->getNamespaceName();
67		}
68
69		if ($subject instanceof ReflectionProperty \|\| $subject instanceof ReflectionMethod) {
70		return $subject->getDeclaringClass()->getNamespaceName();
71		}
72
73		assert(false, 'Unsupported Reflector');
		0 ignored issues – show Bug Best Practice introduced 2018-10-16 01:23 UTC by Report Bug Copy Issue Report In this branch, the function will implicitly return `null` which is incompatible with the type-hinted return `string`. Consider adding a return statement or allowing `null` as return value. For hinted functions/methods where all return statements with the correct type are only reachable via conditions, ?null? gets implicitly returned which may be incompatible with the hinted type. Let?s take a look at an example: interface ReturnsInt { public function returnsIntHinted(): int; } class MyClass implements ReturnsInt { public function returnsIntHinted(): int { if (foo()) { return 123; } // here: null is implicitly returned } } Loading history...
74		}
75		}
76

Majkl578 / doctrine-annotations

Push — new-parser-ast-metadata ( 6127e0...5a4a16 )

FallbackReferenceResolver::resolve() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like