php-language-server/src/TolerantDefinitionResolver.php

<?php
declare(strict_types = 1);

namespace LanguageServer;

use LanguageServer\Protocol\TolerantSymbolInformation;
use PhpParser\Node;
use phpDocumentor\Reflection\{
    DocBlock, DocBlockFactory, Types, Type, Fqsen, TypeResolver
};
use LanguageServer\Protocol\SymbolInformation;
use LanguageServer\Index\ReadableIndex;
use Microsoft\PhpParser as Tolerant;

class TolerantDefinitionResolver implements DefinitionResolverInterface
{
    /**
     * The current project index (for retrieving existing definitions)
     *
     * @var \LanguageServer\Index\ReadableIndex
     */
    protected $index;

    /**
     * Resolves strings to a type object.
     *
     * @var \phpDocumentor\Reflection\TypeResolver
     */
    private $typeResolver;

    /**
     * Parses Doc Block comments given the DocBlock text and import tables at a position.
     *
     * @var DocBlockFactory
     */
    private $docBlockFactory;

    /**
     * @param ReadableIndex $index
     */
    public function __construct(ReadableIndex $index)
    {
        $this->index = $index;
        $this->typeResolver = new TypeResolver;
        $this->docBlockFactory = DocBlockFactory::createInstance();
    }

    /**
     * Builds the declaration line for a given node. Declarations with multiple lines are trimmed.
     *
     * @param Tolerant\Node $node
     * @return string
     */
    public function getDeclarationLineFromNode($node): string
    {
        // If node is part of a declaration list, build a declaration line that discludes other elements in the list
        //  - [PropertyDeclaration] // public $a, [$b = 3], $c; => public $b = 3;
        //  - [ConstDeclaration | ClassConstDeclaration] // "const A = 3, [B = 4];" => "const B = 4;"
        if (
            ($declaration = TolerantParserHelpers::tryGetPropertyDeclaration($node)) && ($elements = $declaration->propertyElements) ||
            ($declaration = TolerantParserHelpers::tryGetConstOrClassConstDeclaration($node)) && ($elements = $declaration->constElements)
        ) {
            $defLine = $declaration->getText();
            $defLineStart = $declaration->getStart();

            $defLine = \substr_replace(
                $defLine,
                $node->getFullText(),
                $elements->getFullStart() - $defLineStart,
                $elements->getFullWidth()
            );
        } else {
            $defLine = $node->getText();
        }

        // Trim string to only include first line
        $defLine = \rtrim(\strtok($defLine, "\n"), "\r");

        // TODO - pretty print rather than getting text
        
        return $defLine;
    }

    /**
     * Gets the documentation string for a node, if it has one
     *
     * @param Tolerant\Node $node
     * @return string|null
     */
    public function getDocumentationFromNode($node)
    {
        // Any NamespaceDefinition comments likely apply to the file, not the declaration itself.
        if ($node instanceof Tolerant\Node\Statement\NamespaceDefinition) {
            return null;
        }
        
        // For properties and constants, set the node to the declaration node, rather than the individual property.
        // This is because they get defined as part of a list.
        $constOrPropertyDeclaration = TolerantParserHelpers::tryGetPropertyDeclaration($node) ?? TolerantParserHelpers::tryGetConstOrClassConstDeclaration($node);
        if ($constOrPropertyDeclaration !== null) {
            $node = $constOrPropertyDeclaration;
        }

        // For parameters, parse the function-like declaration to get documentation for a parameter
        if ($node instanceof Tolerant\Node\Parameter) {
            $variableName = $node->getName();

            $functionLikeDeclaration = TolerantParserHelpers::getFunctionLikeDeclarationFromParameter($node);
            $docBlock = $this->getDocBlock($functionLikeDeclaration);

            $parameterDocBlockTag = $this->tryGetDocBlockTagForParameter($docBlock, $variableName);
            return $parameterDocBlockTag !== null ? $parameterDocBlockTag->getDescription()->render() : null;
        }

        // For everything else, get the doc block summary corresponding to the current node.
        $docBlock = $this->getDocBlock($node);
        if ($docBlock !== null) {
            return $docBlock->getSummary();
        }
        return null;
    }

    /**
     * Gets Doc Block with resolved names for a Node
     *
     * @param Tolerant\Node $node
     * @return DocBlock | null
     */
    private function getDocBlock(Tolerant\Node $node)
    {
        // TODO make more efficient (caching, ensure import table is in right format to begin with)
        $docCommentText = $node->getDocCommentText();
        if ($docCommentText !== null) {
            list($namespaceImportTable,,) = $node->getImportTablesForCurrentScope();
            foreach ($namespaceImportTable as $alias=>$name) {
                $namespaceImportTable[$alias] = (string)$name;
            }
            $namespaceDefinition = $node->getNamespaceDefinition();
            if ($namespaceDefinition !== null && $namespaceDefinition->name !== null) {
                $namespaceName = (string)$namespaceDefinition->name->getNamespacedName();
            } else {
                $namespaceName = 'global';
            }
            $context = new Types\Context($namespaceName, $namespaceImportTable);

            try {
                return $this->docBlockFactory->create($docCommentText, $context);
            } catch (\InvalidArgumentException $e) {
                return null;
            }
        }
        return null;
    }

    /**
     * Create a Definition for a definition node
     *
     * @param Tolerant\Node $node
     * @param string $fqn
     * @return Definition
     */
    public function createDefinitionFromNode($node, string $fqn = null): Definition
    {
        $def = new Definition;
        $def->fqn = $fqn;

        // Determines whether the suggestion will show after "new"
        $def->canBeInstantiated = $node instanceof Tolerant\Node\Statement\ClassDeclaration;

        // Interfaces, classes, traits, namespaces, functions, and global const elements
        $def->isGlobal = (
            $node instanceof Tolerant\Node\Statement\InterfaceDeclaration ||
            $node instanceof Tolerant\Node\Statement\ClassDeclaration ||
            $node instanceof Tolerant\Node\Statement\TraitDeclaration ||

            ($node instanceof Tolerant\Node\Statement\NamespaceDefinition && $node->name !== null) ||

            $node instanceof Tolerant\Node\Statement\FunctionDeclaration ||

            ($node instanceof Tolerant\Node\ConstElement && $node->parent->parent instanceof Tolerant\Node\Statement\ConstDeclaration)
        );

        // Static methods and static property declarations
        $def->isStatic = (
            ($node instanceof Tolerant\Node\MethodDeclaration && $node->isStatic()) ||

            (($propertyDeclaration = TolerantParserHelpers::tryGetPropertyDeclaration($node)) !== null
            && $propertyDeclaration->isStatic())
        );

        if ($node instanceof Tolerant\Node\Statement\ClassDeclaration &&
            // TODO - this should be bette rrpreented in the parser API
            $node->classBaseClause !== null && $node->classBaseClause->baseClass !== null)
        {
            $def->extends = [(string)$node->classBaseClause->baseClass->getResolvedName()];
            // TODO - why is this represented as an array?
            // TODO interface implementations.
        } elseif (
            $node instanceof Tolerant\Node\Statement\InterfaceDeclaration && 
            // TODO - this hould be better represented in the parser API
            $node->interfaceBaseClause !== null && $node->interfaceBaseClause->interfaceNameList !== null
        ) {
            $def->extends = [];
            foreach ($node->interfaceBaseClause->interfaceNameList->getValues() as $n) {
                $def->extends[] = (string)$n->getResolvedName();
            }
        }

        $def->symbolInformation = TolerantSymbolInformation::fromNode($node, $fqn);

        if ($def->symbolInformation !== null) {
            $def->type = $this->getTypeFromNode($node);
            $def->declarationLine = $this->getDeclarationLineFromNode($node);
            $def->documentation = $this->getDocumentationFromNode($node);
        }

        return $def;
    }

    /**
     * Given any node, returns the Definition object of the symbol that is referenced
     *
     * @param Tolerant\Node $node Any reference node
     * @return Definition|null
     */
    public function resolveReferenceNodeToDefinition($node)
    {
        $parent = $node->parent;
        // Variables are not indexed globally, as they stay in the file scope anyway.
        // Ignore variable nodes that are part of ScopedPropertyAccessExpression,
        // as the scoped property access expression node is handled separately.
        if ($node instanceof Tolerant\Node\Expression\Variable && 
            !($parent instanceof Tolerant\Node\Expression\ScopedPropertyAccessExpression))
        {
            // Resolve $this to the containing class definition.
            if ($node->getName() === 'this' && $fqn = $this->getContainingClassFqn($node)) {
                return $this->index->getDefinition($fqn, false);
            }

            // Resolve the variable to a definition node (assignment, param or closure use)
            $defNode = $this->resolveVariableToNode($node);
            if ($defNode === null) {
                return null;
            }
            return $this->createDefinitionFromNode($defNode);
        }
        // Other references are references to a global symbol that have an FQN
        // Find out the FQN
        $fqn = $this->resolveReferenceNodeToFqn($node);
        if ($fqn === null) {
            return null;
        }
        // If the node is a function or constant, it could be namespaced, but PHP falls back to global
        // http://php.net/manual/en/language.namespaces.fallback.php
        $globalFallback = TolerantParserHelpers::isConstantFetch($node) || $parent instanceof Tolerant\Node\Expression\CallExpression;
        // Return the Definition object from the index index
        return $this->index->getDefinition($fqn, $globalFallback);
    }

    /**
     * Given any node, returns the FQN of the symbol that is referenced
     * Returns null if the FQN could not be resolved or the reference node references a variable
     *
     * @param Node $node
     * @return string|null
     */
    public function resolveReferenceNodeToFqn($node) {        
        // TODO all name tokens should be a part of a node
        if ($node instanceof Tolerant\Node\QualifiedName) {
            return $this->resolveQualifiedNameNodeToFqn($node);
        }

        else if ($node instanceof Tolerant\Node\Expression\MemberAccessExpression) {
            return $this->resolveMemberAccessExpressionNodeToFqn($node);
        }
        else if (TolerantParserHelpers::isConstantFetch($node)) {
            return (string)($node->getNamespacedName());
        }
        else if (
            // A\B::C - constant access expression
            $node instanceof Tolerant\Node\Expression\ScopedPropertyAccessExpression 
            && !($node->memberName instanceof Tolerant\Node\Expression\Variable)
        ) {
            return $this->resolveScopedPropertyAccessExpressionNodeToFqn($node);
        } else if (
            // A\B::$c - static property access expression
            $node->parent instanceof Tolerant\Node\Expression\ScopedPropertyAccessExpression
        ) {
            return $this->resolveScopedPropertyAccessExpressionNodeToFqn($node->parent);
        }

        return null;
    }

    private function resolveQualifiedNameNodeToFqn(Tolerant\Node\QualifiedName $node) {
        $parent = $node->parent;

        if ($parent instanceof Tolerant\Node\TraitSelectOrAliasClause) {
            return null;
        }
        // Add use clause references
        if (($useClause = $parent) instanceof Tolerant\Node\NamespaceUseGroupClause 
            || $useClause instanceof Tolerant\Node\NamespaceUseClause
        ) {
            $contents = $node->getFileContents();                
            if ($useClause instanceof Tolerant\Node\NamespaceUseGroupClause) {
                $prefix = $useClause->parent->parent->namespaceName;
                if ($prefix === null) {
                    return null;
                }
                $name = Tolerant\ResolvedName::buildName($prefix->nameParts, $contents);
                $name->addNameParts($node->nameParts, $contents);
                $name = (string)$name;

                if ($useClause->functionOrConst === null) {
                    $useClause = $node->getFirstAncestor(Tolerant\Node\Statement\NamespaceUseDeclaration::class);
                    if ($useClause->functionOrConst !== null && $useClause->functionOrConst->kind === Tolerant\TokenKind::FunctionKeyword) {
                        $name .= '()';
                    }
                }
                return $name;
            } else {
                $name = (string) Tolerant\ResolvedName::buildName($node->nameParts, $contents);
                if ($useClause->groupClauses === null && $useClause->parent->parent->functionOrConst !== null && $useClause->parent->parent->functionOrConst->kind === Tolerant\TokenKind::FunctionKeyword) {
                    $name .= '()';
                }
            }

            return $name;
        }

        // For extends, implements, type hints and classes of classes of static calls use the name directly
        $name = (string) ($node->getResolvedName() ?? $node->getNamespacedName());
        
        if ($node->parent instanceof Tolerant\Node\Expression\CallExpression) {
            $name .= '()';
        }
        return $name;
    }

    private function resolveMemberAccessExpressionNodeToFqn(Tolerant\Node\Expression\MemberAccessExpression $access) {
        if ($access->memberName instanceof Tolerant\Node\Expression) {
            // Cannot get definition if right-hand side is expression
            return null;
        }
        // Get the type of the left-hand expression
        $varType = $this->resolveExpressionNodeToType($access->dereferencableExpression);

        if ($varType instanceof Types\Compound) {
            // For compound types, use the first FQN we find
            // (popular use case is ClassName|null)
            for ($i = 0; $t = $varType->get($i); $i++) {
                if (
                    $t instanceof Types\This
                    || $t instanceof Types\Object_
                    || $t instanceof Types\Static_
                    || $t instanceof Types\Self_
                ) {
                    $varType = $t;
                    break;
                }
            }
        }
        if (
            $varType instanceof Types\This
            || $varType instanceof Types\Static_
            || $varType instanceof Types\Self_
        ) {
            // $this/static/self is resolved to the containing class
            $classFqn = self::getContainingClassFqn($access);
        } else if (!($varType instanceof Types\Object_) || $varType->getFqsen() === null) {
            // Left-hand expression could not be resolved to a class
            return null;
        } else {
            $classFqn = substr((string)$varType->getFqsen(), 1);
        }
        $memberSuffix = '->' . (string)($access->memberName->getText() ?? $access->memberName->getText($access->getFileContents()));
        if ($access->parent instanceof Tolerant\Node\Expression\CallExpression) {
            $memberSuffix .= '()';
        }

        // Find the right class that implements the member
        $implementorFqns = [$classFqn];

        while ($implementorFqn = array_shift($implementorFqns)) {
            // If the member FQN exists, return it
            if ($this->index->getDefinition($implementorFqn . $memberSuffix)) {

                return $implementorFqn . $memberSuffix;
            }
            // Get Definition of implementor class
            $implementorDef = $this->index->getDefinition($implementorFqn);
            // If it doesn't exist, return the initial guess
            if ($implementorDef === null) {
                break;
            }
            // Repeat for parent class
            if ($implementorDef->extends) {
                foreach ($implementorDef->extends as $extends) {
                    $implementorFqns[] = $extends;
                }
            }
        }

        return $classFqn . $memberSuffix;
    }

    private function resolveScopedPropertyAccessExpressionNodeToFqn(Tolerant\Node\Expression\ScopedPropertyAccessExpression $scoped) {
        if ($scoped->scopeResolutionQualifier instanceof Tolerant\Node\Expression\Variable) {
            $varType = $this->getTypeFromNode($scoped->scopeResolutionQualifier);
            if ($varType === null) {
                return null;
            }
            $className = substr((string)$varType->getFqsen(), 1);
        } elseif ($scoped->scopeResolutionQualifier instanceof Tolerant\Node\QualifiedName) {
            $className = (string)$scoped->scopeResolutionQualifier->getResolvedName();
        } else {
            return null;
        }

        if ($className === 'self' || $className === 'static' || $className === 'parent') {
            // self and static are resolved to the containing class
            $classNode = $scoped->getFirstAncestor(Tolerant\Node\Statement\ClassDeclaration::class);
            if ($classNode === null) {
                return null;
            }
            if ($className === 'parent') {
                // parent is resolved to the parent class
                if (!isset($classNode->extends)) {
                    return null;
                }
                $className = (string)$classNode->extends->getResolvedName();
            } else {
                $className = (string)$classNode->getNamespacedName();
            }
        } elseif ($scoped->scopeResolutionQualifier instanceof Tolerant\Node\QualifiedName) {
            $className = $scoped->scopeResolutionQualifier->getResolvedName();
        }
        if ($scoped->memberName instanceof Tolerant\Node\Expression\Variable) {
            if ($scoped->parent instanceof Tolerant\Node\Expression\CallExpression) {
                return null;
            }
            $memberName = $scoped->memberName->getName();
            if (empty($memberName)) {
                return null;
            }
            $name = (string)$className . '::$' . $memberName;
        } else {
            $name = (string)$className . '::' . $scoped->memberName->getText($scoped->getFileContents());
        }
        if ($scoped->parent instanceof Tolerant\Node\Expression\CallExpression) {
            $name .= '()';
        }
        return $name;
    }

    /**
     * Returns FQN of the class a node is contained in
     * Returns null if the class is anonymous or the node is not contained in a class
     *
     * @param Tolerant\Node $node
     * @return string|null
     */
    private static function getContainingClassFqn(Tolerant\Node $node)
    {
        $classNode = $node->getFirstAncestor(Tolerant\Node\Statement\ClassDeclaration::class);
        if ($classNode === null) {
            return null;
        }
        return (string)$classNode->getNamespacedName();
    }

    /**
     * Returns the assignment or parameter node where a variable was defined
     *
     * @param Node\Expr\Variable|Node\Expr\ClosureUse $var The variable access
     * @return Node\Expr\Assign|Node\Expr\AssignOp|Node\Param|Node\Expr\ClosureUse|null
     */
    public function resolveVariableToNode($var)
    {
        $n = $var;
        // When a use is passed, start outside the closure to not return immediately
        // Use variable vs variable parsing?
        if ($var instanceof Tolerant\Node\UseVariableName) {
            $n = $var->getFirstAncestor(Tolerant\Node\Expression\AnonymousFunctionCreationExpression::class)->parent;
            $name = $var->getName();
        } else if ($var instanceof Tolerant\Node\Expression\Variable || $var instanceof Tolerant\Node\Parameter) {
            $name = $var->getName();
        } else {
            throw new \InvalidArgumentException('$var must be Variable, Param or ClosureUse, not ' . get_class($var));
        }
        // Traverse the AST up
        do {
            // If a function is met, check the parameters and use statements
            if (TolerantParserHelpers::isFunctionLike($n)) {
                if ($n->parameters !== null) {

                    foreach ($n->parameters->getElements() as $param) {
                        if ($param->getName() === $name) {
                            return $param;
                        }
                    }
                }
                // If it is a closure, also check use statements
                if ($n instanceof Tolerant\Node\Expression\AnonymousFunctionCreationExpression &&
                    $n->anonymousFunctionUseClause !== null &&
                    $n->anonymousFunctionUseClause->useVariableNameList !== null) {
                    foreach ($n->anonymousFunctionUseClause->useVariableNameList->getElements() as $use
                    ) {
                        if ($use->getName() === $name) {
                            return $use;
                        }
                    }
                }
                break;
            }
            // Check each previous sibling node for a variable assignment to that variable
            while (($prevSibling = $n->getPreviousSibling()) !== null && $n = $prevSibling) {
                if ($n instanceof Tolerant\Node\Statement\ExpressionStatement) {
                    $n = $n->expression;
                }
                if (
                    // TODO - clean this up
                    ($n instanceof Tolerant\Node\Expression\AssignmentExpression && $n->operator->kind === Tolerant\TokenKind::EqualsToken)
                    && $n->leftOperand instanceof Tolerant\Node\Expression\Variable && $n->leftOperand->getName() === $name
                ) {
                    return $n;
                }
            }
        } while (isset($n) && $n = $n->parent);
        // Return null if nothing was found
        return null;
    }

    /**
     * Given an expression node, resolves that expression recursively to a type.
     * If the type could not be resolved, returns Types\Mixed.
     *
     * @param Tolerant\Node\Expression $expr
     * @return \phpDocumentor\Reflection\Type
     */
    public function resolveExpressionNodeToType($expr): Type
    {
        if ($expr == null || $expr instanceof Tolerant\MissingToken || $expr instanceof Tolerant\SkippedToken) {
            // TODO some members are null or Missing/SkippedToken
            // How do we handle this more generally?
            return new Types\Mixed;
        }

        // PARENTHESIZED EXPRESSION
        // Retrieve inner expression from parenthesized expression
        while ($expr instanceof Tolerant\Node\Expression\ParenthesizedExpression) {
            $expr = $expr->expression;
        }

        // VARIABLE
        //   $this -> Type\this
        //   $myVariable -> type of corresponding assignment expression 
        if ($expr instanceof Tolerant\Node\Expression\Variable || $expr instanceof Tolerant\Node\UseVariableName) {
            if ($expr->getName() === 'this') {
                return new Types\This;
            }
            // Find variable definition (parameter or assignment expression)
            $defNode = $this->resolveVariableToNode($expr);
            if ($defNode instanceof Tolerant\Node\Expression\AssignmentExpression || $defNode instanceof Tolerant\Node\UseVariableName) {
                return $this->resolveExpressionNodeToType($defNode);
            }
            if ($defNode instanceof Tolerant\Node\Parameter) {
                return $this->getTypeFromNode($defNode);
            }
        }

        // FUNCTION CALL
        // Function calls are resolved to type corresponding to their FQN
        if ($expr instanceof Tolerant\Node\Expression\CallExpression &&
            !(
                $expr->callableExpression instanceof Tolerant\Node\Expression\ScopedPropertyAccessExpression ||
                $expr->callableExpression instanceof Tolerant\Node\Expression\MemberAccessExpression)
        ) {
            
            // Find the function definition
            if ($expr->callableExpression instanceof Tolerant\Node\Expression) {
                // Cannot get type for dynamic function call
                return new Types\Mixed;
            }

            if ($expr->callableExpression instanceof Tolerant\Node\QualifiedName) {
                $fqn = $expr->callableExpression->getResolvedName() ?? $expr->callableExpression->getNamespacedName();
                $fqn .= '()';
                $def = $this->index->getDefinition($fqn, true);
                if ($def !== null) {
                    return $def->type;
                }
            }
        }

        // TRUE / FALSE / NULL
        // Resolve true and false reserved words to Types\Boolean
        if ($expr instanceof Tolerant\Node\ReservedWord) {
            $token = $expr->children->kind;
            if ($token === Tolerant\TokenKind::TrueReservedWord || $token === Tolerant\TokenKind::FalseReservedWord) {
                return new Types\Boolean;
            }

            if ($token === Tolerant\TokenKind::NullReservedWord) {
                return new Types\Null_;
            }
        }

        // CONSTANT FETCH
        // Resolve constants by retrieving corresponding definition type from FQN
        if (TolerantParserHelpers::isConstantFetch($expr)) {
            $fqn = (string)$expr->getNamespacedName();
            $def = $this->index->getDefinition($fqn, true);
            if ($def !== null) {
                return $def->type;
            }
        }

        // MEMBER ACCESS EXPRESSION
        if ($expr instanceof Tolerant\Node\Expression\MemberAccessExpression) {
           if ($expr->memberName instanceof Tolerant\Node\Expression) {
               return new Types\Mixed;
           }
           $var = $expr->dereferencableExpression;

           // Resolve object
           $objType = $this->resolveExpressionNodeToType($var);
           if (!($objType instanceof Types\Compound)) {
               $objType = new Types\Compound([$objType]);
           }
           for ($i = 0; $t = $objType->get($i); $i++) {
               if ($t instanceof Types\This) {
                   $classFqn = self::getContainingClassFqn($expr);
                   if ($classFqn === null) {
                       return new Types\Mixed;
                   }
               } else if (!($t instanceof Types\Object_) || $t->getFqsen() === null) {
                   return new Types\Mixed;
               } else {
                   $classFqn = substr((string)$t->getFqsen(), 1);
               }
               $fqn = $classFqn . '->' . $expr->memberName->getText($expr->getFileContents());
               if ($expr->parent instanceof Tolerant\Node\Expression\CallExpression) {
                   $fqn .= '()';
               }
               $def = $this->index->getDefinition($fqn);
               if ($def !== null) {
                   return $def->type;
               }
           }
        }

        // SCOPED PROPERTY ACCESS EXPRESSION
        if ($expr instanceof Tolerant\Node\Expression\ScopedPropertyAccessExpression) {
            $classType = $this->resolveClassNameToType($expr->scopeResolutionQualifier);
            if (!($classType instanceof Types\Object_) || $classType->getFqsen() === null) {
                return new Types\Mixed;
            }
            $fqn = substr((string)$classType->getFqsen(), 1) . '::';

            // TODO is there a cleaner way to do this?
            $fqn .= $expr->memberName->getText() ?? $expr->memberName->getText($expr->getFileContents());
            if ($expr->parent instanceof Tolerant\Node\Expression\CallExpression) {
                $fqn .= '()';
            }
            
            $def = $this->index->getDefinition($fqn);
            if ($def === null) {
                return new Types\Mixed;
            }
            return $def->type;
        }

        // OBJECT CREATION EXPRESSION
        //   new A() => resolves to the type of the class type designator (A)
        //   TODO: new $this->a => resolves to the string represented by "a"
        if ($expr instanceof Tolerant\Node\Expression\ObjectCreationExpression) {
            return $this->resolveClassNameToType($expr->classTypeDesignator);
        }

        // CLONE EXPRESSION
        //   clone($a) => resolves to the type of $a
        if ($expr instanceof Tolerant\Node\Expression\CloneExpression) {
            return $this->resolveExpressionNodeToType($expr->expression);
        }

        // ASSIGNMENT EXPRESSION
        //   $a = $myExpression => resolves to the type of the right-hand operand 
        if ($expr instanceof Tolerant\Node\Expression\AssignmentExpression) {
            return $this->resolveExpressionNodeToType($expr->rightOperand);
        }

        // TERNARY EXPRESSION
        //   $condition ? $ifExpression : $elseExpression => reslves to type of $ifCondition or $elseExpression
        //   $condition ?: $elseExpression => resolves to type of $condition or $elseExpression 
        if ($expr instanceof Tolerant\Node\Expression\TernaryExpression) {
            // ?:
            if ($expr->ifExpression === null) {
                return new Types\Compound([
                    $this->resolveExpressionNodeToType($expr->condition), // TODO: why?
                    $this->resolveExpressionNodeToType($expr->elseExpression)
                ]);
            }
            // Ternary is a compound of the two possible values
            return new Types\Compound([
                $this->resolveExpressionNodeToType($expr->ifExpression),
                $this->resolveExpressionNodeToType($expr->elseExpression)
            ]);
        }

        // NULL COALLESCE
        //   $rightOperand ?? $leftOperand => resolves to type of $rightOperand or $leftOperand
        if ($expr instanceof Tolerant\Node\Expression\BinaryExpression && $expr->operator->kind === Tolerant\TokenKind::QuestionQuestionToken) {
            // ?? operator
            return new Types\Compound([
                $this->resolveExpressionNodeToType($expr->leftOperand),
                $this->resolveExpressionNodeToType($expr->rightOperand)
            ]);
        }

        // BOOLEAN EXPRESSIONS: resolve to Types\Boolean
        //   (bool) $expression
        //   !$expression
        //   empty($var)
        //   isset($var)
        //   >, >=, <, <=, &&, ||, AND, OR, XOR, ==, ===, !=, !==
        if (
            TolerantParserHelpers::isBooleanExpression($expr)

            || ($expr instanceof Tolerant\Node\Expression\CastExpression && $expr->castType->kind === Tolerant\TokenKind::BoolCastToken)
            || ($expr instanceof Tolerant\Node\Expression\UnaryOpExpression && $expr->operator->kind === Tolerant\TokenKind::ExclamationToken)
            || $expr instanceof Tolerant\Node\Expression\EmptyIntrinsicExpression
            || $expr instanceof Tolerant\Node\Expression\IssetIntrinsicExpression
        ) {
            return new Types\Boolean;
        }

        // STRING EXPRESSIONS: resolve to Types\String
        //   [concatenation] .=, .
        //   [literals] "hello", \b"hello", \B"hello", 'hello', \b'hello', HEREDOC, NOWDOC
        //   [cast] (string) "hello"
        //
        //   TODO: Magic constants (__CLASS__, __DIR__, __FUNCTION__, __METHOD__, __NAMESPACE__, __TRAIT__, __FILE__)
        if (
            ($expr instanceof Tolerant\Node\Expression\BinaryExpression &&
                ($expr->operator->kind === Tolerant\TokenKind::DotToken || $expr->operator->kind === Tolerant\TokenKind::DotEqualsToken)) ||
            $expr instanceof Tolerant\Node\StringLiteral ||
            ($expr instanceof Tolerant\Node\Expression\CastExpression && $expr->castType->kind === Tolerant\TokenKind::StringCastToken)
        ) {
            return new Types\String_;
        }

        // BINARY EXPRESSIONS: 
        // Resolve to Types\Integer if both left and right operands are integer types, otherwise Types\Float
        //   [operator] +, -, *, **
        //   [assignment] *=, **=, -=, +=
        // Resolve to Types\Float
        //   [assignment] /=
        if (
            $expr instanceof Tolerant\Node\Expression\BinaryExpression &&
            ($operator = $expr->operator->kind)
            && ($operator === Tolerant\TokenKind::PlusToken ||
                $operator === Tolerant\TokenKind::AsteriskAsteriskToken ||
                $operator === Tolerant\TokenKind::AsteriskToken ||
                $operator === Tolerant\TokenKind::MinusToken ||

                // Assignment expressions (TODO: consider making this a type of AssignmentExpression rather than kind of BinaryExpression)
                $operator === Tolerant\TokenKind::AsteriskEqualsToken||
                $operator === Tolerant\TokenKind::AsteriskAsteriskEqualsToken ||
                $operator === Tolerant\TokenKind::MinusEqualsToken ||
                $operator === Tolerant\TokenKind::PlusEqualsToken
            )
        ) {
            if (
                $this->resolveExpressionNodeToType($expr->leftOperand) instanceof Types\Integer
                && $this->resolveExpressionNodeToType($expr->rightOperand) instanceof Types\Integer
            ) {
                return new Types\Integer;
            }
            return new Types\Float_;
        } else if (
            $expr instanceof Tolerant\Node\Expression\BinaryExpression &&
            $expr->operator->kind === Tolerant\TokenKind::SlashEqualsToken
        ) {
            return new Types\Float_;
        }

        // INTEGER EXPRESSIONS: resolve to Types\Integer
        //   [literal] 1
        //   [operator] <=>, &, ^, |
        //   TODO: Magic constants (__LINE__)
        if (
            // TODO: consider different Node types of float/int, also better property name (not "children")
            ($expr instanceof Tolerant\Node\NumericLiteral && $expr->children->kind === Tolerant\TokenKind::IntegerLiteralToken) ||
            $expr instanceof Tolerant\Node\Expression\BinaryExpression && (
                ($operator = $expr->operator->kind)
                && ($operator === Tolerant\TokenKind::LessThanEqualsGreaterThanToken ||
                    $operator === Tolerant\TokenKind::AmpersandToken ||
                    $operator === Tolerant\TokenKind::CaretToken ||
                    $operator === Tolerant\TokenKind::BarToken)
            )
        ) {
            return new Types\Integer;
        }

        // FLOAT EXPRESSIONS: resolve to Types\Float
        //   [literal] 1.5
        //   [operator] /
        //   [cast] (double)
        if (
            $expr instanceof Tolerant\Node\NumericLiteral && $expr->children->kind === Tolerant\TokenKind::FloatingLiteralToken ||
            ($expr instanceof Tolerant\Node\Expression\CastExpression && $expr->castType->kind === Tolerant\TokenKind::DoubleCastToken) ||
            ($expr instanceof Tolerant\Node\Expression\BinaryExpression && $expr->operator->kind === Tolerant\TokenKind::SlashToken)
        ) {
            return new Types\Float_;
        }

        // ARRAY CREATION EXPRESSION:
        // Resolve to Types\Array (Types\Compound of value and key types)
        //  [a, b, c]
        //  [1=>"hello", "hi"=>1, 4=>[]]s
        if ($expr instanceof Tolerant\Node\Expression\ArrayCreationExpression) {
            $valueTypes = [];
            $keyTypes = [];
            if ($expr->arrayElements !== null) {
                foreach ($expr->arrayElements->getElements() as $item) {
                    $valueTypes[] = $this->resolveExpressionNodeToType($item->elementValue);
                    $keyTypes[] = $item->elementKey ? $this->resolveExpressionNodeToType($item->elementKey) : new Types\Integer;
                }
            }
            $valueTypes = array_unique($keyTypes);
            $keyTypes = array_unique($keyTypes);
            if (empty($valueTypes)) {
                $valueType = null;
            } else if (count($valueTypes) === 1) {
                $valueType = $valueTypes[0];
            } else {
                $valueType = new Types\Compound($valueTypes);
            }
            if (empty($keyTypes)) {
                $keyType = null;
            } else if (count($keyTypes) === 1) {
                $keyType = $keyTypes[0];
            } else {
                $keyType = new Types\Compound($keyTypes);
            }
            return new Types\Array_($valueType, $keyType);
        }

        // SUBSCRIPT EXPRESSION
        // $myArray[3]
        // $myArray{"hello"}
        if ($expr instanceof Tolerant\Node\Expression\SubscriptExpression) {
            $varType = $this->resolveExpressionNodeToType($expr->postfixExpression);
            if (!($varType instanceof Types\Array_)) {
                return new Types\Mixed;
            }
            return $varType->getValueType();
        }

        // SCRIPT INCLUSION EXPRESSION
        //   include, require, include_once, require_once
        if ($expr instanceof Tolerant\Node\Expression\ScriptInclusionExpression) {
            // TODO: resolve path to PhpDocument and find return statement
            return new Types\Mixed;
        }

        if ($expr instanceof Tolerant\Node\QualifiedName) {
            return $this->resolveClassNameToType($expr);
        }

        return new Types\Mixed;
    }


    /**
     * Takes any class name node (from a static method call, or new node) and returns a Type object
     * Resolves keywords like self, static and parent
     *
     * @param Tolerant\Node || Tolerant\Token $class
     * @return Type
     */
    public function resolveClassNameToType($class): Type
    {
        if ($class instanceof Tolerant\Node\Expression) {
            return new Types\Mixed;
        }
        if ($class instanceof Tolerant\Token && $class->kind === Tolerant\TokenKind::ClassKeyword) {
            // Anonymous class
            return new Types\Object_;
        }
        $className = (string)$class->getResolvedName();

        if ($className === 'static') {
            return new Types\Static_;
        }
        if ($className === 'self' || $className === 'parent') {
            $classNode = $class->getFirstAncestor(Tolerant\Node\Statement\ClassDeclaration::class);
            if ($className === 'parent') {
                if ($classNode === null || $classNode->classBaseClause === null) {
                    return new Types\Object_;
                }
                // parent is resolved to the parent class
                $classFqn = (string)$classNode->classBaseClause->baseClass->getResolvedName();
            } else {
                if ($classNode === null) {
                    return new Types\Self_;
                }
                // self is resolved to the containing class
                $classFqn = (string)$classNode->getNamespacedName();
            }
            return new Types\Object_(new Fqsen('\\' . $classFqn));
        }
        return new Types\Object_(new Fqsen('\\' . $className));
    }

    /**
     * Returns the type a reference to this symbol will resolve to.
     * For properties and constants, this is the type of the property/constant.
     * For functions and methods, this is the return type.
     * For parameters, this is the type of the parameter.
     * For classes and interfaces, this is the class type (object).
     * For variables / assignments, this is the documented type or type the assignment resolves to.
     * Can also be a compound type.
     * If it is unknown, will be Types\Mixed.
     * Returns null if the node does not have a type.
     *
     * @param Tolerant\Node $node
     * @return \phpDocumentor\Reflection\Type|null
     */
    public function getTypeFromNode($node)
    {
        // PARAMETERS
        // Get the type of the parameter:
        //   1. Doc block
        //   2. Parameter type and default
        if ($node instanceof Tolerant\Node\Parameter) {
            // Parameters
            // Get the doc block for the the function call
            // /**
            //  * @param MyClass $myParam
            //  */
            //  function foo($a)
            $functionLikeDeclaration = TolerantParserHelpers::getFunctionLikeDeclarationFromParameter($node);
            $variableName = $node->getName();
            $docBlock = $this->getDocBlock($functionLikeDeclaration);

            $parameterDocBlockTag = $this->tryGetDocBlockTagForParameter($docBlock, $variableName);
            if ($parameterDocBlockTag !== null && ($type = $parameterDocBlockTag->getType())) {
                // Doc block comments supercede all other forms of type inference
                return $type;
            }

            // function foo(MyClass $a)
            if ($node->typeDeclaration !== null) {
                // Use PHP7 return type hint
                if ($node->typeDeclaration instanceof Tolerant\Token) {
                    // Resolve a string like "bool" to a type object
                    $type = $this->typeResolver->resolve($node->typeDeclaration->getText($node->getFileContents()));
                } else {
                    $type = new Types\Object_(new Fqsen('\\' . (string)$node->typeDeclaration->getResolvedName()));
                }
            }
            // function foo($a = 3)
            if ($node->default !== null) {
                $defaultType = $this->resolveExpressionNodeToType($node->default);
                if (isset($type) && !is_a($type, get_class($defaultType))) {
                    // TODO - verify it is worth creating a compound type
                    return new Types\Compound([$type, $defaultType]);
                }
                $type = $defaultType;
            }
            return $type ?? new Types\Mixed;
        }

        // FUNCTIONS AND METHODS
        // Get the return type
        //   1. doc block
        //   2. return type hint
        //   3. TODO: infer from return statements
        if (TolerantParserHelpers::isFunctionLike($node)) {
            // Functions/methods
            $docBlock = $this->getDocBlock($node);
            if (
                $docBlock !== null
                && !empty($returnTags = $docBlock->getTagsByName('return'))
                && $returnTags[0]->getType() !== null
            ) {
                // Use @return tag
                return $returnTags[0]->getType();
            }
            if ($node->returnType !== null && !($node->returnType instanceof Tolerant\MissingToken)) {
                // Use PHP7 return type hint
                if ($node->returnType instanceof Tolerant\Token) {
                    // Resolve a string like "bool" to a type object
                    return $this->typeResolver->resolve($node->returnType->getText($node->getFileContents()));
                }
                return new Types\Object_(new Fqsen('\\' . (string)$node->returnType->getResolvedName()));
            }
            // Unknown return type
            return new Types\Mixed;
        }

        // PROPERTIES, CONSTS, CLASS CONSTS, ASSIGNMENT EXPRESSIONS
        // Get the documented type the assignment resolves to.
        if (
            ($declarationNode = 
                TolerantParserHelpers::tryGetPropertyDeclaration($node) ?? 
                TolerantParserHelpers::tryGetConstOrClassConstDeclaration($node)
            ) !== null ||
            ($node = $node->parent) instanceof Tolerant\Node\Expression\AssignmentExpression)
        {
            $declarationNode = $declarationNode ?? $node;

            // Property, constant or variable
            // Use @var tag
            if (
                ($docBlock = $this->getDocBlock($declarationNode))
                && !empty($varTags = $docBlock->getTagsByName('var'))
                && ($type = $varTags[0]->getType())
            ) {
                return $type;
            }

            // Resolve the expression
            if ($declarationNode instanceof Tolerant\Node\PropertyDeclaration) {
                // TODO should have default
                if (isset($node->parent->rightOperand)) {
                    return $this->resolveExpressionNodeToType($node->parent->rightOperand);
                }
            } else if ($node instanceof Tolerant\Node\ConstElement) {
                return $this->resolveExpressionNodeToType($node->assignment);
            } else if ($node instanceof Tolerant\Node\Expression\AssignmentExpression) {
                return $this->resolveExpressionNodeToType($node->rightOperand);
            }
            // TODO: read @property tags of class
            // TODO: Try to infer the type from default value / constant value
            // Unknown
            return new Types\Mixed;
        }

        // The node does not have a type
        return null;
    }

    /**
     * Returns the fully qualified name (FQN) that is defined by a node
     * Returns null if the node does not declare any symbol that can be referenced by an FQN
     *
     * @param Tolerant\Node $node
     * @return string|null
     */
    public static function getDefinedFqn($node)
    {
        $parent = $node->parent;
        // Anonymous classes don't count as a definition
        // INPUT                    OUTPUT:
        // namespace A\B;
        // class C { }              A\B\C
        // interface C { }          A\B\C
        // trait C { }              A\B\C
        if (
            $node instanceof Tolerant\Node\Statement\ClassDeclaration ||
            $node instanceof Tolerant\Node\Statement\InterfaceDeclaration ||
            $node instanceof Tolerant\Node\Statement\TraitDeclaration
        ) {
            return (string) $node->getNamespacedName();
        }

        // INPUT                   OUTPUT:
        // namespace A\B;           A\B
        else if ($node instanceof Tolerant\Node\Statement\NamespaceDefinition && $node->name instanceof Tolerant\Node\QualifiedName) {
            $name = (string) Tolerant\ResolvedName::buildName($node->name->nameParts, $node->getFileContents());
            return \count($name) > 0 ? $name : null;
        }
        // INPUT                   OUTPUT:
        // namespace A\B;
        // function a();           A\B\a();
        else if ($node instanceof Tolerant\Node\Statement\FunctionDeclaration) {
            // Function: use functionName() as the name
            $name = (string)$node->getNamespacedName();
            return \count($name) > 0 ? $name . '()' : null;
        }
        // INPUT                        OUTPUT
        // namespace A\B;
        // class C {
        //   function a () {}           A\B\C::a()
        //   static function b() {}     A\B\C->b()
        // }
        else if ($node instanceof Tolerant\Node\MethodDeclaration) {
            // Class method: use ClassName->methodName() as name
            $class = $node->getFirstAncestor(
                Tolerant\Node\Expression\ObjectCreationExpression::class,
                Tolerant\Node\Statement\ClassDeclaration::class,
                Tolerant\Node\Statement\InterfaceDeclaration::class,
                Tolerant\Node\Statement\TraitDeclaration::class
            );
            if (!isset($class->name)) {
                // Ignore anonymous classes
                return null;
            }
            if ($node->isStatic()) {
                return (string)$class->getNamespacedName() . '::' . $node->getName() . '()';
            } else {
                return (string)$class->getNamespacedName() . '->' . $node->getName() . '()';
            }
        }

        // INPUT                        OUTPUT
        // namespace A\B;
        // class C {
        //   static $a = 4, $b = 4      A\B\C::$a, A\B\C::$b
        //   $a = 4, $b = 4             A\B\C->$a, A\B\C->$b
        // }
        else if (
            ($propertyDeclaration = TolerantParserHelpers::tryGetPropertyDeclaration($node)) !== null &&
            ($classDeclaration =
                $node->getFirstAncestor(
                    Tolerant\Node\Expression\ObjectCreationExpression::class,
                    Tolerant\Node\Statement\ClassDeclaration::class,
                    Tolerant\Node\Statement\InterfaceDeclaration::class,
                    Tolerant\Node\Statement\TraitDeclaration::class
                )
            ) !== null && isset($classDeclaration->name))
        {
            $name = $node->getName();
            if ($propertyDeclaration->isStatic()) {
                // Static Property: use ClassName::$propertyName as name
                return (string)$classDeclaration->getNamespacedName() . '::$' . $name;
            }

            // Instance Property: use ClassName->propertyName as name
            return (string)$classDeclaration->getNamespacedName() . '->' . $name;
        }

        // INPUT                        OUTPUT
        // namespace A\B;
        // const FOO = 5;               A\B\FOO
        // class C {
        //   const $a, $b = 4           A\B\C::$a(), A\B\C::$b
        // }
        else if (($constDeclaration = TolerantParserHelpers::tryGetConstOrClassConstDeclaration($node)) !== null) {
            if ($constDeclaration instanceof Tolerant\Node\Statement\ConstDeclaration) {
                // Basic constant: use CONSTANT_NAME as name
                return (string)$node->getNamespacedName();
            }

            // Class constant: use ClassName::CONSTANT_NAME as name
            $classDeclaration = $constDeclaration->getFirstAncestor(
                Tolerant\Node\Expression\ObjectCreationExpression::class,
                Tolerant\Node\Statement\ClassDeclaration::class,
                Tolerant\Node\Statement\InterfaceDeclaration::class,
                Tolerant\Node\Statement\TraitDeclaration::class
            );

            if (!isset($classDeclaration->name)) {
                return null;
            }
            return (string)$classDeclaration->getNamespacedName() . '::' . $node->getName();
        }

        return null;
    }

    /**
     * @param DocBlock | null $docBlock
     * @param $variableName
     * @return DocBlock\Tags\Param | null
     */
    private function tryGetDocBlockTagForParameter($docBlock, $variableName) {
        if ($docBlock === null) {
            return null;
        }
        $tags = $docBlock->getTagsByName('param');
        foreach ($tags as $tag) {
            if ($tag->getVariableName() === \ltrim($variableName, "$")) {
                return $tag;
            }
        }
    }
}