@harmoniclabs/pebble 0.1.0-dev5 → 0.1.0-dev7

package/dist/parser/Parser.js

@@ -43,9 +43,9 @@ import { FuncDecl } from "../ast/nodes/statements/declarations/FuncDecl.js";
 import { FailStmt } from "../ast/nodes/statements/FailStmt.js";
 import { AssertStmt } from "../ast/nodes/statements/AssertStmt.js";
 import { TestStmt } from "../ast/nodes/statements/TestStmt.js";
-import { MatchStmt, MatchStmtCase } from "../ast/nodes/statements/MatchStmt.js";
+import { MatchStmt, MatchStmtCase, MatchStmtElseCase } from "../ast/nodes/statements/MatchStmt.js";
 import { WhileStmt } from "../ast/nodes/statements/WhileStmt.js";
-import { CaseExpr, CaseExprMatcher } from "../ast/nodes/expr/CaseExpr.js";
+import { CaseExpr, CaseExprMatcher, CaseWildcardMatcher } from "../ast/nodes/expr/CaseExpr.js";
 import { StructConstrDecl, StructDecl, StructDeclAstFlags } from "../ast/nodes/statements/declarations/StructDecl.js";
 import { InterfaceDecl, InterfaceDeclMethod } from "../ast/nodes/statements/declarations/InterfaceDecl.js";
 import { ImportStarStmt } from "../ast/nodes/statements/ImportStarStmt.js";
@@ -69,6 +69,9 @@ import { DecrStmt } from "../ast/nodes/statements/DecrStmt.js";
 import { ExportStmt } from "../ast/nodes/statements/ExportStmt.js";
 import { defaultSymbolForge } from "../compiler/internalVar.js";
 import { Precedence, determinePrecedence } from "./Precedence.js";
+import { LitFailExpr } from "../ast/nodes/expr/litteral/LitFailExpr.js";
+import { ContractDecl } from "../ast/nodes/statements/declarations/ContractDecl.js";
+import { LitContextExpr } from "../ast/nodes/expr/litteral/LitContextExpr.js";
 export class Parser extends DiagnosticEmitter {
     tn;
     constructor(tokenizer, diagnostics = undefined) {
@@ -120,6 +123,8 @@ export class Parser extends DiagnosticEmitter {
             const stmt = this.parseTopLevelStatement();
             if (!stmt)
                 return undefined;
+            if (stmt instanceof ContractDecl)
+                return this.error(DiagnosticCode.Contract_declarations_cannot_be_exported, stmt.range);
             return new ExportStmt(stmt, tn.range(startPos, exportEnd));
         }
         const initialState = tn.mark();
@@ -158,19 +163,24 @@ export class Parser extends DiagnosticEmitter {
                 break;
             }
             case Token.Data: {
-                // skips `data` keyword
+                // `next()` skips `data` keyword
+                tn.next();
                 // positions on (expected) `struct` keyword
-                if (tn.next() !== Token.Struct)
+                if (tn.peek() !== Token.Struct) {
+                    console.error(Token[tn.peek()]);
                     return this.error(DiagnosticCode._0_expected, tn.range(), "struct");
+                }
                 tn.next(); // skip `struct`
                 statement = this.parseStruct(StructDeclAstFlags.onlyDataEncoding, flags, startPos);
                 break;
             }
             case Token.Runtime: {
-                // skips `runtime` keyword
+                // `next()` skips `runtime` keyword
+                tn.next();
                 // positions on (expected) `struct` keyword
-                if (tn.next() !== Token.Struct)
+                if (tn.peek() !== Token.Struct) {
                     return this.error(DiagnosticCode._0_expected, tn.range(), "struct");
+                }
                 tn.next(); // skip `struct`
                 statement = this.parseStruct(StructDeclAstFlags.onlySopEncoding, flags, startPos);
                 break;
@@ -205,6 +215,11 @@ export class Parser extends DiagnosticEmitter {
                 statement = this.parseTypeStmt(flags, startPos);
                 break;
             }
+            case Token.Contract: {
+                tn.next(); // skip `contract`
+                statement = this.parseContractDecl(startPos);
+                break;
+            }
             default:
                 {
                     statement = this.parseStatement({ topLevel: true, isExport: false });
@@ -214,6 +229,75 @@ export class Parser extends DiagnosticEmitter {
         tn.skip(Token.Semicolon); // if any
         return statement;
     }
+    parseContractDecl(startPos) {
+        const tn = this.tn;
+        startPos = typeof startPos === "number" ? startPos : tn.tokenPos;
+        // at 'contract': Identifier '{' ... '}'
+        const contractName = this.parseIdentifier();
+        if (!contractName)
+            return this.error(DiagnosticCode.Identifier_expected, tn.range());
+        if (!tn.skip(Token.OpenBrace))
+            return this.error(DiagnosticCode._0_expected, tn.range(), "{");
+        const params = [];
+        const spendMethods = [];
+        const mintMethods = [];
+        const certifyMethods = [];
+        const withdrawMethods = [];
+        const proposeMethods = [];
+        const voteMethods = [];
+        while (!tn.skip(Token.CloseBrace)) {
+            const thisStartPos = tn.tokenPos;
+            const prevState = tn.mark();
+            const nextToken = tn.next();
+            switch (nextToken) {
+                case Token.Param:
+                    {
+                        const varDecl = this._parseVarDecl(CommonFlags.Const);
+                        if (!varDecl)
+                            return undefined;
+                        if (!(varDecl instanceof SimpleVarDecl))
+                            return this.error(DiagnosticCode._0_expected, varDecl.range, "simple variable declaration");
+                        if (!varDecl.type)
+                            return this.error(DiagnosticCode._0_expected, varDecl.range, "Type annotation");
+                        if (varDecl.initExpr)
+                            return this.error(DiagnosticCode.Contract_parameters_cannot_have_an_initializer_expression, varDecl.range);
+                        params.push(varDecl);
+                        continue;
+                    }
+                    break;
+                // methods
+                case Token.Spend:
+                case Token.Mint:
+                case Token.Certify:
+                case Token.Withdraw:
+                case Token.Propose:
+                case Token.Vote:
+                    {
+                        const funcDecl = this.parseFuncDecl(CommonFlags.None, thisStartPos, new AstVoidType(tn.range()));
+                        if (!funcDecl)
+                            return undefined;
+                        if (!(funcDecl.expr.signature.returnType instanceof AstVoidType))
+                            return this.error(DiagnosticCode.Contract_methods_must_return_void_or_fail, funcDecl.expr.signature.returnType?.range ?? funcDecl.expr.signature.range);
+                        (nextToken === Token.Spend ? spendMethods :
+                            nextToken === Token.Mint ? mintMethods :
+                                nextToken === Token.Certify ? certifyMethods :
+                                    nextToken === Token.Withdraw ? withdrawMethods :
+                                        nextToken === Token.Propose ? proposeMethods :
+                                            nextToken === Token.Vote ? voteMethods :
+                                                spendMethods // default to spendMethods, should never happen
+                        ).push(funcDecl);
+                        continue;
+                    }
+                    break;
+                default: {
+                    tn.reset(prevState);
+                    return this.error(DiagnosticCode._0_expected, tn.range(), "contract member declaration");
+                }
+            }
+            continue;
+        }
+        return new ContractDecl(contractName, params, spendMethods, mintMethods, certifyMethods, withdrawMethods, proposeMethods, voteMethods, tn.range(startPos, tn.pos));
+    }
     parseUsingDecl() {
         const tn = this.tn;
         const startPos = tn.tokenPos;
@@ -509,7 +593,7 @@ export class Parser extends DiagnosticEmitter {
             [
                 new StructConstrDecl(new Identifier(name.text, name.range), [], // fields
                 range)
-            ], structDeclFlags & StructDeclAstFlags.untaggedSingleConstructor, range.clone());
+            ], structDeclFlags | StructDeclAstFlags.untaggedSingleConstructor, range.clone());
         }
         let constrIdentifier = undefined;
         // in case of single constr shortcut
@@ -530,7 +614,7 @@ export class Parser extends DiagnosticEmitter {
             tn.skip(Token.Semicolon); // if any
             return new StructDecl(name, typeParams, [
                 new StructConstrDecl(new Identifier(name.text, name.range), fields, tn.range(startPos, tn.pos))
-            ], structDeclFlags & StructDeclAstFlags.untaggedSingleConstructor, tn.range(startPos, tn.pos));
+            ], structDeclFlags | StructDeclAstFlags.untaggedSingleConstructor, tn.range(startPos, tn.pos));
         }
         const constrFields = this.parseStructConstrFields(flags);
         if (!Array.isArray(constrFields))
@@ -580,7 +664,7 @@ export class Parser extends DiagnosticEmitter {
         }
         return fields;
     }
-    parseNamedFuncSig(flags = CommonFlags.None, startPos) {
+    parseNamedFuncSig(flags = CommonFlags.None, startPos, defaultReturnType) {
         const tn = this.tn;
         startPos = startPos ?? tn.tokenPos;
         if (!tn.skipIdentifier())
@@ -601,7 +685,7 @@ export class Parser extends DiagnosticEmitter {
         const params = this.parseParameters();
         if (!params)
             return undefined;
-        let returnType = undefined;
+        let returnType = defaultReturnType;
         if (tn.skip(Token.Colon)) {
             returnType = this.parseTypeExpr();
             if (!returnType)
@@ -613,10 +697,10 @@ export class Parser extends DiagnosticEmitter {
             new AstFuncType(params, returnType, tn.range(sigStart, tn.pos))
         ];
     }
-    parseFuncDecl(flags, startPos) {
+    parseFuncDecl(flags, startPos, defaultReturnType) {
         const tn = this.tn;
         startPos = startPos ?? tn.tokenPos;
-        const namedSig = this.parseNamedFuncSig(flags, startPos);
+        const namedSig = this.parseNamedFuncSig(flags, startPos, defaultReturnType);
         if (!namedSig)
             return undefined;
         const [name, typeArgs, sig] = namedSig;
@@ -740,14 +824,17 @@ export class Parser extends DiagnosticEmitter {
      *
      * on the contrary in case we are parsing a field of a deconstructed variable declaration
      * an initializer MUST NOT be present NOR a type
+     *
+     * EDIT:
+     * This method is also used while parsing contract `param`s;
      */
-    _parseVarDecl(flags) {
+    _parseVarDecl(flags, skipTypeAndInitializer = false) {
         const tn = this.tn;
         // ConstrName{ ... } || renamed
         const renamedField = this.parseIdentifier();
         if (tn.skip(Token.OpenBrace)) // ConstrName{ ... } || { ... }
          {
-            const unnamed = this.parseSingleDeconstructVarDecl(flags);
+            const unnamed = this.parseSingleDeconstructVarDecl(flags, skipTypeAndInitializer);
             if (!unnamed)
                 return undefined;
             return renamedField instanceof Identifier ?
@@ -763,11 +850,15 @@ export class Parser extends DiagnosticEmitter {
                 this.error(DiagnosticCode.Unexpected_token, tn.range());
                 return undefined;
             }
-            return this.parseArrayLikeDeconstr(flags);
+            return this.parseArrayLikeDeconstr(flags, skipTypeAndInitializer);
         }
         else if (renamedField instanceof Identifier) // renamed
          {
-            const [explicitType, initializer] = this._parseTypeAndInitializer();
+            let explicitType = undefined;
+            let initializer = undefined;
+            if (!skipTypeAndInitializer) {
+                [explicitType, initializer] = this._parseTypeAndInitializer();
+            }
             let range = renamedField.range;
             if (initializer)
                 range = SourceRange.join(range, initializer.range);
@@ -778,7 +869,7 @@ export class Parser extends DiagnosticEmitter {
         else
             return undefined;
     }
-    parseSingleDeconstructVarDecl(flags) {
+    parseSingleDeconstructVarDecl(flags, skipTypeAndInitializer = false) {
         const tn = this.tn;
         const initRange = tn.range();
         let elements = new Map();
@@ -849,10 +940,12 @@ export class Parser extends DiagnosticEmitter {
             elements.set(fieldName, element);
             tn.skip(Token.Comma); // skip comma if present
         } // while( !tn.skip( Token.CloseBrace ) )
-        [explicitType, initializer] = this._parseTypeAndInitializer();
+        if (!skipTypeAndInitializer) {
+            [explicitType, initializer] = this._parseTypeAndInitializer();
+        }
         return new SingleDeconstructVarDecl(elements, rest, explicitType, initializer, flags, SourceRange.join(initRange, tn.range()));
     }
-    parseArrayLikeDeconstr(flags) {
+    parseArrayLikeDeconstr(flags, skipTypeAndInitializer = false) {
         const tn = this.tn;
         // at '[': ( VarDecl ','? )* ']' ( ':' AstTypeExpr )? ( '=' PebbleExpr )?
         const startPos = tn.pos;
@@ -896,7 +989,11 @@ export class Parser extends DiagnosticEmitter {
                 return undefined;
             }
         }
-        const [explicitType, initializer] = this._parseTypeAndInitializer();
+        let explicitType = undefined;
+        let initializer = undefined;
+        if (!skipTypeAndInitializer) {
+            [explicitType, initializer] = this._parseTypeAndInitializer();
+        }
         let range = tn.range(startPos, tn.pos);
         if (initializer)
             range = SourceRange.join(range, initializer.range);
@@ -1029,8 +1126,9 @@ export class Parser extends DiagnosticEmitter {
     parseExpr(precedence = Precedence.Comma) {
         const tn = this.tn;
         let expr = this.parseExprStart();
-        if (!expr)
+        if (!expr) {
             return undefined;
+        }
         const startPos = expr.range.start;
         if (tn.skip(Token.HexBytesLiteral)) {
             const hexBytes = tn.readHexBytes();
@@ -1041,8 +1139,13 @@ export class Parser extends DiagnosticEmitter {
         // precedence climbing
         // see: http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm#climbing
         let nextPrecedence;
-        while ((nextPrecedence = determinePrecedence(tn.peek())) >= precedence) {
+        let prevState;
+        outer_while: while ((nextPrecedence = determinePrecedence(tn.peek())) >= precedence) {
+            prevState = tn.mark();
             const token = tn.next();
+            // DO NOT DIRECTLY RETURN FROM HERE
+            // we need to loop to support right associative operators
+            // and also to support constructs like a.b().c.d()[x]!.e().f.g
             switch (token) {
                 case Token.As: {
                     if (tn.skip(Token.Const))
@@ -1219,6 +1322,11 @@ export class Parser extends DiagnosticEmitter {
                         expr = makeBinaryExpr(token, expr, next, tn.range(startPos, tn.pos));
                         break;
                     }
+                // comma operator handled in caller (only valid in for statements)
+                case Token.Comma: {
+                    tn.reset(prevState);
+                    break outer_while;
+                }
                 default: {
                     return this.error(DiagnosticCode.Expression_expected, tn.range());
                 }
@@ -1266,10 +1374,12 @@ export class Parser extends DiagnosticEmitter {
             }
             // Special Identifier
             case Token.Void: return new LitVoidExpr(tn.range());
+            case Token.Fail: return new LitFailExpr(tn.range());
             case Token.Undefined: return new LitUndefExpr(tn.range());
             case Token.True: return new LitTrueExpr(tn.range());
             case Token.False: return new LitFalseExpr(tn.range());
             case Token.This: return new LitThisExpr(tn.range());
+            case Token.Context: return new LitContextExpr(tn.range());
             // ParenthesizedPebbleExpr or FunctionPebbleExpr
             case Token.OpenParen: {
                 // determine whether this is a function expression
@@ -1350,8 +1460,15 @@ export class Parser extends DiagnosticEmitter {
             }
             case Token.Identifier: {
                 const identifierText = tn.readIdentifier();
-                if (identifierText === "undefined")
-                    return new LitUndefExpr(tn.range()); // special
+                // special expressions
+                switch (identifierText) {
+                    case "undefined": return new LitUndefExpr(tn.range());
+                    case "true": return new LitTrueExpr(tn.range());
+                    case "false": return new LitFalseExpr(tn.range());
+                    case "this": return new LitThisExpr(tn.range());
+                    case "void": return new LitVoidExpr(tn.range());
+                    case "fail": return new LitFailExpr(tn.range());
+                }
                 const identifier = new Identifier(identifierText, tn.range(startPos, tn.pos));
                 // LitNamedObjExpr
                 // eg: `Identifier{ a: 1, b: 2 }`
@@ -1422,6 +1539,9 @@ export class Parser extends DiagnosticEmitter {
                 if (!expr)
                     return undefined;
             }
+            case Token.Fail: {
+                return new LitFailExpr(tn.range());
+            }
             // case Token.Class: return this.parseClassPebbleExpr();
             // case Token.Struct: return this.parseStructExpr();
             default: {
@@ -1455,7 +1575,7 @@ export class Parser extends DiagnosticEmitter {
     }
     parseCaseExpr() {
         const tn = this.tn;
-        // at 'case': Expression ('is' VarDecl '=>' Expression)+
+        // at 'case': Expression ('is' VarDecl '=>' Expression)+ ('else' Expression)?
         const startPos = tn.tokenPos;
         const expr = this.parseExpr();
         if (!expr)
@@ -1480,11 +1600,19 @@ export class Parser extends DiagnosticEmitter {
                 return undefined;
             cases.push(new CaseExprMatcher(matcher, body, tn.range(startPos, tn.pos)));
         }
+        let wildcardCase = undefined;
+        if (tn.skip(Token.Else)) {
+            const wildcardStart = tn.tokenPos;
+            const body = this.parseExpr(Precedence.CaseExpr);
+            if (!body)
+                return undefined;
+            wildcardCase = new CaseWildcardMatcher(body, tn.range(wildcardStart));
+        }
+        tn.skip(Token.Semicolon); // if any
         const finalRange = tn.range(startPos, tn.pos);
         if (cases.length < 1)
             return this.error(DiagnosticCode.A_case_expression_must_have_at_least_one_clause, finalRange);
-        return new CaseExpr(expr, cases, undefined, // wildcard case
-        finalRange);
+        return new CaseExpr(expr, cases, wildcardCase, finalRange);
     }
     parseFunctionExpr() {
         const tn = this.tn;
@@ -1895,6 +2023,12 @@ export class Parser extends DiagnosticEmitter {
             case Token.Question_Question_Equals: {
                 return this.error(DiagnosticCode.Not_implemented_0, tn.range(), "??=");
             }
+            case Token.Plus_Plus: {
+                return makeAssignmentStmt(varIdentifier, Token.Plus_Equals, new LitIntExpr(BigInt(1), tn.range()), tn.range(startPos, tn.pos));
+            }
+            case Token.Minus_Minus: {
+                return makeAssignmentStmt(varIdentifier, Token.Minus_Equals, new LitIntExpr(BigInt(1), tn.range()), tn.range(startPos, tn.pos));
+            }
             default: {
                 return this.error(DiagnosticCode._0_expected, tn.range(), "=");
             }
@@ -2059,8 +2193,11 @@ export class Parser extends DiagnosticEmitter {
                     return this.error(DiagnosticCode.Invalid_for_statement_update, update.range);
                 updates.push(update);
             } while (tn.skip(Token.Comma)); // comma expression (allowed only in for update part)
-            if (!tn.skip(Token.CloseParen))
+            if (!tn.skip(Token.CloseParen)) {
+                const next = tn.peek();
+                console.error('next token after for updates:', Token[next]);
                 return this.error(DiagnosticCode._0_expected, tn.range(), ")");
+            }
         }
         const body = this.parseStatement();
         if (!body)
@@ -2128,11 +2265,13 @@ export class Parser extends DiagnosticEmitter {
             return this.error(DiagnosticCode._0_expected, tn.range(), "{");
         let noPatternCaseSeen = false;
         const cases = new Array();
-        while (!tn.skip(Token.CloseBrace)) {
-            if (!tn.skip(Token.When))
+        while (!tn.skip(Token.CloseBrace)
+            && tn.peek() !== Token.Else) {
+            if (!tn.skip(Token.When)) {
                 return this.error(DiagnosticCode._0_expected, tn.range(), "when");
+            }
             // const startPos = tn.pos;
-            const pattern = this._parseVarDecl(CommonFlags.Const);
+            const pattern = this._parseVarDecl(CommonFlags.Const, true);
             if (!pattern)
                 return this.error(DiagnosticCode.Pattern_expected, tn.range());
             if (noPatternCaseSeen)
@@ -2147,9 +2286,18 @@ export class Parser extends DiagnosticEmitter {
                 return this.error(DiagnosticCode._0_expected, tn.range(statePreBody.tokenPos, statePreBody.pos), "{");
             cases.push(new MatchStmtCase(pattern, body, tn.range()));
         }
+        let elseCase = undefined;
+        if (tn.skip(Token.Else)) {
+            const body = this.parseStatement({ topLevel: false, isExport: false });
+            if (!body)
+                return this.error(DiagnosticCode.Statement_expected, tn.range());
+            elseCase = new MatchStmtElseCase(body, tn.range());
+            if (!tn.skip(Token.CloseBrace))
+                return this.error(DiagnosticCode._0_expected, tn.range(), "}");
+        }
         if (cases.length < 1)
             return this.error(DiagnosticCode.A_match_statement_must_have_at_least_one_case, tn.range(startPos, tn.pos));
-        return new MatchStmt(expr, cases, tn.range(startPos, tn.pos));
+        return new MatchStmt(expr, cases, elseCase, tn.range(startPos, tn.pos));
     }
     parseFailStatement() {
         const tn = this.tn;

package/dist/parser/Precedence.js

@@ -89,6 +89,7 @@ export function determinePrecedence(kind) {
         case Token.Plus_Plus:
         case Token.Minus_Minus: return Precedence.UnaryPostfix;
         case Token.Dot:
+        case Token.Exclamation_Dot:
         case Token.Question_Dot:
         case Token.OpenBracket:
         case Token.Exclamation: return Precedence.MemberAccess;

package/dist/tokenizer/Token.d.ts

@@ -41,120 +41,129 @@ export declare enum Token {
     Test = 38,
     Fail = 39,
     Assert = 40,
+    Contract = 41,
+    Param = 42,
+    Spend = 43,
+    Mint = 44,
+    Certify = 45,
+    Withdraw = 46,
+    Propose = 47,
+    Vote = 48,
+    Context = 49,
     /** `{` */
-    OpenBrace = 41,
+    OpenBrace = 50,
     /** `}` */
-    CloseBrace = 42,
-    OpenParen = 43,
-    CloseParen = 44,
+    CloseBrace = 51,
+    OpenParen = 52,
+    CloseParen = 53,
     /** `[` */
-    OpenBracket = 45,
+    OpenBracket = 54,
     /** `]` */
-    CloseBracket = 46,
+    CloseBracket = 55,
     /** `.` */
-    Dot = 47,
+    Dot = 56,
     /** `...` */
-    Dot_Dot_Dot = 48,
+    Dot_Dot_Dot = 57,
     /** `;` */
-    Semicolon = 49,
+    Semicolon = 58,
     /** `,` */
-    Comma = 50,
+    Comma = 59,
     /** `<` */
-    LessThan = 51,
+    LessThan = 60,
     /** `>` */
-    GreaterThan = 52,
+    GreaterThan = 61,
     /** `<=` */
-    LessThan_Equals = 53,
+    LessThan_Equals = 62,
     /** `>=` */
-    GreaterThan_Equals = 54,
+    GreaterThan_Equals = 63,
     /** `==` */
-    Equals_Equals = 55,
+    Equals_Equals = 64,
     /** `!=` */
-    Exclamation_Equals = 56,
+    Exclamation_Equals = 65,
     /** `===` */
-    Equals_Equals_Equals = 57,
+    Equals_Equals_Equals = 66,
     /** `!==` */
-    Exclamation_Equals_Equals = 58,
+    Exclamation_Equals_Equals = 67,
     /** `=>` */
-    FatArrow = 59,
+    FatArrow = 68,
     /** `+` */
-    Plus = 60,
+    Plus = 69,
     /** `-` */
-    Minus = 61,
+    Minus = 70,
     /** `**` */
-    Asterisk_Asterisk = 62,
+    Asterisk_Asterisk = 71,
     /** `*` */
-    Asterisk = 63,
+    Asterisk = 72,
     /** `/` */
-    Slash = 64,
+    Slash = 73,
     /** `%` */
-    Percent = 65,
+    Percent = 74,
     /** `++` */
-    Plus_Plus = 66,
+    Plus_Plus = 75,
     /** `--` */
-    Minus_Minus = 67,
+    Minus_Minus = 76,
     /** `<<` */
-    LessThan_LessThan = 68,
+    LessThan_LessThan = 77,
     /** `>>` */
-    GreaterThan_GreaterThan = 69,
+    GreaterThan_GreaterThan = 78,
     /** `>>>` */
-    GreaterThan_GreaterThan_GreaterThan = 70,
+    GreaterThan_GreaterThan_GreaterThan = 79,
     /** `+` */
-    Ampersand = 71,
+    Ampersand = 80,
     /** `|` */
-    Bar = 72,
+    Bar = 81,
     /** `^` */
-    Caret = 73,
+    Caret = 82,
     /** `!` */
-    Exclamation = 74,
+    Exclamation = 83,
     /** `~` */
-    Tilde = 75,
+    Tilde = 84,
     /** `&&` */
-    Ampersand_Ampersand = 76,
+    Ampersand_Ampersand = 85,
     /** `||` */
-    Bar_Bar = 77,
+    Bar_Bar = 86,
     /** `?` */
-    Question = 78,
+    Question = 87,
     /** `:` */
-    Colon = 79,
+    Colon = 88,
     /** `=` */
-    Equals = 80,
-    Plus_Equals = 81,
-    Minus_Equals = 82,
-    Asterisk_Equals = 83,
-    Asterisk_Asterisk_Equals = 84,
-    Slash_Equals = 85,
-    Percent_Equals = 86,
-    LessThan_LessThan_Equals = 87,
-    GreaterThan_GreaterThan_Equals = 88,
-    GreaterThan_GreaterThan_GreaterThan_Equals = 89,
-    Ampersand_Equals = 90,
-    Bar_Equals = 91,
-    Caret_Equals = 92,
-    At = 93,
+    Equals = 89,
+    Plus_Equals = 90,
+    Minus_Equals = 91,
+    Asterisk_Equals = 92,
+    Asterisk_Asterisk_Equals = 93,
+    Slash_Equals = 94,
+    Percent_Equals = 95,
+    LessThan_LessThan_Equals = 96,
+    GreaterThan_GreaterThan_Equals = 97,
+    GreaterThan_GreaterThan_GreaterThan_Equals = 98,
+    Ampersand_Equals = 99,
+    Bar_Equals = 100,
+    Caret_Equals = 101,
+    At = 102,
     /** `??=` */
-    Question_Question_Equals = 94,
+    Question_Question_Equals = 103,
     /** `||=` */
-    Bar_Bar_Equals = 95,
+    Bar_Bar_Equals = 104,
     /** `&&=` */
-    Ampersand_Ampersand_Equals = 96,
+    Ampersand_Ampersand_Equals = 105,
     /** `??` */
-    Question_Question = 97,
+    Question_Question = 106,
     /** `?.` */
-    Question_Dot = 98,
+    Question_Dot = 107,
     /** `!.` */
-    Exclamation_Dot = 99,
-    Data = 100,
-    Bytes = 101,
-    Optional = 102,
-    List = 103,
-    LinearMap = 104,
-    Runtime = 105,
-    Identifier = 106,
-    StringLiteral = 107,
-    HexBytesLiteral = 108,
-    IntegerLiteral = 109,
-    StringTemplateLiteralQuote = 110,
-    Invalid = 111,
-    EndOfFile = 112
+    Exclamation_Dot = 108,
+    Data = 109,
+    Bytes = 110,
+    Optional = 111,
+    List = 112,
+    LinearMap = 113,
+    Runtime = 114,
+    Identifier = 115,
+    StringLiteral = 116,
+    HexBytesLiteral = 117,
+    IntegerLiteral = 118,
+    StringTemplateLiteralQuote = 119,
+    Invalid = 120,
+    EndOfFile = 121
 }