Method getSuggestionsForNode

packages/expr/src/autocomplete.ts:112–206

* Provides autocomplete suggestions for a specific node in the AST.

(
        ast: Expression,
        node: AnyNode,
        expr: string,
        cursorOffset: number,
        context: SymbolsTable
    )

     * Provides autocomplete suggestions for a specific node in the AST.
     */
    private getSuggestionsForNode(
        ast: Expression,
        node: AnyNode,
        expr: string,
        cursorOffset: number,
        context: SymbolsTable
    ): AutocompleteSuggestions {
        // When the node is an identifier look up the parent to get more context for the suggestions.
        let inferNode: AnyNode = node;
        if (node.type === 'Identifier' || node.type === 'Literal') {
            const parent = findParentNode(node, ast);
            inferNode =
                parent &&
                !['ExpressionStatement', 'LogicalExpression', 'ConditionalExpression'].includes(
                    parent.type
                )
                    ? parent
                    : node;
        }

        switch (inferNode.type) {
            case 'Identifier':
            case 'MemberExpression': {
                const pathParts = this.getSymbolsPathPartsForMemberExpressionNode(
                    inferNode,
                    cursorOffset
                );

                // Fetch suggestions from the symbol table
                const candidatesKeys = context.getMatchingSymbolsKeys(pathParts);

                const suggestions: AutocompleteSymbolSuggestion[] = [];
                for (const candidate of candidatesKeys) {
                    const symbolInfo = context.getSymbolInfo(candidate);
                    if (symbolInfo) {
                        suggestions.push({ type: 'symbol', symbol: symbolInfo });
                    }
                }

                if (suggestions.length === 1) {
                    const lastPathSegment = pathParts.at(-1)?.replace(/\*$/, '');

                    // Return no suggestion when the only match is an exact match of the
                    // typed token.
                    return lastPathSegment !== suggestions[0]?.symbol.definition.name
                        ? suggestions
                        : [];
                }

                return suggestions;
            }
            case 'AssignmentExpression':
            case 'UnaryExpression': {
                // Provide suggestions for binary or logical operators based on the parsed operator
                // of the partial expression (e.g suggest "==" when typing "=" (parsed as AssignmentExpression)).
                return this.getOperatorSuggestionsForNode(ast, inferNode, cursorOffset, context);
            }
            case 'BinaryExpression': {