TheCodingMachine\PHPStan\Rules\TypeHints\AbstractMissingTypeHintRule

Complexity

Total Complexity

71

Size/Duplication

Total Lines	339
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
	getNodeType()	0	1	?
A	__construct()	0	4	1
	isReturnIgnored()	0	1	?
	getReflection()	0	1	?
	shouldSkip()	0	1	?
B	processNode()	0	34	6
A	analyzeParameter()	0	27	4
A	analyzeReturnType()	0	12	3
D	analyzeWithTypehint()	0	67	24
A	isTypeIterable()	0	21	1
B	analyzeWithoutTypehint()	0	22	6
C	isNativelyTypehintable()	0	49	12
B	isNativeType()	0	13	7
A	isNullable()	0	11	4
A	typesWithoutNullable()	0	13	3

<?php
declare(strict_types=1);

namespace TheCodingMachine\PHPStan\Rules\TypeHints;

use PHPStan\Reflection\Php\PhpFunctionReflection;
use PHPStan\Reflection\Php\PhpMethodReflection;
use PHPStan\Type\ArrayType;
use PHPStan\Type\BooleanType;
use PHPStan\Type\CallableType;
use PHPStan\Type\FloatType;
use PHPStan\Type\IntegerType;
use PHPStan\Type\IterableType;
use PHPStan\Type\MixedType;
use PHPStan\Type\NullType;
use PHPStan\Type\ObjectType;
use PHPStan\Type\ObjectWithoutClassType;
use PHPStan\Type\StringType;
use PHPStan\Type\Type;
use PhpParser\Node;
use PHPStan\Analyser\Scope;
use PHPStan\Broker\Broker;
use PHPStan\Reflection\ParametersAcceptorWithPhpDocs;
use PHPStan\Reflection\Php\PhpParameterReflection;
use PHPStan\Rules\Rule;
use PHPStan\Type\UnionType;
use PHPStan\Type\VerbosityLevel;

abstract class AbstractMissingTypeHintRule implements Rule
{

    /**
     * @var Broker
     */
    private $broker;

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

    abstract public function getNodeType(): string;

    abstract public function isReturnIgnored(Node $node): bool;

    abstract protected function getReflection(Node\FunctionLike $function, Scope $scope, Broker $broker) : ParametersAcceptorWithPhpDocs;

    abstract protected function shouldSkip(Node\FunctionLike $function, Scope $scope): bool;

    /**
     * @param \PhpParser\Node\Stmt\Function_|\PhpParser\Node\Stmt\ClassMethod $node
     * @param \PHPStan\Analyser\Scope $scope
     * @return string[]
     */
    public function processNode(Node $node, Scope $scope): array
    {
        /*if ($node->getLine() < 0) {
            // Fixes some problems with methods in anonymous class (the line number is poorly reported).
            return [];
        }*/

        if ($this->shouldSkip($node, $scope)) {
            return [];
        }

        $parametersAcceptor = $this->getReflection($node, $scope, $this->broker);

        $errors = [];

        foreach ($parametersAcceptor->getParameters() as $parameter) {
            $debugContext = new ParameterDebugContext($scope, $node, $parameter);
            $result = $this->analyzeParameter($debugContext, $parameter);

            if ($result !== null) {
                $errors[] = $result;
            }
        }

        if (!$this->isReturnIgnored($node)) {
            $debugContext = new FunctionDebugContext($scope, $node);
            $returnTypeError = $this->analyzeReturnType($debugContext, $parametersAcceptor);
            if ($returnTypeError !== null) {
                $errors[] = $returnTypeError;
            }
        }

        return $errors;
    }

    /**
     * Analyzes a parameter and returns the error string if something goes wrong or null if everything is ok.
     *
     * @param PhpParameterReflection $parameter
     * @return null|string
     */
    private function analyzeParameter(DebugContextInterface $context, PhpParameterReflection $parameter): ?string
    {
        //$typeResolver = new \phpDocumentor\Reflection\TypeResolver();

50% of this comment could be valid code. Did you maybe forget this after debugging?

        $phpTypeHint = $parameter->getNativeType();
        //try {
            $docBlockTypeHints = $parameter->getPhpDocType();
        /*} catch (\InvalidArgumentException $e) {

64% of this comment could be valid code. Did you maybe forget this after debugging?

            return sprintf('%s, for parameter $%s, invalid docblock @param encountered. %s',
                $this->getContext($parameter),
                $parameter->getName(),
                $e->getMessage()
            );
        }*/

        if ($phpTypeHint instanceof MixedType && $phpTypeHint->isExplicitMixed() === false) {

The class PHPStan\Type\MixedType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            return $this->analyzeWithoutTypehint($context, $docBlockTypeHints);
        } else {
            // If there is a type-hint, we have nothing to say unless it is an array.
            if ($parameter->isVariadic()) {
                // Hack: wrap the native type in an array is variadic
                $phpTypeHint = new ArrayType(new IntegerType(), $phpTypeHint);
            }

            return $this->analyzeWithTypehint($context, $phpTypeHint, $docBlockTypeHints);
        }
    }

    /**
     * @return null|string
     */
    private function analyzeReturnType(DebugContextInterface $debugContext, ParametersAcceptorWithPhpDocs $function): ?string
    {
        $phpTypeHint = $function->getNativeReturnType();
        $docBlockTypeHints = $function->getPhpDocReturnType();

        // If there is a type-hint, we have nothing to say unless it is an array.
        if ($phpTypeHint instanceof MixedType && $phpTypeHint->isExplicitMixed() === false) {

The class PHPStan\Type\MixedType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            return $this->analyzeWithoutTypehint($debugContext, $docBlockTypeHints);
        } else {
            return $this->analyzeWithTypehint($debugContext, $phpTypeHint, $docBlockTypeHints);
        }
    }

    /**
     * @param DebugContextInterface $debugContext
     * @param Type $phpTypeHint
     * @param Type $docBlockTypeHints
     * @return null|string
     */
    private function analyzeWithTypehint(DebugContextInterface $debugContext, Type $phpTypeHint, Type $docBlockTypeHints): ?string
    {
        $docblockWithoutNullable = $this->typesWithoutNullable($docBlockTypeHints);

        if (!$this->isTypeIterable($phpTypeHint)) {
            // FIXME: this should be handled with the "accepts" method of types (and actually, this is already triggered by PHPStan 0.10)

            if ($docBlockTypeHints instanceof MixedType && $docBlockTypeHints->isExplicitMixed() === false) {

The class PHPStan\Type\MixedType does not exist. Did you forget a USE statement, or did you not list all dependencies?

                // No docblock.
                return null;
            }

            // Let's detect mismatches between docblock and PHP typehint
            if ($docblockWithoutNullable instanceof UnionType) {

The class PHPStan\Type\UnionType does not exist. Did you forget a USE statement, or did you not list all dependencies?

                $docblocks = $docblockWithoutNullable->getTypes();
            } else {
                $docblocks = [$docblockWithoutNullable];
            }
            $phpTypeHintWithoutNullable = $this->typesWithoutNullable($phpTypeHint);
            foreach ($docblocks as $docblockTypehint) {
                if (get_class($docblockTypehint) !== get_class($phpTypeHintWithoutNullable)) {
                    if ($debugContext instanceof ParameterDebugContext) {
                        return sprintf('%s type is type-hinted to "%s" but the @param annotation says it is a "%s". Please fix the @param annotation.', (string) $debugContext, $phpTypeHint->describe(VerbosityLevel::typeOnly()), $docblockTypehint->describe(VerbosityLevel::typeOnly()));
                    } elseif (!$docblockTypehint instanceof MixedType || $docblockTypehint->isExplicitMixed()) {

The class PHPStan\Type\MixedType does not exist. Did you forget a USE statement, or did you not list all dependencies?

                        return sprintf('%s return type is type-hinted to "%s" but the @return annotation says it is a "%s". Please fix the @return annotation.', (string) $debugContext, $phpTypeHint->describe(VerbosityLevel::typeOnly()), $docblockTypehint->describe(VerbosityLevel::typeOnly()));
                    }
                }
            }

            return null;
        }

        if ($phpTypeHint instanceof ArrayType) {

The class PHPStan\Type\ArrayType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            if ($docblockWithoutNullable instanceof MixedType && !$docblockWithoutNullable->isExplicitMixed()) {

The class PHPStan\Type\MixedType does not exist. Did you forget a USE statement, or did you not list all dependencies?

                if ($debugContext instanceof ParameterDebugContext) {
                    return sprintf('%s type is "array". Please provide a @param annotation to further specify the type of the array. For instance: @param int[] $%s', (string) $debugContext, $debugContext->getName());
                } else {
                    return sprintf('%s return type is "array". Please provide a @param annotation to further specify the type of the array. For instance: @return int[]', (string) $debugContext);
                }
            } else {
                if ($docblockWithoutNullable instanceof UnionType) {

The class PHPStan\Type\UnionType does not exist. Did you forget a USE statement, or did you not list all dependencies?

                    $docblocks = $docblockWithoutNullable->getTypes();
                } else {
                    $docblocks = [$docblockWithoutNullable];
                }
                foreach ($docblocks as $docblockTypehint) {
                    if (!$this->isTypeIterable($docblockTypehint)) {
                        if ($debugContext instanceof ParameterDebugContext) {
                            return sprintf('%s mismatching type-hints for parameter %s. PHP type hint is "array" and docblock type hint is %s.', (string) $debugContext, $debugContext->getName(), $docblockTypehint->describe(VerbosityLevel::typeOnly()));
                        } else {
                            return sprintf('%s mismatching type-hints for return type. PHP type hint is "array" and docblock declared return type is %s.', (string) $debugContext, $docblockTypehint->describe(VerbosityLevel::typeOnly()));
                        }
                    }

                    if ($docblockTypehint instanceof ArrayType && $docblockTypehint->getKeyType() instanceof MixedType && $docblockTypehint->getItemType() instanceof MixedType && $docblockTypehint->getKeyType()->isExplicitMixed() && $docblockTypehint->getItemType()->isExplicitMixed()) {

The class PHPStan\Type\ArrayType does not exist. Did you forget a USE statement, or did you not list all dependencies?

The class PHPStan\Type\MixedType does not exist. Did you forget a USE statement, or did you not list all dependencies?

                        if ($debugContext instanceof ParameterDebugContext) {
                            return sprintf('%s type is "array". Please provide a more specific @param annotation in the docblock. For instance: @param int[] $%s. Use @param mixed[] $%s if this is really an array of mixed values.', (string) $debugContext, $debugContext->getName(), $debugContext->getName());
                        } else {
                            return sprintf('%s return type is "array". Please provide a more specific @return annotation. For instance: @return int[]. Use @return mixed[] if this is really an array of mixed values.', (string) $debugContext);
                        }
                    }
                }
            }
        }

        return null;
    }

    private function isTypeIterable(Type $phpTypeHint) : bool
    {
        return /*$phpTypeHint->isIterable()->maybe() ||*/ $phpTypeHint->isIterable()->yes();

73% of this comment could be valid code. Did you maybe forget this after debugging?

        /*if ($phpTypeHint instanceof Array_ || $phpTypeHint instanceof Iterable_) {
            return true;
        }
        if ($phpTypeHint instanceof Object_) {
            // TODO: cache BetterReflection for better performance!
            try {
                $class = (new BetterReflection())->classReflector()->reflect((string) $phpTypeHint);
            } catch (IdentifierNotFound $e) {
                // Class not found? Let's not throw an error. It will be caught by other rules anyway.
                return false;
            }
            if ($class->implementsInterface('Traversable')) {
                return true;
            }
        }

        return false;*/
    }

    /**
     * @param DebugContextInterface $debugContext
     * @param Type $docBlockTypeHints
     * @return null|string
     */
    private function analyzeWithoutTypehint(DebugContextInterface $debugContext, Type $docBlockTypeHints): ?string
    {
        if ($docBlockTypeHints instanceof MixedType && $docBlockTypeHints->isExplicitMixed() === false) {

The class PHPStan\Type\MixedType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            if ($debugContext instanceof ParameterDebugContext) {
                return sprintf('%s has no type-hint and no @param annotation.', (string) $debugContext);
            } else {
                return sprintf('%s there is no return type and no @return annotation.', (string) $debugContext);
            }
        }

        $nativeTypehint = $this->isNativelyTypehintable($docBlockTypeHints);

        if ($nativeTypehint !== null) {
            if ($debugContext instanceof ParameterDebugContext) {
                return sprintf('%s can be type-hinted to "%s".', (string) $debugContext, $nativeTypehint);
            } else {
                return sprintf('%s a "%s" return type can be added.', (string) $debugContext, $nativeTypehint);
            }
        }

        return null;
    }

    /**
     * @param Type $docBlockTypeHints
     * @return string|null
     */
    private function isNativelyTypehintable(Type $docBlockTypeHints): ?string
    {
        if ($docBlockTypeHints instanceof UnionType) {

The class PHPStan\Type\UnionType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            $count = count($docBlockTypeHints->getTypes());
        } else {
            $count = 1;
        }

        if ($count > 2) {
            return null;
        }
        $isNullable = $this->isNullable($docBlockTypeHints);
        if ($count === 2 && !$isNullable) {
            return null;
        }

        $type = $this->typesWithoutNullable($docBlockTypeHints);
        // At this point, there is at most one element here
        /*if (empty($type)) {

71% of this comment could be valid code. Did you maybe forget this after debugging?

            return null;
        }*/

        //$type = $types[0];

67% of this comment could be valid code. Did you maybe forget this after debugging?

        // "object" type-hint is not available in PHP 7.1
        if ($type instanceof ObjectWithoutClassType) {

The class PHPStan\Type\ObjectWithoutClassType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            // In PHP 7.2, this is true but not in PHP 7.1
            return null;
        }

        if ($type instanceof ObjectType) {

The class PHPStan\Type\ObjectType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            return ($isNullable?'?':'').'\\'.$type->describe(VerbosityLevel::typeOnly());
        }

        if ($type instanceof ArrayType) {

The class PHPStan\Type\ArrayType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            return ($isNullable?'?':'').'array';
        }

        if ($this->isNativeType($type)) {
            return ($isNullable?'?':'').$type->describe(VerbosityLevel::typeOnly());
        }

        // TODO: more definitions to add here
        // Manage interface/classes
        // Manage array of things => (cast to array)


        return null;
    }

    private function isNativeType(Type $type): bool
    {
        if ($type instanceof StringType

The class PHPStan\Type\StringType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            || $type instanceof IntegerType

The class PHPStan\Type\IntegerType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            || $type instanceof BooleanType

The class PHPStan\Type\BooleanType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            || $type instanceof FloatType

The class PHPStan\Type\FloatType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            || $type instanceof CallableType

The class PHPStan\Type\CallableType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            || $type instanceof IterableType

The class PHPStan\Type\IterableType does not exist. Did you forget a USE statement, or did you not list all dependencies?

        ) {
            return true;
        }
        return false;
    }

    /**
     * @param Type $docBlockTypeHints
     * @return bool
     */
    private function isNullable(Type $docBlockTypeHints): bool
    {
        if ($docBlockTypeHints instanceof UnionType) {

The class PHPStan\Type\UnionType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            foreach ($docBlockTypeHints->getTypes() as $docBlockTypeHint) {
                if ($docBlockTypeHint instanceof NullType) {

The class PHPStan\Type\NullType does not exist. Did you forget a USE statement, or did you not list all dependencies?

                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Removes "null" from the list of types.
     *
     * @param Type $docBlockTypeHints
     * @return Type
     */
    private function typesWithoutNullable(Type $docBlockTypeHints): Type
    {
        if ($docBlockTypeHints instanceof UnionType) {

The class PHPStan\Type\UnionType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            $filteredTypes = array_values(array_filter($docBlockTypeHints->getTypes(), function (Type $item) {
                return !$item instanceof NullType;

The class PHPStan\Type\NullType does not exist. Did you forget a USE statement, or did you not list all dependencies?

            }));
            if (\count($filteredTypes) === 1) {
                return $filteredTypes[0];
            }
            return new UnionType($filteredTypes);
        }
        return $docBlockTypeHints;
    }
}