@harmoniclabs/pebble 0.1.0-dev2 → 0.1.0-dev4

package/dist/ast/nodes/expr/functions/CallExpr.d.ts

@@ -0,0 +1,17 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { AstTypeExpr } from "../../types/AstTypeExpr.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+export declare class CallExpr implements HasSourceRange {
+    /** any expression that yeidls a function */
+    readonly funcExpr: PebbleExpr;
+    /** if the function is generic */
+    readonly genericTypeArgs: AstTypeExpr[] | undefined;
+    readonly args: PebbleExpr[];
+    readonly range: SourceRange;
+    constructor(
+    /** any expression that yeidls a function */
+    funcExpr: PebbleExpr, 
+    /** if the function is generic */
+    genericTypeArgs: AstTypeExpr[] | undefined, args: PebbleExpr[], range: SourceRange);
+}

package/dist/ast/nodes/expr/functions/CallExpr.js

@@ -0,0 +1,16 @@
+export class CallExpr {
+    funcExpr;
+    genericTypeArgs;
+    args;
+    range;
+    constructor(
+    /** any expression that yeidls a function */
+    funcExpr, 
+    /** if the function is generic */
+    genericTypeArgs, args, range) {
+        this.funcExpr = funcExpr;
+        this.genericTypeArgs = genericTypeArgs;
+        this.args = args;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/functions/FuncExpr.d.ts

@@ -0,0 +1,21 @@
+import { CommonFlags } from "../../../../common.js";
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { Identifier } from "../../common/Identifier.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { BlockStmt } from "../../statements/BlockStmt.js";
+import { AstFuncType } from "../../types/AstNativeTypeExpr.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+import { ArrowKind } from "./ArrowKind.js";
+/**
+ * a litteral function value
+**/
+export declare class FuncExpr implements HasSourceRange {
+    readonly name: Identifier;
+    readonly flags: CommonFlags;
+    readonly typeParams: Identifier[];
+    readonly signature: AstFuncType;
+    readonly body: BlockStmt | PebbleExpr;
+    readonly arrowKind: ArrowKind;
+    readonly range: SourceRange;
+    constructor(name: Identifier, flags: CommonFlags, typeParams: Identifier[], signature: AstFuncType, body: BlockStmt | PebbleExpr, arrowKind: ArrowKind, range: SourceRange);
+}

package/dist/ast/nodes/expr/functions/FuncExpr.js

@@ -0,0 +1,21 @@
+/**
+ * a litteral function value
+**/
+export class FuncExpr {
+    name;
+    flags;
+    typeParams;
+    signature;
+    body;
+    arrowKind;
+    range;
+    constructor(name, flags, typeParams, signature, body, arrowKind, range) {
+        this.name = name;
+        this.flags = flags;
+        this.typeParams = typeParams;
+        this.signature = signature;
+        this.body = body;
+        this.arrowKind = arrowKind;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitArrExpr.d.ts

@@ -0,0 +1,8 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+export declare class LitArrExpr implements HasSourceRange {
+    readonly elems: PebbleExpr[];
+    readonly range: SourceRange;
+    constructor(elems: PebbleExpr[], range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitArrExpr.js

@@ -0,0 +1,8 @@
+export class LitArrExpr {
+    elems;
+    range;
+    constructor(elems, range) {
+        this.elems = elems;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitFalseExpr.d.ts

@@ -0,0 +1,6 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class LitFalseExpr implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitFalseExpr.js

@@ -0,0 +1,6 @@
+export class LitFalseExpr {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitHexBytesExpr.d.ts

@@ -0,0 +1,7 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class LitHexBytesExpr implements HasSourceRange {
+    readonly bytes: Uint8Array;
+    readonly range: SourceRange;
+    constructor(bytes: Uint8Array, range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitHexBytesExpr.js

@@ -0,0 +1,8 @@
+export class LitHexBytesExpr {
+    bytes;
+    range;
+    constructor(bytes, range) {
+        this.bytes = bytes;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitIntExpr.d.ts

@@ -0,0 +1,7 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class LitIntExpr implements HasSourceRange {
+    readonly integer: bigint;
+    readonly range: SourceRange;
+    constructor(integer: bigint, range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitIntExpr.js

@@ -0,0 +1,8 @@
+export class LitIntExpr {
+    integer;
+    range;
+    constructor(integer, range) {
+        this.integer = integer;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitNamedObjExpr.d.ts

@@ -0,0 +1,12 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { Identifier } from "../../common/Identifier.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+import { ILibObjExpr } from "./LitObjExpr.js";
+export declare class LitNamedObjExpr implements HasSourceRange, ILibObjExpr {
+    readonly name: Identifier;
+    readonly fieldNames: Identifier[];
+    readonly values: PebbleExpr[];
+    readonly range: SourceRange;
+    constructor(name: Identifier, fieldNames: Identifier[], values: PebbleExpr[], range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitNamedObjExpr.js

@@ -0,0 +1,12 @@
+export class LitNamedObjExpr {
+    name;
+    fieldNames;
+    values;
+    range;
+    constructor(name, fieldNames, values, range) {
+        this.name = name;
+        this.fieldNames = fieldNames;
+        this.values = values;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitObjExpr.d.ts

@@ -0,0 +1,14 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { Identifier } from "../../common/Identifier.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+export interface ILibObjExpr {
+    fieldNames: Identifier[];
+    values: PebbleExpr[];
+}
+export declare class LitObjExpr implements HasSourceRange, ILibObjExpr {
+    readonly fieldNames: Identifier[];
+    readonly values: PebbleExpr[];
+    readonly range: SourceRange;
+    constructor(fieldNames: Identifier[], values: PebbleExpr[], range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitObjExpr.js

@@ -0,0 +1,10 @@
+export class LitObjExpr {
+    fieldNames;
+    values;
+    range;
+    constructor(fieldNames, values, range) {
+        this.fieldNames = fieldNames;
+        this.values = values;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitStrExpr.d.ts

@@ -0,0 +1,7 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class LitStrExpr implements HasSourceRange {
+    readonly string: string;
+    readonly range: SourceRange;
+    constructor(string: string, range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitStrExpr.js

@@ -0,0 +1,8 @@
+export class LitStrExpr {
+    string;
+    range;
+    constructor(string, range) {
+        this.string = string;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitThisExpr.d.ts

@@ -0,0 +1,6 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class LitThisExpr implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitThisExpr.js

@@ -0,0 +1,6 @@
+export class LitThisExpr {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitTrueExpr.d.ts

@@ -0,0 +1,6 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class LitTrueExpr implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitTrueExpr.js

@@ -0,0 +1,6 @@
+export class LitTrueExpr {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitUndefExpr.d.ts

@@ -0,0 +1,6 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class LitUndefExpr implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitUndefExpr.js

@@ -0,0 +1,6 @@
+export class LitUndefExpr {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitVoidExpr.d.ts

@@ -0,0 +1,6 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+export declare class LitVoidExpr implements HasSourceRange {
+    readonly range: SourceRange;
+    constructor(range: SourceRange);
+}

package/dist/ast/nodes/expr/litteral/LitVoidExpr.js

@@ -0,0 +1,6 @@
+export class LitVoidExpr {
+    range;
+    constructor(range) {
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/litteral/LitteralExpr.d.ts

@@ -0,0 +1,13 @@
+import { LitArrExpr } from "./LitArrExpr.js";
+import { LitFalseExpr } from "./LitFalseExpr.js";
+import { LitHexBytesExpr } from "./LitHexBytesExpr.js";
+import { LitIntExpr } from "./LitIntExpr.js";
+import { LitNamedObjExpr } from "./LitNamedObjExpr.js";
+import { LitObjExpr } from "./LitObjExpr.js";
+import { LitStrExpr } from "./LitStrExpr.js";
+import { LitThisExpr } from "./LitThisExpr.js";
+import { LitTrueExpr } from "./LitTrueExpr.js";
+import { LitUndefExpr } from "./LitUndefExpr.js";
+import { LitVoidExpr } from "./LitVoidExpr.js";
+export type LitteralExpr = LitVoidExpr | LitUndefExpr | LitTrueExpr | LitFalseExpr | LitThisExpr | LitArrExpr | LitObjExpr | LitNamedObjExpr | LitStrExpr | LitIntExpr | LitHexBytesExpr;
+export declare function isLitteralExpr(thing: any): thing is LitteralExpr;

package/dist/ast/nodes/expr/litteral/LitteralExpr.js

@@ -0,0 +1,24 @@
+import { LitArrExpr } from "./LitArrExpr.js";
+import { LitFalseExpr } from "./LitFalseExpr.js";
+import { LitHexBytesExpr } from "./LitHexBytesExpr.js";
+import { LitIntExpr } from "./LitIntExpr.js";
+import { LitNamedObjExpr } from "./LitNamedObjExpr.js";
+import { LitObjExpr } from "./LitObjExpr.js";
+import { LitStrExpr } from "./LitStrExpr.js";
+import { LitThisExpr } from "./LitThisExpr.js";
+import { LitTrueExpr } from "./LitTrueExpr.js";
+import { LitUndefExpr } from "./LitUndefExpr.js";
+import { LitVoidExpr } from "./LitVoidExpr.js";
+export function isLitteralExpr(thing) {
+    return (thing instanceof LitVoidExpr
+        || thing instanceof LitUndefExpr
+        || thing instanceof LitTrueExpr
+        || thing instanceof LitFalseExpr
+        || thing instanceof LitThisExpr
+        || thing instanceof LitArrExpr
+        || thing instanceof LitObjExpr
+        || thing instanceof LitNamedObjExpr
+        || thing instanceof LitStrExpr
+        || thing instanceof LitIntExpr
+        || thing instanceof LitHexBytesExpr);
+}

package/dist/ast/nodes/expr/unary/IUnaryExpression.d.ts

@@ -0,0 +1,4 @@
+import { PebbleExpr } from "../PebbleExpr.js";
+export interface IUnaryExpression {
+    operand: PebbleExpr;
+}

package/dist/ast/nodes/expr/unary/IUnaryExpression.js

@@ -0,0 +1 @@
+export {};

package/dist/ast/nodes/expr/unary/NonNullExpr.d.ts

@@ -0,0 +1,8 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+export declare class NonNullExpr implements HasSourceRange {
+    operand: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(operand: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/expr/unary/NonNullExpr.js

@@ -0,0 +1,8 @@
+export class NonNullExpr {
+    operand;
+    range;
+    constructor(operand, range) {
+        this.operand = operand;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/unary/UnaryExclamation.d.ts

@@ -0,0 +1,9 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+import { IUnaryExpression } from "./IUnaryExpression.js";
+export declare class UnaryExclamation implements HasSourceRange, IUnaryExpression {
+    operand: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(operand: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/expr/unary/UnaryExclamation.js

@@ -0,0 +1,8 @@
+export class UnaryExclamation {
+    operand;
+    range;
+    constructor(operand, range) {
+        this.operand = operand;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/unary/UnaryMinus.d.ts

@@ -0,0 +1,9 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+import { IUnaryExpression } from "./IUnaryExpression.js";
+export declare class UnaryMinus implements HasSourceRange, IUnaryExpression {
+    operand: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(operand: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/expr/unary/UnaryMinus.js

@@ -0,0 +1,8 @@
+export class UnaryMinus {
+    operand;
+    range;
+    constructor(operand, range) {
+        this.operand = operand;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/unary/UnaryPlus.d.ts

@@ -0,0 +1,9 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+import { IUnaryExpression } from "./IUnaryExpression.js";
+export declare class UnaryPlus implements HasSourceRange, IUnaryExpression {
+    operand: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(operand: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/expr/unary/UnaryPlus.js

@@ -0,0 +1,8 @@
+export class UnaryPlus {
+    operand;
+    range;
+    constructor(operand, range) {
+        this.operand = operand;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/expr/unary/UnaryPrefixExpr.d.ts

@@ -0,0 +1,14 @@
+import { Token } from "../../../../tokenizer/Token.js";
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+import { IncrStmt } from "../../statements/IncrStmt.js";
+import { UnaryExclamation } from "./UnaryExclamation.js";
+import { UnaryMinus } from "./UnaryMinus.js";
+import { UnaryPlus } from "./UnaryPlus.js";
+import { UnaryTilde } from "./UnaryTilde.js";
+import { DecrStmt } from "../../statements/DecrStmt.js";
+export type UnaryPrefixExpr = UnaryExclamation | UnaryPlus | UnaryMinus | UnaryTilde;
+export declare function isUnaryPrefixExpr(thing: any): thing is UnaryPrefixExpr;
+export type UnaryPrefixToken = Token.Exclamation | Token.Plus | Token.Minus | Token.Tilde | Token.Plus_Plus | Token.Minus_Minus;
+export type UnaryPrefixTokenToExpr<T extends UnaryPrefixToken> = T extends Token.Exclamation ? UnaryExclamation : T extends Token.Plus ? UnaryPlus : T extends Token.Minus ? UnaryMinus : T extends Token.Tilde ? UnaryTilde : T extends Token.Plus_Plus ? IncrStmt : T extends Token.Minus_Minus ? DecrStmt : never;
+export declare function makeUnaryPrefixExpr<T extends UnaryPrefixToken>(token: T, operand: PebbleExpr, range: SourceRange): UnaryPrefixTokenToExpr<T>;

package/dist/ast/nodes/expr/unary/UnaryPrefixExpr.js

@@ -0,0 +1,27 @@
+import { Token } from "../../../../tokenizer/Token.js";
+import { IncrStmt } from "../../statements/IncrStmt.js";
+import { UnaryExclamation } from "./UnaryExclamation.js";
+import { UnaryMinus } from "./UnaryMinus.js";
+import { UnaryPlus } from "./UnaryPlus.js";
+import { UnaryTilde } from "./UnaryTilde.js";
+import { DecrStmt } from "../../statements/DecrStmt.js";
+export function isUnaryPrefixExpr(thing) {
+    return (thing instanceof UnaryExclamation ||
+        thing instanceof UnaryPlus ||
+        thing instanceof UnaryMinus ||
+        thing instanceof UnaryTilde ||
+        thing instanceof IncrStmt ||
+        thing instanceof DecrStmt);
+}
+export function makeUnaryPrefixExpr(token, operand, range) {
+    switch (token) {
+        case Token.Exclamation: return new UnaryExclamation(operand, range);
+        case Token.Plus: return new UnaryPlus(operand, range);
+        case Token.Minus: return new UnaryMinus(operand, range);
+        case Token.Tilde: return new UnaryTilde(operand, range);
+        case Token.Plus_Plus: return new IncrStmt(operand, range);
+        case Token.Minus_Minus: return new DecrStmt(operand, range);
+        default:
+            throw new Error("Invalid token for unary prefix expression");
+    }
+}

package/dist/ast/nodes/expr/unary/UnaryTilde.d.ts

@@ -0,0 +1,9 @@
+import { SourceRange } from "../../../Source/SourceRange.js";
+import { HasSourceRange } from "../../HasSourceRange.js";
+import { PebbleExpr } from "../PebbleExpr.js";
+import { IUnaryExpression } from "./IUnaryExpression.js";
+export declare class UnaryTilde implements HasSourceRange, IUnaryExpression {
+    operand: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(operand: PebbleExpr, range: SourceRange);
+}

package/dist/ast/nodes/expr/unary/UnaryTilde.js

@@ -0,0 +1,8 @@
+export class UnaryTilde {
+    operand;
+    range;
+    constructor(operand, range) {
+        this.operand = operand;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/AssertStmt.d.ts

@@ -0,0 +1,15 @@
+import { SourceRange } from "../../Source/SourceRange.js";
+import { PebbleExpr } from "../expr/PebbleExpr.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+export declare class AssertStmt implements HasSourceRange {
+    /** must be boolean or Optional */
+    readonly condition: PebbleExpr;
+    /** must be string */
+    readonly elseExpr: PebbleExpr | undefined;
+    readonly range: SourceRange;
+    constructor(
+    /** must be boolean or Optional */
+    condition: PebbleExpr, 
+    /** must be string */
+    elseExpr: PebbleExpr | undefined, range: SourceRange);
+}

package/dist/ast/nodes/statements/AssertStmt.js

@@ -0,0 +1,14 @@
+export class AssertStmt {
+    condition;
+    elseExpr;
+    range;
+    constructor(
+    /** must be boolean or Optional */
+    condition, 
+    /** must be string */
+    elseExpr, range) {
+        this.condition = condition;
+        this.elseExpr = elseExpr;
+        this.range = range;
+    }
+}

package/dist/ast/nodes/statements/AssignmentStmt.d.ts

@@ -0,0 +1,105 @@
+import { Token } from "../../../tokenizer/Token.js";
+import { Identifier } from "../common/Identifier.js";
+import { PebbleExpr } from "../expr/PebbleExpr.js";
+import { SourceRange } from "../../Source/SourceRange.js";
+import { HasSourceRange } from "../HasSourceRange.js";
+import { DecrStmt } from "./DecrStmt.js";
+import { IncrStmt } from "./IncrStmt.js";
+export type ExplicitAssignmentStmt = SimpleAssignmentStmt | AddAssignmentStmt | SubAssignmentStmt | ExpAssignmentStmt | MultAssignmentStmt | DivAssignmentStmt | ModuloAssignmentStmt | ShiftLeftAssignmentStmt | ShiftRightAssignmentStmt | BitwiseAndAssignmentStmt | BitwiseXorAssignmentStmt | BitwiseOrAssignmentStmt | LogicalAndAssignmentStmt | LogicalOrAssignmentStmt;
+export type ImplicitAssignmentStmt = IncrStmt | DecrStmt;
+export type AssignmentStmt = ExplicitAssignmentStmt | ImplicitAssignmentStmt;
+export type AssignmentStmtToken = Token.Equals | Token.Plus_Equals | Token.Minus_Equals | Token.Asterisk_Asterisk_Equals | Token.Asterisk_Equals | Token.Slash_Equals | Token.Percent_Equals | Token.Plus_Plus | Token.Minus_Minus | Token.LessThan_LessThan_Equals | Token.GreaterThan_GreaterThan_Equals | Token.GreaterThan_GreaterThan_GreaterThan_Equals | Token.Ampersand_Equals | Token.Caret_Equals | Token.Bar_Equals | Token.Ampersand_Ampersand_Equals | Token.Bar_Bar_Equals;
+export type AssignmentTokenToStmt<T extends AssignmentStmtToken> = T extends Token.Equals ? SimpleAssignmentStmt : T extends Token.Plus_Equals ? AddAssignmentStmt : T extends Token.Minus_Equals ? SubAssignmentStmt : T extends Token.Asterisk_Asterisk_Equals ? ExpAssignmentStmt : T extends Token.Asterisk_Equals ? MultAssignmentStmt : T extends Token.Slash_Equals ? DivAssignmentStmt : T extends Token.Percent_Equals ? ModuloAssignmentStmt : T extends Token.Plus_Plus ? IncrStmt : T extends Token.Minus_Minus ? DecrStmt : T extends Token.LessThan_LessThan_Equals ? ShiftLeftAssignmentStmt : T extends Token.GreaterThan_GreaterThan_Equals ? ShiftRightAssignmentStmt : T extends Token.GreaterThan_GreaterThan_GreaterThan_Equals ? ShiftRightAssignmentStmt : T extends Token.Ampersand_Equals ? BitwiseAndAssignmentStmt : T extends Token.Caret_Equals ? BitwiseXorAssignmentStmt : T extends Token.Bar_Equals ? BitwiseOrAssignmentStmt : T extends Token.Ampersand_Ampersand_Equals ? LogicalAndAssignmentStmt : T extends Token.Bar_Bar_Equals ? LogicalOrAssignmentStmt : never;
+export declare function isAssignmentToken(token: any): token is AssignmentStmtToken;
+export declare function isAssignmentStmt(stmt: any): stmt is AssignmentStmt;
+export declare function isImplicitAssignmentStmt(stmt: any): stmt is ImplicitAssignmentStmt;
+export declare function isExplicitAssignmentStmt(stmt: any): stmt is ExpAssignmentStmt;
+export declare function makeAssignmentStmt<T extends AssignmentStmtToken>(varIdentifier: Identifier, token: T, assignedExpr: PebbleExpr, range: SourceRange): AssignmentTokenToStmt<T>;
+export interface IAssignmentStmt extends HasSourceRange {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+}
+export declare class SimpleAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class AddAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class SubAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class ExpAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class MultAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class DivAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class ModuloAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class ShiftLeftAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class ShiftRightAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class BitwiseAndAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class BitwiseXorAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class BitwiseOrAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class LogicalAndAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}
+export declare class LogicalOrAssignmentStmt implements IAssignmentStmt {
+    readonly varIdentifier: Identifier;
+    readonly assignedExpr: PebbleExpr;
+    readonly range: SourceRange;
+    constructor(varIdentifier: Identifier, assignedExpr: PebbleExpr, range: SourceRange);
+}