@lingo-dsl/compiler 0.1.0

package/dist/parser/LingoParser.js

@@ -0,0 +1,697 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LingoParser = void 0;
+const Token_1 = require("../tokenizer/Token");
+const IErrorReporter_1 = require("../errors/IErrorReporter");
+const AST_1 = require("./AST");
+class LingoParser {
+    constructor(errorReporter) {
+        this.errorReporter = errorReporter;
+        this.tokens = [];
+        this.current = 0;
+    }
+    parse(tokens) {
+        this.tokens = tokens;
+        this.current = 0;
+        const statements = [];
+        while (!this.isAtEnd()) {
+            // Skip newlines and comments at the top level
+            if (this.check(Token_1.TokenType.NEWLINE)) {
+                this.advance();
+                continue;
+            }
+            const stmt = this.parseStatement();
+            if (stmt) {
+                statements.push(stmt);
+            }
+        }
+        return {
+            type: AST_1.ASTNodeType.PROGRAM,
+            statements,
+            location: this.currentLocation(),
+        };
+    }
+    parseStatement() {
+        try {
+            if (this.check(Token_1.TokenType.THERE)) {
+                return this.parseStateDecl();
+            }
+            if (this.check(Token_1.TokenType.SHOW)) {
+                return this.parseShowStmt();
+            }
+            if (this.check(Token_1.TokenType.WHEN)) {
+                return this.parseEventBlock();
+            }
+            if (this.check(Token_1.TokenType.IF)) {
+                return this.parseIfBlock();
+            }
+            if (this.check(Token_1.TokenType.FOR)) {
+                return this.parseForEachBlock();
+            }
+            // Unknown statement, report error and skip to next line
+            this.reportError(`Unexpected token: ${this.peek().value}`);
+            this.synchronize();
+            return null;
+        }
+        catch (error) {
+            // Error already reported, synchronize to next statement
+            this.synchronize();
+            return null;
+        }
+    }
+    parseStateDecl() {
+        const location = this.currentLocation();
+        this.consume(Token_1.TokenType.THERE, "Expected 'There'");
+        this.consume(Token_1.TokenType.IS, "Expected 'is'");
+        // Article (a/an) - optional for backwards compatibility
+        if (this.check(Token_1.TokenType.A) || this.check(Token_1.TokenType.AN)) {
+            this.advance();
+        }
+        // Type
+        const varType = this.parseType();
+        this.consume(Token_1.TokenType.CALLED, "Expected 'called'");
+        const identifier = this.consumeIdentifierOrKeyword();
+        this.consume(Token_1.TokenType.STARTING, "Expected 'starting'");
+        // Optional 'at' keyword (as identifier 'at')
+        if (this.check(Token_1.TokenType.IDENTIFIER) && this.peek().value === "at") {
+            this.advance();
+        }
+        const initialValue = this.parseValue();
+        this.consume(Token_1.TokenType.PERIOD, "Expected '.'");
+        this.skipNewlines();
+        return {
+            type: AST_1.ASTNodeType.STATE_DECL,
+            varType,
+            identifier,
+            initialValue,
+            location,
+        };
+    }
+    parseType() {
+        const token = this.peek();
+        switch (token.type) {
+            case Token_1.TokenType.NUMBER_TYPE:
+                this.advance();
+                return "number";
+            case Token_1.TokenType.TEXT_TYPE:
+            case Token_1.TokenType.TEXT: // "text" can be both a type and a widget
+                this.advance();
+                return "text";
+            case Token_1.TokenType.BOOLEAN_TYPE:
+                this.advance();
+                return "boolean";
+            case Token_1.TokenType.LIST_TYPE:
+                this.advance();
+                return "list";
+            case Token_1.TokenType.INPUT:
+            case Token_1.TokenType.BUTTON:
+            case Token_1.TokenType.HEADING:
+            case Token_1.TokenType.IMAGE:
+            case Token_1.TokenType.ROW:
+            case Token_1.TokenType.COLUMN:
+                // Widgets can also be used as types for convenience
+                this.advance();
+                return "text"; // Treat widget types as text for now
+            default:
+                this.reportError(`Expected type, got '${token.value}'`);
+                this.advance();
+                return "number"; // Default fallback
+        }
+    }
+    parseValue() {
+        const token = this.peek();
+        if (token.type === Token_1.TokenType.NUMBER) {
+            this.advance();
+            return { type: "number", value: parseFloat(token.value) };
+        }
+        if (token.type === Token_1.TokenType.STRING) {
+            this.advance();
+            return { type: "text", value: token.value };
+        }
+        if (token.type === Token_1.TokenType.TRUE) {
+            this.advance();
+            return { type: "boolean", value: true };
+        }
+        if (token.type === Token_1.TokenType.FALSE) {
+            this.advance();
+            return { type: "boolean", value: false };
+        }
+        if (token.type === Token_1.TokenType.EMPTY) {
+            this.advance();
+            return { type: "empty" };
+        }
+        // Allow identifiers and widget/type keywords as identifier values
+        const allowedTypes = [
+            Token_1.TokenType.IDENTIFIER,
+            Token_1.TokenType.INPUT,
+            Token_1.TokenType.BUTTON,
+            Token_1.TokenType.TEXT,
+            Token_1.TokenType.HEADING,
+            Token_1.TokenType.IMAGE,
+            Token_1.TokenType.ROW,
+            Token_1.TokenType.COLUMN,
+        ];
+        if (allowedTypes.includes(token.type)) {
+            this.advance();
+            return { type: "identifier", name: token.value };
+        }
+        this.reportError(`Expected value, got '${token.value}'`);
+        this.advance();
+        return { type: "empty" };
+    }
+    parseShowStmt(lowercase = false) {
+        const location = this.currentLocation();
+        this.consume(Token_1.TokenType.SHOW, lowercase ? "Expected 'show'" : "Expected 'Show'");
+        // Article - optional for backwards compatibility
+        if (this.check(Token_1.TokenType.A) || this.check(Token_1.TokenType.AN)) {
+            this.advance();
+        }
+        // Check if this is a custom widget (identifier instead of keyword)
+        const isCustom = this.check(Token_1.TokenType.IDENTIFIER);
+        const widget = isCustom ? this.parseCustomWidget() : this.parseWidget();
+        const config = isCustom ? this.parseCustomConfig() : this.parseShowConfig();
+        this.consume(Token_1.TokenType.PERIOD, "Expected '.'");
+        this.skipNewlines();
+        return {
+            type: AST_1.ASTNodeType.SHOW_STMT,
+            widget,
+            config,
+            isCustom,
+            location,
+        };
+    }
+    parseCustomWidget() {
+        // Custom widget is just an identifier (e.g., "card", "modal", etc.)
+        const token = this.consume(Token_1.TokenType.IDENTIFIER, "Expected widget name");
+        return token.value;
+    }
+    parseCustomConfig() {
+        const params = {};
+        // Parse: with key "value" and key2 "value2" ...
+        if (this.check(Token_1.TokenType.WITH)) {
+            this.advance();
+            do {
+                // Parse parameter name (can be any identifier or keyword)
+                const paramName = this.consumeIdentifierOrKeyword();
+                // Parse parameter value (string)
+                const paramValue = this.consume(Token_1.TokenType.STRING, "Expected string value for parameter").value;
+                params[paramName] = paramValue;
+                // Check for "and" to continue with more parameters
+                if (this.check(Token_1.TokenType.AND)) {
+                    this.advance();
+                }
+                else {
+                    break;
+                }
+            } while (true);
+        }
+        return { type: "custom", params };
+    }
+    parseWidget() {
+        const token = this.peek();
+        const widgets = [
+            Token_1.TokenType.HEADING,
+            Token_1.TokenType.TEXT,
+            Token_1.TokenType.PARAGRAPH,
+            Token_1.TokenType.BUTTON,
+            Token_1.TokenType.INPUT,
+            Token_1.TokenType.TEXTAREA,
+            Token_1.TokenType.IMAGE,
+            Token_1.TokenType.ROW,
+            Token_1.TokenType.COLUMN,
+            Token_1.TokenType.CONTAINER,
+            Token_1.TokenType.DIVISION,
+            Token_1.TokenType.ITALIC,
+            Token_1.TokenType.BOLD,
+            Token_1.TokenType.STRONG,
+            Token_1.TokenType.EMPHASIS,
+            Token_1.TokenType.UNDERLINE,
+            Token_1.TokenType.SMALL,
+            Token_1.TokenType.MARK,
+            Token_1.TokenType.DELETED,
+            Token_1.TokenType.INSERTED,
+            Token_1.TokenType.SUBSCRIPT,
+            Token_1.TokenType.SUPERSCRIPT,
+            Token_1.TokenType.CODE,
+            Token_1.TokenType.PREFORMATTED,
+            Token_1.TokenType.QUOTE,
+            Token_1.TokenType.LINK,
+            Token_1.TokenType.UNORDERED_LIST,
+            Token_1.TokenType.ORDERED_LIST,
+            Token_1.TokenType.LISTITEM,
+            Token_1.TokenType.SECTION,
+            Token_1.TokenType.ARTICLE,
+            Token_1.TokenType.ASIDE,
+            Token_1.TokenType.HEADER,
+            Token_1.TokenType.FOOTER,
+            Token_1.TokenType.NAV,
+            Token_1.TokenType.MAIN,
+            Token_1.TokenType.SPAN,
+            Token_1.TokenType.LINEBREAK,
+            Token_1.TokenType.RULE,
+            Token_1.TokenType.TABLE,
+            Token_1.TokenType.TABLEROW,
+            Token_1.TokenType.TABLEDATA,
+            Token_1.TokenType.TABLEHEADER,
+        ];
+        if (!widgets.includes(token.type)) {
+            this.reportError(`Expected widget type, got '${token.value}'`);
+            this.advance();
+            return "text"; // Default fallback
+        }
+        this.advance();
+        // Map English-friendly names to HTML tags
+        return this.mapTokenToWidgetType(token.type);
+    }
+    mapTokenToWidgetType(tokenType) {
+        const mapping = {
+            // Original widgets - keep as-is for backwards compatibility
+            [Token_1.TokenType.HEADING]: "heading",
+            [Token_1.TokenType.TEXT]: "text",
+            [Token_1.TokenType.BUTTON]: "button",
+            [Token_1.TokenType.INPUT]: "input",
+            [Token_1.TokenType.IMAGE]: "image",
+            [Token_1.TokenType.ROW]: "row",
+            [Token_1.TokenType.COLUMN]: "column",
+            // New HTML-friendly widgets
+            [Token_1.TokenType.PARAGRAPH]: "p",
+            [Token_1.TokenType.TEXTAREA]: "textarea",
+            [Token_1.TokenType.CONTAINER]: "div",
+            [Token_1.TokenType.DIVISION]: "div",
+            [Token_1.TokenType.ITALIC]: "i",
+            [Token_1.TokenType.BOLD]: "b",
+            [Token_1.TokenType.STRONG]: "strong",
+            [Token_1.TokenType.EMPHASIS]: "em",
+            [Token_1.TokenType.UNDERLINE]: "u",
+            [Token_1.TokenType.SMALL]: "small",
+            [Token_1.TokenType.MARK]: "mark",
+            [Token_1.TokenType.DELETED]: "del",
+            [Token_1.TokenType.INSERTED]: "ins",
+            [Token_1.TokenType.SUBSCRIPT]: "sub",
+            [Token_1.TokenType.SUPERSCRIPT]: "sup",
+            [Token_1.TokenType.CODE]: "code",
+            [Token_1.TokenType.PREFORMATTED]: "pre",
+            [Token_1.TokenType.QUOTE]: "blockquote",
+            [Token_1.TokenType.LINK]: "a",
+            [Token_1.TokenType.UNORDERED_LIST]: "ul",
+            [Token_1.TokenType.ORDERED_LIST]: "ol",
+            [Token_1.TokenType.LISTITEM]: "li",
+            [Token_1.TokenType.SECTION]: "section",
+            [Token_1.TokenType.ARTICLE]: "article",
+            [Token_1.TokenType.ASIDE]: "aside",
+            [Token_1.TokenType.HEADER]: "header",
+            [Token_1.TokenType.FOOTER]: "footer",
+            [Token_1.TokenType.NAV]: "nav",
+            [Token_1.TokenType.MAIN]: "main",
+            [Token_1.TokenType.SPAN]: "span",
+            [Token_1.TokenType.LINEBREAK]: "br",
+            [Token_1.TokenType.RULE]: "hr",
+            [Token_1.TokenType.TABLE]: "table",
+            [Token_1.TokenType.TABLEROW]: "tr",
+            [Token_1.TokenType.TABLEDATA]: "td",
+            [Token_1.TokenType.TABLEHEADER]: "th",
+        };
+        return mapping[tokenType] || "text";
+    }
+    parseShowConfig() {
+        if (this.check(Token_1.TokenType.SAYING)) {
+            this.advance();
+            const template = this.consume(Token_1.TokenType.STRING, "Expected string after 'saying'").value;
+            return { type: "saying", template };
+        }
+        if (this.check(Token_1.TokenType.CALLED)) {
+            this.advance();
+            const identifier = this.consumeIdentifierOrKeyword();
+            return { type: "called", identifier };
+        }
+        if (this.check(Token_1.TokenType.WITH)) {
+            this.advance();
+            this.consume(Token_1.TokenType.SOURCE, "Expected 'source' after 'with'");
+            const source = this.consume(Token_1.TokenType.STRING, "Expected string after 'source'").value;
+            return { type: "image", source };
+        }
+        return { type: "empty" };
+    }
+    parseEventBlock() {
+        const location = this.currentLocation();
+        this.consume(Token_1.TokenType.WHEN, "Expected 'When'");
+        this.consume(Token_1.TokenType.I, "Expected 'I'");
+        const verb = this.parseEventVerb();
+        this.consume(Token_1.TokenType.THE, "Expected 'the'");
+        const widgetRef = this.parseWidgetRef();
+        this.consume(Token_1.TokenType.COMMA, "Expected ','");
+        this.skipNewlines();
+        const actions = [];
+        while (!this.isAtEnd() && !this.isStatementStart()) {
+            if (this.check(Token_1.TokenType.NEWLINE)) {
+                this.advance();
+                continue;
+            }
+            const action = this.parseActionStmt();
+            if (action) {
+                actions.push(action);
+            }
+        }
+        return {
+            type: AST_1.ASTNodeType.EVENT_BLOCK,
+            verb,
+            widgetRef,
+            actions,
+            location,
+        };
+    }
+    parseEventVerb() {
+        const token = this.peek();
+        if (token.type === Token_1.TokenType.CLICK) {
+            this.advance();
+            return "click";
+        }
+        if (token.type === Token_1.TokenType.TYPE) {
+            this.advance();
+            return "type";
+        }
+        this.reportError(`Expected event verb (click/type), got '${token.value}'`);
+        this.advance();
+        return "click";
+    }
+    parseWidgetRef() {
+        const widget = this.parseWidget();
+        if (this.check(Token_1.TokenType.STRING)) {
+            const label = this.advance().value;
+            return { type: "literal", widget, label };
+        }
+        if (this.check(Token_1.TokenType.CALLED)) {
+            this.advance();
+            const identifier = this.consume(Token_1.TokenType.IDENTIFIER, "Expected identifier").value;
+            return { type: "identifier", widget, identifier };
+        }
+        this.reportError("Expected string or 'called' after widget type");
+        return { type: "literal", widget, label: "" };
+    }
+    parseActionStmt() {
+        const location = this.currentLocation();
+        const action = this.parseAction();
+        if (!action)
+            return null;
+        this.consume(Token_1.TokenType.PERIOD, "Expected '.' after action");
+        this.skipNewlines();
+        return {
+            type: AST_1.ASTNodeType.ACTION_STMT,
+            action,
+            location,
+        };
+    }
+    parseAction() {
+        if (this.check(Token_1.TokenType.INCREASE)) {
+            return this.parseIncreaseAction();
+        }
+        if (this.check(Token_1.TokenType.DECREASE)) {
+            return this.parseDecreaseAction();
+        }
+        if (this.check(Token_1.TokenType.SET)) {
+            return this.parseSetAction();
+        }
+        if (this.check(Token_1.TokenType.ADD)) {
+            return this.parseAddAction();
+        }
+        if (this.check(Token_1.TokenType.REMOVE)) {
+            return this.parseRemoveAction();
+        }
+        if (this.check(Token_1.TokenType.TOGGLE)) {
+            return this.parseToggleAction();
+        }
+        // Check for custom action (identifier)
+        if (this.check(Token_1.TokenType.IDENTIFIER)) {
+            return this.parseCustomAction();
+        }
+        this.reportError(`Expected action keyword, got '${this.peek().value}'`);
+        return null;
+    }
+    parseCustomAction() {
+        const name = this.consume(Token_1.TokenType.IDENTIFIER, "Expected action name").value;
+        const identifier = this.consumeIdentifierOrKeyword();
+        // Optional parameters: with param1 "value1" and param2 "value2"
+        const params = {};
+        if (this.check(Token_1.TokenType.WITH)) {
+            this.advance();
+            do {
+                const paramName = this.consumeIdentifierOrKeyword();
+                const paramValue = this.consume(Token_1.TokenType.STRING, "Expected string value").value;
+                params[paramName] = paramValue;
+                if (this.check(Token_1.TokenType.AND)) {
+                    this.advance();
+                }
+                else {
+                    break;
+                }
+            } while (true);
+        }
+        return {
+            type: "custom",
+            name,
+            identifier,
+            params: Object.keys(params).length > 0 ? params : undefined,
+        };
+    }
+    parseIncreaseAction() {
+        this.consume(Token_1.TokenType.INCREASE, "Expected 'increase'");
+        const identifier = this.consumeIdentifierOrKeyword();
+        this.consume(Token_1.TokenType.BY, "Expected 'by'");
+        const amount = parseFloat(this.consume(Token_1.TokenType.NUMBER, "Expected number").value);
+        return { type: "increase", identifier, amount };
+    }
+    parseDecreaseAction() {
+        this.consume(Token_1.TokenType.DECREASE, "Expected 'decrease'");
+        const identifier = this.consumeIdentifierOrKeyword();
+        this.consume(Token_1.TokenType.BY, "Expected 'by'");
+        const amount = parseFloat(this.consume(Token_1.TokenType.NUMBER, "Expected number").value);
+        return { type: "decrease", identifier, amount };
+    }
+    parseSetAction() {
+        this.consume(Token_1.TokenType.SET, "Expected 'set'");
+        const identifier = this.consumeIdentifierOrKeyword();
+        this.consume(Token_1.TokenType.TO, "Expected 'to'");
+        const value = this.parseValue();
+        return { type: "set", identifier, value };
+    }
+    parseAddAction() {
+        this.consume(Token_1.TokenType.ADD, "Expected 'add'");
+        const value = this.parseValue();
+        this.consume(Token_1.TokenType.TO, "Expected 'to'");
+        const list = this.consumeIdentifierOrKeyword();
+        return { type: "add", value, list };
+    }
+    parseRemoveAction() {
+        this.consume(Token_1.TokenType.REMOVE, "Expected 'remove'");
+        const value = this.parseValue();
+        this.consume(Token_1.TokenType.FROM, "Expected 'from'");
+        const list = this.consumeIdentifierOrKeyword();
+        return { type: "remove", value, list };
+    }
+    parseToggleAction() {
+        this.consume(Token_1.TokenType.TOGGLE, "Expected 'toggle'");
+        const identifier = this.consumeIdentifierOrKeyword();
+        return { type: "toggle", identifier };
+    }
+    parseIfBlock() {
+        const location = this.currentLocation();
+        this.consume(Token_1.TokenType.IF, "Expected 'If'");
+        const condition = this.parseCondition();
+        this.consume(Token_1.TokenType.COMMA, "Expected ','");
+        this.skipNewlines();
+        const body = [];
+        while (!this.isAtEnd() && !this.isStatementStart()) {
+            if (this.check(Token_1.TokenType.NEWLINE)) {
+                this.advance();
+                continue;
+            }
+            const showStmt = this.parseShowStmt(true);
+            body.push(showStmt);
+        }
+        return {
+            type: AST_1.ASTNodeType.IF_BLOCK,
+            condition,
+            body,
+            location,
+        };
+    }
+    parseCondition() {
+        const location = this.currentLocation();
+        const identifier = this.consumeIdentifierOrKeyword();
+        this.consume(Token_1.TokenType.IS, "Expected 'is'");
+        const comparator = this.parseComparator();
+        const value = this.parseValue();
+        return {
+            type: AST_1.ASTNodeType.CONDITION,
+            identifier,
+            comparator,
+            value,
+            location,
+        };
+    }
+    parseComparator() {
+        // Handle 'not equal to'
+        if (this.check(Token_1.TokenType.NOT)) {
+            this.advance();
+            this.consume(Token_1.TokenType.EQUAL, "Expected 'equal'");
+            this.consume(Token_1.TokenType.TO, "Expected 'to'");
+            return "notEqual";
+        }
+        // Handle 'equal to'
+        if (this.check(Token_1.TokenType.EQUAL)) {
+            this.advance();
+            this.consume(Token_1.TokenType.TO, "Expected 'to'");
+            return "equal";
+        }
+        // Handle 'greater than [or equal to]'
+        if (this.check(Token_1.TokenType.GREATER)) {
+            this.advance();
+            this.consume(Token_1.TokenType.THAN, "Expected 'than'");
+            if (this.check(Token_1.TokenType.OR)) {
+                this.advance();
+                this.consume(Token_1.TokenType.EQUAL, "Expected 'equal'");
+                this.consume(Token_1.TokenType.TO, "Expected 'to'");
+                return "greaterOrEqual";
+            }
+            return "greater";
+        }
+        // Handle 'less than [or equal to]'
+        if (this.check(Token_1.TokenType.LESS)) {
+            this.advance();
+            this.consume(Token_1.TokenType.THAN, "Expected 'than'");
+            if (this.check(Token_1.TokenType.OR)) {
+                this.advance();
+                this.consume(Token_1.TokenType.EQUAL, "Expected 'equal'");
+                this.consume(Token_1.TokenType.TO, "Expected 'to'");
+                return "lessOrEqual";
+            }
+            return "less";
+        }
+        this.reportError("Expected comparator");
+        return "equal";
+    }
+    parseForEachBlock() {
+        const location = this.currentLocation();
+        this.consume(Token_1.TokenType.FOR, "Expected 'For'");
+        this.consume(Token_1.TokenType.EACH, "Expected 'each'");
+        const itemName = this.consumeIdentifierOrKeyword();
+        this.consume(Token_1.TokenType.IN, "Expected 'in'");
+        const listName = this.consumeIdentifierOrKeyword();
+        this.consume(Token_1.TokenType.COMMA, "Expected ','");
+        this.skipNewlines();
+        const body = [];
+        while (!this.isAtEnd() && !this.isStatementStart()) {
+            if (this.check(Token_1.TokenType.NEWLINE)) {
+                this.advance();
+                continue;
+            }
+            const showStmt = this.parseShowStmt(true);
+            body.push(showStmt);
+        }
+        return {
+            type: AST_1.ASTNodeType.FOR_EACH_BLOCK,
+            itemName,
+            listName,
+            body,
+            location,
+        };
+    }
+    // Helper methods
+    isStatementStart() {
+        const token = this.peek();
+        return (this.check(Token_1.TokenType.THERE) ||
+            (this.check(Token_1.TokenType.SHOW) && token.value === "Show") || // Only capitalized Show
+            this.check(Token_1.TokenType.WHEN) ||
+            this.check(Token_1.TokenType.IF) ||
+            this.check(Token_1.TokenType.FOR));
+    }
+    skipNewlines() {
+        while (this.check(Token_1.TokenType.NEWLINE)) {
+            this.advance();
+        }
+    }
+    check(type) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().type === type;
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.current++;
+        return this.previous();
+    }
+    isAtEnd() {
+        return this.peek().type === Token_1.TokenType.EOF;
+    }
+    peek() {
+        return this.tokens[this.current];
+    }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+    consumeIdentifierOrKeyword() {
+        const token = this.peek();
+        // Allow identifiers and almost any keyword as identifiers in certain contexts
+        // This is useful for variable names and custom widget parameters
+        const allowedTypes = [
+            Token_1.TokenType.IDENTIFIER,
+            // Widgets
+            Token_1.TokenType.INPUT,
+            Token_1.TokenType.BUTTON,
+            Token_1.TokenType.TEXT,
+            Token_1.TokenType.HEADING,
+            Token_1.TokenType.IMAGE,
+            Token_1.TokenType.ROW,
+            Token_1.TokenType.COLUMN,
+            // Types
+            Token_1.TokenType.NUMBER_TYPE,
+            Token_1.TokenType.TEXT_TYPE,
+            Token_1.TokenType.BOOLEAN_TYPE,
+            Token_1.TokenType.LIST_TYPE,
+            // Other keywords that might be used as parameter names
+            Token_1.TokenType.TYPE,
+            Token_1.TokenType.SOURCE,
+            Token_1.TokenType.BY,
+            Token_1.TokenType.TO,
+            Token_1.TokenType.FROM,
+            Token_1.TokenType.WITH,
+            Token_1.TokenType.AT,
+        ];
+        if (allowedTypes.includes(token.type)) {
+            this.advance();
+            return token.value;
+        }
+        this.reportError("Expected identifier");
+        throw new Error("Expected identifier");
+    }
+    consume(type, message) {
+        if (this.check(type))
+            return this.advance();
+        this.reportError(message);
+        throw new Error(message);
+    }
+    currentLocation() {
+        return this.peek().location;
+    }
+    reportError(message) {
+        this.errorReporter.report({
+            message,
+            location: this.currentLocation(),
+            severity: IErrorReporter_1.ErrorSeverity.ERROR,
+        });
+    }
+    synchronize() {
+        this.advance();
+        while (!this.isAtEnd()) {
+            if (this.previous().type === Token_1.TokenType.NEWLINE) {
+                return;
+            }
+            if (this.isStatementStart()) {
+                return;
+            }
+            this.advance();
+        }
+    }
+}
+exports.LingoParser = LingoParser;
+//# sourceMappingURL=LingoParser.js.map