qasm-ts 1.1.2 → 2.0.0

package/dist/qasm3/parser.js

@@ -0,0 +1,2030 @@
+"use strict";
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+var token_1 = require("./token");
+var version_1 = require("../version");
+var errors_1 = require("../errors");
+var ast_1 = require("./ast");
+/**
+ * Handles throwing parser errors with basic stack trace.
+ * @param error - The error to throw.
+ * @param token - The source token for the error.
+ * @param index - The token index.
+ * @param message - Optional additional error context.
+ */
+function throwParserError(error, token, index, message) {
+    var errorMessage = message
+        ? "index: ".concat(index, " at token [").concat(token, "], ").concat(message)
+        : "index: ".concat(index, " at token [").concat(token, "]");
+    throw new error(errorMessage);
+}
+/** Class representing a token parser. */
+var Parser = /** @class */ (function () {
+    /**
+     * Creates a parser.
+     * @param tokens - Tokens to parse.
+     * @param defaultFloatWidth - Optional default float width override.
+     * @param machineIntSize - Optional default int size override.
+     */
+    function Parser(tokens, defaultFloatWidth, machineIntSize) {
+        this.tokens = tokens;
+        this.gates = new Set(["U", "gphase"]);
+        this.standardGates = new Set();
+        this.customGates = new Set();
+        this.subroutines = new Set();
+        this.customArrays = new Set();
+        this.aliases = new Map();
+        this.index = 0;
+        this.machineFloatWidth = defaultFloatWidth ? defaultFloatWidth : 64;
+        this.machineIntSize = machineIntSize ? machineIntSize : 32;
+    }
+    /**
+     * Loads the standard library gates.
+     */
+    Parser.prototype.stdGates = function () {
+        var gates = [
+            "p",
+            "x",
+            "y",
+            "z",
+            "h",
+            "s",
+            "sdg",
+            "t",
+            "tdg",
+            "sx",
+            "rx",
+            "ry",
+            "rz",
+            "cx",
+            "cy",
+            "cz",
+            "cp",
+            "crx",
+            "cry",
+            "crz",
+            "ch",
+            "swap",
+            "ccx",
+            "cswap",
+            "cu",
+            // OpenQASM 2 backwards compatibility gates
+            "CX",
+            "phase",
+            "cphase",
+            "id",
+            "u1",
+            "u2",
+            "u3",
+        ];
+        gates.forEach(this.standardGates.add, this.standardGates);
+    };
+    /**
+     * Parses the token stream and generates an abstract syntax tree.
+     * @return The abstract syntax tree.
+     */
+    Parser.prototype.parse = function () {
+        var ast = [];
+        while (this.index < this.tokens.length - 1) {
+            var _a = this.parseNode(this.tokens.slice(this.index)), nodes = _a[0], consumed = _a[1];
+            ast = ast.concat(nodes ? nodes : []);
+            this.index += consumed;
+        }
+        return ast;
+        // let i = 0;
+        // while (i < this.tokens.length - 1) {
+        //   this.index = i;
+        //   const nodes = this.parseNode(this.tokens.slice(i))[0];
+        //   ast = ast.concat(nodes ? nodes : []);
+        //   while (!this.matchNext(this.tokens.slice(i), [Token.Semicolon])) {
+        //     if (this.matchNext(this.tokens.slice(i), [Token.LCParen])) {
+        //       while (!this.matchNext(this.tokens.slice(i), [Token.RCParen])) {
+        //         i++;
+        //       }
+        //       break;
+        //     } else if (this.matchNext(this.tokens.slice(i), [Token.RCParen])) {
+        //       break;
+        //     }
+        //     i++;
+        //   }
+        //   i++;
+        // }
+        // return ast;
+    };
+    /**
+    * Parses a single statement or declaration by delegating the parsing of the next set of tokens to the appropriate method.
+    * @param tokens - Remaining tokens to parse.
+    * @param allowVariables - Whether encountered identifiers should be consider
+        variable initializations or references.
+    * @return A set of AST nodes and the number of consumed tokens.
+    */
+    Parser.prototype.parseNode = function (tokens, allowVariables) {
+        if (allowVariables === void 0) { allowVariables = true; }
+        var token = tokens[0];
+        switch (token[0]) {
+            case token_1.Token.DefcalGrammar: {
+                var _a = this.defcalGrammarDeclaration(tokens), defcalGrammarNode = _a[0], consumed = _a[1];
+                return [[defcalGrammarNode], consumed];
+            }
+            case token_1.Token.Include: {
+                var _b = this.include(tokens), includeNode = _b[0], consumed = _b[1];
+                if (includeNode.filename === '"stdgates.inc"') {
+                    this.stdGates();
+                }
+                return [[includeNode], consumed];
+            }
+            case token_1.Token.OpenQASM: {
+                var _c = this.versionHeader(tokens), qasmNode = _c[0], consumed = _c[1];
+                return [[qasmNode], consumed];
+            }
+            case token_1.Token.Const: {
+                var _d = this.classicalDeclaration(tokens.slice(1), true), constNode = _d[0], consumed = _d[1];
+                return [[constNode], consumed + 1];
+            }
+            case token_1.Token.Input:
+            case token_1.Token.Output: {
+                var _e = this.ioType(tokens), ioType = _e[0], consumed = _e[1];
+                return [[ioType], consumed];
+            }
+            case token_1.Token.Float:
+            case token_1.Token.Int:
+            case token_1.Token.UInt:
+            case token_1.Token.Bool:
+            case token_1.Token.Angle:
+            case token_1.Token.Stretch:
+            case token_1.Token.Complex:
+            case token_1.Token.Duration: {
+                var _f = this.classicalDeclaration(tokens, false), classicalNode = _f[0], consumed = _f[1];
+                return [[classicalNode], consumed];
+            }
+            case token_1.Token.Qubit:
+            case token_1.Token.QReg: {
+                var _g = this.quantumDeclaration(tokens), qregNode = _g[0], qregConsumed = _g[1];
+                return [[qregNode], qregConsumed];
+            }
+            case token_1.Token.Break:
+                return [[new ast_1.BreakStatement()], 1];
+            case token_1.Token.Reset: {
+                var _h = this.resetStatement(tokens), resetNode = _h[0], resetConsumed = _h[1];
+                return [[resetNode], resetConsumed];
+            }
+            case token_1.Token.Continue:
+                return [[new ast_1.ContinueStatement()], 1];
+            case token_1.Token.Let: {
+                var _j = this.aliasStatement(tokens), letNode = _j[0], letConsumed = _j[1];
+                return [[letNode], letConsumed];
+            }
+            case token_1.Token.Bit:
+                if (this.isMeasurement(tokens.slice(1))) {
+                    var _k = this.measureStatement(tokens), measureNode = _k[0], measureConsumed = _k[1];
+                    return [[measureNode], measureConsumed];
+                }
+                else {
+                    var _l = this.classicalDeclaration(tokens, false), classicalNode = _l[0], consumed = _l[1];
+                    return [[classicalNode], consumed];
+                }
+            case token_1.Token.CReg: {
+                var _m = this.classicalDeclaration(tokens, false), classicalNode = _m[0], consumed = _m[1];
+                return [[classicalNode], consumed];
+            }
+            case token_1.Token.Measure: {
+                var _o = this.measureStatement(tokens), measureNode = _o[0], measureConsumed = _o[1];
+                return [[measureNode], measureConsumed];
+            }
+            case token_1.Token.Gate: {
+                var _p = this.quantumGateDefinition(tokens), gateNode = _p[0], gateConsumed = _p[1];
+                this.customGates.add(gateNode.name.name);
+                return [[gateNode], gateConsumed];
+            }
+            case token_1.Token.Return: {
+                var _q = this.returnStatement(tokens), returnNode = _q[0], returnConsumed = _q[1];
+                return [[returnNode], returnConsumed];
+            }
+            case token_1.Token.Def: {
+                var _r = this.subroutineDefinition(tokens), subroutineNode = _r[0], subroutineConsumed = _r[1];
+                this.subroutines.add(subroutineNode.name.name);
+                return [[subroutineNode], subroutineConsumed];
+            }
+            case token_1.Token.Extern: {
+                var _s = this.externSignature(tokens), externNode = _s[0], consumed = _s[1];
+                this.subroutines.add(externNode.name.name);
+                return [[externNode], consumed];
+            }
+            case token_1.Token.Ctrl:
+            case token_1.Token.NegCtrl:
+            case token_1.Token.Inv:
+            case token_1.Token.PowM: {
+                var _t = this.quantumGateCall(tokens), gateCallNode = _t[0], gateCallConsumed = _t[1];
+                return [[gateCallNode], gateCallConsumed];
+            }
+            case token_1.Token.Ceiling:
+            case token_1.Token.Exp:
+            case token_1.Token.Floor:
+            case token_1.Token.Log:
+            case token_1.Token.Mod:
+            case token_1.Token.Popcount:
+            case token_1.Token.Pow:
+            case token_1.Token.Sqrt:
+            case token_1.Token.Rotr:
+            case token_1.Token.Rotl: {
+                var _u = this.binaryExpression(tokens.slice(1)), expr = _u[0], exprConsumed = _u[1];
+                var consumed = exprConsumed + 1;
+                var _v = this.createMathOrTrigFunction(token[0], expr), math = _v[0], mathConsumed = _v[1];
+                consumed += mathConsumed;
+                return [[math], consumed];
+            }
+            case token_1.Token.Opaque: {
+                var consumed = 1;
+                while (consumed < this.tokens.length &&
+                    !this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+                    consumed++;
+                }
+                return [[], consumed];
+            }
+            case token_1.Token.DurationOf: {
+                var _w = this.durationOf(tokens), durationOfNOde = _w[0], consumed = _w[1];
+                return [[durationOfNOde], consumed];
+            }
+            case token_1.Token.SizeOf: {
+                var _x = this.sizeOf(tokens), sizeOfNode = _x[0], consumed = _x[1];
+                return [[sizeOfNode], consumed];
+            }
+            case token_1.Token.Delay: {
+                var _y = this.delay(tokens), delayNode = _y[0], delayConsumed = _y[1];
+                return [[delayNode], delayConsumed];
+            }
+            case token_1.Token.If: {
+                var _z = this.ifStatement(tokens), ifNode = _z[0], ifConsumed = _z[1];
+                return [[ifNode], ifConsumed];
+            }
+            case token_1.Token.For: {
+                var _0 = this.forLoopStatement(tokens), forNode = _0[0], forConsumed = _0[1];
+                return [[forNode], forConsumed];
+            }
+            case token_1.Token.While: {
+                var _1 = this.whileLoopStatement(tokens), whileNode = _1[0], whileConsumed = _1[1];
+                return [[whileNode], whileConsumed];
+            }
+            case token_1.Token.Switch: {
+                var _2 = this.switchStatement(tokens), switchNode = _2[0], switchConsumed = _2[1];
+                return [[switchNode], switchConsumed];
+            }
+            case token_1.Token.Array: {
+                var _3 = this.arrayDeclaration(tokens), arrayNode = _3[0], arrayConsumed = _3[1];
+                this.customArrays.add(arrayNode.identifier.name);
+                return [[arrayNode], arrayConsumed];
+            }
+            case token_1.Token.Box: {
+                var _4 = this.box(tokens), boxNode = _4[0], boxConsumed = _4[1];
+                return [[boxNode], boxConsumed];
+            }
+            case token_1.Token.Barrier: {
+                var _5 = this.barrier(tokens), barrierNode = _5[0], barrierConsumed = _5[1];
+                return [[barrierNode], barrierConsumed];
+            }
+            case token_1.Token.Id:
+                if (this.isQuantumGateCall(tokens)) {
+                    var _6 = this.quantumGateCall(tokens), gateCallNode = _6[0], gateCallConsumed = _6[1];
+                    return [[gateCallNode], gateCallConsumed];
+                }
+                else if (this.isSubroutineCall(tokens)) {
+                    var _7 = this.subroutineCall(tokens), subroutineCallNode = _7[0], subroutineCallConsumed = _7[1];
+                    return [[subroutineCallNode], subroutineCallConsumed];
+                }
+                else if (this.isMeasurement(tokens)) {
+                    var _8 = this.measureStatement(tokens), measureNode = _8[0], measureConsumed = _8[1];
+                    return [[measureNode], measureConsumed];
+                }
+                else if (this.matchNext(tokens.slice(1), [token_1.Token.EqualsAssmt]) ||
+                    this.matchNext(tokens.slice(1), [token_1.Token.CompoundArithmeticOp]) ||
+                    this.matchNext(tokens.slice(1), [token_1.Token.CompoundBinaryOp]) ||
+                    this.isAssignment(tokens)) {
+                    var _9 = this.assignment(tokens), assignmentNode = _9[0], consumed = _9[1];
+                    return [[assignmentNode], consumed];
+                }
+                else if (allowVariables) {
+                    var _10 = this.binaryExpression(tokens), expr = _10[0], consumed = _10[1];
+                    if (this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+                        return [[expr], consumed + 1];
+                    }
+                    else {
+                        throwParserError(errors_1.MissingSemicolonError, tokens[consumed], this.index + consumed, "expected semicolon");
+                    }
+                }
+                break;
+            default:
+                return [[], 1];
+        }
+    };
+    /**
+     * Checks if the next tokens match those expected.
+     * @param tokens - Remaining tokens to parse.
+     * @param expectedTokens - Expected tokens.
+     * @return Whether these is a match.
+     */
+    Parser.prototype.matchNext = function (tokens, expectedTokens) {
+        var matches = true;
+        var i = 0;
+        if (tokens.length == 0) {
+            return false;
+        }
+        while (i < expectedTokens.length) {
+            if (tokens[i][0] != expectedTokens[i]) {
+                matches = false;
+                break;
+            }
+            i++;
+        }
+        return matches;
+    };
+    /**
+     * Parses a `defcalgrammar` declaration.
+     *
+     * calibrationGrammarStatement:
+     *   DEFCALGRAMMAR StringLiteral SEMICOLON
+     *
+     * @param tokens - Remaining tokens to parse.
+     * @return The parsed CalibrationGrammarDeclaration AstNode node and the number of consumed tokens.
+     */
+    Parser.prototype.defcalGrammarDeclaration = function (tokens) {
+        var consumed = 1;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.String, token_1.Token.Semicolon])) {
+            return [
+                new ast_1.CalibrationGrammarDeclaration(tokens[0][1].toString()),
+                consumed + 2,
+            ];
+        }
+        throwParserError(errors_1.BadStringLiteralError, tokens[consumed], this.index + consumed, "expected string literal following `defcalgrammar` keyword");
+    };
+    /**
+     * Parses a classical type declaration.
+     * @param tokens - Remaining tokens to parse.
+     * @param isConst - Whether the declaration is for a constant, defaults to False.
+     * @return The parsed ClassicalDeclaration AstNode and the number of consumed tokens.
+     */
+    Parser.prototype.classicalDeclaration = function (tokens, isConst) {
+        var isConstParam = isConst ? isConst : false;
+        var id = null;
+        var initialValue;
+        var consumed = 0;
+        var _a = this.parseClassicalType(tokens), classicalType = _a[0], classicalTypeConsumed = _a[1];
+        consumed += classicalTypeConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen]) &&
+            !this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+            var _b = this.unaryExpression(tokens.slice(consumed)), identifier = _b[0], idConsumed = _b[1];
+            id = identifier;
+            consumed += idConsumed;
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.EqualsAssmt])) {
+                consumed++;
+                var _c = this.binaryExpression(tokens.slice(consumed)), value = _c[0], valueConsumed = _c[1];
+                initialValue = value;
+                consumed += valueConsumed;
+            }
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+                consumed++;
+            }
+        }
+        return [
+            new ast_1.ClassicalDeclaration(classicalType, id, initialValue, isConstParam),
+            consumed,
+        ];
+    };
+    /**
+     * Parses an IO declaration statement.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the parsed IODeclaration and the number of tokens consumed.
+     */
+    Parser.prototype.ioType = function (tokens) {
+        var consumed = 0;
+        var modifier;
+        switch (tokens[consumed][0]) {
+            case token_1.Token.Input:
+                modifier = ast_1.IOModifier.INPUT;
+                break;
+            case token_1.Token.Output:
+                modifier = ast_1.IOModifier.OUTPUT;
+                break;
+            default:
+                throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "unsupported IO modifier");
+        }
+        consumed++;
+        var _a = this.classicalDeclaration(tokens.slice(consumed)), classicalDeclaration = _a[0], typeConsumed = _a[1];
+        consumed += typeConsumed;
+        return [new ast_1.IODeclaration(modifier, classicalDeclaration), consumed];
+    };
+    /**
+     * Parses a unary expression.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the parsed Expression and the number of tokens consumed.
+     */
+    Parser.prototype.unaryExpression = function (tokens) {
+        var token = tokens[0];
+        var consumed = 1;
+        switch (token[0]) {
+            case token_1.Token.NNInteger: {
+                if (this.isImaginary(tokens[consumed])) {
+                    return [
+                        new ast_1.ImaginaryLiteral("".concat(token[1].toString(), "im")),
+                        consumed + 1,
+                    ];
+                }
+                else if (this.isDuration(tokens.slice(consumed))) {
+                    return [
+                        new ast_1.DurationLiteral(Number(token[1]), tokens[consumed][1].toString()),
+                        consumed + 1,
+                    ];
+                }
+                return [new ast_1.IntegerLiteral(Number(token[1])), consumed];
+            }
+            case token_1.Token.Integer: {
+                if (this.isImaginary(tokens[consumed])) {
+                    return [
+                        new ast_1.ImaginaryLiteral("".concat(token[1].toString(), "im")),
+                        consumed + 1,
+                    ];
+                }
+                return [new ast_1.IntegerLiteral(token[1].toString()), consumed];
+            }
+            case token_1.Token.BinaryLiteral:
+            case token_1.Token.OctalLiteral:
+            case token_1.Token.HexLiteral:
+            case token_1.Token.ScientificNotation:
+                return [new ast_1.NumericLiteral(token[1].toString()), consumed];
+            case token_1.Token.Real:
+                if (this.isImaginary(tokens[consumed])) {
+                    return [
+                        new ast_1.ImaginaryLiteral("".concat(token[1].toString(), "im")),
+                        consumed + 1,
+                    ];
+                }
+                return [new ast_1.FloatLiteral(Number(token[1])), consumed];
+            case token_1.Token.BoolLiteral:
+                return [new ast_1.BooleanLiteral(token[1] === "true"), consumed];
+            case token_1.Token.Arccos:
+            case token_1.Token.Arcsin:
+            case token_1.Token.Arctan:
+            case token_1.Token.Cos:
+            case token_1.Token.Sin:
+            case token_1.Token.Tan:
+            case token_1.Token.Ceiling:
+            case token_1.Token.Exp:
+            case token_1.Token.Floor:
+            case token_1.Token.Log:
+            case token_1.Token.Mod:
+            case token_1.Token.Popcount:
+            case token_1.Token.Pow:
+            case token_1.Token.Sqrt:
+            case token_1.Token.Rotr:
+            case token_1.Token.Rotl: {
+                var _a = this.unaryExpression(tokens.slice(1)), funcExpr = _a[0], funcConsumed = _a[1];
+                consumed += funcConsumed;
+                return [
+                    this.createMathOrTrigFunction(tokens[0][0], funcExpr),
+                    consumed,
+                ];
+            }
+            case token_1.Token.Id:
+                // Handle array identifiers, identifiers, and subscripted identifiers
+                if (this.matchNext(tokens.slice(1), [token_1.Token.LSParen])) {
+                    if (this.isArray(tokens)) {
+                        var _b = this.parseArrayAccess(tokens), arrayAccess = _b[0], arrayAccessConsumed = _b[1];
+                        return [arrayAccess, arrayAccessConsumed];
+                    }
+                    else {
+                        var identifier = new ast_1.Identifier(token[1].toString());
+                        var _c = this.parseSubscript(tokens.slice(1)), subscript = _c[0], subscriptConsumed = _c[1];
+                        consumed += subscriptConsumed;
+                        return [
+                            new ast_1.SubscriptedIdentifier(identifier.name, subscript),
+                            consumed,
+                        ];
+                    }
+                }
+                return [new ast_1.Identifier(token[1].toString()), consumed];
+            case token_1.Token.Pi:
+                return [new ast_1.Pi(), consumed];
+            case token_1.Token.Euler:
+                return [new ast_1.Euler(), consumed];
+            case token_1.Token.Tau:
+                return [new ast_1.Tau(), consumed];
+            case token_1.Token.String:
+                return [new ast_1.BitstringLiteral(token[1].toString()), consumed];
+            case token_1.Token.DurationOf:
+                return this.durationOf(tokens);
+            case token_1.Token.SizeOf:
+                return this.sizeOf(tokens);
+            case token_1.Token.UnaryOp: {
+                var _d = this.unaryExpression(tokens.slice(1)), expr = _d[0], exprConsumed = _d[1];
+                return [new ast_1.Unary(token[1], expr), consumed + exprConsumed];
+            }
+            case token_1.Token.LParen: {
+                var i = 1;
+                var parenCount = 1;
+                while (parenCount > 0 && i < tokens.length) {
+                    if (tokens[i][0] === token_1.Token.LParen) {
+                        parenCount++;
+                    }
+                    else if (tokens[i][0] === token_1.Token.RParen) {
+                        parenCount--;
+                    }
+                    else if (parenCount === 1 && tokens[i][0] === token_1.Token.Comma) {
+                        return this.parseParameters(tokens);
+                    }
+                    i++;
+                }
+                var _e = this.binaryExpression(tokens.slice(1)), expr = _e[0], exprConsumed = _e[1];
+                consumed += exprConsumed;
+                if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen])) {
+                    throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing parenthesis");
+                }
+                consumed++;
+                return [expr, consumed];
+            }
+            default:
+                if (isTypeToken(token[0])) {
+                    return this.parseTypeCast(tokens);
+                }
+                throwParserError(errors_1.BadExpressionError, token, this.index, "invalid expression");
+        }
+    };
+    /**
+     * Parses a binary expression.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the parsed Expression and the number of tokens consumed.
+     */
+    Parser.prototype.binaryExpression = function (tokens) {
+        var unaryExpr = this.unaryExpression(tokens);
+        var leftExpr = unaryExpr[0];
+        var leftConsumed = unaryExpr[1];
+        var consumed = leftConsumed;
+        while (consumed < tokens.length) {
+            var token = tokens[consumed];
+            if (token[0] === token_1.Token.BinaryOp ||
+                token[0] === token_1.Token.ArithmeticOp ||
+                (token[0] === token_1.Token.UnaryOp && token[1] === "-")) {
+                consumed++;
+                var _a = this.unaryExpression(tokens.slice(consumed)), rightExpr = _a[0], rightConsumed = _a[1];
+                if (token[0] === token_1.Token.BinaryOp) {
+                    leftExpr = new ast_1.Binary(token[1], leftExpr, rightExpr);
+                }
+                else if (token[0] === token_1.Token.UnaryOp && token[1] === "-") {
+                    leftExpr = new ast_1.Arithmetic(ast_1.ArithmeticOp.MINUS, leftExpr, rightExpr);
+                }
+                else {
+                    leftExpr = new ast_1.Arithmetic(token[1], leftExpr, rightExpr);
+                }
+                consumed += rightConsumed;
+            }
+            else {
+                break;
+            }
+        }
+        return [leftExpr, consumed];
+    };
+    /**
+     * Parses an assignment statement.
+     * @param tokens - Remaining tokens to parse.
+     * @return The parsed AssignmentStatement AstNode and the number of consumed tokens.
+     */
+    Parser.prototype.assignment = function (tokens) {
+        var consumed = 0;
+        var _a = this.unaryExpression(tokens), lhs = _a[0], lhsConsumed = _a[1];
+        consumed += lhsConsumed;
+        // Handle compound assignments
+        var operatorToken = tokens[consumed][0];
+        if (operatorToken === token_1.Token.CompoundArithmeticOp ||
+            operatorToken === token_1.Token.CompoundBinaryOp) {
+            consumed++;
+            var operator = tokens[lhsConsumed][1].toString();
+            var _b = this.binaryExpression(tokens.slice(consumed)), rhs_1 = _b[0], rhsConsumed = _b[1];
+            consumed += rhsConsumed;
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+                throwParserError(errors_1.MissingSemicolonError, tokens[consumed], this.index + consumed, "expected semicolon");
+            }
+            consumed++;
+            var op = void 0;
+            var expression = void 0;
+            switch (operatorToken) {
+                case token_1.Token.CompoundArithmeticOp:
+                    op = operator.slice(0, -1);
+                    expression = new ast_1.Arithmetic(op, lhs, rhs_1);
+                    break;
+                case token_1.Token.CompoundBinaryOp:
+                    op = operator.slice(0, -1);
+                    expression = new ast_1.Binary(op, lhs, rhs_1);
+                    break;
+                default:
+                    throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "invalid compound operator");
+            }
+            return [
+                new ast_1.AssignmentStatement(lhs, expression),
+                consumed,
+            ];
+        }
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.EqualsAssmt])) {
+            consumed++;
+        }
+        else {
+            throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected `=` in assignment statement");
+        }
+        var rhs;
+        if (this.isSubroutineCall(tokens.slice(consumed))) {
+            var _c = this.subroutineCall(tokens.slice(consumed)), subroutineCall = _c[0], subroutineCallConsumed = _c[1];
+            rhs = subroutineCall;
+            consumed += subroutineCallConsumed;
+        }
+        else {
+            var _d = this.binaryExpression(tokens.slice(consumed)), rhsExpression = _d[0], rhsConsumed = _d[1];
+            rhs = rhsExpression;
+            consumed += rhsConsumed;
+        }
+        // if (!this.matchNext(tokens.slice(consumed), [Token.Semicolon])) {
+        //   throwParserError(
+        //     MissingSemicolonError,
+        //     tokens[consumed],
+        //     this.index + consumed,
+        //     "expected semicolon",
+        //   );
+        // }
+        // consumed++;
+        return [
+            new ast_1.AssignmentStatement(lhs, rhs),
+            consumed,
+        ];
+    };
+    /**
+     * Parses a quantum declaration.
+     * @param tokens - Tokens to parse.
+     * @return A QuantumDeclaration node and the number of tokens consumed.
+     */
+    Parser.prototype.quantumDeclaration = function (tokens) {
+        var consumed = 1;
+        var isQubit = tokens[0][0] === token_1.Token.Qubit;
+        var size = null;
+        // Qubit
+        if (isQubit) {
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.LSParen])) {
+                consumed++;
+                var _a = this.binaryExpression(tokens.slice(consumed)), sizeExpr = _a[0], sizeConsumed = _a[1];
+                consumed += sizeConsumed;
+                size = sizeExpr;
+                if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+                    throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing bracket ] for qubit declaration size");
+                }
+                consumed++;
+            }
+        }
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadQregError, tokens[consumed], this.index + consumed, "expected identifier for quantum declaration");
+        }
+        var _b = this.unaryExpression(tokens.slice(consumed, consumed + 1)), identifier = _b[0], idConsumed = _b[1];
+        consumed += idConsumed;
+        // Qreg
+        if (!isQubit && this.matchNext(tokens.slice(consumed), [token_1.Token.LSParen])) {
+            consumed++;
+            var _c = this.binaryExpression(tokens.slice(consumed)), sizeExpr = _c[0], sizeConsumed = _c[1];
+            size = sizeExpr;
+            consumed += sizeConsumed;
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+                throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing bracket ] for quantum register size");
+            }
+            consumed++;
+        }
+        if (!(this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon]) ||
+            this.matchNext(tokens.slice(consumed), [token_1.Token.Comma]) ||
+            this.matchNext(tokens.slice(consumed), [token_1.Token.RParen]))) {
+            throwParserError(errors_1.BadQregError, tokens[consumed], this.index + consumed, "expected semicolon, comma, or closing parenthesis after quantum register declaration");
+        }
+        // Only consume semicolon, if paren or comma that token will be handled in calling function
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+            consumed++;
+        }
+        return [new ast_1.QuantumDeclaration(identifier, size), consumed];
+    };
+    /**
+     * Parses a measure statement.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the QuantumMeasurementAssignment or QuantumMeasurement and the number of tokens consumed.
+     */
+    Parser.prototype.measureStatement = function (tokens) {
+        var consumed = 0;
+        // Legacy syntax: measure qubit|qubit[] -> bit|bit[];
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.Measure])) {
+            consumed++;
+            var qubitIdentifiers = [];
+            while (!(this.matchNext(tokens.slice(consumed), [token_1.Token.Arrow]) ||
+                this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon]))) {
+                var _a = this.unaryExpression(tokens.slice(consumed)), identifier = _a[0], idConsumed = _a[1];
+                qubitIdentifiers.push(identifier);
+                consumed += idConsumed;
+                if (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+                    consumed++;
+                }
+                else if (!(this.matchNext(tokens.slice(consumed), [token_1.Token.Arrow]) ||
+                    this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon]))) {
+                    throwParserError(errors_1.BadMeasurementError, tokens[consumed], this.index + consumed, "expected comma or arrow in measurement statement");
+                }
+            }
+            var measurement = new ast_1.QuantumMeasurement(qubitIdentifiers);
+            // If there's an arrow, build a QuantumMeasurementAssignment
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Arrow])) {
+                consumed++;
+                var _b = this.unaryExpression(tokens.slice(consumed)), identifier = _b[0], idConsumed = _b[1];
+                var classicalBit = identifier;
+                consumed += idConsumed;
+                if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+                    throwParserError(errors_1.MissingSemicolonError, tokens[consumed], this.index + consumed);
+                }
+                consumed++;
+                return [
+                    new ast_1.QuantumMeasurementAssignment(classicalBit, measurement),
+                    consumed,
+                ];
+            }
+            else {
+                if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+                    throwParserError(errors_1.MissingSemicolonError, tokens[consumed], this.index + consumed);
+                }
+                consumed++;
+                return [measurement, consumed];
+            }
+        }
+        // New syntax: bit|bit[] = measure qubit|qreg;
+        else {
+            var _c = this.unaryExpression(tokens.slice(consumed)), leftIdentifier = _c[0], leftIdConsumed = _c[1];
+            var classicalBit = leftIdentifier;
+            consumed += leftIdConsumed;
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.EqualsAssmt])) {
+                throwParserError(errors_1.BadMeasurementError, tokens[consumed], this.index + consumed, "expected `=` in measurement assignment");
+            }
+            consumed++;
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Measure])) {
+                throwParserError(errors_1.BadMeasurementError, tokens[consumed], this.index + consumed, "expected `measure` keyword in measurement assignment");
+            }
+            consumed++;
+            var _d = this.unaryExpression(tokens.slice(consumed)), rightIdentifier = _d[0], rightIdConsumed = _d[1];
+            var qubitIdentifier = rightIdentifier;
+            consumed += rightIdConsumed;
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+                throwParserError(errors_1.MissingSemicolonError, tokens[consumed], this.index + consumed);
+            }
+            consumed++;
+            var measurement = new ast_1.QuantumMeasurement([
+                qubitIdentifier,
+            ]);
+            return [
+                new ast_1.QuantumMeasurementAssignment(classicalBit, measurement),
+                consumed,
+            ];
+        }
+    };
+    /**
+     * Parses a subroutine return statement.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the SubroutineDefinition and the number of tokens consumed.
+     */
+    Parser.prototype.returnStatement = function (tokens) {
+        var consumed = 1;
+        var expression = null;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+            var _a = this.parseNode(tokens.slice(consumed)), expr = _a[0], exprConsumed = _a[1];
+            expression = expr;
+            consumed += exprConsumed;
+        }
+        return [new ast_1.ReturnStatement(expression), consumed];
+    };
+    /**
+     * Parses an extern signature.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the ExternSignature and the number of tokens consumed.
+     */
+    Parser.prototype.externSignature = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadSubroutineError, tokens[consumed], this.index + consumed, "expected identifier following extern keyword");
+        }
+        var _a = this.unaryExpression(tokens.slice(consumed)), identifier = _a[0], identifierConsumed = _a[1];
+        consumed += identifierConsumed;
+        var externParams = null;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            var _b = this.parseParameters(tokens.slice(consumed)), params = _b[0], paramsConsumed = _b[1];
+            externParams = params;
+            consumed += paramsConsumed;
+        }
+        var returnType = null;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.Arrow])) {
+            consumed++;
+            var _c = this.parseClassicalType(tokens.slice(consumed)), type = _c[0], typeConsumed = _c[1];
+            returnType = type;
+            consumed += typeConsumed;
+        }
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+            throwParserError(errors_1.MissingSemicolonError, tokens[consumed], this.index + consumed, "expected semicolon");
+        }
+        consumed++;
+        return [
+            new ast_1.ExternSignature(identifier, externParams, returnType),
+            consumed,
+        ];
+    };
+    /**
+     * Parses a subroutine definition.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the SubroutineDefinition and the number of tokens consumed.
+     */
+    Parser.prototype.subroutineDefinition = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadSubroutineError, tokens[consumed], this.index + consumed, "expected subroutine name");
+        }
+        var _a = this.unaryExpression(tokens.slice(consumed)), name = _a[0], nameConsumed = _a[1];
+        consumed += nameConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected opening parenthesis for subroutine definition");
+        }
+        var _b = this.parseParameters(tokens.slice(consumed)), params = _b[0], paramsConsumed = _b[1];
+        consumed += paramsConsumed;
+        var returnType = null;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.Arrow])) {
+            consumed++;
+            var _c = this.parseClassicalType(tokens.slice(consumed)), type = _c[0], typeConsumed = _c[1];
+            returnType = type;
+            consumed += typeConsumed;
+        }
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected opening brace for subroutine body");
+        }
+        var _d = this.programBlock(tokens.slice(consumed)), body = _d[0], bodyConsumed = _d[1];
+        consumed += bodyConsumed;
+        return [
+            new ast_1.SubroutineDefinition(name, body, params, returnType),
+            consumed,
+        ];
+    };
+    /**
+     * Parses a subroutine call.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the SubroutineCall and the number of tokens consumed.
+     */
+    Parser.prototype.subroutineCall = function (tokens) {
+        var consumed = 0;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadSubroutineError, tokens[consumed], this.index + consumed, "expected subroutine name");
+        }
+        var _a = this.unaryExpression(tokens.slice(consumed)), subroutineName = _a[0], subroutineNameConsumed = _a[1];
+        consumed += subroutineNameConsumed;
+        var callParams = null;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            var _b = this.parseParameters(tokens.slice(consumed)), params = _b[0], paramsConsumed = _b[1];
+            callParams = params;
+            consumed += paramsConsumed;
+        }
+        // if (!this.matchNext(tokens.slice(consumed), [Token.Semicolon])) {
+        //   throwParserError(
+        //     MissingSemicolonError,
+        //     tokens[consumed],
+        //     this.index + consumed,
+        //     "expected semicolon after subroutine call",
+        //   );
+        // }
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+            consumed++;
+        }
+        return [
+            new ast_1.SubroutineCall(subroutineName, callParams),
+            consumed,
+        ];
+    };
+    /**
+     * Parses a quantum gate definition.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the QuantumGateDefinition and the number of tokens consumed.
+     */
+    Parser.prototype.quantumGateDefinition = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadGateError, tokens[consumed], this.index + consumed, "expected gate name");
+        }
+        var _a = this.unaryExpression(tokens.slice(consumed)), name = _a[0], nameConsumed = _a[1];
+        consumed += nameConsumed;
+        // Parse optional parameters
+        var _b = this.parseParameters(tokens.slice(consumed)), params = _b[0], paramsConsumed = _b[1];
+        consumed += paramsConsumed;
+        // Parse qubits
+        var qubits = [];
+        while (!this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+                throwParserError(errors_1.BadGateError, tokens[consumed], this.index + consumed, "expected qubit argument");
+            }
+            var _c = this.unaryExpression(tokens.slice(consumed)), qubit = _c[0], qubitConsumed = _c[1];
+            qubits.push(qubit);
+            consumed += qubitConsumed;
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+                consumed++;
+            }
+            else if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+                throwParserError(errors_1.BadGateError, tokens[consumed], this.index + consumed, "expected comma or opening brace for gate body");
+            }
+        }
+        var _d = this.programBlock(tokens.slice(consumed)), body = _d[0], bodyConsumed = _d[1];
+        consumed += bodyConsumed;
+        return [
+            new ast_1.QuantumGateDefinition(name, params, qubits, body),
+            consumed,
+        ];
+    };
+    /**
+     * Parses a quantum gate call.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the QuantumGateCall and the number of tokens consumed.
+     */
+    Parser.prototype.quantumGateCall = function (tokens) {
+        var consumed = 0;
+        var modifiers = [];
+        // Parse modifier(s)
+        while (this.matchNext(tokens.slice(consumed), [token_1.Token.Ctrl]) ||
+            this.matchNext(tokens.slice(consumed), [token_1.Token.NegCtrl]) ||
+            this.matchNext(tokens.slice(consumed), [token_1.Token.Inv]) ||
+            this.matchNext(tokens.slice(consumed), [token_1.Token.PowM])) {
+            var _a = this.parseQuantumGateModifier(tokens.slice(consumed)), modifier = _a[0], modifierConsumed = _a[1];
+            modifiers.push(modifier);
+            consumed += modifierConsumed;
+        }
+        // Parse gate name
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadGateError, tokens[consumed], this.index + consumed, "expected gate name");
+        }
+        var _b = this.unaryExpression(tokens.slice(consumed)), gateName = _b[0], gateNameConsumed = _b[1];
+        consumed += gateNameConsumed;
+        var callParams = null;
+        // Parse optional parameters
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            var _c = this.parseParameters(tokens.slice(consumed)), params = _c[0], paramsConsumed = _c[1];
+            callParams = params;
+            consumed += paramsConsumed;
+        }
+        // Parse qubit arguments
+        var _d = this.parseQubitList(tokens.slice(consumed)), qubits = _d[0], qubitsConsumed = _d[1];
+        consumed += qubitsConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+            throwParserError(errors_1.MissingSemicolonError, tokens[consumed], this.index + consumed, "expected semicolon");
+        }
+        consumed++;
+        return [
+            new ast_1.QuantumGateCall(gateName, qubits, callParams, modifiers),
+            consumed,
+        ];
+    };
+    /**
+     * Parses a list of qubits.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the list of qubits and the number of tokens consumed.
+     */
+    Parser.prototype.parseQubitList = function (tokens) {
+        var consumed = 0;
+        var qubits = [];
+        while (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Dollar, token_1.Token.NNInteger])) {
+                var _a = this.parseHardwareQubit(tokens.slice(consumed)), hardwareQubit = _a[0], hardwareQubitConsumed = _a[1];
+                qubits.push(hardwareQubit);
+                consumed += hardwareQubitConsumed;
+                if (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+                    consumed++;
+                }
+                continue;
+            }
+            else if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+                throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected qubit argument");
+            }
+            var _b = this.unaryExpression(tokens.slice(consumed)), qubit = _b[0], qubitConsumed = _b[1];
+            qubits.push(qubit);
+            consumed += qubitConsumed;
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+                consumed++;
+            }
+            else if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+                break;
+            }
+        }
+        return [qubits, consumed];
+    };
+    /**
+     * Parses a hardware qubit.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the HardwareQubit and the number of tokens consumed.
+     */
+    Parser.prototype.parseHardwareQubit = function (tokens) {
+        var consumed = 0;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Dollar])) {
+            throwParserError(errors_1.BadGateError, tokens[consumed], this.index + consumed, "expected dollar sign for hardware qubit");
+        }
+        consumed++;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.NNInteger])) {
+            throwParserError(errors_1.BadGateError, tokens[consumed], this.index + consumed, "expected non-negative integer for hardware qubit");
+        }
+        return [new ast_1.HardwareQubit(Number(tokens[consumed][1])), consumed + 1];
+    };
+    /**
+     * Parses a gate modifier.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the gate modifier and the number of tokens consumed.
+     */
+    Parser.prototype.parseQuantumGateModifier = function (tokens) {
+        var consumed = 1;
+        var modifierToken = tokens[0][0];
+        var modifier;
+        var argument = null;
+        switch (modifierToken) {
+            case token_1.Token.Ctrl:
+                modifier = ast_1.QuantumGateModifierName.CTRL;
+                break;
+            case token_1.Token.NegCtrl:
+                modifier = ast_1.QuantumGateModifierName.NRGCTRL;
+                break;
+            case token_1.Token.Inv:
+                modifier = ast_1.QuantumGateModifierName.INV;
+                break;
+            case token_1.Token.PowM:
+                modifier = ast_1.QuantumGateModifierName.POW;
+                break;
+            default:
+                throwParserError(errors_1.BadGateError, tokens[0], this.index, "invalid gate modifier");
+        }
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            consumed++;
+            var _a = this.binaryExpression(tokens.slice(consumed)), arg = _a[0], argConsumed = _a[1];
+            argument = arg;
+            consumed += argConsumed;
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen])) {
+                throwParserError(errors_1.BadGateError, tokens[consumed], this.index + consumed, "expected closing parenthesis after gate modifier argument");
+            }
+            consumed++;
+        }
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.At])) {
+            throwParserError(errors_1.BadGateError, tokens[consumed], this.index + consumed, "expected `@` symbol after gate modifier");
+        }
+        consumed++;
+        return [new ast_1.QuantumGateModifier(modifier, argument), consumed];
+    };
+    /**
+     * Parses a set of parameters.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the Parameters and the number of tokens consumed.
+     */
+    Parser.prototype.parseParameters = function (tokens) {
+        var consumed = 0;
+        var args = [];
+        if (this.matchNext(tokens, [token_1.Token.LParen])) {
+            consumed++;
+            while (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen])) {
+                if (this.matchNext(tokens.slice(consumed), [token_1.Token.Qubit])) {
+                    var _a = this.parseNode(tokens.slice(consumed)), qubitParam = _a[0], qubitConsumed = _a[1];
+                    args.push(qubitParam);
+                    consumed += qubitConsumed;
+                }
+                else if (this.matchNext(tokens.slice(consumed), [token_1.Token.Bit]) ||
+                    this.matchNext(tokens.slice(consumed), [token_1.Token.CReg])) {
+                    var _b = this.parseNode(tokens.slice(consumed)), bitParam = _b[0], bitConsumed = _b[1];
+                    args.push(bitParam);
+                    consumed += bitConsumed;
+                }
+                else if (isTypeToken(tokens[consumed][0])) {
+                    var _c = this.classicalDeclaration(tokens.slice(consumed)), param = _c[0], paramConsumed = _c[1];
+                    args.push(param);
+                    consumed += paramConsumed;
+                }
+                else if (this.matchNext(tokens.slice(consumed), [token_1.Token.ReadOnly]) ||
+                    this.matchNext(tokens.slice(consumed), [token_1.Token.Mutable])) {
+                    var _d = this.parseArrayReference(tokens.slice(consumed)), arrayRef = _d[0], arrayRefConsumed = _d[1];
+                    args.push(arrayRef);
+                    consumed += arrayRefConsumed;
+                }
+                else {
+                    var _e = this.binaryExpression(tokens.slice(consumed)), param = _e[0], paramConsumed = _e[1];
+                    args.push(param);
+                    consumed += paramConsumed;
+                }
+                if (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+                    consumed++;
+                }
+                else if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen])) {
+                    throwParserError(errors_1.BadParameterError, tokens[consumed], this.index + consumed, "expected comma or closing parenthesis in parameter list");
+                }
+            }
+            consumed++;
+        }
+        return [new ast_1.Parameters(args), consumed];
+    };
+    /**
+     * Parses an array reference.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the ArrayReference and the number of tokens consumed.
+     */
+    Parser.prototype.parseArrayReference = function (tokens) {
+        var consumed = 0;
+        var modifier;
+        switch (tokens[consumed][0]) {
+            case token_1.Token.Mutable:
+                modifier = ast_1.ArrayReferenceModifier.MUTABLE;
+                break;
+            case token_1.Token.ReadOnly:
+                modifier = ast_1.ArrayReferenceModifier.READONLY;
+                break;
+            default:
+                throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "unsupported array reference modifier");
+        }
+        consumed++;
+        var _a = this.arrayDeclaration(tokens.slice(consumed)), arrayNode = _a[0], arrayConsumed = _a[1];
+        consumed += arrayConsumed;
+        return [new ast_1.ArrayReference(arrayNode, modifier), consumed];
+    };
+    /**
+     * Parses an alias statement.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the AliasStatement and the number of tokens consumed.
+     */
+    Parser.prototype.aliasStatement = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected identifier for alias statement");
+        }
+        var _a = this.unaryExpression(tokens.slice(consumed)), identifier = _a[0], identifierConsumed = _a[1];
+        consumed += identifierConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.EqualsAssmt])) {
+            throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected `=` symbol following identifier for alias statement");
+        }
+        consumed++;
+        var _b = this.binaryExpression(tokens.slice(consumed)), aliasExpression = _b[0], aliasExpressionConsumed = _b[1];
+        consumed += aliasExpressionConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+            throwParserError(errors_1.MissingSemicolonError, tokens[consumed], this.index + consumed, "expected semicolon");
+        }
+        consumed++;
+        return [
+            new ast_1.AliasStatement(identifier, aliasExpression),
+            consumed,
+        ];
+    };
+    /**
+     * Parses a quantum reset.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the QuantumReset and the number of tokens consumed.
+     */
+    Parser.prototype.resetStatement = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadQuantumInstructionError, tokens[consumed], this.index + consumed, "expected identifier after reset keyword");
+        }
+        var _a = this.unaryExpression(tokens.slice(consumed)), idNode = _a[0], idConsumed = _a[1];
+        consumed += idConsumed;
+        var id = null;
+        if (idNode instanceof ast_1.SubscriptedIdentifier) {
+            id = idNode;
+        }
+        else {
+            id = idNode;
+        }
+        consumed++;
+        return [new ast_1.QuantumReset(id), consumed];
+    };
+    /**
+     * Parses a subscript expression as a Range.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the parsed Expression or Range and the number of tokens consumed.
+     */
+    Parser.prototype.parseSubscript = function (tokens) {
+        var consumed = 1;
+        var start = null;
+        var step = new ast_1.IntegerLiteral(1);
+        var stop = null;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+            var _a = this.parseIndexSet(tokens.slice(consumed)), indexSet = _a[0], indexSetConsumed = _a[1];
+            consumed += indexSetConsumed;
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+                throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing curly bracket } for index set");
+            }
+            consumed++;
+            return [indexSet, consumed];
+        }
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Colon])) {
+            // Parse start
+            var _b = this.binaryExpression(tokens.slice(consumed)), startExpr = _b[0], startConsumed = _b[1];
+            start = startExpr;
+            consumed += startConsumed;
+        }
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+            return [start, consumed + 1];
+        }
+        // Check for colon after start
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Colon])) {
+            throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected colon in range expression");
+        }
+        consumed++;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+            var _c = this.binaryExpression(tokens.slice(consumed)), expr = _c[0], exprConsumed = _c[1];
+            consumed += exprConsumed;
+            // Check if its a step or stop
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Colon])) {
+                step = expr;
+                consumed++;
+                // Parse stop
+                if (this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+                    throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected stop value in range expression");
+                }
+                var _d = this.binaryExpression(tokens.slice(consumed)), stopExpr = _d[0], stopConsumed = _d[1];
+                stop = stopExpr;
+                consumed += stopConsumed;
+            }
+            else {
+                stop = expr;
+            }
+        }
+        // Check for closing square bracket
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing bracket ] for range expression");
+        }
+        consumed++;
+        // Validate that both start and stop are provided
+        if (start === null || stop === null) {
+            throwParserError(errors_1.BadExpressionError, tokens[0], this.index, "both start and stop must be provided in range expression");
+        }
+        return [new ast_1.Range(start, stop, step), consumed];
+    };
+    /**
+     * Parses a type cast expression.
+     * @param tokens - Remaining tokens to parse.
+     * @return A tuple containing the parsed Cast Expression and the number of tokens consumed.
+     */
+    Parser.prototype.parseTypeCast = function (tokens) {
+        var consumed = 1;
+        var widthExpr = null;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.LSParen])) {
+            consumed++;
+            var _a = this.binaryExpression(tokens.slice(consumed)), width = _a[0], widthConsumed = _a[1];
+            consumed += widthConsumed;
+            widthExpr = width;
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+                throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "missing closing bracket ] for type designator");
+            }
+            consumed++;
+        }
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[0], this.index, "expected opening parenthesis ( for type cast");
+        }
+        consumed++;
+        var _b = this.binaryExpression(tokens.slice(consumed)), castExpr = _b[0], castConsumed = _b[1];
+        consumed += castConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[0], this.index, "expected closing parenthesis ) for type cast");
+        }
+        consumed++;
+        var castType = this.createClassicalType(tokens[0][0], widthExpr);
+        return [new ast_1.Cast(castType, castExpr), consumed];
+    };
+    /**
+     * Parses a branching condition (if) statement.
+     * @param tokens - Tokens to parse.
+     * @return A BranchingStatement node representing the if statement and the number of tokens consumed.
+     */
+    Parser.prototype.ifStatement = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected opening parenthesis after if");
+        }
+        consumed++;
+        var _a = this.binaryExpression(tokens.slice(consumed)), condition = _a[0], conditionConsumed = _a[1];
+        consumed += conditionConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing parenthesis after if statement condition");
+        }
+        consumed++;
+        var _b = this.programBlock(tokens.slice(consumed)), trueBody = _b[0], trueBodyConsumed = _b[1];
+        consumed += trueBodyConsumed;
+        var falseBody = null;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.Else])) {
+            consumed++;
+            var _c = this.programBlock(tokens.slice(consumed)), elseBody = _c[0], elseBodyConsumed = _c[1];
+            falseBody = elseBody;
+            consumed += elseBodyConsumed;
+        }
+        return [new ast_1.BranchingStatement(condition, trueBody, falseBody), consumed];
+    };
+    /**
+     * Parses a for loop.
+     * @param tokens - Tokens to parse.
+     * @return A ForLoopStatement node and the number of tokens consumed.
+     */
+    Parser.prototype.forLoopStatement = function (tokens) {
+        var consumed = 1;
+        // Parse the type of the loop variable
+        var _a = this.parseClassicalType(tokens.slice(consumed)), loopVarType = _a[0], loopVarTypeConsumed = _a[1];
+        consumed += loopVarTypeConsumed;
+        // Expect an identifier (loop variable)
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadLoopError, tokens[consumed], this.index + consumed, "expected identifier for loop variable");
+        }
+        var _b = this.unaryExpression(tokens.slice(consumed)), loopVar = _b[0], loopVarConsumed = _b[1];
+        if (!(loopVar instanceof ast_1.Identifier)) {
+            throwParserError(errors_1.BadLoopError, tokens[consumed], this.index + consumed, "expected identifier for loop variable");
+        }
+        consumed += loopVarConsumed;
+        // Expect `in` keyword
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.In])) {
+            throwParserError(errors_1.BadLoopError, tokens[consumed], this.index + consumed, "expected `in` keyword in for loop");
+        }
+        consumed++;
+        var _c = this.parseSetDeclaration(tokens.slice(consumed)), indexSet = _c[0], indexSetConsumed = _c[1];
+        consumed += indexSetConsumed;
+        var _d = this.programBlock(tokens.slice(consumed)), body = _d[0], bodyConsumed = _d[1];
+        consumed += bodyConsumed;
+        return [
+            new ast_1.ForLoopStatement(indexSet, loopVarType, loopVar, body),
+            consumed,
+        ];
+    };
+    /**
+     * Parses a while loop.
+     * @param tokens - Tokens to parse.
+     * @return A ForLoopStatement node and the number of tokens consumed.
+     */
+    Parser.prototype.whileLoopStatement = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected opening parenthesis after while keyword");
+        }
+        consumed++;
+        var _a = this.binaryExpression(tokens.slice(consumed)), condition = _a[0], conditionConsumed = _a[1];
+        consumed += conditionConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing parenthesis after while loop condition");
+        }
+        consumed++;
+        var _b = this.programBlock(tokens.slice(consumed)), body = _b[0], bodyConsumed = _b[1];
+        consumed += bodyConsumed;
+        return [new ast_1.WhileLoopStatement(condition, body), consumed];
+    };
+    /**
+     * Parses a barrier statement.
+     * @param tokens - Tokens to parse.
+     * @return An QuantumBarrier node and the number of tokens consumed.
+     */
+    Parser.prototype.barrier = function (tokens) {
+        var consumed = 1;
+        var _a = this.parseQubitList(tokens.slice(consumed)), qubits = _a[0], qubitsConsumed = _a[1];
+        consumed += qubitsConsumed;
+        return [new ast_1.QuantumBarrier(qubits), consumed];
+    };
+    /**
+     * Parses a box statement.
+     * @param tokens - Tokens to parse.
+     * @return An BoxDefinition node and the number of tokens consumed.
+     */
+    Parser.prototype.box = function (tokens) {
+        var consumed = 1;
+        var designator = null;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.LSParen])) {
+            consumed++;
+            var _a = this.binaryExpression(tokens.slice(consumed)), desginatorNode = _a[0], designatorConsumed = _a[1];
+            consumed += designatorConsumed;
+            designator = desginatorNode;
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+                throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing ] bracket following box designator");
+            }
+            consumed++;
+        }
+        var _b = this.programBlock(tokens.slice(consumed)), scope = _b[0], scopeConsumed = _b[1];
+        consumed += scopeConsumed;
+        return [new ast_1.BoxDefinition(scope, designator), consumed];
+    };
+    /**
+     * Parses an array statement.
+     * @param tokens - Tokens to parse.
+     * @return An ArrayDeclaration node and the number of tokens consumed.
+     */
+    Parser.prototype.arrayDeclaration = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LSParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected [ after array keyword");
+        }
+        consumed++;
+        var _a = this.parseClassicalType(tokens.slice(consumed)), baseType = _a[0], baseTypeConsumed = _a[1];
+        consumed += baseTypeConsumed;
+        var dimensions = [];
+        while (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+            consumed++;
+            if (this.matchNext(tokens.slice(consumed), [
+                token_1.Token.Dim,
+                token_1.Token.EqualsAssmt,
+                token_1.Token.NNInteger,
+            ])) {
+                consumed += 2;
+                dimensions = Number(tokens[consumed][1]);
+                consumed++;
+                break;
+            }
+            var _b = this.binaryExpression(tokens.slice(consumed)), dimension = _b[0], dimensionConsumed = _b[1];
+            dimensions.push(dimension);
+            consumed += dimensionConsumed;
+        }
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected ] after array type declaration");
+        }
+        consumed++;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected identifier for array declaration");
+        }
+        var _c = this.unaryExpression(tokens.slice(consumed)), identifier = _c[0], identifierConsumed = _c[1];
+        consumed += identifierConsumed;
+        var initializer = null;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.EqualsAssmt])) {
+            consumed++;
+            var _d = this.parseArrayInitializer(tokens.slice(consumed)), parsedInitializer = _d[0], initializerConsumed = _d[1];
+            initializer = parsedInitializer;
+            consumed += initializerConsumed;
+        }
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+            consumed++;
+        }
+        return [
+            new ast_1.ArrayDeclaration(baseType, dimensions, identifier, initializer),
+            consumed,
+        ];
+    };
+    /**
+     * Parses an array initializer.
+     * @param tokens - Tokens to parse.
+     * @return An ArrayInitializer node and the number of tokens consumed.
+     */
+    Parser.prototype.parseArrayInitializer = function (tokens) {
+        var consumed = 0;
+        if (!this.matchNext(tokens, [token_1.Token.LCParen])) {
+            var _a = this.binaryExpression(tokens.slice(consumed)), expr = _a[0], exprConsumed = _a[1];
+            consumed += exprConsumed;
+            return [expr, consumed];
+        }
+        consumed++;
+        var values = [];
+        while (!this.matchNext(tokens.slice(consumed), [token_1.Token.RCParen])) {
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+                var _b = this.parseArrayInitializer(tokens.slice(consumed)), subInitializer = _b[0], subConsumed = _b[1];
+                values.push(subInitializer);
+                consumed += subConsumed;
+            }
+            else {
+                var _c = this.binaryExpression(tokens.slice(consumed)), expr = _c[0], exprConsumed = _c[1];
+                values.push(expr);
+                consumed += exprConsumed;
+            }
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+                consumed++;
+            }
+            else if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RCParen])) {
+                throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected comma or } in array initializer");
+            }
+        }
+        consumed++;
+        return [new ast_1.ArrayInitializer(values), consumed];
+    };
+    /**
+     * Parses an array access.
+     * @param tokens - Tokens to parse.
+     * @return An ArrayAccess  node and the number of tokens consumed.
+     */
+    Parser.prototype.parseArrayAccess = function (tokens) {
+        var consumed = 0;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Id])) {
+            throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected identifier for array access");
+        }
+        var identifier = new ast_1.Identifier(tokens[0][1].toString());
+        consumed++;
+        var indices = [];
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.LSParen])) {
+            consumed++;
+            while (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+                var _a = this.binaryExpression(tokens.slice(consumed)), index1 = _a[0], index1Consumed = _a[1];
+                indices.push(index1);
+                consumed += index1Consumed;
+                if (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+                    consumed++;
+                }
+                else if (this.matchNext(tokens.slice(consumed), [token_1.Token.Colon])) {
+                    consumed++;
+                    var step = new ast_1.IntegerLiteral(1);
+                    var stop_1 = void 0;
+                    var _b = this.binaryExpression(tokens.slice(consumed)), index2 = _b[0], index2Consumed = _b[1];
+                    consumed += index2Consumed;
+                    if (this.matchNext(tokens.slice(consumed), [token_1.Token.Colon])) {
+                        consumed++;
+                        var _c = this.binaryExpression(tokens.slice(consumed)), index3 = _c[0], index3Consumed = _c[1];
+                        consumed += index3Consumed;
+                        stop_1 = index3;
+                        step = index2;
+                    }
+                    else {
+                        stop_1 = index2;
+                    }
+                    indices = new ast_1.Range(index1, stop_1, step);
+                    break;
+                }
+                else if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+                    throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected comma or closing bracket for array access");
+                }
+            }
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+                throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing bracket ] for array access");
+            }
+            consumed++;
+        }
+        return [new ast_1.ArrayAccess(identifier, indices), consumed];
+    };
+    /**
+     * Parses a switch statement.
+     * @param tokens - Tokens to parse.
+     * @return A SwitchStatement node and the number of tokens consumed.
+     */
+    Parser.prototype.switchStatement = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected opening parenthesis after switch keywork");
+        }
+        consumed++;
+        var _a = this.binaryExpression(tokens.slice(consumed)), controlExpr = _a[0], controlExprConsumed = _a[1];
+        consumed += controlExprConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing parenthesis after switch control expression");
+        }
+        consumed++;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected opening curly brace for switch body");
+        }
+        consumed++;
+        var cases = [];
+        var defaultCase = null;
+        while (!this.matchNext(tokens.slice(consumed), [token_1.Token.RCParen])) {
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Case])) {
+                var _b = this.parseCaseStatement(tokens.slice(consumed)), caseStmt = _b[0], caseConsumed = _b[1];
+                cases.push(caseStmt);
+                consumed += caseConsumed;
+            }
+            else if (this.matchNext(tokens.slice(consumed), [token_1.Token.Default])) {
+                if (defaultCase !== null) {
+                    throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "multiple default statements not allowed in a swtich statement");
+                }
+                var _c = this.parseDefaultStatement(tokens.slice(consumed)), defaultStmt = _c[0], defaultConsumed = _c[1];
+                defaultCase = defaultStmt;
+                consumed += defaultConsumed;
+            }
+            else {
+                throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected case or default statement in switch body");
+            }
+        }
+        if (cases.length === 0) {
+            throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "swtich statement must contain at least one case statement");
+        }
+        consumed++;
+        return [new ast_1.SwitchStatement(controlExpr, cases, defaultCase), consumed];
+    };
+    /**
+     * Parses a case statement.
+     * @param tokens - Tokens to parse.
+     * @return A CaseStatement node and the number of tokens consumed.
+     */
+    Parser.prototype.parseCaseStatement = function (tokens) {
+        var consumed = 1;
+        var labels = [];
+        while (!this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+            var _a = this.binaryExpression(tokens.slice(consumed)), label = _a[0], labelConsumed = _a[1];
+            labels.push(label);
+            consumed += labelConsumed;
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+                consumed++;
+            }
+            else if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+                throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected comma or opening brace in case statement");
+            }
+        }
+        var _b = this.programBlock(tokens.slice(consumed)), body = _b[0], bodyConsumed = _b[1];
+        consumed += bodyConsumed;
+        return [new ast_1.CaseStatement(labels, body), consumed];
+    };
+    /**
+     * Parses a default statement.
+     * @param tokens - Tokens to parse.
+     * @return A DefaultStatement node and the number of tokens consumed.
+     */
+    Parser.prototype.parseDefaultStatement = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expecting opening brace for default statement");
+        }
+        var _a = this.programBlock(tokens.slice(consumed)), body = _a[0], bodyConsumed = _a[1];
+        consumed += bodyConsumed;
+        return [new ast_1.DefaultStatement(body), consumed];
+    };
+    /**
+     * Parses a delay statement.
+     * @param tokens - Tokens to parse.
+     * @return A QuantumDelay node and the number of tokens consumed.
+     */
+    Parser.prototype.delay = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LSParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected opening bracket [ after delay keyword");
+        }
+        consumed++;
+        var _a = this.binaryExpression(tokens.slice(consumed)), duration = _a[0], durationConsumed = _a[1];
+        consumed += durationConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing bracket ] after delay designator");
+        }
+        consumed++;
+        var _b = this.parseQubitList(tokens.slice(consumed)), qubits = _b[0], qubitsConsumed = _b[1];
+        consumed += qubitsConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+            throwParserError(errors_1.MissingSemicolonError, tokens[consumed], this.index + consumed, "expected semicolon");
+        }
+        consumed++;
+        return [new ast_1.QuantumDelay(duration, qubits), consumed];
+    };
+    /**
+     * Parses a durationof function call.
+     * @param tokens - Tokens to parse.
+     * @return A DurationOf node and the number of tokens consumed.
+     */
+    Parser.prototype.durationOf = function (tokens) {
+        var consumed = 1;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected opening parenthesis after durationof");
+        }
+        consumed++;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected opening brace for durationof scope");
+        }
+        var _a = this.programBlock(tokens.slice(consumed)), scope = _a[0], scopeConsumed = _a[1];
+        consumed += scopeConsumed;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing parenthesis after durationof scope");
+        }
+        consumed++;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+            consumed++;
+        }
+        return [new ast_1.DurationOf(scope), consumed];
+    };
+    /**
+     * Parses a sizeof function call.
+     * @param tokens - Tokens to parse.
+     * @return A SizeOf node and the number of tokens consumed.
+     */
+    Parser.prototype.sizeOf = function (tokens) {
+        var consumed = 1;
+        var dimensions = null;
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected opening parenthesis for sizeof function call");
+        }
+        consumed++;
+        var _a = this.unaryExpression(tokens.slice(consumed)), arrayId = _a[0], arrayIdConsumed = _a[1];
+        consumed += arrayIdConsumed;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+            consumed++;
+            var _b = this.binaryExpression(tokens.slice(consumed)), dim = _b[0], dimConsumed = _b[1];
+            consumed += dimConsumed;
+            dimensions = dim;
+        }
+        if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RParen])) {
+            throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing parenthesis for sizeof function call");
+        }
+        consumed++;
+        return [new ast_1.SizeOf(arrayId, dimensions), consumed];
+    };
+    /**
+     * Parses a program block.
+     * @param tokens - Tokens to parse.
+     * @return A ProgramBlock node and the number of tokens consumed.
+     */
+    Parser.prototype.programBlock = function (tokens) {
+        var statements = [];
+        var consumed = 0;
+        var braceCount = 0;
+        if (this.matchNext(tokens, [token_1.Token.LCParen])) {
+            consumed++;
+            braceCount++;
+            while (braceCount > 0 && consumed < tokens.length) {
+                if (this.matchNext(tokens.slice(consumed), [token_1.Token.LCParen])) {
+                    braceCount++;
+                }
+                else if (this.matchNext(tokens.slice(consumed), [token_1.Token.RCParen])) {
+                    braceCount--;
+                }
+                if (braceCount === 0) {
+                    break;
+                }
+                var _a = this.parseNode(tokens.slice(consumed)), node = _a[0], nodeConsumed = _a[1];
+                if (node && node.length > 0) {
+                    statements.push(node[0]);
+                }
+                consumed += nodeConsumed;
+                if (this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+                    consumed++;
+                }
+            }
+            if (braceCount !== 0) {
+                throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "mismatched curly braces in program block");
+            }
+            consumed++;
+        }
+        else {
+            var _b = this.parseNode(tokens.slice(consumed)), node = _b[0], nodeConsumed = _b[1];
+            if (node && node.length > 0) {
+                statements.push(node[0]);
+            }
+            consumed += nodeConsumed;
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Semicolon])) {
+                consumed++;
+            }
+        }
+        return [new ast_1.ProgramBlock(statements), consumed];
+    };
+    /**
+     * Parses an include statement.
+     * @param tokens - Tokens to parse.
+     * @return An Include node representing the include statement and the number of consumed tokens.
+     */
+    Parser.prototype.include = function (tokens) {
+        var filename;
+        var consumed = 1;
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.String, token_1.Token.Semicolon])) {
+            filename = tokens[consumed][1].toString();
+            return [new ast_1.Include(filename), consumed + 2];
+        }
+        throwParserError(errors_1.BadStringLiteralError, tokens[consumed], this.index + consumed, "expected string literal following `include` keyword");
+    };
+    /**
+     * Parses the version header and sets the parser version.
+     * @param tokens - Tokens to parse.
+     * @return A Version node representing the version statement and the number of consumed tokens.
+     */
+    Parser.prototype.versionHeader = function (tokens) {
+        var version;
+        var consumed = 1;
+        var slicedTokens = tokens.slice(consumed);
+        if (this.matchNext(slicedTokens, [token_1.Token.NNInteger, token_1.Token.Semicolon])) {
+            version = new version_1.OpenQASMVersion(Number(tokens[0][1]));
+            if (!version.isVersion3()) {
+                throwParserError(errors_1.UnsupportedOpenQASMVersionError, tokens[consumed], this.index + consumed, "expected QASM version 3");
+            }
+            consumed += 2;
+            return [new ast_1.Version(version), consumed];
+        }
+        else if (this.matchNext(slicedTokens, [token_1.Token.Real, token_1.Token.Semicolon])) {
+            var versionSplits = tokens[consumed][1].toString().split(".");
+            version = new version_1.OpenQASMVersion(Number(versionSplits[0]), Number(versionSplits[1]));
+            if (!version.isVersion3()) {
+                throwParserError(errors_1.UnsupportedOpenQASMVersionError, tokens[consumed], this.index + consumed, "expected QASM version 3");
+            }
+            consumed += 2;
+            return [new ast_1.Version(version), consumed];
+        }
+        throwParserError(errors_1.UnsupportedOpenQASMVersionError, tokens[consumed], this.index + consumed, "expected QASM version 3");
+    };
+    /**
+     * Parses a classical type.
+     * @param token - The token that represents the type.
+     * @return The ClassicalType and the number of consumed tokens.
+     */
+    Parser.prototype.parseClassicalType = function (tokens) {
+        var typeToken = tokens[0][0];
+        var consumed = 1;
+        var width;
+        var isComplex = false;
+        if (typeToken === token_1.Token.Complex) {
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.LSParen, token_1.Token.Float])) {
+                throwParserError(errors_1.BadClassicalTypeError, tokens[consumed], this.index + consumed, "expected float type for complex number");
+            }
+            isComplex = true;
+            consumed += 2;
+            typeToken = tokens[2][0];
+        }
+        // Check if there's a width or size specification
+        if (this.matchNext(tokens.slice(consumed), [token_1.Token.LSParen])) {
+            consumed++;
+            var _a = this.binaryExpression(tokens.slice(consumed)), widthExpr = _a[0], widthConsumed = _a[1];
+            width = widthExpr;
+            consumed += widthConsumed;
+            if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RSParen])) {
+                throwParserError(errors_1.MissingBraceError, tokens[consumed], this.index + consumed, "expected closing bracket ] for type width");
+            }
+            if (isComplex) {
+                consumed++;
+            }
+            consumed++;
+        }
+        var classicalType = this.createClassicalType(typeToken, width);
+        if (isComplex) {
+            return [new ast_1.ComplexType(classicalType), consumed];
+        }
+        else {
+            return [classicalType, consumed];
+        }
+    };
+    /**
+     * Parses a set declaration.
+     * @param token - The token that represents the type.
+     * @return The resulting Identifier, IndexSet, or Range node and the number of consumed tokens.
+     */
+    Parser.prototype.parseSetDeclaration = function (tokens) {
+        if (this.matchNext(tokens, [token_1.Token.Id])) {
+            var _a = this.unaryExpression(tokens), identifier = _a[0], identifierConsumed = _a[1];
+            return [identifier, identifierConsumed];
+        }
+        else if (this.matchNext(tokens, [token_1.Token.LCParen])) {
+            return this.parseIndexSet(tokens);
+        }
+        else if (this.matchNext(tokens, [token_1.Token.LSParen])) {
+            return this.parseSubscript(tokens);
+        }
+        else {
+            return this.binaryExpression(tokens);
+        }
+    };
+    /**
+     * Parses an index set.
+     * @param token - The token that represents the type.
+     * @return The resulting Identifier, IndexSet, or Range node and the number of consumed tokens.
+     */
+    Parser.prototype.parseIndexSet = function (tokens) {
+        var consumed = 1;
+        var values = [];
+        while (!this.matchNext(tokens.slice(consumed), [token_1.Token.RCParen])) {
+            var _a = this.binaryExpression(tokens.slice(consumed)), expr = _a[0], exprConsumed = _a[1];
+            values.push(expr);
+            consumed += exprConsumed;
+            if (this.matchNext(tokens.slice(consumed), [token_1.Token.Comma])) {
+                consumed++;
+            }
+            else if (!this.matchNext(tokens.slice(consumed), [token_1.Token.RCParen])) {
+                throwParserError(errors_1.BadExpressionError, tokens[consumed], this.index + consumed, "expected comma or closing curly brace in index set");
+            }
+        }
+        consumed++;
+        return [new ast_1.IndexSet(values), consumed];
+    };
+    /**
+     * Creates a classical type.
+     * @param token - The token that represents the type.
+     * @width - The type's width or size, if applicable.
+     * @return The created ClassicalType.
+     */
+    Parser.prototype.createClassicalType = function (token, width) {
+        switch (token) {
+            case token_1.Token.Int:
+                return new ast_1.IntType(width || this.machineIntSize);
+            case token_1.Token.UInt:
+                return new ast_1.UIntType(width || this.machineIntSize);
+            case token_1.Token.Float:
+                return new ast_1.FloatType(width || this.machineFloatWidth);
+            case token_1.Token.Bool:
+                return new ast_1.BoolType();
+            case token_1.Token.Bit:
+                return new ast_1.BitType(width);
+            case token_1.Token.CReg:
+                return new ast_1.BitType(width);
+            case token_1.Token.Stretch:
+                return new ast_1.StretchType();
+            case token_1.Token.Duration:
+                return new ast_1.DurationType();
+            case token_1.Token.Angle:
+                return new ast_1.AngleType(width);
+            default:
+                throwParserError(errors_1.BadClassicalTypeError, token, this.index, "unsupported classical type");
+        }
+    };
+    /**
+     * Creates a math or trigonometric function node.
+     * @param token - The token representing the function.
+     * @param expr - The expression to which the function is applied.
+     * @return The created MathFunction or TrigFunction node and the number of consumed tokens.
+     */
+    Parser.prototype.createMathOrTrigFunction = function (token, expr) {
+        switch (token) {
+            case token_1.Token.Arccos:
+                return [new ast_1.TrigFunction(ast_1.TrigFunctionTypes.ARCCOS, expr), 1];
+            case token_1.Token.Arcsin:
+                return [new ast_1.TrigFunction(ast_1.TrigFunctionTypes.ARCSIN, expr), 1];
+            case token_1.Token.Arctan:
+                return [new ast_1.TrigFunction(ast_1.TrigFunctionTypes.ARCTAN, expr), 1];
+            case token_1.Token.Cos:
+                return [new ast_1.TrigFunction(ast_1.TrigFunctionTypes.COS, expr), 1];
+            case token_1.Token.Sin:
+                return [new ast_1.TrigFunction(ast_1.TrigFunctionTypes.SIN, expr), 1];
+            case token_1.Token.Tan:
+                return [new ast_1.TrigFunction(ast_1.TrigFunctionTypes.TAN, expr), 1];
+            case token_1.Token.Ceiling:
+                return [new ast_1.MathFunction(ast_1.MathFunctionTypes.CEILING, expr), 1];
+            case token_1.Token.Exp:
+                return [new ast_1.MathFunction(ast_1.MathFunctionTypes.EXP, expr), 1];
+            case token_1.Token.Floor:
+                return [new ast_1.MathFunction(ast_1.MathFunctionTypes.FLOOR, expr), 1];
+            case token_1.Token.Log:
+                return [new ast_1.MathFunction(ast_1.MathFunctionTypes.LOG, expr), 1];
+            case token_1.Token.Mod:
+                return [new ast_1.MathFunction(ast_1.MathFunctionTypes.MOD, expr), 1];
+            case token_1.Token.Popcount:
+                return [new ast_1.MathFunction(ast_1.MathFunctionTypes.POPCOUNT, expr), 1];
+            case token_1.Token.Pow:
+                return [new ast_1.MathFunction(ast_1.MathFunctionTypes.POW, expr), 1];
+            case token_1.Token.Rotl:
+                return [new ast_1.MathFunction(ast_1.MathFunctionTypes.ROTL, expr), 1];
+            case token_1.Token.Rotr:
+                return [new ast_1.MathFunction(ast_1.MathFunctionTypes.ROTR, expr), 1];
+            case token_1.Token.Sqrt:
+                return [new ast_1.MathFunction(ast_1.MathFunctionTypes.SQRT, expr), 1];
+            default:
+                throwParserError(errors_1.BadExpressionError, token, this.index, "unsupported math or trig function");
+        }
+    };
+    /** Checks whether a Bit token precedes a measurement statement. */
+    Parser.prototype.isMeasurement = function (tokens) {
+        var i = 0;
+        while (i < tokens.length - 1 &&
+            tokens[i][0] !== token_1.Token.LCParen &&
+            tokens[i][0] !== token_1.Token.Semicolon &&
+            tokens[i][0] !== token_1.Token.EqualsAssmt) {
+            i++;
+        }
+        return (tokens[i][0] === token_1.Token.EqualsAssmt && tokens[i + 1][0] === token_1.Token.Measure);
+    };
+    /** Checks whether the statement is part of an assignment. */
+    Parser.prototype.isAssignment = function (tokens) {
+        var i = 0;
+        while (i < tokens.length - 1 &&
+            tokens[i][0] !== token_1.Token.LCParen &&
+            tokens[i][0] !== token_1.Token.Semicolon &&
+            tokens[i][0] !== token_1.Token.EqualsAssmt) {
+            i++;
+        }
+        return tokens[i][0] === token_1.Token.EqualsAssmt;
+    };
+    /** Checks whether an identifier is a quantum gate call. */
+    Parser.prototype.isQuantumGateCall = function (tokens) {
+        var gateName = tokens[0][1];
+        return (this.gates.has(gateName) ||
+            this.standardGates.has(gateName) ||
+            this.customGates.has(gateName));
+    };
+    /** Checks whether an identifier is a subroutine call. */
+    Parser.prototype.isSubroutineCall = function (tokens) {
+        var subroutineName = tokens[0][1];
+        return this.subroutines.has(subroutineName);
+    };
+    /** Checks whether a number is imaginary. */
+    Parser.prototype.isImaginary = function (token) {
+        if (token.length !== 2) {
+            return false;
+        }
+        return token[1].toString() === "im";
+    };
+    /** Checks whether an identifier is an array. */
+    Parser.prototype.isArray = function (tokens) {
+        if (tokens[0][0] !== token_1.Token.Id) {
+            return false;
+        }
+        var identifierName = tokens[0][1].toString();
+        return this.customArrays.has(identifierName);
+    };
+    /** Checks whether an identifier represents a duration literal unit. */
+    Parser.prototype.isDuration = function (tokens) {
+        var checkToken = tokens[0];
+        if (checkToken.length !== 2 || checkToken[0] !== token_1.Token.Id) {
+            return false;
+        }
+        if (Object.values(ast_1.DurationUnit).includes(checkToken[1].toString())) {
+            return true;
+        }
+        return false;
+    };
+    /** TODO : update this
+     * Validates whether a register or gate identifier.
+     * @param identifier - The identifier to validate.
+     * @return Boolean indicating successful validation or not.
+     */
+    Parser.prototype.validateIdentifier = function (identifier) {
+        var firstChar = identifier[0];
+        return /^[a-z]$/.test(firstChar);
+    };
+    return Parser;
+}());
+/**
+ * Checks if a token represents a type.
+ */
+function isTypeToken(token) {
+    return (token === token_1.Token.Float ||
+        token === token_1.Token.Int ||
+        token === token_1.Token.UInt ||
+        token === token_1.Token.Bool ||
+        token === token_1.Token.Duration ||
+        token === token_1.Token.Angle ||
+        token === token_1.Token.Stretch ||
+        token === token_1.Token.Bit);
+}
+exports.default = Parser;