@katnip-org/compiler 0.1.0

package/build/lexer/Token.js

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Token definitions for the Katnip lexer.
+ */
+// Valued token types
+export const ValuedTokenType = {
+    // Literals
+    String: "String",
+    InterpolatedString: "InterpolatedString",
+    InterpolatedStringEnd: "InterpolatedStringEnd",
+    Number: "Number",
+    // Comments
+    Comment_SingleExpanded: "Comment_SingleExpanded",
+    Comment_SingleCollapsed: "Comment_SingleCollapsed",
+    Comment_SingleIgnored: "Comment_SingleIgnored",
+    Comment_MultilineExpanded: "Comment_MultilineExpanded",
+    Comment_MultilineCollapsed: "Comment_MultilineCollapsed",
+    Comment_MultilineIgnored: "Comment_MultilineIgnored",
+    // Misc
+    Identifier: "Identifier",
+    // Used for error handling, not a real token type
+    ErrorToken: "ErrorToken",
+};
+// Unit token types
+export const UnitTokenType = {
+    // Grouping
+    BracketOpen: "[",
+    BracketClose: "]",
+    BraceOpen: "{",
+    BraceClose: "}",
+    ParenOpen: "(",
+    ParenClose: ")",
+    // Punctuation
+    Dot: ".",
+    Comma: ",",
+    Colon: ":",
+    Semicolon: ";",
+    AtSymbol: "@",
+    // Misc punctuation
+    Pound: "#",
+    QuestionMark: "?",
+    // Operators
+    Plus: "+",
+    Minus: "-",
+    Asterisk: "*",
+    FwdSlash: "/",
+    Percent: "%",
+    Caret: "^",
+    Exclamation: "!",
+    Ampersand: "&",
+    Pipe: "|",
+    LeftChevron: "<",
+    RightChevron: ">",
+    Equals: "=",
+    // Double-character operators
+    Power: "**",
+    EqualsTo: "==",
+    LessThanOrEqualsTo: "<=",
+    GreaterThanOrEqualsTo: ">=",
+    AND: "&&",
+    OR: "||",
+    NAND: "!&",
+    NOR: "!|",
+    XNOR: "!^",
+    // Assignment operators
+    PlusEquals: "+=",
+    MinusEquals: "-=",
+    AsteriskEquals: "*=",
+    PowerEquals: "**=",
+    FwdSlashEquals: "/=",
+    PercentEquals: "%=",
+    // Special
+    FunctionReturn: "->",
+    Newline: "\n",
+    EOF: "<EOF>",
+};
+export const unitTokenByLexeme = new Map(Object.entries(UnitTokenType).map(([_, value]) => [value, value]));
+export const singleCharUnitTokens = new Set(Object.values(UnitTokenType).filter(t => t.length === 1));
+export class OperatorTrieNode {
+    children = new Map();
+    tokenType = null;
+}
+export class OperatorTrie {
+    root = new OperatorTrieNode();
+    constructor(operators) {
+        for (const op of operators) {
+            this.insert(op);
+        }
+    }
+    insert(op) {
+        let node = this.root;
+        for (const char of op) {
+            let next = node.children.get(char);
+            if (!next) {
+                next = new OperatorTrieNode();
+                node.children.set(char, next);
+            }
+            node = next;
+        }
+        node.tokenType = op;
+    }
+    start() { return this.root; }
+    step(node, char) { return node.children.get(char) ?? null; }
+}
+export const operatorTrie = new OperatorTrie(Object.values(UnitTokenType));
+// Type guards
+const valuedTokenTypeSet = new Set(Object.values(ValuedTokenType));
+const unitTokenTypeSet = new Set(Object.values(UnitTokenType));
+export function isValuedTokenType(type) {
+    return valuedTokenTypeSet.has(type);
+}
+export function isUnitTokenType(type) {
+    return unitTokenTypeSet.has(type);
+}
+//# sourceMappingURL=Token.js.map

package/build/lexer/Token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Token.js","sourceRoot":"","sources":["../../src/lexer/Token.ts"],"names":[],"mappings":"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"}

package/build/parser/AST-nodes.d.ts

@@ -0,0 +1,230 @@
+/**
+ * @fileoverview Contains all the AST node interfaces for the Katnip parser.
+ */
+export interface AST {
+    body: StatementNode[];
+}
+export interface NodeBase {
+    type: string;
+    loc: SourceLocation;
+    comment?: CommentNode;
+}
+export interface SourceLocation {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+}
+export interface CommentNode {
+    type: "Comment";
+    loc: SourceLocation;
+    content: string;
+    isExpanded: boolean;
+}
+export interface SingleTypeNode extends NodeBase {
+    type: "Type";
+    typeName: string;
+    typeParams?: TypeNode[];
+}
+export interface UnionTypeNode extends NodeBase {
+    type: "UnionType";
+    left: TypeNode;
+    right: TypeNode;
+}
+export interface TupleTypeNode extends NodeBase {
+    type: "TupleType";
+    elements: TypeNode[];
+}
+export type TypeNode = SingleTypeNode | UnionTypeNode | TupleTypeNode;
+export interface ProcedureDeclarationNode extends NodeBase {
+    type: "ProcedureDeclaration";
+    access: VariableDeclarationType;
+    name: string;
+    decorators: DecoratorNode[];
+    parameters: ParameterNode[];
+    returnType: TypeNode | null;
+    body: BlockNode;
+}
+export interface DecoratorNode extends NodeBase {
+    type: "Decorator";
+    name: string;
+    value: ExpressionNode;
+}
+export interface ParameterNode extends NodeBase {
+    type: "Parameter";
+    name: string;
+    paramType: TypeNode;
+    default?: ExpressionNode;
+}
+export interface EnumDeclarationNode extends NodeBase {
+    type: "EnumDeclaration";
+    access: VariableDeclarationType;
+    name: string;
+    members: (string | number)[];
+}
+export type StatementNode = ExpressionStatementNode | VariableDeclarationNode | VariableAssignmentNode | HandlerStatementNode | IfStatementNode | WhileStatementNode | DoWhileStatementNode | ForStatementNode | ProcedureDeclarationNode | EnumDeclarationNode | SwitchDeclarationNode | CaseDeclarationNode | DefaultCaseDeclarationNode | SpriteDeclarationNode | ReturnStatementNode | ErrorStatementNode;
+export type StatementNodeType = StatementNode[];
+export interface BlockNode extends NodeBase {
+    type: "Block";
+    body: StatementNode[];
+}
+export interface BlockStatementBase extends NodeBase {
+    body: BlockNode;
+}
+export interface HandlerStatementNode extends BlockStatementBase {
+    type: "HandlerStatement";
+    call: CallExpressionNode;
+}
+export interface ElifClauseNode extends NodeBase {
+    type: "ElifClause";
+    condition: ExpressionNode;
+    block: BlockNode;
+}
+export interface IfStatementNode extends NodeBase {
+    type: "IfStatement";
+    condition: ExpressionNode;
+    thenBlock: BlockNode;
+    elifs: ElifClauseNode[];
+    elseBlock: BlockNode | null;
+}
+export interface WhileStatementNode extends BlockStatementBase {
+    type: "WhileStatement";
+    condition: ExpressionNode;
+}
+export interface DoWhileStatementNode extends BlockStatementBase {
+    type: "DoWhileStatement";
+    condition: ExpressionNode;
+}
+export interface ForStatementNode extends BlockStatementBase {
+    type: "ForStatement";
+    pattern: (IdentifierExpressionNode | TupleExpressionNode);
+    iterable: ExpressionNode;
+}
+export interface ExpressionStatementNode extends NodeBase {
+    type: "ExpressionStatement";
+    expression: ExpressionNode;
+}
+export interface ReturnStatementNode extends NodeBase {
+    type: "ReturnStatement";
+    argument: ExpressionNode | null;
+}
+export declare enum VariableDeclarationType {
+    private = "private",
+    public = "public",
+    temp = "temp"
+}
+export interface VariableDeclarationNode extends NodeBase {
+    type: "VariableDeclaration";
+    access: VariableDeclarationType;
+    name: string;
+    varType: TypeNode | null;
+    initializer: ExpressionNode | null;
+}
+export interface VariableAssignmentNode extends NodeBase {
+    type: "VariableAssignment";
+    operator: AssignmentOperator;
+    left: ExpressionNode;
+    right: ExpressionNode;
+}
+export interface CaseDeclarationNode extends BlockStatementBase {
+    type: "CaseDeclaration";
+    values: ExpressionNode[];
+}
+export interface DefaultCaseDeclarationNode extends BlockStatementBase {
+    type: "DefaultCaseDeclaration";
+}
+export interface SwitchDeclarationNode extends NodeBase {
+    type: "SwitchDeclaration";
+    value: ExpressionNode;
+    body: (CaseDeclarationNode | DefaultCaseDeclarationNode)[];
+}
+export interface SpriteDeclarationNode extends BlockStatementBase {
+    type: "SpriteDeclaration";
+    name: string;
+}
+export interface ErrorStatementNode extends NodeBase {
+    type: "ErrorStatement";
+    message: string;
+}
+export type ExpressionNode = IdentifierExpressionNode | LiteralExpressionNode | InterpolatedStringExpressionNode | BinaryExpressionNode | CallExpressionNode | IndexerAccessNode | SliceAccessNode | UnaryExpressionNode | MemberExpressionNode | ListExpressionNode | DictExpressionNode | TupleExpressionNode | EmptyExpressionNode | ErrorExpressionNode;
+export interface IdentifierExpressionNode extends NodeBase {
+    type: "Identifier";
+    name: string;
+}
+export interface LiteralExpressionNode extends NodeBase {
+    type: "Literal";
+    value: string | number | boolean | null;
+    valueType: "String" | "Number" | "Boolean" | "Null";
+}
+export interface InterpolatedStringExpressionNode extends NodeBase {
+    type: "InterpolatedString";
+    parts: (string | ExpressionNode)[];
+}
+export type BinaryOperator = "+" | "-" | "*" | "/" | "%" | "**" | "==" | "<" | ">" | "<=" | ">=" | "&&" | "||" | "!&" | "!|" | "!^" | "^";
+export type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "**=" | "/=" | "%=";
+export type UnaryOperator = "!" | "-";
+export interface BinaryExpressionNode extends NodeBase {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: ExpressionNode;
+    right: ExpressionNode;
+}
+export interface NamedArgumentNode extends NodeBase {
+    type: "NamedArgument";
+    name: string;
+    value: ExpressionNode;
+}
+export interface CallExpressionNode extends NodeBase {
+    type: "CallExpression";
+    object: ExpressionNode;
+    arguments: (ExpressionNode | NamedArgumentNode)[];
+}
+export interface IndexerAccessNode extends NodeBase {
+    type: "IndexerAccess";
+    object: ExpressionNode;
+    index: ExpressionNode;
+}
+export interface SliceAccessNode extends NodeBase {
+    type: "SliceAccess";
+    object: ExpressionNode;
+    start: ExpressionNode | null;
+    end: ExpressionNode | null;
+    step: ExpressionNode | null;
+}
+export interface UnaryExpressionNode extends NodeBase {
+    type: "UnaryExpression";
+    operator: UnaryOperator;
+    argument: ExpressionNode;
+}
+export interface MemberExpressionNode extends NodeBase {
+    type: "MemberExpression";
+    object: ExpressionNode;
+    property: IdentifierExpressionNode;
+}
+export interface ListExpressionNode extends NodeBase {
+    type: "ListExpression";
+    elements: ExpressionNode[];
+}
+export interface DictEntryNode {
+    key: ExpressionNode;
+    value: ExpressionNode;
+}
+export interface DictExpressionNode extends NodeBase {
+    type: "DictExpression";
+    entries: DictEntryNode[];
+}
+export interface TupleExpressionNode extends NodeBase {
+    type: "TupleExpression";
+    elements: ExpressionNode[];
+}
+export interface EmptyExpressionNode extends NodeBase {
+    type: "EmptyExpression";
+}
+export interface ErrorExpressionNode extends NodeBase {
+    type: "ErrorToken";
+    value: string;
+}

package/build/parser/AST-nodes.js

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Contains all the AST node interfaces for the Katnip parser.
+ */
+export var VariableDeclarationType;
+(function (VariableDeclarationType) {
+    VariableDeclarationType["private"] = "private";
+    VariableDeclarationType["public"] = "public";
+    VariableDeclarationType["temp"] = "temp";
+})(VariableDeclarationType || (VariableDeclarationType = {}));
+//# sourceMappingURL=AST-nodes.js.map

package/build/parser/AST-nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AST-nodes.js","sourceRoot":"","sources":["../../src/parser/AST-nodes.ts"],"names":[],"mappings":"AAAA;;GAEG;AAuJH,MAAM,CAAN,IAAY,uBAIX;AAJD,WAAY,uBAAuB;IAC/B,8CAAmB,CAAA;IACnB,4CAAiB,CAAA;IACjB,wCAAa,CAAA;AACjB,CAAC,EAJW,uBAAuB,KAAvB,uBAAuB,QAIlC"}

package/build/parser/BindingPowerTable.d.ts

@@ -0,0 +1,8 @@
+import type { Token } from "../lexer/Token.js";
+interface BindingPower {
+    lbp: number;
+    rbp: number;
+}
+export declare const bindingPowerTable: Record<string, BindingPower>;
+export declare function getBindingPower(token: Token | null): BindingPower;
+export {};

package/build/parser/BindingPowerTable.js

@@ -0,0 +1,37 @@
+export const bindingPowerTable = {
+    // logical operators
+    "||": { lbp: 20, rbp: 19 },
+    "&&": { lbp: 30, rbp: 29 },
+    "!|": { lbp: 25, rbp: 24 },
+    "!&": { lbp: 25, rbp: 24 },
+    "!^": { lbp: 25, rbp: 24 },
+    "^": { lbp: 25, rbp: 24 },
+    // comparison operators
+    "==": { lbp: 45, rbp: 44 },
+    "<": { lbp: 50, rbp: 49 },
+    ">": { lbp: 50, rbp: 49 },
+    "<=": { lbp: 50, rbp: 49 },
+    ">=": { lbp: 50, rbp: 49 },
+    // arithmetic operators
+    "+": { lbp: 60, rbp: 59 },
+    "-": { lbp: 60, rbp: 59 },
+    "*": { lbp: 70, rbp: 69 },
+    "/": { lbp: 70, rbp: 69 },
+    "%": { lbp: 70, rbp: 69 },
+    // right associative
+    "**": { lbp: 80, rbp: 81 },
+    // unary operators
+    "!": { lbp: 0, rbp: 79 },
+    "UnaryMinus": { lbp: 0, rbp: 79 }, // unary minus
+    // access/call
+    ".": { lbp: 100, rbp: 100 }, // member access, non-associative
+    "(": { lbp: 110, rbp: 110 }, // function call, non-associative
+    "[": { lbp: 110, rbp: 110 }, // indexing, non-associative
+};
+export function getBindingPower(token) {
+    if (!token)
+        return { lbp: 0, rbp: 0 };
+    const key = token.token.type;
+    return bindingPowerTable[key] || { lbp: 0, rbp: 0 };
+}
+//# sourceMappingURL=BindingPowerTable.js.map

package/build/parser/BindingPowerTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BindingPowerTable.js","sourceRoot":"","sources":["../../src/parser/BindingPowerTable.ts"],"names":[],"mappings":"AAOA,MAAM,CAAC,MAAM,iBAAiB,GAAiC;IAC7D,oBAAoB;IACpB,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,GAAG,EAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAE1B,uBAAuB;IACvB,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,GAAG,EAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,GAAG,EAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAE1B,uBAAuB;IACvB,GAAG,EAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,GAAG,EAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,GAAG,EAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,GAAG,EAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAC1B,GAAG,EAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAE1B,oBAAoB;IACpB,IAAI,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE;IAE1B,kBAAkB;IAClB,GAAG,EAAG,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE;IACzB,YAAY,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,cAAc;IAEjD,cAAc;IACd,GAAG,EAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,iCAAiC;IAC/D,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,iCAAiC;IAC9D,GAAG,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,4BAA4B;CAC1D,CAAC;AAEF,MAAM,UAAU,eAAe,CAAC,KAAmB;IAC/C,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;IAEtC,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;IAC7B,OAAO,iBAAiB,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;AACxD,CAAC"}

package/build/parser/Parser.d.ts

@@ -0,0 +1,208 @@
+/**
+ * @fileoverview Contains the main parser class for the Katnip compiler.
+ */
+import type { Token } from "../lexer/Token.js";
+import { ErrorReporter } from "../utils/ErrorReporter.js";
+import { Logger } from "../utils/Logger.js";
+import { type AST } from "./AST-nodes.js";
+export declare class Parser {
+    private reporter;
+    private logger;
+    private tokens;
+    private position;
+    constructor(reporter: ErrorReporter, 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: Token[]): AST | void;
+    /**
+     * 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.
+     */
+    private peek;
+    /**
+     * Retrieves the previous token.
+     * @returns The previous token or null if at the beginning.
+     */
+    private previous;
+    /**
+     * Advances the position and retrieves the previous token.
+     * @returns The previous token or null if at the beginning.
+     */
+    private advance;
+    /**
+     * Checks if the parser has reached the end of the token list.
+     * @returns True if at the end, false otherwise.
+     */
+    private isAtEnd;
+    /**
+     * 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.
+     */
+    private checkToken;
+    /**
+     * 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.
+     */
+    private tryConsume;
+    /**
+     * 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.
+     */
+    private consume;
+    /**
+     * 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.
+     */
+    private expect;
+    /**
+     * 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.
+     */
+    private synchronize;
+    /**
+     * Consumes a statement-terminating ';'.
+     * If it is missing, reports the errorbut does NOT advance.
+     * The current token starts the next statement.
+     */
+    private expectSemicolon;
+    /**
+     * Parses through and returns a type annotation.
+     * @returns The parsed type annotation
+     */
+    private parseTypeAnnotation;
+    /**
+     * Parses a union type expression (e.g., A | B).
+     * @returns The parsed type node.
+     */
+    private parseUnionType;
+    /**
+     * Parses a primary type, including optional generic parameters.
+     * @returns The parsed type node.
+     */
+    private parsePrimaryType;
+    /**
+     * 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.
+     */
+    private parseTupleType;
+    /**
+     * Parses a single statement from the token list.
+     * @returns The parsed statement or an error token.
+     */
+    private parseStatement;
+    /**
+     * Parses a return statement: `return;` or `return <expression>;`.
+     * @returns The parsed return statement node.
+     */
+    private parseReturnStatement;
+    /**
+     * Parses an optional leading access modifier (`public`/`private`/`temp`).
+     * Defaults to `private`. `start` is the modifier's position (or null) to anchor at loc.
+     */
+    private parseAccessModifier;
+    /**
+     * Parses a procedure definition from the token list.
+     * @returns The parsed procedure declaration node.
+     */
+    private parseProcedureDefinition;
+    /**
+     * Parses an enum definition from the token list.
+     * @returns The parsed enum declaration node.
+     */
+    private parseEnumDefinition;
+    /**
+     * Parses a variable declaration from the token list.
+     * @returns The parsed variable declaration node.
+     */
+    private parseVariableDeclaration;
+    private parseSpriteDefinition;
+    /**
+     * 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.
+     */
+    private parseAssignmentExpression;
+    /**
+     * 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.
+     */
+    private parseHandlerDeclaration;
+    /**
+     * Parses a for statement from the token list.
+     * @returns The parsed for statement node.
+     */
+    private parseForStatement;
+    /**
+     * Parses a while statement from the token list.
+     * @returns The parsed while statement node.
+     */
+    private parseWhileStatement;
+    /**
+     * Parses a do-while statement from the token list.
+     * @returns The parsed do-while statement node.
+     */
+    private parseDoWhileStatement;
+    private parseSwitchStatement;
+    private parseCaseStatement;
+    private parseDefaultCaseStatement;
+    /**
+     * Parses an if/elif/else statement from the token list.
+     * @returns The parsed if statement node.
+     */
+    private parseIfStatement;
+    /**
+     * Parses an expression from the token list.
+     * @returns The parsed expression node.
+     */
+    private parseExpression;
+    /**
+     * 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.
+     */
+    private canStartExpression;
+    /**
+     * Parses an interpolated string expression.
+     * @returns The parsed interpolated string expression node.
+     */
+    private parseInterpolatedString;
+    /**
+     * Parses the prefix part of an expression.
+     * @returns The parsed expression node.
+     */
+    private parsePrefix;
+    /**
+     * Parses a single call argument: either a positional expression or a named argument of the form `name = value`.
+     * @returns The parsed argument node.
+     */
+    private parseArgument;
+    /**
+     * Parses the infix part of an expression.
+     * @returns The parsed expression node.
+     */
+    private parseInfix;
+    /**
+     * 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.
+     */
+    private parseBlockExpression;
+}