@harmoniclabs/pebble 0.1.8 → 0.1.9

package/dist/compiler/tir/types/TirStructType.d.ts

@@ -17,13 +17,33 @@ export declare class TirDataStructType implements ITirStructType {
     /** points to an array possibly shared with alternative encoding types */
     readonly methodNamesPtr: Map<AstFuncName, TirFuncName>;
     readonly untagged: boolean;
+    /**
+     * indexes (in the ORIGINAL parent struct's constructors array) of the
+     * constructors still possible after flow-sensitive narrowing.
+     *
+     * `undefined` means "not narrowed" (full struct).
+     * If present, length matches `this.constructors.length` and entries
+     * correspond positionally to `this.constructors`.
+     */
+    readonly narrowedFromParentCtorIdxs: number[] | undefined;
     constructor(name: string, fileUid: string, constructors: TirStructConstr[], 
     /** points to an array possibly shared with alternative encoding types */
-    methodNamesPtr: Map<AstFuncName, TirFuncName>, untagged?: boolean);
+    methodNamesPtr: Map<AstFuncName, TirFuncName>, untagged?: boolean, narrowedFromParentCtorIdxs?: number[] | undefined);
     hasDataEncoding(): boolean;
     toTirTypeKey(): string;
     toConcreteTirTypeName(): string;
     isSingleConstr(): boolean;
+    isNarrowed(): boolean;
+    /**
+     * Original ctor index of `this.constructors[localIdx]` in the
+     * un-narrowed parent type. For un-narrowed types this is identity.
+     */
+    parentCtorIdx(localIdx: number): number;
+    /**
+     * Returns a clone of this struct type narrowed to the constructors
+     * whose ORIGINAL parent indexes are listed in `parentIdxs`.
+     */
+    narrowTo(parentIdxs: number[]): TirDataStructType;
     toString(): string;
     toAstName(): string;
     protected _isConcrete: boolean | undefined;
@@ -37,13 +57,24 @@ export declare class TirSoPStructType implements ITirStructType {
     readonly constructors: TirStructConstr[];
     /** points to an array possibly shared with alternative encoding types */
     readonly methodNamesPtr: Map<AstFuncName, TirFuncName>;
+    /**
+     * indexes (in the ORIGINAL parent struct's constructors array) of the
+     * constructors still possible after flow-sensitive narrowing.
+     *
+     * `undefined` means "not narrowed" (full struct).
+     * If present, length matches `this.constructors.length`.
+     */
+    readonly narrowedFromParentCtorIdxs: number[] | undefined;
     constructor(name: string, fileUid: string, constructors: TirStructConstr[], 
     /** points to an array possibly shared with alternative encoding types */
-    methodNamesPtr: Map<AstFuncName, TirFuncName>);
+    methodNamesPtr: Map<AstFuncName, TirFuncName>, narrowedFromParentCtorIdxs?: number[] | undefined);
     hasDataEncoding(): boolean;
     toTirTypeKey(): string;
     toConcreteTirTypeName(): string;
     isSingleConstr(): boolean;
+    isNarrowed(): boolean;
+    parentCtorIdx(localIdx: number): number;
+    narrowTo(parentIdxs: number[]): TirSoPStructType;
     toString(): string;
     toAstName(): string;
     protected _isConcrete: boolean | undefined;

package/dist/compiler/tir/types/TirStructType.js

@@ -10,15 +10,25 @@ export class TirDataStructType {
     constructors;
     methodNamesPtr;
     untagged;
+    /**
+     * indexes (in the ORIGINAL parent struct's constructors array) of the
+     * constructors still possible after flow-sensitive narrowing.
+     *
+     * `undefined` means "not narrowed" (full struct).
+     * If present, length matches `this.constructors.length` and entries
+     * correspond positionally to `this.constructors`.
+     */
+    narrowedFromParentCtorIdxs;
     constructor(name, fileUid, constructors, 
     /** points to an array possibly shared with alternative encoding types */
-    methodNamesPtr, untagged = false) {
+    methodNamesPtr, untagged = false, narrowedFromParentCtorIdxs = undefined) {
         this.name = name;
         this.fileUid = fileUid;
         this.constructors = constructors;
         this.methodNamesPtr = methodNamesPtr;
         this.untagged = untagged;
         this.untagged = false; // always false for now
+        this.narrowedFromParentCtorIdxs = narrowedFromParentCtorIdxs;
     }
     hasDataEncoding() { return true; }
     toTirTypeKey() {
@@ -30,6 +40,33 @@ export class TirDataStructType {
     isSingleConstr() {
         return this.constructors.length === 1;
     }
+    isNarrowed() {
+        return this.narrowedFromParentCtorIdxs !== undefined;
+    }
+    /**
+     * Original ctor index of `this.constructors[localIdx]` in the
+     * un-narrowed parent type. For un-narrowed types this is identity.
+     */
+    parentCtorIdx(localIdx) {
+        return this.narrowedFromParentCtorIdxs?.[localIdx] ?? localIdx;
+    }
+    /**
+     * Returns a clone of this struct type narrowed to the constructors
+     * whose ORIGINAL parent indexes are listed in `parentIdxs`.
+     */
+    narrowTo(parentIdxs) {
+        const baseIdxs = this.narrowedFromParentCtorIdxs ?? this.constructors.map((_, i) => i);
+        const filtered = [];
+        const filteredCtors = [];
+        for (let i = 0; i < this.constructors.length; i++) {
+            const parentIdx = baseIdxs[i];
+            if (parentIdxs.includes(parentIdx)) {
+                filtered.push(parentIdx);
+                filteredCtors.push(this.constructors[i]);
+            }
+        }
+        return new TirDataStructType(this.name, this.fileUid, filteredCtors, this.methodNamesPtr, this.untagged, filtered);
+    }
     toString() {
         return this.name;
     }
@@ -43,7 +80,7 @@ export class TirDataStructType {
         return this._isConcrete;
     }
     clone() {
-        const result = new TirDataStructType(this.name, this.fileUid, this.constructors.map(c => c.clone()), this.methodNamesPtr);
+        const result = new TirDataStructType(this.name, this.fileUid, this.constructors.map(c => c.clone()), this.methodNamesPtr, this.untagged, this.narrowedFromParentCtorIdxs ? [...this.narrowedFromParentCtorIdxs] : undefined);
         result._isConcrete = this._isConcrete;
         return result;
     }
@@ -56,13 +93,22 @@ export class TirSoPStructType {
     fileUid;
     constructors;
     methodNamesPtr;
+    /**
+     * indexes (in the ORIGINAL parent struct's constructors array) of the
+     * constructors still possible after flow-sensitive narrowing.
+     *
+     * `undefined` means "not narrowed" (full struct).
+     * If present, length matches `this.constructors.length`.
+     */
+    narrowedFromParentCtorIdxs;
     constructor(name, fileUid, constructors, 
     /** points to an array possibly shared with alternative encoding types */
-    methodNamesPtr) {
+    methodNamesPtr, narrowedFromParentCtorIdxs = undefined) {
         this.name = name;
         this.fileUid = fileUid;
         this.constructors = constructors;
         this.methodNamesPtr = methodNamesPtr;
+        this.narrowedFromParentCtorIdxs = narrowedFromParentCtorIdxs;
     }
     hasDataEncoding() { return false; }
     toTirTypeKey() {
@@ -74,6 +120,25 @@ export class TirSoPStructType {
     isSingleConstr() {
         return this.constructors.length === 1;
     }
+    isNarrowed() {
+        return this.narrowedFromParentCtorIdxs !== undefined;
+    }
+    parentCtorIdx(localIdx) {
+        return this.narrowedFromParentCtorIdxs?.[localIdx] ?? localIdx;
+    }
+    narrowTo(parentIdxs) {
+        const baseIdxs = this.narrowedFromParentCtorIdxs ?? this.constructors.map((_, i) => i);
+        const filtered = [];
+        const filteredCtors = [];
+        for (let i = 0; i < this.constructors.length; i++) {
+            const parentIdx = baseIdxs[i];
+            if (parentIdxs.includes(parentIdx)) {
+                filtered.push(parentIdx);
+                filteredCtors.push(this.constructors[i]);
+            }
+        }
+        return new TirSoPStructType(this.name, this.fileUid, filteredCtors, this.methodNamesPtr, filtered);
+    }
     toString() {
         return this.name;
     }
@@ -87,7 +152,7 @@ export class TirSoPStructType {
         return this._isConcrete;
     }
     clone() {
-        const result = new TirSoPStructType(this.name, this.fileUid, this.constructors.map(c => c.clone()), this.methodNamesPtr);
+        const result = new TirSoPStructType(this.name, this.fileUid, this.constructors.map(c => c.clone()), this.methodNamesPtr, this.narrowedFromParentCtorIdxs ? [...this.narrowedFromParentCtorIdxs] : undefined);
         result._isConcrete = this._isConcrete;
         return result;
     }

package/dist/compiler/tir/types/utils/canAssignTo.js

@@ -240,6 +240,20 @@ function canAssignStruct(a, b, symbols) {
         a = a.aliased;
     while (b instanceof TirAliasType)
         b = b.aliased;
+    // Same logical struct type? (same name + fileUid). When this holds,
+    // we use parent-ctor-idx based subset checks to handle narrowing.
+    const sameLogicalType = a.name === b.name
+        && a.fileUid === b.fileUid;
+    if (sameLogicalType) {
+        const aIdxs = a.narrowedFromParentCtorIdxs ?? a.constructors.map((_, i) => i);
+        const bIdxs = b.narrowedFromParentCtorIdxs ?? b.constructors.map((_, i) => i);
+        // a is assignable to b iff a's parent-ctor set is a SUBSET of b's
+        for (const idx of aIdxs) {
+            if (!bIdxs.includes(idx))
+                return CanAssign.No;
+        }
+        return CanAssign.Yes;
+    }
     const aCtors = a.constructors;
     const bCtors = b.constructors;
     if (aCtors.length !== bCtors.length)

package/dist/parser/Parser.d.ts

@@ -43,6 +43,7 @@ import { UsingStmt } from "../ast/nodes/statements/UsingStmt.js";
 import { BodyStmt, TopLevelStmt } from "../ast/nodes/statements/PebbleStmt.js";
 import { Precedence } from "./Precedence.js";
 import { ContractDecl } from "../ast/nodes/statements/declarations/ContractDecl.js";
+import { StateDecl } from "../ast/nodes/statements/declarations/StateDecl.js";
 interface ParseStmtOpts {
     isExport?: boolean;
     topLevel?: boolean;
@@ -55,6 +56,7 @@ export declare class Parser extends DiagnosticEmitter {
     parseSource(): DiagnosticMessage[];
     parseTopLevelStatement(): TopLevelStmt | undefined;
     parseContractDecl(startPos: number): ContractDecl | undefined;
+    parseStateDecl(startPos: number): StateDecl | undefined;
     parseUsingDecl(): UsingStmt | undefined;
     parseTypeParameters(): Identifier[] | undefined;
     parseTypeArguments(): AstTypeExpr[] | undefined;

package/dist/parser/Parser.js

@@ -59,6 +59,7 @@ import { EnumDecl, EnumValueDecl } from "../ast/nodes/statements/declarations/En
 import { TypeConversionExpr } from "../ast/nodes/expr/TypeConversionExpr.js";
 import { NonNullExpr } from "../ast/nodes/expr/unary/NonNullExpr.js";
 import { ElemAccessExpr } from "../ast/nodes/expr/ElemAccessExpr.js";
+import { IsExpr } from "../ast/nodes/expr/IsExpr.js";
 import { TernaryExpr } from "../ast/nodes/expr/TernaryExpr.js";
 import { makePropAccessExpr } from "../ast/nodes/expr/PropAccessExpr.js";
 import { makeBinaryExpr } from "../ast/nodes/expr/binary/BinaryExpr.js";
@@ -72,6 +73,7 @@ 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 { StateDecl } from "../ast/nodes/statements/declarations/StateDecl.js";
 import { LitContextExpr } from "../ast/nodes/expr/litteral/LitContextExpr.js";
 import { tokenIsAlsoIdentifier } from "../tokenizer/utils/tokenIsAlsoIdentifier.js";
 export class Parser extends DiagnosticEmitter {
@@ -247,12 +249,24 @@ export class Parser extends DiagnosticEmitter {
         const withdrawMethods = [];
         const proposeMethods = [];
         const voteMethods = [];
+        const stateDecls = [];
         while (!tn.skip(Token.CloseBrace)) {
             tn.skip(Token.Semicolon); // if any
             const thisStartPos = tn.tokenPos;
             const prevState = tn.mark();
             const nextToken = tn.next();
             switch (nextToken) {
+                case Token.State:
+                    {
+                        const stateDecl = this.parseStateDecl(thisStartPos);
+                        if (!stateDecl)
+                            return undefined;
+                        if (stateDecls.some(s => s.name.text === stateDecl.name.text))
+                            return this.error(DiagnosticCode.Duplicate_identifier_0, stateDecl.name.range, stateDecl.name.text);
+                        stateDecls.push(stateDecl);
+                        continue;
+                    }
+                    break;
                 case Token.Param:
                     {
                         const varDecl = this._parseVarDecl(CommonFlags.Const);
@@ -300,7 +314,62 @@ export class Parser extends DiagnosticEmitter {
             }
             continue;
         }
-        return new ContractDecl(contractName, params, spendMethods, mintMethods, certifyMethods, withdrawMethods, proposeMethods, voteMethods, tn.range(startPos, tn.pos));
+        return new ContractDecl(contractName, params, spendMethods, mintMethods, certifyMethods, withdrawMethods, proposeMethods, voteMethods, stateDecls, tn.range(startPos, tn.pos));
+    }
+    parseStateDecl(startPos) {
+        const tn = this.tn;
+        startPos = typeof startPos === "number" ? startPos : tn.tokenPos;
+        // at 'state': Identifier '{' ... '}'
+        if (!tn.skipIdentifier())
+            return this.error(DiagnosticCode.Identifier_expected, tn.range());
+        const name = new Identifier(tn.readIdentifier(), tn.range());
+        if (!tn.skip(Token.OpenBrace))
+            return this.error(DiagnosticCode._0_expected, tn.range(), "{");
+        const fields = [];
+        const spendMethods = [];
+        while (!tn.skip(Token.CloseBrace)) {
+            tn.skip(Token.Comma); // if any
+            tn.skip(Token.Semicolon); // if any
+            if (tn.skip(Token.CloseBrace))
+                break;
+            const memberStartPos = tn.tokenPos;
+            const prevState = tn.mark();
+            const nextToken = tn.next();
+            if (nextToken === Token.Spend) {
+                const funcDecl = this.parseFuncDecl(CommonFlags.None, memberStartPos, 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);
+                spendMethods.push(funcDecl);
+                continue;
+            }
+            if (nextToken === Token.Mint
+                || nextToken === Token.Certify
+                || nextToken === Token.Withdraw
+                || nextToken === Token.Propose
+                || nextToken === Token.Vote) {
+                return this.error(DiagnosticCode._0_expected, tn.range(), "spend method or field");
+            }
+            // not a method: parse as field declaration
+            tn.reset(prevState);
+            if (spendMethods.length > 0) {
+                // fields must come before spend methods
+                return this.error(DiagnosticCode._0_expected, tn.range(), "spend method");
+            }
+            const field = this._parseVarDecl(CommonFlags.Const);
+            if (!field)
+                return undefined;
+            if (!(field instanceof SimpleVarDecl))
+                return this.error(DiagnosticCode.Invalid_field_declaration, field.range);
+            if (!field.type)
+                return this.error(DiagnosticCode.Type_expected, field.range.atEnd());
+            if (field.initExpr)
+                return this.error(DiagnosticCode.Initialization_expressions_are_not_allowed_in_a_struct_declaration, SourceRange.join(field.type.range.atEnd(), field.initExpr.range));
+            fields.push(field);
+        }
+        tn.skip(Token.Semicolon); // if any
+        return new StateDecl(name, fields, spendMethods, tn.range(startPos, tn.pos));
     }
     parseUsingDecl() {
         const tn = this.tn;
@@ -1171,28 +1240,15 @@ export class Parser extends DiagnosticEmitter {
                     expr = this.tryParseCallExprOrReturnSame(expr);
                     break;
                 }
-                /*
                 case Token.Is: {
-                    // TODO:
-                    // should optionally check for destructuring
-                    if(!(tn.skipIdentifier()))
-                    {
-                        this.error(
-                            DiagnosticCode.Identifier_expected,
-                            tn.range()
-                        );
-                        return undefined
+                    if (!tn.skipIdentifier()) {
+                        this.error(DiagnosticCode.Identifier_expected, tn.range());
+                        return undefined;
                     }
-                    const ofType = new Identifier( tn.readIdentifier(), tn.range() );
-                    tn.skip( Token.Semicolon); // if any
-                    expr = new IsExpr(
-                        expr,
-                        ofType,
-                        tn.range( startPos, tn.pos )
-                    );
+                    const ofConstr = new Identifier(tn.readIdentifier(), tn.range());
+                    expr = new IsExpr(expr, ofConstr, tn.range(startPos, tn.pos));
                     break;
                 }
-                //*/
                 case Token.OpenBracket: { // [ // accessing list element
                     const idxExpr = this.parseExpr();
                     if (!idxExpr)
@@ -1565,6 +1621,7 @@ export class Parser extends DiagnosticEmitter {
                 const expr = this.parseCaseExpr();
                 if (!expr)
                     return undefined;
+                return expr;
             }
             case Token.Fail: {
                 return new LitFailExpr(tn.range());
@@ -1604,7 +1661,9 @@ export class Parser extends DiagnosticEmitter {
         const tn = this.tn;
         // at 'case': Expression ('is' VarDecl '=>' Expression)+ ('else' Expression)?
         const startPos = tn.tokenPos;
-        const expr = this.parseExpr();
+        // parse the matched expression at a precedence higher than `is`
+        // so the case-level `is` is left unconsumed
+        const expr = this.parseExpr(Precedence.Relational + 1);
         if (!expr)
             return undefined;
         let noPatternCaseSeen = false;
@@ -1622,7 +1681,10 @@ export class Parser extends DiagnosticEmitter {
                 return this.error(DiagnosticCode.Patterns_may_not_have_initializers_or_explicit_types, matcher.initExpr ? matcher.initExpr.range : matcher.type.range);
             if (!tn.skip(Token.FatArrow))
                 return this.error(DiagnosticCode._0_expected, tn.range(), "=>");
-            const body = this.parseExpr(Precedence.CaseExpr);
+            // parse body at precedence higher than `is` so the next case-arm's
+            // `is` is left unconsumed (otherwise `is` would be greedily parsed
+            // as the binary `is` operator inside the body)
+            const body = this.parseExpr(Precedence.Relational + 1);
             if (!body)
                 return undefined;
             cases.push(new CaseExprMatcher(matcher, body, tn.range(startPos, tn.pos)));
@@ -1630,7 +1692,10 @@ export class Parser extends DiagnosticEmitter {
         let wildcardCase = undefined;
         if (tn.skip(Token.Else)) {
             const wildcardStart = tn.tokenPos;
-            const body = this.parseExpr(Precedence.CaseExpr);
+            // parse body at precedence higher than `is` so the next case-arm's
+            // `is` is left unconsumed (otherwise `is` would be greedily parsed
+            // as the binary `is` operator inside the body)
+            const body = this.parseExpr(Precedence.Relational + 1);
             if (!body)
                 return undefined;
             wildcardCase = new CaseWildcardMatcher(body, tn.range(wildcardStart));

package/dist/tokenizer/Token.d.ts

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