dt-sql-parser 4.1.0-beta.6 → 4.1.0-beta.7

package/dist/parser/common/basicSQL.d.ts

@@ -94,6 +94,10 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      * @returns syntax errors
      */
     validate(input: string): ParseError[];
+    /**
+     * Get the input string that has been parsed.
+     */
+    getParsedInput(): string;
     /**
      * Get all Tokens of input string，'<EOF>' is not included.
      * @param input source string
@@ -111,6 +115,19 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      * @param input source string
      */
     splitSQLByStatement(input: string): TextSlice[] | null;
+    /**
+     * Get a minimum boundary parser near tokenIndex.
+     * @param input source string.
+     * @param tokenIndex start from which index to minimize the boundary.
+     * @param originParseTree the parse tree need to be minimized, default value is the result of parsing `input`.
+     * @returns minimum parser info
+     */
+    getMinimumParserInfo(input: string, tokenIndex: number, originParseTree?: ParserRuleContext | null): {
+        parser: P;
+        parseTree: ParserRuleContext;
+        tokenIndexOffset: number;
+        newTokenIndex: number;
+    } | null;
     /**
      * Get suggestions of syntax and token at caretPosition
      * @param input source string

package/dist/parser/common/basicSQL.js

@@ -109,6 +109,12 @@ export class BasicSQL {
         this.parseWithCache(input);
         return this._parseErrors;
     }
+    /**
+     * Get the input string that has been parsed.
+     */
+    getParsedInput() {
+        return this._parsedInput;
+    }
     /**
      * Get all Tokens of input string，'<EOF>' is not included.
      * @param input source string
@@ -149,31 +155,31 @@ export class BasicSQL {
         return res;
     }
     /**
-     * Get suggestions of syntax and token at caretPosition
-     * @param input source string
-     * @param caretPosition caret position, such as cursor position
-     * @returns suggestion
+     * Get a minimum boundary parser near tokenIndex.
+     * @param input source string.
+     * @param tokenIndex start from which index to minimize the boundary.
+     * @param originParseTree the parse tree need to be minimized, default value is the result of parsing `input`.
+     * @returns minimum parser info
      */
-    getSuggestionAtCaretPosition(input, caretPosition) {
+    getMinimumParserInfo(input, tokenIndex, originParseTree) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        const splitListener = this.splitListener;
-        this.parseWithCache(input);
-        if (!this._parseTree)
-            return null;
-        let sqlParserIns = this._parser;
-        const allTokens = this.getAllTokens(input);
-        let caretTokenIndex = findCaretTokenIndex(caretPosition, allTokens);
-        let c3Context = this._parseTree;
-        let tokenIndexOffset = 0;
-        if (!caretTokenIndex && caretTokenIndex !== 0)
+        if (arguments.length <= 2) {
+            this.parseWithCache(input);
+            originParseTree = this._parseTree;
+        }
+        if (!originParseTree || !(input === null || input === void 0 ? void 0 : input.length))
             return null;
+        const splitListener = this.splitListener;
         /**
          * Split sql by statement.
          * Try to collect candidates in as small a range as possible.
          */
-        this.listen(splitListener, this._parseTree);
+        this.listen(splitListener, originParseTree);
         const statementCount = (_a = splitListener.statementsContext) === null || _a === void 0 ? void 0 : _a.length;
         const statementsContext = splitListener.statementsContext;
+        let tokenIndexOffset = 0;
+        let sqlParserIns = this._parser;
+        let parseTree = originParseTree;
         // If there are multiple statements.
         if (statementCount > 1) {
             /**
@@ -194,12 +200,12 @@ export class BasicSQL {
                  */
                 const isPrevCtxValid = index === 0 || !((_b = statementsContext[index - 1]) === null || _b === void 0 ? void 0 : _b.exception);
                 const isNextCtxValid = index === statementCount - 1 || !((_c = statementsContext[index + 1]) === null || _c === void 0 ? void 0 : _c.exception);
-                if (ctx.stop && ctx.stop.tokenIndex < caretTokenIndex && isPrevCtxValid) {
+                if (ctx.stop && ctx.stop.tokenIndex < tokenIndex && isPrevCtxValid) {
                     startStatement = ctx;
                 }
                 if (ctx.start &&
                     !stopStatement &&
-                    ctx.start.tokenIndex > caretTokenIndex &&
+                    ctx.start.tokenIndex > tokenIndex &&
                     isNextCtxValid) {
                     stopStatement = ctx;
                     break;
@@ -213,7 +219,7 @@ export class BasicSQL {
              * compared to the tokenIndex in the whole input
              */
             tokenIndexOffset = (_j = (_h = startStatement === null || startStatement === void 0 ? void 0 : startStatement.start) === null || _h === void 0 ? void 0 : _h.tokenIndex) !== null && _j !== void 0 ? _j : 0;
-            caretTokenIndex = caretTokenIndex - tokenIndexOffset;
+            tokenIndex = tokenIndex - tokenIndexOffset;
             /**
              * Reparse the input fragment，
              * and c3 will collect candidates in the newly generated parseTree.
@@ -229,12 +235,37 @@ export class BasicSQL {
             parser.buildParseTrees = true;
             parser.errorHandler = new ErrorStrategy();
             sqlParserIns = parser;
-            c3Context = parser.program();
+            parseTree = parser.program();
         }
+        return {
+            parser: sqlParserIns,
+            parseTree,
+            tokenIndexOffset,
+            newTokenIndex: tokenIndex,
+        };
+    }
+    /**
+     * Get suggestions of syntax and token at caretPosition
+     * @param input source string
+     * @param caretPosition caret position, such as cursor position
+     * @returns suggestion
+     */
+    getSuggestionAtCaretPosition(input, caretPosition) {
+        this.parseWithCache(input);
+        if (!this._parseTree)
+            return null;
+        const allTokens = this.getAllTokens(input);
+        let caretTokenIndex = findCaretTokenIndex(caretPosition, allTokens);
+        if (!caretTokenIndex && caretTokenIndex !== 0)
+            return null;
+        const minimumParser = this.getMinimumParserInfo(input, caretTokenIndex);
+        if (!minimumParser)
+            return null;
+        const { parser: sqlParserIns, tokenIndexOffset, newTokenIndex, parseTree: c3Context, } = minimumParser;
         const core = new CodeCompletionCore(sqlParserIns);
         core.preferredRules = this.preferredRules;
-        const candidates = core.collectCandidates(caretTokenIndex, c3Context);
-        const originalSuggestions = this.processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset);
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
+        const originalSuggestions = this.processCandidates(candidates, allTokens, newTokenIndex, tokenIndexOffset);
         const syntaxSuggestions = originalSuggestions.syntax.map((syntaxCtx) => {
             const wordRanges = syntaxCtx.wordRanges.map((token) => {
                 return tokenToWord(token, this._parsedInput);

package/dist/parser/common/parseErrorListener.d.ts

@@ -1,5 +1,5 @@
 import { Token, Recognizer, ANTLRErrorListener, RecognitionException, ATNSimulator, Parser } from 'antlr4ng';
-import { LOCALE_TYPE } from './types';
+import { BasicSQL } from './basicSQL';
 /**
  * Converted from {@link SyntaxError}.
  */
@@ -32,8 +32,10 @@ export interface SyntaxError {
 export type ErrorListener = (parseError: ParseError, originalError: SyntaxError) => void;
 export declare abstract class ParseErrorListener implements ANTLRErrorListener {
     private _errorListener;
-    private locale;
-    constructor(errorListener: ErrorListener, locale?: LOCALE_TYPE);
+    protected preferredRules: Set<number>;
+    protected get locale(): import("./types").LOCALE_TYPE;
+    protected parserContext: BasicSQL;
+    constructor(errorListener: ErrorListener, parserContext: BasicSQL, preferredRules: Set<number>);
     reportAmbiguity(): void;
     reportAttemptingFullContext(): void;
     reportContextSensitivity(): void;

package/dist/parser/common/parseErrorListener.js

@@ -1,8 +1,12 @@
 import { Token, LexerNoViableAltException, InputMismatchException, NoViableAltException, } from 'antlr4ng';
 import { transform } from './transform';
 export class ParseErrorListener {
-    constructor(errorListener, locale = 'en_US') {
-        this.locale = locale;
+    get locale() {
+        return this.parserContext.locale;
+    }
+    constructor(errorListener, parserContext, preferredRules) {
+        this.parserContext = parserContext;
+        this.preferredRules = preferredRules;
         this._errorListener = errorListener;
     }
     reportAmbiguity() { }

package/dist/parser/flink/flinkErrorListener.d.ts

@@ -1,9 +1,6 @@
-import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
+import { ParseErrorListener } from '../common/parseErrorListener';
 import { Parser, Token } from 'antlr4ng';
-import { LOCALE_TYPE } from '../common/types';
 export declare class FlinkErrorListener extends ParseErrorListener {
-    private preferredRules;
     private objectNames;
-    constructor(errorListener: ErrorListener, preferredRules: Set<number>, locale: LOCALE_TYPE);
     getExpectedText(parser: Parser, token: Token): string;
 }

package/dist/parser/flink/flinkErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { FlinkSqlParser } from '../../lib/flink/FlinkSqlParser';
 export class FlinkErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [FlinkSqlParser.RULE_catalogPath, 'catalog'],
             [FlinkSqlParser.RULE_catalogPathCreate, 'catalog'],
@@ -18,18 +18,27 @@ export class FlinkErrorListener extends ParseErrorListener {
             [FlinkSqlParser.RULE_columnName, 'column'],
             [FlinkSqlParser.RULE_columnNameCreate, 'column'],
         ]);
-        this.preferredRules = preferredRules;
     }
     getExpectedText(parser, token) {
         var _a;
         let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        /**
+         * Get the program context.
+         * When called error listener, `this._parseTree` is still `undefined`,
+         * so we can't use cached parseTree in `getMinimumParserInfo`
+         */
         let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
         while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
             currentContext = currentContext.parent;
         }
-        const core = new CodeCompletionCore(parser);
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
         core.preferredRules = this.preferredRules;
-        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
         if (candidates.rules.size) {
             const result = [];
             // get expectedText as collect rules first

package/dist/parser/flink/index.js

@@ -33,7 +33,8 @@ export class FlinkSQL extends BasicSQL {
         return new FlinkSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new FlinkErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new FlinkErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     createEntityCollector(input, caretTokenIndex) {
         return new FlinkEntityCollector(input, caretTokenIndex);

package/dist/parser/hive/hiveErrorListener.d.ts

@@ -1,9 +1,6 @@
-import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
+import { ParseErrorListener } from '../common/parseErrorListener';
 import { Parser, Token } from 'antlr4ng';
-import { LOCALE_TYPE } from '../common/types';
 export declare class HiveErrorListener extends ParseErrorListener {
-    private preferredRules;
     private objectNames;
-    constructor(errorListener: ErrorListener, preferredRules: Set<number>, locale: LOCALE_TYPE);
     getExpectedText(parser: Parser, token: Token): string;
 }

package/dist/parser/hive/hiveErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { HiveSqlParser } from '../../lib/hive/HiveSqlParser';
 export class HiveErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [HiveSqlParser.RULE_dbSchemaName, 'database'],
             [HiveSqlParser.RULE_dbSchemaNameCreate, 'database'],
@@ -17,18 +17,27 @@ export class HiveErrorListener extends ParseErrorListener {
             [HiveSqlParser.RULE_columnName, 'column'],
             [HiveSqlParser.RULE_columnNameCreate, 'column'],
         ]);
-        this.preferredRules = preferredRules;
     }
     getExpectedText(parser, token) {
         var _a;
         let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        /**
+         * Get the program context.
+         * When called error listener, `this._parseTree` is still `undefined`,
+         * so we can't use cached parseTree in `getMinimumParserInfo`
+         */
         let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
         while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
             currentContext = currentContext.parent;
         }
-        const core = new CodeCompletionCore(parser);
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
         core.preferredRules = this.preferredRules;
-        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
         if (candidates.rules.size) {
             const result = [];
             // get expectedText as collect rules first

package/dist/parser/hive/index.js

@@ -33,7 +33,8 @@ export class HiveSQL extends BasicSQL {
         return new HiveSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new HiveErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new HiveErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     createEntityCollector(input, caretTokenIndex) {
         return new HiveEntityCollector(input, caretTokenIndex);

package/dist/parser/impala/ImpalaErrorListener.d.ts

@@ -1,9 +1,6 @@
-import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
+import { ParseErrorListener } from '../common/parseErrorListener';
 import { Parser, Token } from 'antlr4ng';
-import { LOCALE_TYPE } from '../common/types';
 export declare class ImpalaErrorListener extends ParseErrorListener {
-    private preferredRules;
     private objectNames;
-    constructor(errorListener: ErrorListener, preferredRules: Set<number>, locale: LOCALE_TYPE);
     getExpectedText(parser: Parser, token: Token): string;
 }

package/dist/parser/impala/ImpalaErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { ImpalaSqlParser } from '../../lib/impala/ImpalaSqlParser';
 export class ImpalaErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [ImpalaSqlParser.RULE_databaseNamePath, 'database'],
             [ImpalaSqlParser.RULE_databaseNameCreate, 'database'],
@@ -16,18 +16,27 @@ export class ImpalaErrorListener extends ParseErrorListener {
             [ImpalaSqlParser.RULE_columnNamePath, 'column'],
             [ImpalaSqlParser.RULE_columnNamePathCreate, 'column'],
         ]);
-        this.preferredRules = preferredRules;
     }
     getExpectedText(parser, token) {
         var _a;
         let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        /**
+         * Get the program context.
+         * When called error listener, `this._parseTree` is still `undefined`,
+         * so we can't use cached parseTree in `getMinimumParserInfo`
+         */
         let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
         while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
             currentContext = currentContext.parent;
         }
-        const core = new CodeCompletionCore(parser);
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
         core.preferredRules = this.preferredRules;
-        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
         if (candidates.rules.size) {
             const result = [];
             // get expectedText as collect rules first

package/dist/parser/impala/index.js

@@ -32,7 +32,8 @@ export class ImpalaSQL extends BasicSQL {
         return new ImpalaSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new ImpalaErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new ImpalaErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     createEntityCollector(input, caretTokenIndex) {
         return new ImpalaEntityCollector(input, caretTokenIndex);

package/dist/parser/mysql/index.js

@@ -32,7 +32,8 @@ export class MySQL extends BasicSQL {
         return new MysqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new MysqlErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new MysqlErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     createEntityCollector(input, caretTokenIndex) {
         return new MySqlEntityCollector(input, caretTokenIndex);

package/dist/parser/mysql/mysqlErrorListener.d.ts

@@ -1,9 +1,6 @@
-import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
+import { ParseErrorListener } from '../common/parseErrorListener';
 import { Parser, Token } from 'antlr4ng';
-import { LOCALE_TYPE } from '../common/types';
 export declare class MysqlErrorListener extends ParseErrorListener {
-    private preferredRules;
     private objectNames;
-    constructor(errorListener: ErrorListener, preferredRules: Set<number>, locale: LOCALE_TYPE);
     getExpectedText(parser: Parser, token: Token): string;
 }

package/dist/parser/mysql/mysqlErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { MySqlParser } from '../../lib/mysql/MySqlParser';
 export class MysqlErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [MySqlParser.RULE_databaseName, 'database'],
             [MySqlParser.RULE_databaseNameCreate, 'database'],
@@ -16,18 +16,27 @@ export class MysqlErrorListener extends ParseErrorListener {
             [MySqlParser.RULE_columnName, 'column'],
             [MySqlParser.RULE_columnNameCreate, 'column'],
         ]);
-        this.preferredRules = preferredRules;
     }
     getExpectedText(parser, token) {
         var _a;
         let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        /**
+         * Get the program context.
+         * When called error listener, `this._parseTree` is still `undefined`,
+         * so we can't use cached parseTree in `getMinimumParserInfo`
+         */
         let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
         while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
             currentContext = currentContext.parent;
         }
-        const core = new CodeCompletionCore(parser);
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
         core.preferredRules = this.preferredRules;
-        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
         if (candidates.rules.size) {
             const result = [];
             // get expectedText as collect rules first

package/dist/parser/postgresql/index.js

@@ -36,7 +36,8 @@ export class PostgreSQL extends BasicSQL {
         return new PostgreSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new PostgreSqlErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new PostgreSqlErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     createEntityCollector(input, caretTokenIndex) {
         return new PostgreSqlEntityCollector(input, caretTokenIndex);

package/dist/parser/postgresql/postgreErrorListener.d.ts

@@ -1,9 +1,6 @@
-import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
+import { ParseErrorListener } from '../common/parseErrorListener';
 import { Parser, Token } from 'antlr4ng';
-import { LOCALE_TYPE } from '../common/types';
 export declare class PostgreSqlErrorListener extends ParseErrorListener {
-    private preferredRules;
     private objectNames;
-    constructor(errorListener: ErrorListener, preferredRules: Set<number>, locale: LOCALE_TYPE);
     getExpectedText(parser: Parser, token: Token): string;
 }

package/dist/parser/postgresql/postgreErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { PostgreSqlParser } from '../../lib/postgresql/PostgreSqlParser';
 export class PostgreSqlErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [PostgreSqlParser.RULE_database_name, 'database'],
             [PostgreSqlParser.RULE_database_name_create, 'database'],
@@ -20,18 +20,27 @@ export class PostgreSqlErrorListener extends ParseErrorListener {
             [PostgreSqlParser.RULE_procedure_name_create, 'procedure'],
             [PostgreSqlParser.RULE_procedure_name, 'procedure'],
         ]);
-        this.preferredRules = preferredRules;
     }
     getExpectedText(parser, token) {
         var _a;
         let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        /**
+         * Get the program context.
+         * When called error listener, `this._parseTree` is still `undefined`,
+         * so we can't use cached parseTree in `getMinimumParserInfo`
+         */
         let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
         while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
             currentContext = currentContext.parent;
         }
-        const core = new CodeCompletionCore(parser);
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
         core.preferredRules = this.preferredRules;
-        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
         if (candidates.rules.size) {
             const result = [];
             // get expectedText as collect rules first

package/dist/parser/spark/index.js

@@ -32,7 +32,8 @@ export class SparkSQL extends BasicSQL {
         return new SparkSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new SparkErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new SparkErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     createEntityCollector(input, caretTokenIndex) {
         return new SparkEntityCollector(input, caretTokenIndex);

package/dist/parser/spark/sparkErrorListener.d.ts

@@ -1,9 +1,6 @@
-import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
+import { ParseErrorListener } from '../common/parseErrorListener';
 import { Parser, Token } from 'antlr4ng';
-import { LOCALE_TYPE } from '../common/types';
 export declare class SparkErrorListener extends ParseErrorListener {
-    private preferredRules;
     private objectNames;
-    constructor(errorListener: ErrorListener, preferredRules: Set<number>, locale: LOCALE_TYPE);
     getExpectedText(parser: Parser, token: Token): string;
 }

package/dist/parser/spark/sparkErrorListener.js

@@ -2,8 +2,8 @@ import { CodeCompletionCore } from 'antlr4-c3';
 import { ParseErrorListener } from '../common/parseErrorListener';
 import { SparkSqlParser } from '../../lib/spark/SparkSqlParser';
 export class SparkErrorListener extends ParseErrorListener {
-    constructor(errorListener, preferredRules, locale) {
-        super(errorListener, locale);
+    constructor() {
+        super(...arguments);
         this.objectNames = new Map([
             [SparkSqlParser.RULE_namespaceName, 'namespace'],
             [SparkSqlParser.RULE_namespaceNameCreate, 'namespace'],
@@ -16,18 +16,27 @@ export class SparkErrorListener extends ParseErrorListener {
             [SparkSqlParser.RULE_columnName, 'column'],
             [SparkSqlParser.RULE_columnNameCreate, 'column'],
         ]);
-        this.preferredRules = preferredRules;
     }
     getExpectedText(parser, token) {
         var _a;
         let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        /**
+         * Get the program context.
+         * When called error listener, `this._parseTree` is still `undefined`,
+         * so we can't use cached parseTree in `getMinimumParserInfo`
+         */
         let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
         while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
             currentContext = currentContext.parent;
         }
-        const core = new CodeCompletionCore(parser);
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
         core.preferredRules = this.preferredRules;
-        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
         if (candidates.rules.size) {
             const result = [];
             // get expectedText as collect rules first

package/dist/parser/trino/index.js

@@ -34,7 +34,8 @@ export class TrinoSQL extends BasicSQL {
         return new TrinoSqlSplitListener();
     }
     createErrorListener(_errorListener) {
-        return new TrinoErrorListener(_errorListener, this.preferredRules, this.locale);
+        const parserContext = this;
+        return new TrinoErrorListener(_errorListener, parserContext, this.preferredRules);
     }
     createEntityCollector(input, caretTokenIndex) {
         return new TrinoEntityCollector(input, caretTokenIndex);

package/dist/parser/trino/trinoErrorListener.d.ts

@@ -1,9 +1,6 @@
 import { Parser, Token } from 'antlr4ng';
-import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
-import { LOCALE_TYPE } from '../common/types';
+import { ParseErrorListener } from '../common/parseErrorListener';
 export declare class TrinoErrorListener extends ParseErrorListener {
-    private preferredRules;
     private objectNames;
-    constructor(errorListener: ErrorListener, preferredRules: Set<number>, locale: LOCALE_TYPE);
     getExpectedText(parser: Parser, token: Token): string;
 }