@katnip-org/compiler 0.1.0

package/build/parser/Parser.js

@@ -0,0 +1,1215 @@
+/**
+ * @fileoverview Contains the main parser class for the Katnip compiler.
+ */
+import { isValuedTokenType, UnitTokenType } from "../lexer/Token.js";
+import { ErrorReporter, KatnipError } from "../utils/ErrorReporter.js";
+import { KatnipLog, KatnipLogType, Logger } from "../utils/Logger.js";
+import { VariableDeclarationType } from "./AST-nodes.js";
+import { bindingPowerTable, getBindingPower } from "./BindingPowerTable.js";
+export class Parser {
+    reporter;
+    logger;
+    tokens = [];
+    position = 0;
+    constructor(reporter, logger = new Logger()) {
+        this.reporter = reporter;
+        this.logger = logger;
+    }
+    /**
+     * Parses a list of tokens into an Abstract Syntax Tree (AST).
+     * @param tokens - The list of tokens to parse.
+     * @returns The resulting AST or void if parsing fails.
+     */
+    parse(tokens) {
+        this.logger.print(new KatnipLog(KatnipLogType.Info, `--- Parsing started with ${tokens.length} tokens ---`));
+        this.tokens = tokens;
+        this.position = 0;
+        const statements = [];
+        while (!this.isAtEnd()) {
+            const before = this.position;
+            this.logger.log(new KatnipLog(KatnipLogType.Debug, `Parsing statement at token: ${this.peek()?.token.type}`));
+            const stmt = this.parseStatement();
+            if (stmt)
+                statements.push(stmt);
+            if (this.position === before) {
+                this.reporter.add(new KatnipError("Parser", `Parser got stuck on token '${this.peek()?.token.type}'`, this.peek()?.start ?? { line: -1, column: -1 }));
+                this.advance();
+            }
+        }
+        return { type: "Program", body: statements };
+    }
+    // -- Helper functions --
+    /**
+     * Retrieves the current token without advancing the position.
+     * @param lookAhead - Number of tokens to look ahead.
+     * @returns The current token or null if at the end.
+     */
+    peek(lookAhead = 0) {
+        const index = this.position + lookAhead;
+        return index < this.tokens.length ? this.tokens[index] : null;
+    }
+    /**
+     * Retrieves the previous token.
+     * @returns The previous token or null if at the beginning.
+     */
+    previous() {
+        return this.position > 0 ? this.tokens[this.position - 1] : null;
+    }
+    /**
+     * Advances the position and retrieves the previous token.
+     * @returns The previous token or null if at the beginning.
+     */
+    advance() {
+        if (!this.isAtEnd()) {
+            this.position++;
+        }
+        return this.previous();
+    }
+    /**
+     * Checks if the parser has reached the end of the token list.
+     * @returns True if at the end, false otherwise.
+     */
+    isAtEnd() {
+        return this.peek()?.token.type === "<EOF>";
+    }
+    /**
+     * Checks if the current token matches the specified type or value.
+     * @param kind - The kind of check ("type" or "value").
+     * @param patterns - The patterns to match against.
+     * @returns True if the token matches, false otherwise.
+     */
+    checkToken(kind, patterns) {
+        if (this.isAtEnd())
+            return false;
+        const token = this.peek();
+        if (!token)
+            return false;
+        if (kind === "type") {
+            return patterns.includes(token.token.type);
+        }
+        else {
+            if (!isValuedTokenType(token.token.type))
+                return false;
+            return patterns.includes(token.token.value);
+        }
+    }
+    /**
+     * Attempts to consume the current token if it matches the specified type or value.
+     * @param kind - The kind of check ("type" or "value").
+     * @param patterns - The patterns to match against.
+     * @returns True if the token was consumed, false otherwise.
+     */
+    tryConsume(kind, patterns) {
+        if (this.checkToken(kind, patterns)) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Consumes the current token if it matches the specified type or value.
+     * Reports an error if the token does not match.
+     * @param options - The options specifying the type and/or value to match.
+     * @param message - The error message to report if the token does not match.
+     * @returns The consumed token information or an error token.
+     */
+    consume(options, message, sync) {
+        const types = options.type ? (Array.isArray(options.type) ? options.type : [options.type]) : [];
+        const values = options.value ? (Array.isArray(options.value) ? options.value : [options.value]) : [];
+        if (types.length && this.tryConsume("type", types)) {
+            return this.previous();
+        }
+        if (values.length && this.tryConsume("value", values)) {
+            return this.previous();
+        }
+        if (!types.length && !values.length)
+            throw new Error("consume() must be called with either type or value");
+        const previousToken = this.previous();
+        const currentToken = this.peek();
+        if (previousToken) {
+            this.reporter.add(new KatnipError("Parser", message, {
+                line: previousToken.end.line,
+                column: previousToken.end.column
+            }));
+        }
+        else if (currentToken) {
+            this.reporter.add(new KatnipError("Parser", message, currentToken.start));
+        }
+        const before = this.position;
+        if (sync) {
+            this.synchronize(sync, "Failed to synchronize after consume error");
+        }
+        if (this.position === before && !this.isAtEnd()) {
+            this.advance();
+        }
+        return {
+            token: { type: "ErrorToken", value: "" },
+            start: { line: -1, column: -1 },
+            end: { line: -1, column: -1 }
+        };
+    }
+    /**
+     * Checks whether the current token matches without consuming it.
+     * Reports an error if it does not match.
+     * @param options - Token type/value options to check.
+     * @param message - Error message to report on failure.
+     * @returns True when the token matches, false otherwise.
+     */
+    expect(options, message) {
+        const types = options.type
+            ? (Array.isArray(options.type) ? options.type : [options.type])
+            : [];
+        const values = options.value
+            ? (Array.isArray(options.value) ? options.value : [options.value])
+            : [];
+        if ((types.length && this.checkToken("type", types)) ||
+            (values.length && this.checkToken("value", values))) {
+            return true;
+        }
+        const prev = this.previous();
+        if (prev) {
+            this.reporter.add(new KatnipError("Parser", message, {
+                line: prev.end.line,
+                column: prev.end.column
+            }));
+        }
+        else if (this.peek()) {
+            this.reporter.add(new KatnipError("Parser", message, this.peek().start));
+        }
+        return false;
+    }
+    /**
+     * Advances tokens until a matching type/value is found or EOF is reached.
+     * Reports an error if the end is reached without finding a match.
+     * @param options - Token type/value options to synchronize on.
+     * @param message - Error message to report on failure.
+     */
+    synchronize(options, message) {
+        const beginning = this.peek().start;
+        const types = options.type
+            ? (Array.isArray(options.type) ? options.type : [options.type])
+            : [];
+        const values = options.value
+            ? (Array.isArray(options.value) ? options.value : [options.value])
+            : [];
+        const before = this.position;
+        while (this.peek() != null && !this.checkToken("type", types) && !this.checkToken("value", values)) {
+            this.advance();
+        }
+        if (this.position === before && this.peek() != null) {
+            this.advance();
+        }
+        if (this.peek() == null) {
+            this.reporter.add(new KatnipError("Parser", message, beginning));
+        }
+    }
+    /**
+     * Consumes a statement-terminating ';'.
+     * If it is missing, reports the errorbut does NOT advance.
+     * The current token starts the next statement.
+     */
+    expectSemicolon(message) {
+        if (this.tryConsume("type", [";"]))
+            return;
+        const prev = this.previous();
+        this.reporter.add(new KatnipError("Parser", message, prev
+            ? { line: prev.end.line, column: prev.end.column }
+            : this.peek()?.start ?? { line: -1, column: -1 }));
+    }
+    // -- Statement parsing --
+    /**
+     * Parses through and returns a type annotation.
+     * @returns The parsed type annotation
+     */
+    parseTypeAnnotation() {
+        return this.parseUnionType();
+    }
+    /**
+     * Parses a union type expression (e.g., A | B).
+     * @returns The parsed type node.
+     */
+    parseUnionType() {
+        let left = this.parsePrimaryType();
+        while (this.tryConsume("type", ["|"])) {
+            const right = this.parsePrimaryType();
+            left = {
+                type: "UnionType",
+                left,
+                right,
+                loc: { start: left.loc.start, end: right.loc.end }
+            };
+        }
+        return left;
+    }
+    /**
+     * Parses a primary type, including optional generic parameters.
+     * @returns The parsed type node.
+     */
+    parsePrimaryType() {
+        if (this.checkToken("type", ["("])) {
+            return this.parseTupleType();
+        }
+        const typeNameToken = this.consume({ type: "Identifier" }, "Expected type name");
+        const typeName = typeNameToken.token.value;
+        if (this.tryConsume("type", ["<"])) {
+            const typeParams = [];
+            while (!this.checkToken("type", [">"])) {
+                typeParams.push(this.parseTypeAnnotation());
+                if (!this.tryConsume("type", [","]) && !this.checkToken("type", [">"])) {
+                    this.reporter.add(new KatnipError("Parser", "Expected ',' or '>'", this.peek()?.start ?? { line: -1, column: -1 }));
+                }
+            }
+            this.consume({ type: ">" }, "Expected closing '>'");
+            return {
+                type: "Type",
+                typeName,
+                typeParams,
+                loc: { start: typeNameToken.start, end: this.previous().end }
+            };
+        }
+        return {
+            type: "Type",
+            typeName,
+            loc: { start: typeNameToken.start, end: typeNameToken.end }
+        };
+    }
+    /**
+     * Parses a tuple type, e.g. (str, num). Used for fixed-shape sequences
+     * like the element type of list<(str, num)>.
+     * @returns The parsed tuple type node.
+     */
+    parseTupleType() {
+        const open = this.consume({ type: "(" }, "Expected '(' for tuple type");
+        const elements = [];
+        if (!this.checkToken("type", [")"])) {
+            do {
+                elements.push(this.parseTypeAnnotation());
+            } while (this.tryConsume("type", [","]));
+        }
+        const close = this.consume({ type: ")" }, "Expected ')' to close tuple type");
+        return {
+            type: "TupleType",
+            elements,
+            loc: { start: open.start, end: close.end }
+        };
+    }
+    /**
+     * Parses a single statement from the token list.
+     * @returns The parsed statement or an error token.
+     */
+    parseStatement() {
+        this.logger.log(new KatnipLog(KatnipLogType.Debug, `parsing statement starting with token: ${this.peek()?.token.type} | value: ${isValuedTokenType(this.peek()?.token.type || "<EOF>") ? (this.peek()?.token).value : "N/A"}`));
+        if (this.checkToken("type", ["Comment_SingleExpanded", "Comment_SingleCollapsed", "Comment_MultilineExpanded", "Comment_MultilineCollapsed"])) {
+            const comment = (this.peek()?.token).value;
+            this.advance();
+            return null;
+            // return comment;
+        }
+        if (this.checkToken("type", ["Identifier"])) {
+            if (this.checkToken("value", ["proc"]) && !(this.peek(1)?.token.type === "."))
+                return this.parseProcedureDefinition();
+            if (this.checkToken("value", ["enum"]))
+                return this.parseEnumDefinition();
+            if (this.checkToken("value", ["private", "temp", "public"])) {
+                const next = this.peek(1)?.token;
+                const nextVal = next && isValuedTokenType(next.type) ? next.value : undefined;
+                if (nextVal === "proc")
+                    return this.parseProcedureDefinition();
+                if (nextVal === "enum")
+                    return this.parseEnumDefinition();
+                return this.parseVariableDeclaration();
+            }
+            if (this.checkToken("value", ["sprite"]))
+                return this.parseSpriteDefinition();
+            if (this.checkToken("value", ["if"]))
+                return this.parseIfStatement();
+            if (this.checkToken("value", ["for"]))
+                return this.parseForStatement();
+            if (this.checkToken("value", ["while"]))
+                return this.parseWhileStatement();
+            if (this.checkToken("value", ["do"]))
+                return this.parseDoWhileStatement();
+            if (this.checkToken("value", ["return"]))
+                return this.parseReturnStatement();
+            if (this.checkToken("value", ["switch"]))
+                return this.parseSwitchStatement();
+            if (this.checkToken("value", ["case"]))
+                return this.parseCaseStatement();
+            if (this.checkToken("value", ["default"]))
+                return this.parseDefaultCaseStatement();
+            // Parse an expression statement
+            const expression = this.parseExpression();
+            const assignmentExpression = this.parseAssignmentExpression(expression);
+            if (assignmentExpression) {
+                return assignmentExpression;
+            }
+            const handlerDeclaration = this.parseHandlerDeclaration(expression);
+            if (handlerDeclaration) {
+                return handlerDeclaration;
+            }
+            this.expectSemicolon("Expected semicolon at the end of an expression statement");
+            return {
+                type: "ExpressionStatement",
+                expression: expression,
+                loc: { start: expression.loc.start, end: expression.loc.end }
+            };
+        }
+        this.reporter.add(new KatnipError("Parser", `Unexpected token: Type '${this.peek().token.type}'`, this.peek()?.start || { line: -1, column: -1 }));
+        this.advance();
+        return { type: "ErrorStatement", message: "Failed to parse statement", loc: { start: { line: -1, column: -1 }, end: { line: -1, column: -1 } } };
+    }
+    /**
+     * Parses a return statement: `return;` or `return <expression>;`.
+     * @returns The parsed return statement node.
+     */
+    parseReturnStatement() {
+        const keyword = this.consume({ type: "Identifier", value: "return" }, "Expected 'return' keyword");
+        let argument = null;
+        if (!this.checkToken("type", [";"])) {
+            argument = this.parseExpression();
+        }
+        this.expectSemicolon("Expected ';' at the end of return statement");
+        return {
+            type: "ReturnStatement",
+            argument,
+            loc: { start: keyword.start, end: this.previous()?.end || keyword.end },
+        };
+    }
+    /**
+     * Parses an optional leading access modifier (`public`/`private`/`temp`).
+     * Defaults to `private`. `start` is the modifier's position (or null) to anchor at loc.
+     */
+    parseAccessModifier() {
+        if (this.checkToken("value", ["private", "public", "temp"])) {
+            const tok = this.consume({ type: "Identifier", value: Object.values(VariableDeclarationType) }, "Expected access modifier");
+            return { access: tok.token.value, start: tok.start };
+        }
+        return { access: VariableDeclarationType.private, start: null };
+    }
+    /**
+     * Parses a procedure definition from the token list.
+     * @returns The parsed procedure declaration node.
+     */
+    parseProcedureDefinition() {
+        const { access, start: accessStart } = this.parseAccessModifier();
+        this.consume({ type: "Identifier", value: "proc" }, "Expected 'proc' keyword");
+        const nameToken = this.consume({ type: "Identifier" }, "Expected procedure name");
+        const name = nameToken.token.value;
+        let parsingDecorators = true;
+        const decorators = [];
+        const parameters = [];
+        if (this.tryConsume("type", ["("])) {
+            while (!this.checkToken("type", [")"])) {
+                this.logger.log(new KatnipLog(KatnipLogType.Debug, `parsing proc param/decorator, next token: ${this.peek()?.token.type}, ${this.peek() && isValuedTokenType(this.peek().token.type) ? this.peek().token.value : "N/A"}`));
+                if (this.checkToken("type", ["@"])) {
+                    this.advance();
+                }
+                else if (this.checkToken("type", ["Identifier"])) {
+                    parsingDecorators = false;
+                }
+                else {
+                    this.reporter.add(new KatnipError("Parser", "Expected decorator or parameter", this.peek()?.start || { line: -1, column: -1 }));
+                }
+                if (parsingDecorators) {
+                    this.logger.log(new KatnipLog(KatnipLogType.Debug, "parsing decorators"));
+                    const decoratorNameToken = this.consume({ type: "Identifier" }, "Expected decorator name");
+                    const decoratorName = decoratorNameToken.token.value;
+                    let decoratorValue;
+                    if (!this.expect({ type: ["=", ",", ")"] }, "Expected '=', ',' or ')' after decorator name")) {
+                        this.synchronize({ type: [",", "=", ")"] }, "Failed to parse decorator value");
+                    }
+                    if (this.tryConsume("type", ["="])) {
+                        decoratorValue = this.parseExpression();
+                    }
+                    else {
+                        decoratorValue = {
+                            type: "Literal",
+                            value: "true",
+                            valueType: "String",
+                            loc: {
+                                start: decoratorNameToken.start,
+                                end: decoratorNameToken.end
+                            }
+                        };
+                    }
+                    decorators.push({
+                        type: "Decorator",
+                        name: decoratorName,
+                        value: decoratorValue,
+                        loc: {
+                            start: decoratorValue.loc.start,
+                            end: decoratorValue.loc.end
+                        }
+                    });
+                }
+                else {
+                    const parameterNameToken = this.consume({ type: "Identifier" }, "Expected parameter name");
+                    const parameterName = parameterNameToken.token.value;
+                    this.consume({ type: ":" }, "Expected ':' after parameter name for type annotation");
+                    const parameterTypeToken = this.parseTypeAnnotation();
+                    this.logger.log(new KatnipLog(KatnipLogType.Debug, `Parsed parameter type: ${JSON.stringify(parameterTypeToken)}`));
+                    let defaultValueToken;
+                    if (this.tryConsume("type", ["="])) {
+                        defaultValueToken = this.parseExpression();
+                    }
+                    parameters.push({
+                        type: "Parameter",
+                        name: parameterName,
+                        paramType: parameterTypeToken,
+                        default: defaultValueToken,
+                        loc: {
+                            start: parameterNameToken.start,
+                            end: defaultValueToken?.loc.end || parameterTypeToken.loc.end
+                        }
+                    });
+                }
+                if (!this.checkToken("type", [")"])) {
+                    this.consume({ type: "," }, "Expected ',' or ')'");
+                }
+            }
+            this.consume({ type: ")" }, "Expected closing parenthesis for parameters");
+        }
+        this.logger.log(new KatnipLog(KatnipLogType.Debug, "❌ - Finished parsing parameters/decorators"));
+        this.consume({ type: "->" }, "Expected arrow return symbol '->'");
+        const returnType = this.parseTypeAnnotation();
+        this.consume({ type: "{" }, "Expected open curly brace '{' for procedure body");
+        const stmts = [];
+        while (!this.isAtEnd() && !this.checkToken("type", ["}"])) {
+            const stmt = this.parseStatement();
+            if (stmt)
+                stmts.push(stmt);
+        }
+        this.consume({ type: "}" }, "Expected closing curly brace '}' for procedure body");
+        const body = {
+            type: "Block",
+            body: stmts,
+            loc: { start: stmts[0]?.loc.start || nameToken.start, end: stmts[stmts.length - 1]?.loc.end || nameToken.start }
+        };
+        return {
+            type: "ProcedureDeclaration",
+            access,
+            name,
+            decorators,
+            parameters,
+            returnType,
+            body,
+            loc: {
+                start: accessStart ?? nameToken.start,
+                end: this.previous()?.end || { line: -1, column: -1 }
+            }
+        };
+    }
+    /**
+     * Parses an enum definition from the token list.
+     * @returns The parsed enum declaration node.
+     */
+    parseEnumDefinition() {
+        const { access, start: accessStart } = this.parseAccessModifier();
+        this.consume({ type: "Identifier", value: "enum" }, "Expected 'enum' keyword");
+        const nameToken = this.consume({ type: "Identifier" }, "Expected enum name");
+        const name = nameToken.token.value;
+        this.consume({ type: "{" }, "Expected opening brace for enum members");
+        const members = [];
+        while (!this.checkToken("type", ["}"])) {
+            const memberToken = this.consume({ type: "Identifier" }, "Expected enum member name");
+            members.push(memberToken.token.value);
+            if (!this.tryConsume("type", [","]) && !this.checkToken("type", ["}"])) {
+                this.reporter.add(new KatnipError("Parser", "Expected ',' or '}'", this.peek()?.start || { line: -1, column: -1 }));
+            }
+        }
+        this.consume({ type: "}" }, "Expected closing brace for enum members");
+        return {
+            type: "EnumDeclaration",
+            access,
+            name: name,
+            members: members,
+            loc: {
+                start: accessStart ?? nameToken.start,
+                end: this.previous()?.end || { line: -1, column: -1 }
+            }
+        };
+    }
+    /**
+     * Parses a variable declaration from the token list.
+     * @returns The parsed variable declaration node.
+     */
+    parseVariableDeclaration() {
+        this.logger.log(new KatnipLog(KatnipLogType.Debug, `parsing variable declaration starting with token: ${this.peek()?.token.type}`));
+        const access = this.consume({ type: "Identifier", value: Object.values(VariableDeclarationType) }, "Expected 'private', 'temp', or 'public' keyword");
+        const variableName = this.consume({ type: "Identifier" }, "Expected variable name");
+        // Valid fomations: no type + yes init, yes type + yes init, yes type + no init
+        // INvalid formations: no type + no init
+        let typeAnnotation = null;
+        let initializer = null;
+        if (this.tryConsume("type", [":"])) {
+            typeAnnotation = this.parseTypeAnnotation();
+            if (this.tryConsume("type", ["="])) {
+                initializer = this.parseExpression();
+            }
+        }
+        else {
+            this.consume({ type: "=" }, "Expected '=' for variable value declaration");
+            initializer = this.parseExpression();
+        }
+        this.expectSemicolon("Expected ';' at the end of variable declaration");
+        return {
+            type: "VariableDeclaration",
+            access: access.token.value,
+            name: variableName.token.value,
+            varType: typeAnnotation,
+            initializer: initializer,
+            loc: {
+                start: access.start,
+                end: this.previous()?.end || { line: -1, column: -1 }
+            }
+        };
+    }
+    parseSpriteDefinition() {
+        this.consume({ type: "Identifier", value: "sprite" }, "Expected 'sprite' keyword");
+        const nameToken = this.consume({ type: "Identifier" }, "Expected sprite name");
+        const name = nameToken.token.value;
+        const stmts = this.parseBlockExpression();
+        const body = {
+            type: "Block",
+            body: stmts,
+            loc: { start: stmts[0]?.loc.start || nameToken.start, end: stmts[stmts.length - 1]?.loc.end || nameToken.start }
+        };
+        return {
+            type: "SpriteDeclaration",
+            name,
+            body,
+            loc: { start: nameToken.start, end: this.previous()?.end || nameToken.start }
+        };
+    }
+    /**
+     * Parses an assignment expression using a previously parsed left-hand side.
+     * @param left - The expression to assign into.
+     * @returns The assignment node or null if no assignment operator follows.
+     */
+    parseAssignmentExpression(left) {
+        if (!this.checkToken("type", ["=", "+=", "-=", "*=", "/=", "%=", "**="])) {
+            return null;
+        }
+        const assginmentOperator = this.consume({ type: [
+                UnitTokenType.Equals,
+                UnitTokenType.PlusEquals,
+                UnitTokenType.MinusEquals,
+                UnitTokenType.AsteriskEquals,
+                UnitTokenType.FwdSlashEquals,
+                UnitTokenType.PercentEquals,
+                UnitTokenType.PowerEquals
+            ] }, "Expected assignment operator").token.type;
+        const right = this.parseExpression();
+        this.expectSemicolon("Expected semicolon at the end of an expression statement");
+        return {
+            type: "VariableAssignment",
+            operator: assginmentOperator,
+            left: left,
+            right: right,
+            loc: { start: left.loc.start, end: right.loc.end }
+        };
+    }
+    /**
+     * Parses a handler declaration following a call expression.
+     * @param left - The call expression that starts the handler declaration.
+     * @returns The handler declaration node or null if not applicable.
+     */
+    parseHandlerDeclaration(left) {
+        if (left.type == "CallExpression" && this.checkToken("type", ["{"])) {
+            const body = this.parseBlockExpression();
+            return {
+                type: "HandlerStatement",
+                call: left,
+                body: {
+                    type: "Block",
+                    body: body,
+                    loc: {
+                        start: body[0]?.loc.start || left.loc.start,
+                        end: body[body.length - 1]?.loc.end || left.loc.end,
+                    },
+                },
+                loc: {
+                    start: left.loc.start,
+                    end: body[body.length - 1]?.loc.end || left.loc.end,
+                },
+            };
+        }
+        return null;
+    }
+    /**
+     * Parses a for statement from the token list.
+     * @returns The parsed for statement node.
+     */
+    parseForStatement() {
+        this.consume({ type: "Identifier", value: "for" }, "Expected 'for' keyword");
+        this.consume({ type: "(" }, "Expected '(' after 'for'");
+        const rawPattern = this.parseExpression();
+        let pattern;
+        if (rawPattern.type === "Identifier" || rawPattern.type === "TupleExpression") {
+            pattern = rawPattern;
+        }
+        else {
+            this.reporter.add(new KatnipError("Parser", "Expected identifier or tuple pattern in for loop", rawPattern.loc.start));
+            pattern = {
+                type: "Identifier",
+                name: "_",
+                loc: rawPattern.loc
+            };
+        }
+        this.consume({ type: "," }, "Expected ',' after for loop pattern");
+        const iterable = this.parseExpression();
+        this.consume({ type: ")" }, "Expected ')' after for loop iterable");
+        const bodyExpression = this.parseBlockExpression();
+        const body = {
+            type: "Block",
+            body: bodyExpression,
+            loc: {
+                start: bodyExpression[0]?.loc.start || iterable.loc.end,
+                end: bodyExpression[bodyExpression.length - 1]?.loc.end || iterable.loc.end
+            }
+        };
+        return {
+            type: "ForStatement",
+            pattern: pattern,
+            iterable,
+            body,
+            loc: {
+                start: pattern.loc.start,
+                end: body.loc.end
+            }
+        };
+    }
+    /**
+     * Parses a while statement from the token list.
+     * @returns The parsed while statement node.
+     */
+    parseWhileStatement() {
+        this.consume({ type: "Identifier", value: "while" }, "Expected 'while' keyword");
+        this.consume({ type: "(" }, "Expected '(' after 'while'");
+        const condition = this.parseExpression();
+        this.consume({ type: ")" }, "Expected ')' after while condition");
+        const bodyExpression = this.parseBlockExpression();
+        const body = {
+            type: "Block",
+            body: bodyExpression,
+            loc: {
+                start: bodyExpression[0]?.loc.start || condition.loc.end,
+                end: bodyExpression[bodyExpression.length - 1]?.loc.end || condition.loc.end
+            }
+        };
+        return {
+            type: "WhileStatement",
+            condition,
+            body,
+            loc: {
+                start: condition.loc.start,
+                end: body.loc.end
+            }
+        };
+    }
+    /**
+     * Parses a do-while statement from the token list.
+     * @returns The parsed do-while statement node.
+     */
+    parseDoWhileStatement() {
+        this.consume({ type: "Identifier", value: "do" }, "Expected 'do' keyword");
+        const bodyExpression = this.parseBlockExpression();
+        const body = {
+            type: "Block",
+            body: bodyExpression,
+            loc: {
+                start: bodyExpression[0]?.loc.start || this.previous()?.start || { line: -1, column: -1 },
+                end: bodyExpression[bodyExpression.length - 1]?.loc.end || this.previous()?.end || { line: -1, column: -1 }
+            }
+        };
+        this.consume({ type: "Identifier", value: "while" }, "Expected 'while' after do block");
+        this.consume({ type: "(" }, "Expected '(' after 'while'");
+        const condition = this.parseExpression();
+        this.consume({ type: ")" }, "Expected ')' after do-while condition");
+        this.tryConsume("type", [";"]);
+        return {
+            type: "DoWhileStatement",
+            condition,
+            body,
+            loc: {
+                start: body.loc.start,
+                end: this.previous()?.end || condition.loc.end
+            }
+        };
+    }
+    parseSwitchStatement() {
+        const start = this.peek().start;
+        this.consume({ type: "Identifier", value: "switch" }, "Expected 'switch' keyword");
+        this.consume({ type: "(" }, "Expected '(' after 'switch'");
+        const value = this.parseExpression();
+        this.consume({ type: ")" }, "Expected ')' after the 'switch'-value");
+        this.consume({ type: "{" }, "Expected '{' after switch expression");
+        const body = [];
+        while (!this.isAtEnd() && !this.checkToken("type", ["}"])) {
+            const stmt = this.parseStatement();
+            if (stmt?.type === "CaseDeclaration" || stmt?.type === "DefaultCaseDeclaration") {
+                body.push(stmt);
+            }
+        }
+        this.consume({ type: "}" }, "Expected '}' to close switch block");
+        return {
+            type: "SwitchDeclaration",
+            value,
+            body,
+            loc: { start, end: this.previous()?.end || value.loc.end }
+        };
+    }
+    parseCaseStatement() {
+        const start = this.peek().start;
+        this.consume({ type: "Identifier", value: "case" }, "Expected 'case' keyword");
+        this.consume({ type: "(" }, "Expected '(' after 'case'");
+        const values = [this.parseExpression()];
+        while (this.tryConsume("type", [","])) {
+            values.push(this.parseExpression());
+        }
+        this.consume({ type: ")" }, "Expected ')' after case values");
+        const stmts = this.parseBlockExpression();
+        const body = {
+            type: "Block",
+            body: stmts,
+            loc: { start: stmts[0]?.loc.start || start, end: stmts[stmts.length - 1]?.loc.end || start }
+        };
+        return { type: "CaseDeclaration", values, body, loc: { start, end: body.loc.end } };
+    }
+    parseDefaultCaseStatement() {
+        const start = this.peek().start;
+        this.consume({ type: "Identifier", value: "default" }, "Expected 'default' keyword");
+        const stmts = this.parseBlockExpression();
+        const body = {
+            type: "Block",
+            body: stmts,
+            loc: { start: stmts[0]?.loc.start || start, end: stmts[stmts.length - 1]?.loc.end || start }
+        };
+        return { type: "DefaultCaseDeclaration", body, loc: { start, end: body.loc.end } };
+    }
+    /**
+     * Parses an if/elif/else statement from the token list.
+     * @returns The parsed if statement node.
+     */
+    parseIfStatement() {
+        this.consume({ type: "Identifier", value: "if" }, "Expected 'if' keyword");
+        this.consume({ type: "(" }, "Expected '(' after 'if'");
+        const condition = this.parseExpression();
+        this.consume({ type: ")" }, "Expected ')' after the 'if'-condition");
+        const thenBlockExpression = this.parseBlockExpression();
+        const thenBlock = {
+            type: "Block",
+            body: thenBlockExpression,
+            loc: {
+                start: thenBlockExpression[0]?.loc.start || condition.loc.end,
+                end: thenBlockExpression[thenBlockExpression.length - 1]?.loc.end || condition.loc.end
+            }
+        };
+        const elifs = [];
+        while (this.tryConsume("value", ["elif"])) {
+            this.consume({ type: "(" }, "Expected '(' after 'elif'");
+            const elifCondition = this.parseExpression();
+            this.consume({ type: ")" }, "Expected ')' after elif condition");
+            const elifBlock = this.parseBlockExpression();
+            elifs.push({
+                type: "ElifClause",
+                condition: elifCondition,
+                block: {
+                    type: "Block",
+                    body: elifBlock,
+                    loc: {
+                        start: elifBlock[0]?.loc.start || elifCondition.loc.start,
+                        end: elifBlock[elifBlock.length - 1]?.loc.end || elifCondition.loc.end
+                    }
+                },
+                loc: {
+                    start: elifCondition.loc.start,
+                    end: elifBlock[elifBlock.length - 1]?.loc.end || elifCondition.loc.end
+                }
+            });
+        }
+        let elseBlock = null;
+        if (this.tryConsume("value", ["else"])) {
+            const elseBlockExpression = this.parseBlockExpression();
+            elseBlock = {
+                type: "Block",
+                body: elseBlockExpression,
+                loc: {
+                    start: elseBlockExpression[0]?.loc.start || this.peek()?.start || condition.loc.end,
+                    end: elseBlockExpression[elseBlockExpression.length - 1]?.loc.end || this.peek()?.end || condition.loc.end
+                }
+            };
+        }
+        return {
+            type: "IfStatement",
+            condition,
+            thenBlock,
+            elifs,
+            elseBlock,
+            loc: {
+                start: condition.loc.start,
+                end: elseBlock ? elseBlock.loc.end : thenBlock.loc.end
+            }
+        };
+    }
+    /**
+     * Parses an expression from the token list.
+     * @returns The parsed expression node.
+     */
+    parseExpression(minBP = 0) {
+        this.logger.log(new KatnipLog(KatnipLogType.Debug, `PREfix operator: ${this.peek()?.token.type}`));
+        let left = this.parsePrefix();
+        while (true) {
+            const token = this.peek();
+            if (!token)
+                break;
+            const bp = getBindingPower(token);
+            if (!bp || bp.lbp <= minBP)
+                break;
+            //this.advance();
+            this.logger.log(new KatnipLog(KatnipLogType.Debug, `Infix operator: ${this.peek()?.token.type}`));
+            left = this.parseInfix(left, bp);
+        }
+        this.logger.log(new KatnipLog(KatnipLogType.Debug, `QUIT on: ${this.peek()?.token.type}`));
+        return left;
+    }
+    /**
+     * Checks whether a token can begin an expression.
+     * @param token - The token to evaluate.
+     * @returns True when the token can start an expression, otherwise false.
+     */
+    canStartExpression(token) {
+        if (!token)
+            return false;
+        const type = token.token.type;
+        return (type === "Identifier" ||
+            type === "Number" ||
+            type === "String" ||
+            type === "InterpolatedString" ||
+            type === "(" ||
+            type === "[" ||
+            type === "{" ||
+            type === "!" ||
+            type === "-");
+    }
+    /**
+     * Parses an interpolated string expression.
+     * @returns The parsed interpolated string expression node.
+     */
+    parseInterpolatedString() {
+        const startToken = this.consume({ type: "InterpolatedString" }, "Expected interpolated string literal");
+        const parts = [];
+        parts.push(startToken.token.value);
+        let end = startToken.end;
+        while (this.canStartExpression(this.peek())) {
+            const expr = this.parseExpression();
+            parts.push(expr);
+            end = expr.loc.end;
+            if (!this.checkToken("type", ["InterpolatedStringEnd"])) {
+                this.reporter.add(new KatnipError("Parser", "Expected end of interpolated expression '}'", this.peek()?.start ?? expr.loc.end));
+                break;
+            }
+            const endToken = this.consume({ type: "InterpolatedStringEnd" }, "Expected end of interpolated expression '}'");
+            end = endToken.end;
+            if (!this.checkToken("type", ["InterpolatedString"])) {
+                break;
+            }
+            const nextChunk = this.consume({ type: "InterpolatedString" }, "Expected interpolated string chunk");
+            parts.push(nextChunk.token.value);
+            end = nextChunk.end;
+        }
+        return {
+            type: "InterpolatedString",
+            parts,
+            loc: { start: startToken.start, end }
+        };
+    }
+    /**
+     * Parses the prefix part of an expression.
+     * @returns The parsed expression node.
+     */
+    parsePrefix() {
+        const token = this.peek();
+        if (!token)
+            return { type: "ErrorToken", value: "", loc: { start: { line: -1, column: -1 }, end: { line: -1, column: -1 } } };
+        const value = token.token.type;
+        // Unary operators
+        if (value === "!" || value === "-") {
+            this.advance();
+            const opKey = value === "-" ? "UnaryMinus" : value;
+            const { rbp } = bindingPowerTable[opKey];
+            const right = this.parseExpression(rbp);
+            return {
+                type: "UnaryExpression",
+                operator: value,
+                argument: right,
+                loc: { start: token.start, end: right.loc?.end || token.end },
+            };
+        }
+        // Parenthesized expression
+        if (this.tryConsume("type", ["("])) {
+            if (this.checkToken("type", [")"])) {
+                this.advance();
+                return { type: "EmptyExpression", loc: { start: token.start, end: this.previous().end } };
+            }
+            const expr = this.parseExpression();
+            if (this.checkToken("type", [","])) {
+                let tupleElements = [expr];
+                while (this.tryConsume("type", [","])) {
+                    tupleElements.push(this.parseExpression());
+                }
+                this.consume({ type: ")" }, "Expected ')' after parenthesized expression");
+                return {
+                    type: "TupleExpression",
+                    elements: tupleElements,
+                    loc: { start: token.start, end: this.previous().end }
+                };
+            }
+            this.consume({ type: ")" }, "Expected ')' after parenthesized expression");
+            return expr;
+        }
+        // Bracket expression
+        if (this.tryConsume("type", ["["])) {
+            const listContents = [];
+            do {
+                listContents.push(this.parseExpression());
+                this.tryConsume("type", [","]);
+            } while (!this.checkToken("type", ["]"]));
+            this.consume({ type: "]" }, "Expected ']' after list expression");
+            return {
+                type: "ListExpression",
+                elements: listContents,
+                loc: { start: token.start, end: this.previous().end }
+            };
+        }
+        // Dictionary expression
+        if (this.tryConsume("type", ["{"])) {
+            const curlyArgs = [];
+            if (!this.checkToken("type", ["}"])) {
+                do {
+                    const keyToken = this.consume({ type: ["String", "Number", "Identifier"] }, "Expected string or number literal or identifier as dictionary key").token;
+                    this.consume({ type: ":" }, "Expected ':' after dictionary key");
+                    const value = this.parseExpression();
+                    let type = "Null";
+                    if (keyToken.type === "String" ||
+                        keyToken.type === "Identifier") {
+                        type = "String";
+                    }
+                    else if (keyToken.type === "Number") {
+                        type = "Number";
+                    }
+                    curlyArgs.push({ key: { type: "Literal", value: keyToken.value, valueType: type, loc: { start: token.start, end: token.end } }, value });
+                } while (this.tryConsume("type", [","]));
+            }
+            this.consume({ type: "}" }, "Expected '}' after parameters");
+            return {
+                type: "DictExpression",
+                entries: curlyArgs,
+                loc: {
+                    start: token.start,
+                    end: this.previous().end,
+                },
+            };
+        }
+        // Identifiers
+        if (this.checkToken("type", ["Identifier"])) {
+            const id = this.consume({ type: "Identifier" }, "Expected identifier");
+            if (id.token.value === "true" || id.token.value === "false") {
+                return {
+                    type: "Literal",
+                    value: id.token.value === "true",
+                    valueType: "Boolean",
+                    loc: { start: id.start, end: id.end },
+                };
+            }
+            return {
+                type: "Identifier",
+                name: id.token.value,
+                loc: { start: id.start, end: id.end },
+            };
+        }
+        // String literal
+        if (this.checkToken("type", ["String"])) {
+            const lit = this.consume({ type: "String" }, "Expected string literal");
+            return {
+                type: "Literal",
+                value: lit.token.value,
+                valueType: "String",
+                loc: { start: lit.start, end: lit.end },
+            };
+        }
+        if (this.checkToken("type", ["InterpolatedString"])) {
+            return this.parseInterpolatedString();
+        }
+        // Number literal
+        if (this.checkToken("type", ["Number"])) {
+            const lit = this.consume({ type: "Number" }, "Expected number literal");
+            return {
+                type: "Literal",
+                value: Number(lit.token.value),
+                valueType: "Number",
+                loc: { start: lit.start, end: lit.end },
+            };
+        }
+        // EOF
+        if (this.checkToken("type", ["<EOF>"])) {
+            return { type: "ErrorToken", value: "", loc: { start: token.start, end: token.end } };
+        }
+        // Fallback error
+        const unexpectedToken = token.token.type;
+        const unexpectedValue = isValuedTokenType(unexpectedToken) ? token.token.value : null;
+        this.reporter.add(new KatnipError("Parser", `Unexpected token in expression: Type '${unexpectedToken}'${unexpectedValue ? `, Value '${unexpectedValue}'` : ''}`, token.start));
+        this.advance();
+        return { type: "ErrorToken", value: "", loc: { start: token.start, end: token.end } };
+    }
+    /**
+     * Parses a single call argument: either a positional expression or a named argument of the form `name = value`.
+     * @returns The parsed argument node.
+     */
+    parseArgument() {
+        if (this.checkToken("type", ["Identifier"]) &&
+            this.peek(1)?.token.type === "=") {
+            const nameToken = this.consume({ type: "Identifier" }, "Expected argument name");
+            this.consume({ type: "=" }, "Expected '=' after argument name");
+            const value = this.parseExpression();
+            return {
+                type: "NamedArgument",
+                name: nameToken.token.value,
+                value,
+                loc: { start: nameToken.start, end: value.loc.end }
+            };
+        }
+        return this.parseExpression();
+    }
+    /**
+     * Parses the infix part of an expression.
+     * @returns The parsed expression node.
+     */
+    parseInfix(left, bp) {
+        const token = this.peek();
+        if (!token) {
+            this.reporter.add(new KatnipError("Parser", "Unexpected end of input in infix expression", left.loc?.end || { line: -1, column: -1 }));
+            return { type: "ErrorToken", value: "", loc: left.loc || { start: { line: -1, column: -1 }, end: { line: -1, column: -1 } } };
+        }
+        if (this.checkToken("type", ["("])) {
+            this.advance();
+            const parenArgs = [];
+            if (!this.checkToken("type", [")"])) {
+                do {
+                    parenArgs.push(this.parseArgument());
+                } while (this.tryConsume("type", [","]));
+            }
+            this.consume({ type: ")" }, "Expected ')' after arguments");
+            return {
+                type: "CallExpression",
+                object: left,
+                arguments: parenArgs,
+                loc: {
+                    start: left.loc.start,
+                    end: this.previous()?.end || token.end,
+                },
+            };
+        }
+        if (this.checkToken("type", ["["])) {
+            this.advance();
+            // Optional start: absent when the bracket opens straight onto ':' or ']'.
+            let sliceStart = null;
+            if (!this.checkToken("type", [":", "]"])) {
+                sliceStart = this.parseExpression();
+            }
+            // No ':' => plain index access (arr[expr]), which needs an index.
+            if (!this.checkToken("type", [":"])) {
+                if (!sliceStart) {
+                    this.reporter.add(new KatnipError("Parser", "Expected an index or slice inside '[]'", this.peek()?.start || { line: -1, column: -1 }));
+                }
+                this.consume({ type: "]" }, "Expected ']' after index");
+                return {
+                    type: "IndexerAccess",
+                    object: left,
+                    index: sliceStart ?? { type: "ErrorToken", value: "", loc: { start: left.loc.start, end: left.loc.end } },
+                    loc: {
+                        start: left.loc.start,
+                        end: this.previous()?.end || token.end,
+                    },
+                };
+            }
+            // Slice: consume the first ':', then an optional end and optional ':' + step.
+            this.advance(); // consume ':'
+            let sliceEnd = null;
+            if (!this.checkToken("type", [":", "]"])) {
+                sliceEnd = this.parseExpression();
+            }
+            let sliceStep = null;
+            if (this.tryConsume("type", [":"])) {
+                if (!this.checkToken("type", ["]"])) {
+                    sliceStep = this.parseExpression();
+                }
+            }
+            this.consume({ type: "]" }, "Expected ']' after slice");
+            return {
+                type: "SliceAccess",
+                object: left,
+                start: sliceStart,
+                end: sliceEnd,
+                step: sliceStep,
+                loc: {
+                    start: left.loc.start,
+                    end: this.previous()?.end || token.end,
+                },
+            };
+        }
+        if (this.checkToken("type", ["."])) {
+            // Member access
+            if (this.checkToken("type", ["."])) {
+                this.advance();
+                const id = this.consume({ type: "Identifier" }, "Expected property name after '.'");
+                return {
+                    type: "MemberExpression",
+                    object: left,
+                    property: {
+                        type: "Identifier",
+                        name: id.token.value,
+                        loc: { start: id.start, end: id.end },
+                    },
+                    loc: { start: left.loc.start, end: id.end },
+                };
+            }
+        }
+        // Binary operator (fallback). Use binding power to parse right-hand side.
+        const tokenValue = isValuedTokenType(token.token.type)
+            ? token.token.value
+            : token.token.type;
+        this.advance();
+        const right = this.parseExpression(bp.rbp);
+        return {
+            type: "BinaryExpression",
+            operator: tokenValue,
+            left,
+            right,
+            loc: { start: left.loc.start, end: right.loc.end },
+        };
+    }
+    /**
+     * Parses a block expression following a method call.
+     * @param allowedStatements - A list of allowed statement types inside this body.
+     * @returns The parsed block expression node.
+     */
+    parseBlockExpression(allowedStatements) {
+        if (!this.checkToken("type", ["{"])) {
+            this.reporter.add(new KatnipError("Parser", "Expected '{' to open block", this.peek()?.start ?? this.previous()?.end ?? { line: -1, column: -1 }));
+            while (!this.isAtEnd() && !this.checkToken("type", ["{", "}"]))
+                this.advance();
+        }
+        this.tryConsume("type", ["{"]);
+        const body = [];
+        while (!this.isAtEnd() && !this.checkToken("type", ["}"])) {
+            const stmt = this.parseStatement();
+            if (stmt && (!allowedStatements || allowedStatements.includes(stmt))) {
+                body.push(stmt);
+            }
+        }
+        this.consume({ type: "}" }, "Expected '}' to close block");
+        return body;
+    }
+}
+//# sourceMappingURL=Parser.js.map