@algorandfoundation/puya-ts 1.0.0-alpha.4

package/awst_build/eb/transactions/util.d.ts

@@ -0,0 +1,5 @@
+import { TransactionKind } from '../../../awst/models';
+import type { GroupTransactionPType, InnerTransactionPType, ItxnParamsPType } from '../../ptypes';
+export declare function getInnerTransactionType(kind: TransactionKind | undefined): InnerTransactionPType;
+export declare function getItxnParamsType(kind: TransactionKind | undefined): ItxnParamsPType;
+export declare function getGroupTransactionType(kind: TransactionKind | undefined): GroupTransactionPType;

package/awst_build/eb/tuple-expression-builder.d.ts

@@ -0,0 +1,12 @@
+import type { Expression } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import { TuplePType } from '../ptypes';
+import type { InstanceBuilder, NodeBuilder } from './index';
+import { InstanceExpressionBuilder } from './index';
+export declare class TupleExpressionBuilder extends InstanceExpressionBuilder<TuplePType> {
+    constructor(expression: Expression, ptype: PType);
+    iterate(): Expression;
+    indexAccess(index: InstanceBuilder, sourceLocation: SourceLocation): NodeBuilder;
+    getItemBuilders(): InstanceBuilder[];
+}

package/awst_build/eb/uint64-enum-type-builder.d.ts

@@ -0,0 +1,13 @@
+import type { Expression } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import { Uint64EnumMemberType, Uint64EnumType } from '../ptypes';
+import { InstanceExpressionBuilder, NodeBuilder } from './index';
+export declare class Uint64EnumTypeBuilder extends NodeBuilder {
+    readonly ptype: Uint64EnumType;
+    constructor(sourceLocation: SourceLocation, ptype: PType);
+    memberAccess(name: string, sourceLocation: SourceLocation): NodeBuilder;
+}
+export declare class Uint64EnumMemberExpressionBuilder extends InstanceExpressionBuilder<Uint64EnumMemberType> {
+    constructor(expr: Expression, ptype: PType);
+}

package/awst_build/eb/uint64-expression-builder.d.ts

@@ -0,0 +1,21 @@
+import type { awst } from '../../awst';
+import type { Expression } from '../../awst/nodes';
+import type { SourceLocation } from '../../awst/source-location';
+import type { InstanceType, PType } from '../ptypes';
+import type { BuilderComparisonOp, InstanceBuilder } from './index';
+import { BuilderBinaryOp, BuilderUnaryOp, FunctionBuilder, InstanceExpressionBuilder } from './index';
+export declare class UInt64FunctionBuilder extends FunctionBuilder {
+    readonly ptype: import("../ptypes").LibFunctionType;
+    call(args: Array<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): InstanceBuilder;
+}
+export declare class UInt64ExpressionBuilder extends InstanceExpressionBuilder<InstanceType> {
+    constructor(expr: Expression);
+    boolEval(sourceLocation: SourceLocation, negate: boolean): Expression;
+    compare(other: InstanceBuilder, op: BuilderComparisonOp, sourceLocation: SourceLocation): InstanceBuilder;
+    prefixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    postfixUnaryOp(op: BuilderUnaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    binaryOp(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    augmentedAssignment(other: InstanceBuilder, op: BuilderBinaryOp, sourceLocation: SourceLocation): InstanceBuilder;
+    assign(other: InstanceBuilder, sourceLocation: SourceLocation): InstanceBuilder;
+    toBytes(sourceLocation: SourceLocation): awst.Expression;
+}

package/awst_build/eb/urange-function.d.ts

@@ -0,0 +1,7 @@
+import type { SourceLocation } from '../../awst/source-location';
+import type { PType } from '../ptypes';
+import type { InstanceBuilder, NodeBuilder } from './index';
+import { FunctionBuilder } from './index';
+export declare class UrangeFunctionBuilder extends FunctionBuilder {
+    call(args: ReadonlyArray<InstanceBuilder>, typeArgs: ReadonlyArray<PType>, sourceLocation: SourceLocation): NodeBuilder;
+}

package/awst_build/eb/util/arg-parsing.d.ts

@@ -0,0 +1,106 @@
+import type { SourceLocation } from '../../../awst/source-location';
+import type { DeliberateAny, Tuple } from '../../../typescript-helpers';
+import type { PType, PTypeOrClass } from '../../ptypes';
+import type { InstanceBuilder } from '../index';
+declare const ArgSpecDiscriminator: unique symbol;
+/**
+ * Optional arg spec
+ * Will be mapped to `Expression | undefined`
+ */
+type OptionalArg = {
+    t: PTypeOrClass[];
+    required: false;
+    [ArgSpecDiscriminator]: 'arg';
+};
+/**
+ * Required arg spec
+ * Will be mapped to `Expression`
+ */
+type RequiredArg = {
+    t: PTypeOrClass[];
+    required: true;
+    [ArgSpecDiscriminator]: 'arg';
+};
+type ArgSpec = OptionalArg | RequiredArg;
+/**
+ * Object arg spec
+ * Will be mapped to an object with the same keys where each property
+ * is mapped to a Required or Optional spec
+ */
+type ObjArgSpec = Record<string, ArgSpec> & {
+    [ArgSpecDiscriminator]: 'obj';
+};
+/**
+ * Maps an ObjArgSpec to its output type
+ */
+type ArgsForObjSpec<T extends ObjArgSpec> = {
+    [key in keyof T]: ArgFor<T[key]>;
+};
+/**
+ * Defines the expected shape of a single argument.
+ * Either an ArgSpec indicting a single value, or an ObjArgSpec indicating an
+ * object literal with several properties
+ */
+type ArgMap = ArgSpec | ObjArgSpec;
+/**
+ * Maps an arg spec to its output type
+ */
+type ArgFor<T extends ObjArgSpec | ArgSpec> = T extends ObjArgSpec ? ArgsForObjSpec<T> : T extends OptionalArg ? InstanceBuilder | undefined : T extends RequiredArg ? InstanceBuilder : never;
+/**
+ * Maps each arg to an expected output type
+ */
+type ParsedArgs<T extends [...DeliberateAny[]]> = T extends [infer T1 extends ArgMap, ...infer TRest] ? [ArgFor<T1>, ...ParsedArgs<TRest>] : T extends [] ? [] : T extends Array<infer TItem extends ArgMap> ? Array<ArgFor<TItem>> : never;
+declare const argSpecFactory: {
+    /**
+     * A required arg with one of the specified types
+     * @param ptypes
+     */
+    required(...ptypes: PTypeOrClass[]): RequiredArg;
+    /**
+     * An optional arg with one of the specified types
+     * @param ptypes
+     */
+    optional(...ptypes: PTypeOrClass[]): OptionalArg;
+    /**
+     * An object map arg, if all properties are optional - the arg itself becomes optional
+     * @param props A mapping of expected properties to expected ptypes
+     */
+    obj<T extends Omit<ObjArgSpec, typeof ArgSpecDiscriminator>>(props: T): T & {
+        [ArgSpecDiscriminator]: "obj";
+    };
+};
+export type ArgSpecFactory = typeof argSpecFactory;
+export declare function parseFunctionArgs<const TGenericCount extends number, const TArgMap extends [...ArgMap[]]>({ args, typeArgs, funcName, callLocation, genericTypeArgs, argSpec, }: {
+    /**
+     * Raw args array passed to call function
+     */
+    args: ReadonlyArray<InstanceBuilder>;
+    /**
+     * Raw typeArgs array passed to call function
+     */
+    typeArgs: ReadonlyArray<PType>;
+    /**
+     * The name of the function being called
+     * (Used for error context)
+     */
+    funcName: string;
+    /**
+     * The location of the call expression in the application source code
+     */
+    callLocation: SourceLocation;
+    /**
+     * The expected number of generic type arguments
+     */
+    genericTypeArgs: TGenericCount;
+    /**
+     * A mapping of expected argument types
+     */
+    argSpec: (a: ArgSpecFactory) => TArgMap;
+}): {
+    /**
+     * A tuple of generic type args with a length of `TGenericCount`
+     */
+    ptypes: Tuple<PType, TGenericCount>;
+    args: ParsedArgs<TArgMap>;
+};
+export {};

package/awst_build/eb/util/compare-bytes.d.ts

@@ -0,0 +1,5 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import { BooleanExpressionBuilder } from '../boolean-expression-builder';
+import { BuilderComparisonOp } from '../index';
+export declare function compareBytes(left: Expression, right: Expression, op: BuilderComparisonOp, sourceLocation: SourceLocation, typeDescription: string): BooleanExpressionBuilder;

package/awst_build/eb/util/compare-uint64.d.ts

@@ -0,0 +1,5 @@
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import { BooleanExpressionBuilder } from '../boolean-expression-builder';
+import { BuilderComparisonOp } from '../index';
+export declare function compareUint64(left: Expression, right: Expression, op: BuilderComparisonOp, sourceLocation: SourceLocation, typeDescription: string): BooleanExpressionBuilder;

package/awst_build/eb/util/index.d.ts

@@ -0,0 +1,19 @@
+import type { awst, ConstantValue } from '../../../awst';
+import type { Expression } from '../../../awst/nodes';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { PType, PTypeOrClass } from '../../ptypes';
+import type { NodeBuilder } from '../index';
+import { InstanceBuilder } from '../index';
+export declare function requireExpressionOfType(builder: NodeBuilder, ptype: PTypeOrClass): Expression;
+export declare function requireBuilderOfType(builder: NodeBuilder, ptype: PTypeOrClass): InstanceBuilder;
+export declare function resolvableToType(builder: NodeBuilder, ptype: PTypeOrClass): builder is InstanceBuilder;
+export declare function requestExpressionOfType(builder: NodeBuilder, ptype: PTypeOrClass): Expression | undefined;
+export declare function requestBuilderOfType(builder: NodeBuilder, ptype: PTypeOrClass): InstanceBuilder | undefined;
+export declare function requireInstanceBuilder(builder: NodeBuilder): InstanceBuilder;
+export declare function requireExpressionsOfType<const TPTypes extends [...PType[]]>(builders: ReadonlyArray<InstanceBuilder>, ptypes: TPTypes, sourceLocation: SourceLocation): Array<awst.Expression>;
+export declare function requireStringConstant(builder: InstanceBuilder): awst.StringConstant;
+export declare function requireIntegerConstant(builder: InstanceBuilder): awst.IntegerConstant;
+export declare function requireBooleanConstant(builder: InstanceBuilder): awst.BoolConstant;
+export declare function requestConstantOfType(builder: NodeBuilder, ptype: PType): awst.Constant | undefined;
+export declare function requireConstantOfType(builder: NodeBuilder, ptype: PType, messageOverride?: string): awst.Constant;
+export declare function isValidLiteralForPType(literalValue: ConstantValue, ptype: PTypeOrClass): boolean;

package/awst_build/eb/util/require-constant-value.d.ts

@@ -0,0 +1,4 @@
+import type { ConstantValue } from '../../../awst';
+import type { SourceLocation } from '../../../awst/source-location';
+import type { NodeBuilder } from '../index';
+export declare function requireConstantValue(builder: NodeBuilder, sourceLocation: SourceLocation): ConstantValue;

package/awst_build/eb/void-expression-builder.d.ts

@@ -0,0 +1,7 @@
+import type { Expression, LValue } from '../../awst/nodes';
+import type { InstanceType } from '../ptypes';
+import { InstanceExpressionBuilder } from './index';
+export declare class VoidExpressionBuilder extends InstanceExpressionBuilder<InstanceType> {
+    constructor(expr: Expression);
+    resolveLValue(): LValue;
+}

package/awst_build/function-visitor.d.ts

@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import type * as awst from '../awst/nodes';
+import type { SourceLocation } from '../awst/source-location';
+import type { Statements } from '../visitor/syntax-names';
+import type { Visitor } from '../visitor/visitor';
+import { BaseVisitor } from './base-visitor';
+import type { AwstBuildContext } from './context/awst-build-context';
+import type { InstanceBuilder } from './eb';
+import { FunctionPType } from './ptypes';
+export declare class FunctionVisitor extends BaseVisitor implements Visitor<ts.ParameterDeclaration, awst.SubroutineArgument>, Visitor<ts.Block, awst.Block>, Visitor<Statements, awst.Statement | awst.Statement[]> {
+    protected accept: <TNode extends ts.Node>(node: TNode) => import("../visitor/visitor").MethodReturnType<import("../visitor/visitor").VisitorMethod<import("../visitor/visitor").KindForNode<import("../visitor/syntax-names").MapBaseType<TNode>>>, FunctionVisitor>;
+    protected readonly _functionType: FunctionPType;
+    constructor(ctx: AwstBuildContext, node: ts.MethodDeclaration | ts.FunctionDeclaration | ts.ConstructorDeclaration);
+    protected buildFunctionAwst(node: ts.MethodDeclaration | ts.FunctionDeclaration | ts.ConstructorDeclaration): {
+        args: awst.SubroutineArgument[];
+        documentation: awst.MethodDocumentation;
+        body: awst.Block;
+    };
+    buildAssignmentTarget(bindingName: ts.BindingName, sourceLocation: SourceLocation): InstanceBuilder;
+    evaluateParameterBindingExpressions(parameters: Iterable<ts.ParameterDeclaration>, sourceLocation: SourceLocation): awst.Statement[];
+    visitTypeAliasDeclaration(node: ts.TypeAliasDeclaration): awst.Statement[];
+    visitClassDeclaration(node: ts.ClassDeclaration): awst.Statement | awst.Statement[];
+    visitVariableDeclarationList(node: ts.VariableDeclarationList): awst.Statement[];
+    visitVariableStatement(node: ts.VariableStatement): awst.Statement | awst.Statement[];
+    visitForStatement(node: ts.ForStatement): awst.Statement | awst.Statement[];
+    visitForOfStatement(node: ts.ForOfStatement): awst.Statement | awst.Statement[];
+    visitForInStatement(node: ts.ForInStatement): awst.Statement | awst.Statement[];
+    visitTryStatement(node: ts.TryStatement): awst.Statement | awst.Statement[];
+    visitEmptyStatement(node: ts.EmptyStatement): awst.Statement | awst.Statement[];
+    visitExpressionStatement(node: ts.ExpressionStatement): awst.Statement | awst.Statement[];
+    visitIfStatement(node: ts.IfStatement): awst.Statement | awst.Statement[];
+    visitDoStatement(node: ts.DoStatement): awst.Statement | awst.Statement[];
+    visitWhileStatement(node: ts.WhileStatement): awst.Statement | awst.Statement[];
+    visitContinueStatement(node: ts.ContinueStatement): awst.Statement | awst.Statement[];
+    visitBreakStatement(node: ts.BreakStatement): awst.Statement | awst.Statement[];
+    visitReturnStatement(node: ts.ReturnStatement): awst.Statement | awst.Statement[];
+    visitWithStatement(node: ts.WithStatement): awst.Statement | awst.Statement[];
+    visitSwitchStatement(node: ts.SwitchStatement): awst.Statement | awst.Statement[];
+    visitLabeledStatement(node: ts.LabeledStatement): awst.Statement | awst.Statement[];
+    visitThrowStatement(node: ts.ThrowStatement): awst.Statement | awst.Statement[];
+    visitDebuggerStatement(node: ts.DebuggerStatement): awst.Statement | awst.Statement[];
+    visitImportDeclaration(node: ts.ImportDeclaration): awst.Statement | awst.Statement[];
+    visitBlock(node: ts.Block): awst.Block;
+    visitParameter(node: ts.ParameterDeclaration): awst.SubroutineArgument;
+}

package/awst_build/index.d.ts

@@ -0,0 +1,5 @@
+import type { CompilationSet } from '../awst/models';
+import type { AWST } from '../awst/nodes';
+import type { CompileOptions } from '../compile-options';
+import type { CreateProgramResult } from '../parser';
+export declare function buildAwst({ program, sourceFiles }: CreateProgramResult, options: CompileOptions): [AWST[], CompilationSet];

package/awst_build/lib/index.d.ts

@@ -0,0 +1,2 @@
+import type { AWST } from '../../awst/nodes';
+export declare function buildLibAwst(): AWST[];

package/awst_build/op-metadata.d.ts

@@ -0,0 +1,27 @@
+import * as ptypes from './ptypes';
+import type { Expression } from '../awst/nodes';
+export type ImmediateArgMapping = {
+    name: string;
+    ptypes: ptypes.PType[];
+};
+export type StackArg = {
+    name: string;
+    ptypes: ptypes.PType[];
+};
+export type Signature = {
+    argNames: string[];
+    immediateArgs: Array<ImmediateArgMapping | bigint | string>;
+    stackArgs: Array<StackArg | Expression>;
+    returnType: ptypes.PType;
+};
+export type IntrinsicOpMapping = {
+    type: 'op-mapping';
+    op: string;
+    signatures: Signature[];
+};
+export type IntrinsicOpGrouping = {
+    type: 'op-grouping';
+    name: string;
+    ops: Record<string, IntrinsicOpMapping>;
+};
+export declare const OP_METADATA: Record<string, IntrinsicOpMapping | IntrinsicOpGrouping>;

package/awst_build/ptypes/arc4-types.d.ts

@@ -0,0 +1,56 @@
+import type { SourceLocation } from '../../awst/source-location';
+import type { ARC4Type } from '../../awst/wtypes';
+import { ARC4DynamicArray, ARC4StaticArray, ARC4UIntN } from '../../awst/wtypes';
+import { PType } from './base';
+import { LibFunctionType } from './index';
+export declare const UintNConstructor: LibFunctionType;
+export declare abstract class ARC4EncodedType extends PType {
+    abstract get wtype(): ARC4Type;
+}
+export declare class UintNType extends ARC4EncodedType {
+    static baseFullName: string;
+    readonly module: "@algorandfoundation/algorand-typescript/arc4/encoded-types.d.ts";
+    readonly n: bigint;
+    readonly name: string;
+    readonly singleton = false;
+    get wtype(): ARC4UIntN;
+    constructor({ n }: {
+        n: bigint;
+    });
+    static parameterise(typeArgs: PType[]): UintNType;
+    getGenericArgs(): PType[];
+}
+export declare const DynamicArrayConstructor: LibFunctionType;
+export declare class DynamicArrayType extends ARC4EncodedType {
+    static baseFullName: string;
+    readonly module: "@algorandfoundation/algorand-typescript/arc4/encoded-types.d.ts";
+    readonly elementType: ARC4EncodedType;
+    readonly name: string;
+    readonly singleton = false;
+    readonly sourceLocation: SourceLocation | undefined;
+    get wtype(): ARC4DynamicArray;
+    constructor({ elementType, sourceLocation }: {
+        elementType: ARC4EncodedType;
+        sourceLocation?: SourceLocation;
+    });
+    static parameterise(typeArgs: PType[]): DynamicArrayType;
+    getGenericArgs(): PType[];
+}
+export declare const StaticArrayConstructor: LibFunctionType;
+export declare class StaticArrayType extends ARC4EncodedType {
+    static baseFullName: string;
+    readonly module: "@algorandfoundation/algorand-typescript/arc4/encoded-types.d.ts";
+    readonly elementType: ARC4EncodedType;
+    readonly arraySize: bigint;
+    readonly name: string;
+    readonly singleton = false;
+    readonly sourceLocation: SourceLocation | undefined;
+    get wtype(): ARC4StaticArray;
+    constructor({ elementType, arraySize, sourceLocation, }: {
+        elementType: ARC4EncodedType;
+        arraySize: bigint;
+        sourceLocation?: SourceLocation;
+    });
+    static parameterise(typeArgs: PType[]): StaticArrayType;
+    getGenericArgs(): PType[];
+}

package/awst_build/ptypes/base.d.ts

@@ -0,0 +1,31 @@
+import type { wtypes } from '../../awst';
+import type { DeliberateAny } from '../../typescript-helpers';
+/**
+ * Represents a public type visible to a developer of AlgoTS
+ */
+export declare abstract class PType {
+    /**
+     * Get the associated wtype for this ptype if applicable
+     */
+    abstract readonly wtype: wtypes.WType | undefined;
+    /**
+     * Get the unaliased name of this ptype
+     */
+    abstract readonly name: string;
+    /**
+     * Get the declaring module of this ptype
+     */
+    abstract readonly module: string;
+    abstract readonly singleton: boolean;
+    get fullName(): string;
+    get wtypeOrThrow(): wtypes.WType;
+    equals(other: PType): boolean;
+    static equals(other: PType): boolean;
+    equalsOrInstanceOf(other: PTypeOrClass): boolean;
+    toString(): string;
+    getGenericArgs(): PType[];
+}
+export type PTypeOrClass = PType | {
+    new (...args: DeliberateAny[]): PType;
+    equals(other: PType): boolean;
+};