air-dml 1.2.9 → 2.1.0

package/dist/parser/new/parser.js

@@ -0,0 +1,776 @@
+import { TokenType } from './tokens';
+export class ParseError extends Error {
+    constructor(message, position, code) {
+        super(`[${position.line}:${position.column}] ${message}`);
+        this.position = position;
+        this.code = code;
+        this.name = 'ParseError';
+    }
+}
+export class Parser {
+    constructor(tokens) {
+        this.pos = 0;
+        this.errors = [];
+        this.pendingComments = [];
+        this.tokens = tokens;
+    }
+    parse() {
+        this.pos = 0;
+        this.errors = [];
+        this.pendingComments = [];
+        const ast = this.parseProgram();
+        return { ast, errors: this.errors };
+    }
+    parseProgram() {
+        const start = this.currentPosition();
+        let project;
+        const tables = [];
+        const refs = [];
+        const areas = [];
+        while (!this.isAtEnd()) {
+            this.collectComments();
+            if (this.isAtEnd())
+                break;
+            try {
+                const leadingComments = this.consumePendingComments();
+                if (this.check(TokenType.PROJECT)) {
+                    project = this.parseProject();
+                    if (leadingComments.length > 0) {
+                        project.leadingComments = leadingComments;
+                    }
+                }
+                else if (this.check(TokenType.TABLE)) {
+                    const table = this.parseTable();
+                    if (leadingComments.length > 0) {
+                        table.leadingComments = leadingComments;
+                    }
+                    tables.push(table);
+                }
+                else if (this.check(TokenType.REF)) {
+                    const ref = this.parseRef();
+                    if (leadingComments.length > 0) {
+                        ref.leadingComments = leadingComments;
+                    }
+                    refs.push(ref);
+                }
+                else if (this.check(TokenType.AREA)) {
+                    const area = this.parseArea();
+                    if (leadingComments.length > 0) {
+                        area.leadingComments = leadingComments;
+                    }
+                    areas.push(area);
+                }
+                else if (this.check(TokenType.EOF)) {
+                    break;
+                }
+                else {
+                    const token = this.peek();
+                    this.error(`予期しないトークンです: '${token.value}'`, 'UNEXPECTED_TOKEN');
+                    this.advance();
+                }
+            }
+            catch (e) {
+                if (e instanceof ParseError) {
+                    this.errors.push(e);
+                    this.synchronize();
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        return {
+            kind: 'Program',
+            range: { start, end: this.currentPosition() },
+            project,
+            tables,
+            refs,
+            areas,
+        };
+    }
+    parseProject() {
+        const start = this.currentPosition();
+        this.expect(TokenType.PROJECT);
+        const name = this.parseNameOrString();
+        const settings = this.parseProjectBody();
+        return {
+            kind: 'Project',
+            range: { start, end: this.currentPosition() },
+            name,
+            settings,
+        };
+    }
+    parseProjectBody() {
+        const settings = {};
+        if (!this.check(TokenType.LBRACE)) {
+            return settings;
+        }
+        this.advance();
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            this.collectComments();
+            if (this.check(TokenType.RBRACE))
+                break;
+            if (this.check(TokenType.DATABASE_TYPE)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.databaseType = this.parseStringValue();
+            }
+            else if (this.check(TokenType.NOTE)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.note = this.parseStringValue();
+            }
+            else {
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return settings;
+    }
+    parseTable() {
+        const start = this.currentPosition();
+        this.expect(TokenType.TABLE);
+        const name = this.parseIdentifier();
+        const settings = this.parseTableSettings();
+        const { columns, indexes, note } = this.parseTableBody();
+        return {
+            kind: 'Table',
+            range: { start, end: this.currentPosition() },
+            name,
+            columns,
+            indexes: indexes.length > 0 ? indexes : undefined,
+            settings,
+            note,
+        };
+    }
+    parseTableSettings() {
+        const settings = {};
+        if (!this.check(TokenType.LBRACKET)) {
+            return settings;
+        }
+        this.advance();
+        while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
+            if (this.check(TokenType.ALIAS)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.alias = this.parseStringValue();
+            }
+            else if (this.check(TokenType.POS_X)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.posX = this.parseNumberValue();
+            }
+            else if (this.check(TokenType.POS_Y)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.posY = this.parseNumberValue();
+            }
+            else if (this.check(TokenType.COLOR)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.color = this.parseStringValue();
+            }
+            else if (this.check(TokenType.COMMA)) {
+                this.advance();
+            }
+            else {
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RBRACKET);
+        return settings;
+    }
+    parseTableBody() {
+        const columns = [];
+        const indexes = [];
+        let note;
+        this.expect(TokenType.LBRACE);
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            this.collectComments();
+            if (this.check(TokenType.RBRACE))
+                break;
+            if (this.isTopLevelKeyword()) {
+                this.error('テーブル定義が閉じられていません。"}" が必要です', 'UNCLOSED_TABLE');
+                break;
+            }
+            if (this.check(TokenType.INDEXES)) {
+                const parsedIndexes = this.parseIndexes();
+                indexes.push(...parsedIndexes);
+            }
+            else if (this.check(TokenType.NOTE)) {
+                note = this.parseInlineNote();
+            }
+            else if (this.isColumnIdentifier()) {
+                const leadingComments = this.consumePendingComments();
+                const column = this.parseColumn();
+                if (leadingComments.length > 0) {
+                    column.leadingComments = leadingComments;
+                }
+                columns.push(column);
+            }
+            else {
+                this.advance();
+            }
+        }
+        if (this.check(TokenType.RBRACE)) {
+            this.advance();
+        }
+        return { columns, indexes, note };
+    }
+    isTopLevelKeyword() {
+        const type = this.peek().type;
+        return (type === TokenType.PROJECT ||
+            type === TokenType.TABLE ||
+            type === TokenType.REF ||
+            type === TokenType.AREA);
+    }
+    isColumnIdentifier() {
+        const token = this.peek();
+        if (token.type === TokenType.IDENTIFIER || token.type === TokenType.STRING) {
+            return true;
+        }
+        if (this.isKeyword(token.type) && !this.isTopLevelKeyword()) {
+            return true;
+        }
+        return false;
+    }
+    parseColumn() {
+        const start = this.currentPosition();
+        const name = this.parseIdentifier();
+        const { type, typeParams } = this.parseColumnType();
+        const constraints = this.parseColumnConstraints();
+        return {
+            kind: 'Column',
+            range: { start, end: this.currentPosition() },
+            name,
+            type,
+            typeParams,
+            constraints,
+        };
+    }
+    parseColumnType() {
+        const type = this.parseIdentifier();
+        if (this.check(TokenType.LPAREN)) {
+            this.advance();
+            let params = '';
+            while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {
+                const token = this.advance();
+                params += token.value;
+            }
+            this.expect(TokenType.RPAREN);
+            return { type, typeParams: params };
+        }
+        return { type };
+    }
+    parseColumnConstraints() {
+        const constraints = {};
+        if (!this.check(TokenType.LBRACKET)) {
+            return constraints;
+        }
+        this.advance();
+        while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
+            if (this.check(TokenType.PK)) {
+                this.advance();
+                constraints.pk = true;
+            }
+            else if (this.check(TokenType.FK)) {
+                this.advance();
+                constraints.fk = true;
+            }
+            else if (this.check(TokenType.UNIQUE)) {
+                this.advance();
+                constraints.unique = true;
+            }
+            else if (this.check(TokenType.NOT)) {
+                this.advance();
+                if (this.check(TokenType.NULL)) {
+                    this.advance();
+                }
+                constraints.notNull = true;
+            }
+            else if (this.check(TokenType.NULL)) {
+                this.advance();
+            }
+            else if (this.check(TokenType.INCREMENT)) {
+                this.advance();
+                constraints.increment = true;
+            }
+            else if (this.check(TokenType.ALIAS)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                constraints.alias = this.parseStringValue();
+            }
+            else if (this.check(TokenType.NOTE)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                constraints.note = this.parseStringValue();
+            }
+            else if (this.check(TokenType.COMMA)) {
+                this.advance();
+            }
+            else {
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RBRACKET);
+        return constraints;
+    }
+    parseRef() {
+        const start = this.currentPosition();
+        this.expect(TokenType.REF);
+        let name;
+        if (this.check(TokenType.IDENTIFIER) && this.peekNext()?.type === TokenType.COLON) {
+            name = this.parseIdentifier();
+        }
+        this.expect(TokenType.COLON);
+        const from = this.parseRefEndpoint();
+        const relationType = this.parseRelationType();
+        const to = this.parseRefEndpoint();
+        const settings = this.parseRefSettings();
+        return {
+            kind: 'Ref',
+            range: { start, end: this.currentPosition() },
+            name,
+            from,
+            to,
+            relationType,
+            settings,
+        };
+    }
+    parseRefEndpoint() {
+        const table = this.parseIdentifier();
+        this.expect(TokenType.DOT);
+        const column = this.parseIdentifier();
+        return { table, column };
+    }
+    parseRelationType() {
+        if (this.check(TokenType.REF_GT)) {
+            this.advance();
+            return '>';
+        }
+        if (this.check(TokenType.REF_LT)) {
+            this.advance();
+            return '<';
+        }
+        if (this.check(TokenType.REF_LTGT)) {
+            this.advance();
+            return '<>';
+        }
+        if (this.check(TokenType.REF_DASH)) {
+            this.advance();
+            return '-';
+        }
+        if (this.check(TokenType.REF_TILDE)) {
+            this.advance();
+            return '~';
+        }
+        this.error('リレーション演算子が必要です（>, <, -, <>, ~）', 'EXPECTED_REF_OPERATOR');
+        return '>';
+    }
+    parseRefSettings() {
+        const settings = {};
+        if (!this.check(TokenType.LBRACKET)) {
+            return settings;
+        }
+        this.advance();
+        while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
+            if (this.check(TokenType.SWAP_EDGE)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.swapEdge = this.parseBooleanValue();
+            }
+            else if (this.check(TokenType.NOTE)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.note = this.parseStringValue();
+            }
+            else if (this.check(TokenType.COMMA)) {
+                this.advance();
+            }
+            else {
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RBRACKET);
+        return settings;
+    }
+    parseArea() {
+        const start = this.currentPosition();
+        this.expect(TokenType.AREA);
+        const name = this.parseStringValue();
+        const settings = this.parseAreaSettings();
+        const { tables, commonColumns, note } = this.parseAreaBody();
+        return {
+            kind: 'Area',
+            range: { start, end: this.currentPosition() },
+            name,
+            tables,
+            settings,
+            commonColumns: commonColumns.length > 0 ? commonColumns : undefined,
+            note,
+        };
+    }
+    parseAreaSettings() {
+        const settings = {};
+        if (!this.check(TokenType.LBRACKET)) {
+            return settings;
+        }
+        this.advance();
+        while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
+            if (this.check(TokenType.POS_X)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.posX = this.parseNumberValue();
+            }
+            else if (this.check(TokenType.POS_Y)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.posY = this.parseNumberValue();
+            }
+            else if (this.check(TokenType.WIDTH)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.width = this.parseNumberValue();
+            }
+            else if (this.check(TokenType.HEIGHT)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.height = this.parseNumberValue();
+            }
+            else if (this.check(TokenType.COLOR)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.color = this.parseStringValue();
+            }
+            else if (this.check(TokenType.DATABASE_TYPE)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.databaseType = this.parseStringValue();
+            }
+            else if (this.check(TokenType.LABEL_HORIZONTAL)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                const val = this.parseStringValue();
+                if (val === 'left' || val === 'center' || val === 'right') {
+                    settings.labelHorizontal = val;
+                }
+            }
+            else if (this.check(TokenType.LABEL_VERTICAL)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                const val = this.parseStringValue();
+                if (val === 'top' || val === 'center' || val === 'bottom') {
+                    settings.labelVertical = val;
+                }
+            }
+            else if (this.check(TokenType.COMMA)) {
+                this.advance();
+            }
+            else {
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RBRACKET);
+        return settings;
+    }
+    parseAreaBody() {
+        const tables = [];
+        const commonColumns = [];
+        let note;
+        this.expect(TokenType.LBRACE);
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            this.collectComments();
+            if (this.check(TokenType.RBRACE))
+                break;
+            if (this.check(TokenType.COMMON_COLUMNS)) {
+                const cols = this.parseCommonColumns();
+                commonColumns.push(...cols);
+            }
+            else if (this.check(TokenType.NOTE)) {
+                note = this.parseInlineNote();
+            }
+            else if (this.isIdentifierLike()) {
+                tables.push(this.parseIdentifier());
+            }
+            else {
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return { tables, commonColumns, note };
+    }
+    parseCommonColumns() {
+        const columns = [];
+        this.expect(TokenType.COMMON_COLUMNS);
+        this.expect(TokenType.COLON);
+        this.expect(TokenType.LBRACKET);
+        while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
+            this.collectComments();
+            if (this.check(TokenType.RBRACKET))
+                break;
+            if (this.isIdentifierLike()) {
+                const column = this.parseColumn();
+                this.attachComments(column);
+                columns.push(column);
+            }
+            else {
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RBRACKET);
+        return columns;
+    }
+    parseIndexes() {
+        const indexes = [];
+        this.expect(TokenType.INDEXES);
+        this.expect(TokenType.LBRACE);
+        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+            this.collectComments();
+            if (this.check(TokenType.RBRACE))
+                break;
+            if (this.check(TokenType.LPAREN) || this.isIdentifierLike()) {
+                const index = this.parseIndex();
+                this.attachComments(index);
+                indexes.push(index);
+            }
+            else {
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return indexes;
+    }
+    parseIndex() {
+        const start = this.currentPosition();
+        const columns = [];
+        if (this.check(TokenType.LPAREN)) {
+            this.advance();
+            while (!this.check(TokenType.RPAREN) && !this.isAtEnd()) {
+                if (this.isIdentifierLike()) {
+                    columns.push(this.parseIdentifier());
+                }
+                if (this.check(TokenType.COMMA)) {
+                    this.advance();
+                }
+            }
+            this.expect(TokenType.RPAREN);
+        }
+        else {
+            columns.push(this.parseIdentifier());
+        }
+        const settings = this.parseIndexSettings();
+        return {
+            kind: 'Index',
+            range: { start, end: this.currentPosition() },
+            columns,
+            settings,
+        };
+    }
+    parseIndexSettings() {
+        const settings = {};
+        if (!this.check(TokenType.LBRACKET)) {
+            return settings;
+        }
+        this.advance();
+        while (!this.check(TokenType.RBRACKET) && !this.isAtEnd()) {
+            if (this.check(TokenType.UNIQUE)) {
+                this.advance();
+                settings.unique = true;
+            }
+            else if (this.check(TokenType.PK)) {
+                this.advance();
+                settings.pk = true;
+            }
+            else if (this.check(TokenType.NAME)) {
+                this.advance();
+                this.expect(TokenType.COLON);
+                settings.name = this.parseStringValue();
+            }
+            else if (this.check(TokenType.COMMA)) {
+                this.advance();
+            }
+            else {
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RBRACKET);
+        return settings;
+    }
+    parseInlineNote() {
+        this.expect(TokenType.NOTE);
+        this.expect(TokenType.COLON);
+        return this.parseStringValue();
+    }
+    parseIdentifier() {
+        const token = this.peek();
+        if (token.type === TokenType.IDENTIFIER) {
+            this.advance();
+            return token.value;
+        }
+        if (token.type === TokenType.STRING) {
+            this.advance();
+            return token.value;
+        }
+        if (this.isKeyword(token.type)) {
+            this.advance();
+            return token.value;
+        }
+        this.error('識別子が必要です', 'EXPECTED_IDENTIFIER');
+        return '';
+    }
+    parseNameOrString() {
+        const token = this.peek();
+        if (token.type === TokenType.STRING) {
+            this.advance();
+            return token.value;
+        }
+        if (token.type === TokenType.IDENTIFIER) {
+            this.advance();
+            return token.value;
+        }
+        this.error('名前または文字列が必要です', 'EXPECTED_NAME');
+        return '';
+    }
+    parseStringValue() {
+        const token = this.peek();
+        if (token.type === TokenType.STRING ||
+            token.type === TokenType.SINGLE_STRING ||
+            token.type === TokenType.BACKTICK_STRING) {
+            this.advance();
+            return token.value;
+        }
+        if (token.type === TokenType.IDENTIFIER) {
+            this.advance();
+            return token.value;
+        }
+        this.error('文字列が必要です', 'EXPECTED_STRING');
+        return '';
+    }
+    parseNumberValue() {
+        const token = this.peek();
+        if (token.type === TokenType.NUMBER) {
+            this.advance();
+            return parseFloat(token.value);
+        }
+        this.error('数値が必要です', 'EXPECTED_NUMBER');
+        return 0;
+    }
+    parseBooleanValue() {
+        const token = this.peek();
+        if (token.type === TokenType.IDENTIFIER) {
+            this.advance();
+            return token.value.toLowerCase() === 'true';
+        }
+        if (token.type === TokenType.NUMBER) {
+            this.advance();
+            return token.value !== '0';
+        }
+        this.advance();
+        return false;
+    }
+    isIdentifierLike() {
+        const token = this.peek();
+        return (token.type === TokenType.IDENTIFIER ||
+            token.type === TokenType.STRING ||
+            this.isKeyword(token.type));
+    }
+    isKeyword(type) {
+        return [
+            TokenType.PROJECT,
+            TokenType.TABLE,
+            TokenType.AREA,
+            TokenType.REF,
+            TokenType.NOTE,
+            TokenType.INDEXES,
+            TokenType.PK,
+            TokenType.FK,
+            TokenType.UNIQUE,
+            TokenType.NOT,
+            TokenType.NULL,
+            TokenType.INCREMENT,
+            TokenType.ALIAS,
+            TokenType.NAME,
+        ].includes(type);
+    }
+    peek() {
+        return this.tokens[this.pos];
+    }
+    peekNext() {
+        return this.tokens[this.pos + 1];
+    }
+    advance() {
+        const token = this.tokens[this.pos];
+        if (!this.isAtEnd()) {
+            this.pos++;
+        }
+        return token;
+    }
+    check(type) {
+        return this.peek().type === type;
+    }
+    expect(type) {
+        if (this.check(type)) {
+            return this.advance();
+        }
+        const token = this.peek();
+        const expected = this.tokenTypeName(type);
+        this.error(`'${expected}' が必要ですが、'${token.value}' が見つかりました`, 'UNEXPECTED_TOKEN');
+        return token;
+    }
+    isAtEnd() {
+        return this.peek().type === TokenType.EOF;
+    }
+    currentPosition() {
+        return this.peek().start;
+    }
+    collectComments() {
+        while (this.check(TokenType.LINE_COMMENT)) {
+            this.pendingComments.push(this.advance().value);
+        }
+    }
+    consumePendingComments() {
+        const comments = [...this.pendingComments];
+        this.pendingComments = [];
+        return comments;
+    }
+    attachComments(node) {
+        if (this.pendingComments.length > 0) {
+            node.leadingComments = [...this.pendingComments];
+            this.pendingComments = [];
+        }
+    }
+    error(message, code) {
+        throw new ParseError(message, this.currentPosition(), code);
+    }
+    synchronize() {
+        while (!this.isAtEnd()) {
+            const type = this.peek().type;
+            if (type === TokenType.RBRACE) {
+                this.advance();
+                return;
+            }
+            if (type === TokenType.PROJECT ||
+                type === TokenType.TABLE ||
+                type === TokenType.REF ||
+                type === TokenType.AREA) {
+                return;
+            }
+            this.advance();
+        }
+    }
+    tokenTypeName(type) {
+        const names = {
+            [TokenType.LBRACE]: '{',
+            [TokenType.RBRACE]: '}',
+            [TokenType.LBRACKET]: '[',
+            [TokenType.RBRACKET]: ']',
+            [TokenType.LPAREN]: '(',
+            [TokenType.RPAREN]: ')',
+            [TokenType.COLON]: ':',
+            [TokenType.COMMA]: ',',
+            [TokenType.DOT]: '.',
+        };
+        return names[type] ?? type;
+    }
+}
+//# sourceMappingURL=parser.js.map