dt-sql-parser 4.0.1 → 4.1.0-beta.0

package/dist/locale/locale.d.ts

@@ -0,0 +1,41 @@
+declare const i18n: {
+    zh_CN: {
+        stmtInComplete: string;
+        noValidPosition: string;
+        expecting: string;
+        unfinishedMultilineComment: string;
+        unfinishedDoubleQuoted: string;
+        unfinishedSingleQuoted: string;
+        unfinishedTickQuoted: string;
+        noValidInput: string;
+        newObj: string;
+        existingObj: string;
+        new: string;
+        existing: string;
+        orKeyword: string;
+        keyword: string;
+        missing: string;
+        at: string;
+        or: string;
+    };
+    en_US: {
+        stmtInComplete: string;
+        noValidPosition: string;
+        expecting: string;
+        unfinishedMultilineComment: string;
+        unfinishedDoubleQuoted: string;
+        unfinishedSingleQuoted: string;
+        unfinishedTickQuoted: string;
+        noValidInput: string;
+        newObj: string;
+        existingObj: string;
+        new: string;
+        existing: string;
+        orKeyword: string;
+        keyword: string;
+        missing: string;
+        at: string;
+        or: string;
+    };
+};
+export { i18n };

package/dist/locale/locale.js

@@ -0,0 +1,43 @@
+const zh_CN = {
+    stmtInComplete: '语句不完整',
+    noValidPosition: '在此位置无效',
+    expecting: '，期望',
+    unfinishedMultilineComment: '未完成的多行注释',
+    unfinishedDoubleQuoted: '未完成的双引号字符串字变量',
+    unfinishedSingleQuoted: '未完成的单引号字符串字变量',
+    unfinishedTickQuoted: '未完成的反引号引用字符串字变量',
+    noValidInput: '没有有效的输入',
+    newObj: '一个新的对象',
+    existingObj: '一个存在的对象',
+    new: '一个新的',
+    existing: '一个存在的',
+    orKeyword: '或者一个关键字',
+    keyword: '一个关键字',
+    missing: '缺少',
+    at: '在',
+    or: '或者',
+};
+const en_US = {
+    stmtInComplete: 'Statement is incomplete',
+    noValidPosition: 'is not valid at this position',
+    expecting: ', expecting ',
+    unfinishedMultilineComment: 'Unfinished multiline comment',
+    unfinishedDoubleQuoted: 'Unfinished double quoted string literal',
+    unfinishedSingleQuoted: 'Unfinished single quoted string literal',
+    unfinishedTickQuoted: 'Unfinished back tick quoted string literal',
+    noValidInput: 'is no valid input at all',
+    newObj: 'a new object',
+    existingObj: 'an existing object',
+    new: 'a new ',
+    existing: 'an existing ',
+    orKeyword: ' or a keyword',
+    keyword: 'a keyword',
+    missing: 'missing ',
+    at: ' at ',
+    or: ' or ',
+};
+const i18n = {
+    zh_CN,
+    en_US,
+};
+export { i18n };

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

@@ -1,8 +1,8 @@
-import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener } from 'antlr4ng';
+import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener, ANTLRErrorListener } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
 import { SQLParserBase } from '../../lib/SQLParserBase';
 import { TextSlice } from './textAndWord';
-import { CaretPosition, Suggestions } from './types';
+import { CaretPosition, LOCALE_TYPE, Suggestions } from './types';
 import { ParseError, ErrorListener } from './parseErrorListener';
 import type { SplitListener } from './splitListener';
 import type { EntityCollector } from './entityCollector';
@@ -47,10 +47,15 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      * Get a new splitListener instance.
      */
     protected abstract get splitListener(): SplitListener<ParserRuleContext>;
+    /**
+     * Get a new errorListener instance.
+     */
+    protected abstract createErrorListener(errorListener: ErrorListener): ANTLRErrorListener;
     /**
      * Get a new entityCollector instance.
      */
     protected abstract createEntityCollector(input: string, caretTokenIndex?: number): EntityCollector;
+    locale: LOCALE_TYPE;
     /**
      * Create an antlr4 lexer from input.
      * @param input string

package/dist/parser/common/basicSQL.js

@@ -2,7 +2,6 @@ import { CharStreams, CommonTokenStream, ParseTreeWalker, PredictionMode, } from
 import { CodeCompletionCore } from 'antlr4-c3';
 import { findCaretTokenIndex } from './findCaretTokenIndex';
 import { ctxToText, tokenToWord } from './textAndWord';
-import { ParseErrorListener } from './parseErrorListener';
 import { ErrorStrategy } from './errorStrategy';
 /**
  * Basic SQL class, every sql needs extends it.
@@ -14,6 +13,7 @@ export class BasicSQL {
         this._errorListener = (error) => {
             this._parseErrors.push(error);
         };
+        this.locale = 'en_US';
     }
     /**
      * Create an antlr4 lexer from input.
@@ -24,7 +24,7 @@ export class BasicSQL {
         const lexer = this.createLexerFromCharStream(charStreams);
         if (errorListener) {
             lexer.removeErrorListeners();
-            lexer.addErrorListener(new ParseErrorListener(errorListener));
+            lexer.addErrorListener(this.createErrorListener(errorListener));
         }
         return lexer;
     }
@@ -39,7 +39,7 @@ export class BasicSQL {
         parser.interpreter.predictionMode = PredictionMode.SLL;
         if (errorListener) {
             parser.removeErrorListeners();
-            parser.addErrorListener(new ParseErrorListener(errorListener));
+            parser.addErrorListener(this.createErrorListener(errorListener));
         }
         return parser;
     }
@@ -65,7 +65,7 @@ export class BasicSQL {
         this._charStreams = CharStreams.fromString(input);
         this._lexer = this.createLexerFromCharStream(this._charStreams);
         this._lexer.removeErrorListeners();
-        this._lexer.addErrorListener(new ParseErrorListener(this._errorListener));
+        this._lexer.addErrorListener(this.createErrorListener(this._errorListener));
         this._tokenStream = new CommonTokenStream(this._lexer);
         /**
          * All tokens are generated in advance.
@@ -96,7 +96,7 @@ export class BasicSQL {
         const parser = this.createParserWithCache(input);
         this._parsedInput = input;
         parser.removeErrorListeners();
-        parser.addErrorListener(new ParseErrorListener(this._errorListener));
+        parser.addErrorListener(this.createErrorListener(this._errorListener));
         this._parseTree = parser.program();
         return this._parseTree;
     }
@@ -140,9 +140,6 @@ export class BasicSQL {
             return null;
         }
         const splitListener = this.splitListener;
-        // TODO: add splitListener to all sqlParser implements and remove following if
-        if (!splitListener)
-            return null;
         this.listen(splitListener, this._parseTree);
         const res = splitListener.statementsContext
             .map((context) => {
@@ -160,9 +157,6 @@ export class BasicSQL {
     getSuggestionAtCaretPosition(input, caretPosition) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const splitListener = this.splitListener;
-        // TODO: add splitListener to all sqlParser implements and remove following if
-        if (!splitListener)
-            return null;
         this.parseWithCache(input);
         if (!this._parseTree)
             return null;
@@ -261,10 +255,6 @@ export class BasicSQL {
             ? findCaretTokenIndex(caretPosition, allTokens)
             : void 0;
         const collectListener = this.createEntityCollector(input, caretTokenIndex);
-        // TODO: add entityCollector to all sqlParser implements and remove following if
-        if (!collectListener) {
-            return null;
-        }
         // const parser = this.createParserWithCache(input);
         // parser.entityCollecting = true;
         // if(caretPosition) {

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

@@ -1,6 +1,6 @@
-import { ParserRuleContext } from 'antlr4ng';
+import { ParserRuleContext, Token } from 'antlr4ng';
+import { TextPosition, WordPosition, WordRange } from './textAndWord';
 import { EntityContextType } from './types';
-import { WordPosition, TextPosition } from './textAndWord';
 /**
  * TODO: more stmt type should be supported.
  */
@@ -13,7 +13,8 @@ export declare enum StmtContextType {
     CREATE_VIEW_STMT = "createViewStmt",
     SELECT_STMT = "selectStmt",
     INSERT_STMT = "insertStmt",
-    CREATE_FUNCTION_STMT = "createFunctionStmt"
+    CREATE_FUNCTION_STMT = "createFunctionStmt",
+    ALTER_TABLE_STMT = "alterTableStmt"
 }
 export interface StmtContext {
     readonly stmtContextType: StmtContextType;
@@ -23,20 +24,65 @@ export interface StmtContext {
     readonly isContainCaret?: boolean;
 }
 export declare function toStmtContext(ctx: ParserRuleContext, type: StmtContextType, input: string, rootStmt: StmtContext | null, parentStmt: StmtContext | null, isContainCaret?: boolean): StmtContext | null;
-export interface BaseAliasContext {
-    readonly isAlias: boolean;
-    alias?: string | EntityContext | null;
-    origin?: string | EntityContext | StmtContext | null;
+/**
+ * entity's attribute
+ * @key comment: entity's comment attribute
+ * @key colType: column entity's type attribute
+ * @key alias: entity's alias attribute
+ * */
+export declare enum AttrName {
+    comment = "_comment",
+    colType = "_colType",
+    alias = "_alias"
 }
-export interface EntityContext extends BaseAliasContext {
+/**
+ * ParserRuleContext with custom attributes
+ * */
+type ParserRuleContextWithAttr = ParserRuleContext & {
+    [K in AttrName]?: Token;
+};
+/**
+ * Function's arguments
+ * */
+export interface Argument {
+    argMode?: WordRange;
+    argName?: WordRange;
+    argType: WordRange;
+}
+export interface BaseEntityContext {
     readonly entityContextType: EntityContextType;
     readonly text: string;
     readonly position: WordPosition;
     readonly belongStmt: StmtContext;
-    relatedEntities: EntityContext[] | null;
-    columns: EntityContext[] | null;
+    reference?: string | EntityContext;
+    [AttrName.comment]: WordRange | null;
+    [AttrName.alias]?: WordRange | null;
+}
+export interface CommonEntityContext extends BaseEntityContext {
+    relatedEntities: CommonEntityContext[] | null;
+    columns?: ColumnEntityContext[];
+}
+export interface ColumnEntityContext extends BaseEntityContext {
+    [AttrName.colType]: WordRange | null;
+}
+export interface FuncEntityContext extends BaseEntityContext {
+    relatedEntities: CommonEntityContext[] | null;
+    arguments: Argument[] | null;
+    returns?: Argument;
+}
+export type EntityContext = CommonEntityContext | FuncEntityContext | ColumnEntityContext;
+export declare function isCommonEntityContext(entity: EntityContext): entity is CommonEntityContext;
+export declare function isFuncEntityContext(entity: EntityContext): entity is FuncEntityContext;
+export declare function isColumnEntityContext(entity: EntityContext): entity is ColumnEntityContext;
+/**
+ *  what we need when collect attribute information
+ * */
+interface AttrInfo {
+    attrName: AttrName;
+    endContextList: string[];
 }
-export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, alias?: BaseAliasContext): EntityContext | null;
+export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, attrInfo?: AttrInfo[]): EntityContext | null;
+export declare function findAttribute(ctx: ParserRuleContextWithAttr | null, keyName: AttrName, endContextNameList: string[]): Token | null;
 /**
  * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
  * @todo: [may be need] Combine the entities in each clause.
@@ -59,11 +105,12 @@ export declare abstract class EntityCollector {
     visitErrorNode(): void;
     enterEveryRule(): void;
     exitEveryRule(): void;
+    getRootStmt(): StmtContext | null;
     getEntities(): EntityContext[];
     enterProgram(): void;
     protected pushStmt(ctx: ParserRuleContext, type: StmtContextType): StmtContext | null;
     protected popStmt(): StmtContext;
-    protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, alias?: BaseAliasContext): EntityContext | null;
+    protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, attrInfo?: AttrInfo[]): EntityContext | null;
     /**
      * Combine entities that inside a single statement.
      * e.g. combine tableName and column if they are inside a same createTableStatement.
@@ -76,3 +123,4 @@ export declare abstract class EntityCollector {
     protected combineRootStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
     protected combineCreateTableOrViewStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
 }
+export {};

package/dist/parser/common/entityCollector.js

@@ -9,9 +9,10 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { EntityContextType } from './types';
-import { ctxToText, ctxToWord } from './textAndWord';
+import { isToken } from 'antlr4ng';
 import { SimpleStack } from './simpleStack';
+import { ctxToText, isWordRange, tokenToWord, } from './textAndWord';
+import { EntityContextType } from './types';
 /**
  * TODO: more stmt type should be supported.
  */
@@ -26,6 +27,7 @@ export var StmtContextType;
     StmtContextType["SELECT_STMT"] = "selectStmt";
     StmtContextType["INSERT_STMT"] = "insertStmt";
     StmtContextType["CREATE_FUNCTION_STMT"] = "createFunctionStmt";
+    StmtContextType["ALTER_TABLE_STMT"] = "alterTableStmt";
 })(StmtContextType || (StmtContextType = {}));
 export function toStmtContext(ctx, type, input, rootStmt, parentStmt, isContainCaret) {
     const text = ctxToText(ctx, input);
@@ -40,20 +42,131 @@ export function toStmtContext(ctx, type, input, rootStmt, parentStmt, isContainC
         isContainCaret,
     };
 }
-const baseAlias = {
-    isAlias: false,
-    origin: null,
-    alias: null,
-};
-export function toEntityContext(ctx, type, input, belongStmt, alias) {
-    const word = ctxToWord(ctx, input);
+/**
+ * entity's attribute
+ * @key comment: entity's comment attribute
+ * @key colType: column entity's type attribute
+ * @key alias: entity's alias attribute
+ * */
+export var AttrName;
+(function (AttrName) {
+    AttrName["comment"] = "_comment";
+    AttrName["colType"] = "_colType";
+    AttrName["alias"] = "_alias";
+})(AttrName || (AttrName = {}));
+export function isCommonEntityContext(entity) {
+    if (!entity)
+        return false;
+    return 'relatedEntities' in entity && !('arguments' in entity);
+}
+export function isFuncEntityContext(entity) {
+    if (!entity)
+        return false;
+    return 'arguments' in entity;
+}
+export function isColumnEntityContext(entity) {
+    if (!entity)
+        return false;
+    return AttrName.colType in entity;
+}
+export function toEntityContext(ctx, type, input, belongStmt, attrInfo) {
+    var _a, _b;
+    const word = ctxToText(ctx, input);
     if (!word)
         return null;
-    const { text } = word, position = __rest(word, ["text"]);
-    const finalAlias = Object.assign({}, baseAlias, alias !== null && alias !== void 0 ? alias : {});
-    return Object.assign({ entityContextType: type, text,
+    const { text, startLine, endLine } = word, rest = __rest(word, ["text", "startLine", "endLine"]);
+    const position = Object.assign(Object.assign({}, rest), { line: startLine });
+    let entityInfo = {
+        entityContextType: type,
+        text,
         position,
-        belongStmt, relatedEntities: null, columns: null }, finalAlias);
+        belongStmt,
+        [AttrName.comment]: null,
+    };
+    switch (entityInfo.entityContextType) {
+        case EntityContextType.FUNCTION:
+        case EntityContextType.FUNCTION_CREATE: {
+            entityInfo.relatedEntities = null;
+            entityInfo.arguments = null;
+            break;
+        }
+        case EntityContextType.COLUMN:
+        case EntityContextType.COLUMN_CREATE:
+            entityInfo[AttrName.colType] = null;
+            break;
+        default:
+            entityInfo.relatedEntities = null;
+            break;
+    }
+    if (attrInfo) {
+        for (let k = 0; k < attrInfo.length; k++) {
+            const attributeName = (_a = attrInfo[k]) === null || _a === void 0 ? void 0 : _a.attrName;
+            const attrToken = findAttribute(ctx, attributeName, (_b = attrInfo[k]) === null || _b === void 0 ? void 0 : _b.endContextList);
+            if (attrToken) {
+                const attrVal = isToken(attrToken)
+                    ? tokenToWord(attrToken, input)
+                    : ctxToText(attrToken, input);
+                if (attrVal) {
+                    if (isWordRange(attrVal)) {
+                        entityInfo = Object.assign(entityInfo, {
+                            [attributeName]: attrVal,
+                        });
+                    }
+                    else {
+                        const { startIndex, endIndex, startColumn, endColumn, text } = attrVal, rest = __rest(attrVal, ["startIndex", "endIndex", "startColumn", "endColumn", "text"]);
+                        entityInfo = Object.assign(entityInfo, {
+                            [attributeName]: {
+                                startIndex,
+                                endIndex,
+                                startColumn,
+                                endColumn,
+                                text,
+                                line: rest === null || rest === void 0 ? void 0 : rest.startLine,
+                            },
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return entityInfo;
+}
+export function findAttribute(ctx, keyName, endContextNameList) {
+    var _a, _b;
+    const parent = (ctx === null || ctx === void 0 ? void 0 : ctx.parent) || null;
+    let attrVal = null;
+    if (parent === null || parent === void 0 ? void 0 : parent[keyName]) {
+        attrVal = (parent === null || parent === void 0 ? void 0 : parent[keyName]) || null;
+        return attrVal;
+    }
+    else {
+        if (((_a = parent === null || parent === void 0 ? void 0 : parent.constructor) === null || _a === void 0 ? void 0 : _a.name) && !endContextNameList.includes((_b = parent === null || parent === void 0 ? void 0 : parent.constructor) === null || _b === void 0 ? void 0 : _b.name)) {
+            attrVal = findAttribute(parent, keyName, endContextNameList);
+        }
+        if (!attrVal) {
+            if (parent === null || parent === void 0 ? void 0 : parent.children) {
+                attrVal = findAttributeChildren(parent, keyName);
+            }
+        }
+    }
+    return attrVal;
+}
+function findAttributeChildren(ctx, keyName) {
+    const visitChildren = (ctx === null || ctx === void 0 ? void 0 : ctx.children) || [];
+    let attrVal = null;
+    if (visitChildren.length) {
+        for (let i = 0; i < visitChildren.length; i++) {
+            const child = visitChildren[i] || null;
+            if (child === null || child === void 0 ? void 0 : child[keyName]) {
+                attrVal = (child === null || child === void 0 ? void 0 : child[keyName]) || null;
+                return attrVal;
+            }
+            else {
+                attrVal = findAttributeChildren(child, keyName);
+            }
+        }
+    }
+    return attrVal;
 }
 /**
  * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
@@ -72,6 +185,9 @@ export class EntityCollector {
     visitErrorNode() { }
     enterEveryRule() { }
     exitEveryRule() { }
+    getRootStmt() {
+        return this._rootStmt;
+    }
     getEntities() {
         return Array.from(this._entitiesSet);
     }
@@ -111,8 +227,8 @@ export class EntityCollector {
         }
         return stmtContext;
     }
-    pushEntity(ctx, type, alias) {
-        const entityContext = toEntityContext(ctx, type, this._input, this._stmtStack.peek(), alias);
+    pushEntity(ctx, type, attrInfo) {
+        const entityContext = toEntityContext(ctx, type, this._input, this._stmtStack.peek(), attrInfo);
         if (entityContext) {
             if (this._stmtStack.isEmpty()) {
                 this._entitiesSet.add(entityContext);
@@ -181,10 +297,18 @@ export class EntityCollector {
             return result;
         }, []);
         if (mainEntity && columns.length) {
-            mainEntity.columns = columns;
+            if (isCommonEntityContext(mainEntity)) {
+                mainEntity = Object.assign(mainEntity, {
+                    columns,
+                });
+            }
         }
         if (mainEntity && relatedEntities.length) {
-            mainEntity.relatedEntities = relatedEntities;
+            if (isCommonEntityContext(mainEntity) || isFuncEntityContext(mainEntity)) {
+                mainEntity = Object.assign(mainEntity, {
+                    relatedEntities,
+                });
+            }
         }
         return finalEntities;
     }

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

@@ -1,4 +1,5 @@
-import { Token, Recognizer, ANTLRErrorListener, RecognitionException, ATNSimulator } from 'antlr4ng';
+import { Token, Recognizer, ANTLRErrorListener, RecognitionException, ATNSimulator, Parser } from 'antlr4ng';
+import { LOCALE_TYPE } from './types';
 /**
  * Converted from {@link SyntaxError}.
  */
@@ -29,11 +30,13 @@ export interface SyntaxError {
  * Includes lexical errors and parsing errors.
  */
 export type ErrorListener = (parseError: ParseError, originalError: SyntaxError) => void;
-export declare class ParseErrorListener implements ANTLRErrorListener {
+export declare abstract class ParseErrorListener implements ANTLRErrorListener {
     private _errorListener;
-    constructor(errorListener: ErrorListener);
+    private locale;
+    constructor(errorListener: ErrorListener, locale?: LOCALE_TYPE);
     reportAmbiguity(): void;
     reportAttemptingFullContext(): void;
     reportContextSensitivity(): void;
+    protected abstract getExpectedText(parser: Parser, token: Token): string;
     syntaxError(recognizer: Recognizer<ATNSimulator>, offendingSymbol: Token | null, line: number, charPositionInLine: number, msg: string, e: RecognitionException): void;
 }

package/dist/parser/common/parseErrorListener.js

@@ -1,11 +1,92 @@
+import { Token, LexerNoViableAltException, InputMismatchException, NoViableAltException, } from 'antlr4ng';
+import { transform } from './transform';
 export class ParseErrorListener {
-    constructor(errorListener) {
+    constructor(errorListener, locale = 'en_US') {
+        this.locale = locale;
         this._errorListener = errorListener;
     }
     reportAmbiguity() { }
     reportAttemptingFullContext() { }
     reportContextSensitivity() { }
     syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
+        var _a;
+        let message = '';
+        // If not undefined then offendingSymbol is of type Token.
+        if (offendingSymbol) {
+            let token = offendingSymbol;
+            const parser = recognizer;
+            // judge token is EOF
+            const isEof = token.type === Token.EOF;
+            if (isEof) {
+                token = parser.tokenStream.get(token.tokenIndex - 1);
+            }
+            const wrongText = (_a = token.text) !== null && _a !== void 0 ? _a : '';
+            const isInComplete = isEof && wrongText !== ' ';
+            const expectedText = isInComplete ? '' : this.getExpectedText(parser, token);
+            if (!e) {
+                // handle missing or unwanted tokens.
+                message = msg;
+                if (msg.includes('extraneous')) {
+                    message = `'${wrongText}' {noValidPosition}${expectedText.length ? `{expecting}${expectedText}` : ''}`;
+                }
+                if (msg.includes('missing')) {
+                    const regex = /missing\s+'([^']+)'/;
+                    const match = msg.match(regex);
+                    message = `{missing}`;
+                    if (match) {
+                        const missKeyword = match[1];
+                        message += `'${missKeyword}'`;
+                    }
+                    else {
+                        message += `{keyword}`;
+                    }
+                    message += `{at}'${wrongText}'`;
+                }
+            }
+            else {
+                // handle mismatch exception or no viable alt exception
+                if (e instanceof InputMismatchException || e instanceof NoViableAltException) {
+                    if (isEof) {
+                        message = `{stmtInComplete}`;
+                    }
+                    else {
+                        message = `'${wrongText}' {noValidPosition}`;
+                    }
+                    if (expectedText.length > 0) {
+                        message += `{expecting}${expectedText}`;
+                    }
+                }
+                else {
+                    message = msg;
+                }
+            }
+        }
+        else {
+            // No offending symbol, which indicates this is a lexer error.
+            if (e instanceof LexerNoViableAltException) {
+                const lexer = recognizer;
+                const input = lexer.inputStream;
+                let text = lexer.getErrorDisplay(input.getText(lexer._tokenStartCharIndex, input.index));
+                switch (text[0]) {
+                    case '/':
+                        message = '{unfinishedMultilineComment}';
+                        break;
+                    case '"':
+                        message = '{unfinishedDoubleQuoted}';
+                        break;
+                    case "'":
+                        message = '{unfinishedSingleQuoted}';
+                        break;
+                    case '`':
+                        message = '{unfinishedTickQuoted}';
+                        break;
+                    default:
+                        message = '"' + text + '" {noValidInput}';
+                        break;
+                }
+            }
+        }
+        message = transform(message, this.locale);
         let endCol = charPositionInLine + 1;
         if (offendingSymbol && offendingSymbol.text !== null) {
             endCol = charPositionInLine + offendingSymbol.text.length;
@@ -16,7 +97,7 @@ export class ParseErrorListener {
                 endLine: line,
                 startColumn: charPositionInLine + 1,
                 endColumn: endCol + 1,
-                message: msg,
+                message,
             }, {
                 e,
                 line,

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

@@ -35,18 +35,15 @@ export interface TextSlice extends TextPosition {
 /**
  * Convert Token to Word
  */
-export declare function tokenToWord(token: Token, input: string): WordPosition & {
-    text: string;
-};
-/**
- * Convert ParserRuleContext to Word
- */
-export declare function ctxToWord(ctx: ParserRuleContext, input: string): (WordPosition & {
-    text: string;
-}) | null;
+export declare function tokenToWord(token: Token, input: string): WordRange;
 /**
  * Convert ParserRuleContext to Text
  */
 export declare function ctxToText(ctx: ParserRuleContext, input: string): (TextPosition & {
     text: string;
 }) | null;
+/**
+ * judge whether the context is a WordRange
+ * @param textOrWord TextSlice or WordRange object
+ * */
+export declare function isWordRange(textOrWord: TextSlice | WordRange): textOrWord is WordRange;