cashc 0.13.2 → 0.14.0-next.0

package/dist/Errors.d.ts

@@ -1,5 +1,5 @@
 import { Type } from '@cashscript/utils';
-import { IdentifierNode, FunctionDefinitionNode, VariableDefinitionNode, ParameterNode, Node, FunctionCallNode, BinaryOpNode, UnaryOpNode, TimeOpNode, CastNode, AssignNode, BranchNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, StatementNode, ContractNode, ExpressionNode, SliceNode } from './ast/AST.js';
+import { IdentifierNode, ImportNode, FunctionDefinitionNode, VariableDefinitionNode, ParameterNode, Node, FunctionCallNode, BinaryOpNode, UnaryOpNode, TimeOpNode, CastNode, AssignNode, BranchNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, StatementNode, ContractNode, ExpressionNode, SliceNode } from './ast/AST.js';
 import { Symbol, SymbolType } from './ast/SymbolTable.js';
 import { Location } from './ast/Location.js';
 export declare class CashScriptError extends Error {
@@ -25,6 +25,13 @@ export declare class FunctionRedefinitionError extends RedefinitionError {
     node: FunctionDefinitionNode;
     constructor(node: FunctionDefinitionNode);
 }
+export declare class MissingContractError extends Error {
+    constructor();
+}
+export declare class ImportResolutionError extends CashScriptError {
+    node: ImportNode;
+    constructor(node: ImportNode, message: string);
+}
 export declare class VariableRedefinitionError extends RedefinitionError {
     node: VariableDefinitionNode | ParameterNode;
     constructor(node: VariableDefinitionNode | ParameterNode);
@@ -45,11 +52,29 @@ export declare class FinalRequireStatementError extends CashScriptError {
     node: StatementNode;
     constructor(node: StatementNode);
 }
+export declare class UnusedFunctionReturnError extends CashScriptError {
+    node: FunctionCallNode;
+    constructor(node: FunctionCallNode);
+}
+export declare class MissingReturnError extends CashScriptError {
+    node: Node;
+    constructor(node: Node);
+}
+export declare class MisplacedReturnError extends CashScriptError {
+    node: StatementNode;
+    constructor(node: StatementNode);
+}
+export declare class UnsafeFunctionOperationError extends CashScriptError {
+    constructor(node: Node, operation: string);
+}
 export declare class TypeError extends CashScriptError {
     actual?: (Type | Type[]) | undefined;
     expected?: (Type | Type[]) | undefined;
     constructor(node: Node, actual?: (Type | Type[]) | undefined, expected?: (Type | Type[]) | undefined, message?: string);
 }
+export declare class ReturnTypeError extends TypeError {
+    constructor(node: Node, actual?: Type, expected?: Type);
+}
 export declare class InvalidParameterTypeError extends TypeError {
     constructor(node: FunctionCallNode | RequireNode | InstantiationNode, actual: Type[], expected: Type[]);
 }

package/dist/Errors.js

@@ -28,7 +28,7 @@ export class UndefinedReferenceError extends CashScriptError {
 }
 export class InvalidSymbolTypeError extends CashScriptError {
     constructor(node, expected) {
-        super(node, `Found symbol ${node.name} with type ${node.definition?.symbolType} where type ${expected} was expected`);
+        super(node, `Found symbol ${node.name} with type ${node.symbol?.symbolType} where type ${expected} was expected`);
         this.node = node;
         this.expected = expected;
     }
@@ -41,6 +41,18 @@ export class FunctionRedefinitionError extends RedefinitionError {
         this.node = node;
     }
 }
+export class MissingContractError extends Error {
+    constructor() {
+        super('Source file does not contain a contract definition');
+        this.name = this.constructor.name;
+    }
+}
+export class ImportResolutionError extends CashScriptError {
+    constructor(node, message) {
+        super(node, message);
+        this.node = node;
+    }
+}
 export class VariableRedefinitionError extends RedefinitionError {
     constructor(node) {
         super(node, `Redefinition of variable ${node.name}`);
@@ -71,6 +83,30 @@ export class FinalRequireStatementError extends CashScriptError {
         this.node = node;
     }
 }
+export class UnusedFunctionReturnError extends CashScriptError {
+    constructor(node) {
+        super(node, `Return value of ${node.identifier.name} must be used; only void functions may be called as a statement`);
+        this.node = node;
+    }
+}
+export class MissingReturnError extends CashScriptError {
+    constructor(node) {
+        super(node, 'A value-returning function must end with a return statement');
+        this.node = node;
+    }
+}
+export class MisplacedReturnError extends CashScriptError {
+    constructor(node) {
+        super(node, 'A return statement is only allowed as the final statement of a function body');
+        this.node = node;
+    }
+}
+export class UnsafeFunctionOperationError extends CashScriptError {
+    constructor(node, operation) {
+        super(node, `'${operation}' cannot be used inside a user-defined function. Use it directly in a `
+            + 'contract function instead, or pass the resulting value into the function as a parameter');
+    }
+}
 export class TypeError extends CashScriptError {
     constructor(node, actual, expected, message) {
         super(node, message ?? `Found type '${actual}' where type '${expected}' was expected`);
@@ -78,6 +114,11 @@ export class TypeError extends CashScriptError {
         this.expected = expected;
     }
 }
+export class ReturnTypeError extends TypeError {
+    constructor(node, actual, expected) {
+        super(node, actual, expected, `Cannot return type '${actual}' from a function with return type '${expected}'`);
+    }
+}
 export class InvalidParameterTypeError extends TypeError {
     constructor(node, actual, expected) {
         const name = node instanceof RequireNode ? 'require' : node.identifier.name;

package/dist/artifact/Artifact.js

@@ -2,6 +2,8 @@ import { scriptToAsm, } from '@cashscript/utils';
 import { version } from '../index.js';
 export function generateArtifact(ast, script, source, debug, compilerOptions, fingerprint) {
     const { contract } = ast;
+    if (!contract)
+        throw new Error('Internal error: cannot generate an artifact for a source file with no contract');
     const constructorInputs = contract.parameters
         .map((parameter) => ({ name: parameter.name, type: parameter.type.toString() }));
     const abi = contract.functions.map((func) => ({

package/dist/ast/AST.d.ts

@@ -15,9 +15,21 @@ export interface Named {
 export interface Typed {
     type: Type;
 }
+export declare enum FunctionKind {
+    CONTRACT = "contract",
+    GLOBAL = "global"
+}
 export declare class SourceFileNode extends Node {
-    contract: ContractNode;
-    constructor(contract: ContractNode);
+    contract?: ContractNode | undefined;
+    functions: FunctionDefinitionNode[];
+    imports: ImportNode[];
+    symbolTable?: SymbolTable;
+    constructor(contract?: ContractNode | undefined, functions?: FunctionDefinitionNode[], imports?: ImportNode[]);
+    accept<T>(visitor: AstVisitor<T>): T;
+}
+export declare class ImportNode extends Node {
+    path: string;
+    constructor(path: string);
     accept<T>(visitor: AstVisitor<T>): T;
 }
 export declare class ContractNode extends Node implements Named {
@@ -29,12 +41,14 @@ export declare class ContractNode extends Node implements Named {
     accept<T>(visitor: AstVisitor<T>): T;
 }
 export declare class FunctionDefinitionNode extends Node implements Named {
+    kind: FunctionKind;
     name: string;
     parameters: ParameterNode[];
     body: BlockNode;
+    returnType?: Type | undefined;
     symbolTable?: SymbolTable;
     opRolls: Map<string, IdentifierNode>;
-    constructor(name: string, parameters: ParameterNode[], body: BlockNode);
+    constructor(kind: FunctionKind, name: string, parameters: ParameterNode[], body: BlockNode, returnType?: Type | undefined);
     accept<T>(visitor: AstVisitor<T>): T;
 }
 export declare class ParameterNode extends Node implements Named, Typed {
@@ -101,6 +115,16 @@ export declare class ConsoleStatementNode extends NonControlStatementNode {
     constructor(parameters: ConsoleParameterNode[]);
     accept<T>(visitor: AstVisitor<T>): T;
 }
+export declare class FunctionCallStatementNode extends NonControlStatementNode {
+    functionCall: FunctionCallNode;
+    constructor(functionCall: FunctionCallNode);
+    accept<T>(visitor: AstVisitor<T>): T;
+}
+export declare class ReturnNode extends NonControlStatementNode {
+    expression: ExpressionNode;
+    constructor(expression: ExpressionNode);
+    accept<T>(visitor: AstVisitor<T>): T;
+}
 export declare class BranchNode extends ControlStatementNode {
     condition: ExpressionNode;
     ifBlock: BlockNode;
@@ -195,7 +219,7 @@ export declare class ArrayNode extends ExpressionNode {
 }
 export declare class IdentifierNode extends ExpressionNode implements Named {
     name: string;
-    definition?: Symbol;
+    symbol?: Symbol;
     constructor(name: string);
     accept<T>(visitor: AstVisitor<T>): T;
 }

package/dist/ast/AST.js

@@ -2,15 +2,31 @@ import { PrimitiveType, BytesType } from '@cashscript/utils';
 import { binToHex } from '@bitauth/libauth';
 export class Node {
 }
+export var FunctionKind;
+(function (FunctionKind) {
+    FunctionKind["CONTRACT"] = "contract";
+    FunctionKind["GLOBAL"] = "global";
+})(FunctionKind || (FunctionKind = {}));
 export class SourceFileNode extends Node {
-    constructor(contract) {
+    constructor(contract, functions = [], imports = []) {
         super();
         this.contract = contract;
+        this.functions = functions;
+        this.imports = imports;
     }
     accept(visitor) {
         return visitor.visitSourceFile(this);
     }
 }
+export class ImportNode extends Node {
+    constructor(path) {
+        super();
+        this.path = path;
+    }
+    accept(visitor) {
+        return visitor.visitImport(this);
+    }
+}
 export class ContractNode extends Node {
     constructor(name, parameters, functions) {
         super();
@@ -23,11 +39,13 @@ export class ContractNode extends Node {
     }
 }
 export class FunctionDefinitionNode extends Node {
-    constructor(name, parameters, body) {
+    constructor(kind, name, parameters, body, returnType) {
         super();
+        this.kind = kind;
         this.name = name;
         this.parameters = parameters;
         this.body = body;
+        this.returnType = returnType;
         this.opRolls = new Map();
     }
     accept(visitor) {
@@ -117,6 +135,24 @@ export class ConsoleStatementNode extends NonControlStatementNode {
         return visitor.visitConsoleStatement(this);
     }
 }
+export class FunctionCallStatementNode extends NonControlStatementNode {
+    constructor(functionCall) {
+        super();
+        this.functionCall = functionCall;
+    }
+    accept(visitor) {
+        return visitor.visitFunctionCallStatement(this);
+    }
+}
+export class ReturnNode extends NonControlStatementNode {
+    constructor(expression) {
+        super();
+        this.expression = expression;
+    }
+    accept(visitor) {
+        return visitor.visitReturn(this);
+    }
+}
 export class BranchNode extends ControlStatementNode {
     constructor(condition, ifBlock, elseBlock) {
         super();

package/dist/ast/AstBuilder.d.ts

@@ -1,6 +1,6 @@
 import { ParseTree, ParseTreeVisitor } from 'antlr4';
-import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, ExpressionNode, StatementNode, LiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, ConsoleParameterNode, SliceNode, DoWhileNode, WhileNode, ForNode } from './AST.js';
-import type { ContractDefinitionContext, FunctionDefinitionContext, VariableDefinitionContext, TupleAssignmentContext, ParameterContext, AssignStatementContext, IfStatementContext, FunctionCallContext, CastContext, LiteralContext, SourceFileContext, BlockContext, TimeOpStatementContext, ArrayContext, ParenthesisedContext, FunctionCallExpressionContext, UnaryOpContext, BinaryOpContext, IdentifierContext, LiteralExpressionContext, TupleIndexOpContext, RequireStatementContext, PragmaDirectiveContext, InstantiationContext, NullaryOpContext, UnaryIntrospectionOpContext, ConsoleStatementContext, ConsoleParameterContext, StatementContext, NonControlStatementContext, ControlStatementContext, RequireMessageContext, SliceContext, DoWhileStatementContext, LoopStatementContext, WhileStatementContext, ForStatementContext, ForInitContext, FunctionBodyContext } from '../grammar/CashScriptParser.js';
+import { Node, SourceFileNode, ImportNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, ExpressionNode, StatementNode, LiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, ReturnNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, ConsoleParameterNode, FunctionCallStatementNode, SliceNode, DoWhileNode, WhileNode, ForNode } from './AST.js';
+import type { ImportDirectiveContext, ContractDefinitionContext, ContractFunctionDefinitionContext, GlobalFunctionDefinitionContext, ReturnStatementContext, FunctionCallStatementContext, VariableDefinitionContext, TupleAssignmentContext, ParameterContext, AssignStatementContext, IfStatementContext, FunctionCallContext, CastContext, LiteralContext, SourceFileContext, BlockContext, TimeOpStatementContext, ArrayContext, ParenthesisedContext, FunctionCallExpressionContext, UnaryOpContext, BinaryOpContext, IdentifierContext, LiteralExpressionContext, TupleIndexOpContext, RequireStatementContext, PragmaDirectiveContext, InstantiationContext, NullaryOpContext, UnaryIntrospectionOpContext, ConsoleStatementContext, ConsoleParameterContext, StatementContext, NonControlStatementContext, ControlStatementContext, RequireMessageContext, SliceContext, DoWhileStatementContext, LoopStatementContext, WhileStatementContext, ForStatementContext, ForInitContext, FunctionBodyContext } from '../grammar/CashScriptParser.js';
 import CashScriptVisitor from '../grammar/CashScriptVisitor.js';
 export default class AstBuilder extends ParseTreeVisitor<Node> implements CashScriptVisitor<Node> {
     private tree;
@@ -8,9 +8,12 @@ export default class AstBuilder extends ParseTreeVisitor<Node> implements CashSc
     defaultResult(): Node;
     build(): Node;
     visitSourceFile(ctx: SourceFileContext): SourceFileNode;
+    visitImportDirective(ctx: ImportDirectiveContext): ImportNode;
     processPragma(ctx: PragmaDirectiveContext): void;
     visitContractDefinition(ctx: ContractDefinitionContext): ContractNode;
-    visitFunctionDefinition(ctx: FunctionDefinitionContext): FunctionDefinitionNode;
+    visitContractFunctionDefinition(ctx: ContractFunctionDefinitionContext): FunctionDefinitionNode;
+    visitGlobalFunctionDefinition(ctx: GlobalFunctionDefinitionContext): FunctionDefinitionNode;
+    private buildFunctionDefinition;
     visitFunctionBody(ctx: FunctionBodyContext): BlockNode;
     visitParameter(ctx: ParameterContext): ParameterNode;
     visitStatement(ctx: StatementContext): StatementNode;
@@ -22,6 +25,8 @@ export default class AstBuilder extends ParseTreeVisitor<Node> implements CashSc
     private createAssignExpression;
     visitTimeOpStatement(ctx: TimeOpStatementContext): TimeOpNode;
     visitRequireStatement(ctx: RequireStatementContext): RequireNode;
+    visitReturnStatement(ctx: ReturnStatementContext): ReturnNode;
+    visitFunctionCallStatement(ctx: FunctionCallStatementContext): FunctionCallStatementNode;
     visitIfStatement(ctx: IfStatementContext): BranchNode;
     visitLoopStatement(ctx: LoopStatementContext): StatementNode;
     visitDoWhileStatement(ctx: DoWhileStatementContext): DoWhileNode;

package/dist/ast/AstBuilder.js

@@ -2,7 +2,7 @@ import { ParseTreeVisitor } from 'antlr4';
 import { hexToBin } from '@bitauth/libauth';
 import { parseType } from '@cashscript/utils';
 import semver from 'semver';
-import { SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, SliceNode, DoWhileNode, WhileNode, ForNode, } from './AST.js';
+import { SourceFileNode, ImportNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, FunctionKind, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, ReturnNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, FunctionCallStatementNode, SliceNode, DoWhileNode, WhileNode, ForNode, } from './AST.js';
 import { BinaryOperator } from './Operator.js';
 import { Location } from './Location.js';
 import { NumberUnit, } from './Globals.js';
@@ -24,11 +24,30 @@ export default class AstBuilder extends ParseTreeVisitor {
         ctx.pragmaDirective_list().forEach((pragma) => {
             this.processPragma(pragma);
         });
-        const contract = this.visit(ctx.contractDefinition());
-        const sourceFileNode = new SourceFileNode(contract);
+        const imports = ctx.importDirective_list().map((directive) => this.visit(directive));
+        const functions = [];
+        let contract;
+        ctx.topLevelDefinition_list().forEach((def) => {
+            if (def.globalFunctionDefinition()) {
+                functions.push(this.visit(def.globalFunctionDefinition()));
+            }
+            else if (def.contractDefinition()) {
+                if (contract) {
+                    throw new ParseError('A source file may define at most one contract', Location.fromCtx(def.contractDefinition()));
+                }
+                contract = this.visit(def.contractDefinition());
+            }
+        });
+        const sourceFileNode = new SourceFileNode(contract, functions, imports);
         sourceFileNode.location = Location.fromCtx(ctx);
         return sourceFileNode;
     }
+    visitImportDirective(ctx) {
+        const raw = ctx.StringLiteral().getText();
+        const importNode = new ImportNode(raw.substring(1, raw.length - 1));
+        importNode.location = Location.fromCtx(ctx);
+        return importNode;
+    }
     processPragma(ctx) {
         const pragmaName = getPragmaName(ctx.pragmaName().getText());
         if (pragmaName !== PragmaName.CASHSCRIPT)
@@ -46,16 +65,24 @@ export default class AstBuilder extends ParseTreeVisitor {
     visitContractDefinition(ctx) {
         const name = ctx.Identifier().getText();
         const parameters = ctx.parameterList().parameter_list().map((p) => this.visit(p));
-        const functions = ctx.functionDefinition_list().map((f) => this.visit(f));
+        const functions = ctx.contractFunctionDefinition_list()
+            .map((f) => this.visit(f));
         const contract = new ContractNode(name, parameters, functions);
         contract.location = Location.fromCtx(ctx);
         return contract;
     }
-    visitFunctionDefinition(ctx) {
+    visitContractFunctionDefinition(ctx) {
+        return this.buildFunctionDefinition(ctx, FunctionKind.CONTRACT);
+    }
+    visitGlobalFunctionDefinition(ctx) {
+        const returnType = ctx.typeName() ? parseType(ctx.typeName().getText()) : undefined;
+        return this.buildFunctionDefinition(ctx, FunctionKind.GLOBAL, returnType);
+    }
+    buildFunctionDefinition(ctx, kind, returnType) {
         const name = ctx.Identifier().getText();
         const parameters = ctx.parameterList().parameter_list().map((p) => this.visit(p));
         const body = this.visit(ctx.functionBody());
-        const functionDefinition = new FunctionDefinitionNode(name, parameters, body);
+        const functionDefinition = new FunctionDefinitionNode(kind, name, parameters, body, returnType);
         functionDefinition.location = Location.fromCtx(ctx);
         return functionDefinition;
     }
@@ -151,6 +178,18 @@ export default class AstBuilder extends ParseTreeVisitor {
         require.location = Location.fromCtx(ctx);
         return require;
     }
+    visitReturnStatement(ctx) {
+        const expression = this.visit(ctx.expression());
+        const returnNode = new ReturnNode(expression);
+        returnNode.location = Location.fromCtx(ctx);
+        return returnNode;
+    }
+    visitFunctionCallStatement(ctx) {
+        const functionCall = this.visit(ctx.functionCall());
+        const node = new FunctionCallStatementNode(functionCall);
+        node.location = Location.fromCtx(ctx);
+        return node;
+    }
     visitIfStatement(ctx) {
         const condition = this.visit(ctx.expression());
         const ifBlock = this.visit(ctx._ifBlock);

package/dist/ast/AstTraversal.d.ts

@@ -1,7 +1,8 @@
-import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, SliceNode, DoWhileNode, WhileNode, ForNode } from './AST.js';
+import { Node, SourceFileNode, ImportNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, ReturnNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, FunctionCallStatementNode, SliceNode, DoWhileNode, WhileNode, ForNode } from './AST.js';
 import AstVisitor from './AstVisitor.js';
 export default class AstTraversal extends AstVisitor<Node> {
     visitSourceFile(node: SourceFileNode): Node;
+    visitImport(node: ImportNode): Node;
     visitContract(node: ContractNode): Node;
     visitFunctionDefinition(node: FunctionDefinitionNode): Node;
     visitParameter(node: ParameterNode): Node;
@@ -10,7 +11,9 @@ export default class AstTraversal extends AstVisitor<Node> {
     visitAssign(node: AssignNode): Node;
     visitTimeOp(node: TimeOpNode): Node;
     visitRequire(node: RequireNode): Node;
+    visitReturn(node: ReturnNode): Node;
     visitConsoleStatement(node: ConsoleStatementNode): Node;
+    visitFunctionCallStatement(node: FunctionCallStatementNode): Node;
     visitBranch(node: BranchNode): Node;
     visitDoWhile(node: DoWhileNode): Node;
     visitWhile(node: WhileNode): Node;

package/dist/ast/AstTraversal.js

@@ -1,7 +1,11 @@
 import AstVisitor from './AstVisitor.js';
 export default class AstTraversal extends AstVisitor {
     visitSourceFile(node) {
-        node.contract = this.visit(node.contract);
+        node.functions = this.visitList(node.functions);
+        node.contract = this.visitOptional(node.contract);
+        return node;
+    }
+    visitImport(node) {
         return node;
     }
     visitContract(node) {
@@ -38,10 +42,18 @@ export default class AstTraversal extends AstVisitor {
         node.expression = this.visit(node.expression);
         return node;
     }
+    visitReturn(node) {
+        node.expression = this.visit(node.expression);
+        return node;
+    }
     visitConsoleStatement(node) {
         node.parameters = this.visitList(node.parameters);
         return node;
     }
+    visitFunctionCallStatement(node) {
+        node.functionCall = this.visit(node.functionCall);
+        return node;
+    }
     visitBranch(node) {
         node.condition = this.visit(node.condition);
         node.ifBlock = this.visit(node.ifBlock);

package/dist/ast/AstVisitor.d.ts

@@ -1,6 +1,7 @@
-import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, SliceNode, DoWhileNode, WhileNode, ForNode } from './AST.js';
+import { Node, SourceFileNode, ImportNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, ReturnNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode, ConsoleStatementNode, FunctionCallStatementNode, SliceNode, DoWhileNode, WhileNode, ForNode } from './AST.js';
 export default abstract class AstVisitor<T> {
     abstract visitSourceFile(node: SourceFileNode): T;
+    abstract visitImport(node: ImportNode): T;
     abstract visitContract(node: ContractNode): T;
     abstract visitFunctionDefinition(node: FunctionDefinitionNode): T;
     abstract visitParameter(node: ParameterNode): T;
@@ -9,7 +10,9 @@ export default abstract class AstVisitor<T> {
     abstract visitAssign(node: AssignNode): T;
     abstract visitTimeOp(node: TimeOpNode): T;
     abstract visitRequire(node: RequireNode): T;
+    abstract visitReturn(node: ReturnNode): T;
     abstract visitConsoleStatement(node: ConsoleStatementNode): T;
+    abstract visitFunctionCallStatement(node: FunctionCallStatementNode): T;
     abstract visitBranch(node: BranchNode): T;
     abstract visitDoWhile(node: DoWhileNode): T;
     abstract visitWhile(node: WhileNode): T;

package/dist/ast/Globals.js

@@ -1,4 +1,4 @@
-import { PrimitiveType, ArrayType, BytesType } from '@cashscript/utils';
+import { PrimitiveType, ArrayType, BytesType, Op } from '@cashscript/utils';
 import { SymbolTable, Symbol } from './SymbolTable.js';
 export const NumberUnit = {
     SATOSHIS: 1,
@@ -51,17 +51,30 @@ GLOBAL_SYMBOL_TABLE.set(Symbol.class(Class.LOCKING_BYTECODE_P2SH32, new BytesTyp
 GLOBAL_SYMBOL_TABLE.set(Symbol.class(Class.LOCKING_BYTECODE_P2PKH, new BytesType(25), [new BytesType(20)]));
 GLOBAL_SYMBOL_TABLE.set(Symbol.class(Class.LOCKING_BYTECODE_NULLDATA, new BytesType(), [new ArrayType(new BytesType())]));
 // Global functions
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.ABS, PrimitiveType.INT, [PrimitiveType.INT]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.MIN, PrimitiveType.INT, [PrimitiveType.INT, PrimitiveType.INT]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.MAX, PrimitiveType.INT, [PrimitiveType.INT, PrimitiveType.INT]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.WITHIN, PrimitiveType.BOOL, [PrimitiveType.INT, PrimitiveType.INT, PrimitiveType.INT]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.RIPEMD160, new BytesType(20), [PrimitiveType.ANY]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.SHA1, new BytesType(20), [PrimitiveType.ANY]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.SHA256, new BytesType(32), [PrimitiveType.ANY]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.HASH160, new BytesType(20), [PrimitiveType.ANY]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.HASH256, new BytesType(32), [PrimitiveType.ANY]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.CHECKSIG, PrimitiveType.BOOL, [PrimitiveType.SIG, PrimitiveType.PUBKEY]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.CHECKMULTISIG, PrimitiveType.BOOL, [new ArrayType(PrimitiveType.SIG), new ArrayType(PrimitiveType.PUBKEY)]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.CHECKDATASIG, PrimitiveType.BOOL, [PrimitiveType.DATASIG, new BytesType(), PrimitiveType.PUBKEY]));
-GLOBAL_SYMBOL_TABLE.set(Symbol.function(GlobalFunction.TO_PADDED_BYTES, new BytesType(), [PrimitiveType.INT, PrimitiveType.INT]));
+// abs(int) -> int
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.ABS, PrimitiveType.INT, [PrimitiveType.INT], [Op.OP_ABS]));
+// min(int, int) -> int
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.MIN, PrimitiveType.INT, [PrimitiveType.INT, PrimitiveType.INT], [Op.OP_MIN]));
+// max(int, int) -> int
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.MAX, PrimitiveType.INT, [PrimitiveType.INT, PrimitiveType.INT], [Op.OP_MAX]));
+// within(int, int, int) -> bool
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.WITHIN, PrimitiveType.BOOL, [PrimitiveType.INT, PrimitiveType.INT, PrimitiveType.INT], [Op.OP_WITHIN]));
+// ripemd160(any) -> bytes20
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.RIPEMD160, new BytesType(20), [PrimitiveType.ANY], [Op.OP_RIPEMD160]));
+// sha1(any) -> bytes20
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.SHA1, new BytesType(20), [PrimitiveType.ANY], [Op.OP_SHA1]));
+// sha256(any) -> bytes32
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.SHA256, new BytesType(32), [PrimitiveType.ANY], [Op.OP_SHA256]));
+// hash160(any) -> bytes20
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.HASH160, new BytesType(20), [PrimitiveType.ANY], [Op.OP_HASH160]));
+// hash256(any) -> bytes32
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.HASH256, new BytesType(32), [PrimitiveType.ANY], [Op.OP_HASH256]));
+// checkSig(sig, pubkey) -> bool
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.CHECKSIG, PrimitiveType.BOOL, [PrimitiveType.SIG, PrimitiveType.PUBKEY], [Op.OP_CHECKSIG]));
+// checkMultiSig(sig[], pubkey[]) -> bool
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.CHECKMULTISIG, PrimitiveType.BOOL, [new ArrayType(PrimitiveType.SIG), new ArrayType(PrimitiveType.PUBKEY)], [Op.OP_CHECKMULTISIG]));
+// checkDataSig(datasig, bytes, pubkey) -> bool
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.CHECKDATASIG, PrimitiveType.BOOL, [PrimitiveType.DATASIG, new BytesType(), PrimitiveType.PUBKEY], [Op.OP_CHECKDATASIG]));
+// toPaddedBytes(int, int) -> bytes
+GLOBAL_SYMBOL_TABLE.set(Symbol.builtinFunction(GlobalFunction.TO_PADDED_BYTES, new BytesType(), [PrimitiveType.INT, PrimitiveType.INT], [Op.OP_NUM2BIN]));
 //# sourceMappingURL=Globals.js.map

package/dist/ast/SymbolTable.d.ts

@@ -1,16 +1,20 @@
-import { Type } from '@cashscript/utils';
-import { VariableDefinitionNode, ParameterNode, IdentifierNode, Node } from './AST.js';
+import { Type, Script } from '@cashscript/utils';
+import { VariableDefinitionNode, ParameterNode, FunctionDefinitionNode, IdentifierNode, Node } from './AST.js';
 export declare class Symbol {
     name: string;
     type: Type;
     symbolType: SymbolType;
     definition?: Node | undefined;
     parameters?: Type[] | undefined;
+    bytecode?: Script | undefined;
+    functionId?: number | undefined;
     references: IdentifierNode[];
     private constructor();
     static variable(node: VariableDefinitionNode | ParameterNode): Symbol;
     static global(name: string, type: Type): Symbol;
-    static function(name: string, type: Type, parameters: Type[]): Symbol;
+    static builtinFunction(name: string, returnType: Type, parameters: Type[], bytecode: Script): Symbol;
+    static userFunction(node: FunctionDefinitionNode, functionId: number): Symbol;
+    setFunctionId(functionId: number): void;
     static class(name: string, type: Type, parameters: Type[]): Symbol;
     toString(): string;
 }

package/dist/ast/SymbolTable.js

@@ -1,10 +1,13 @@
+import { PrimitiveType, Op, encodeInt } from '@cashscript/utils';
 export class Symbol {
-    constructor(name, type, symbolType, definition, parameters) {
+    constructor(name, type, symbolType, definition, parameters, bytecode, functionId) {
         this.name = name;
         this.type = type;
         this.symbolType = symbolType;
         this.definition = definition;
         this.parameters = parameters;
+        this.bytecode = bytecode;
+        this.functionId = functionId;
         this.references = [];
     }
     static variable(node) {
@@ -13,8 +16,19 @@ export class Symbol {
     static global(name, type) {
         return new Symbol(name, type, SymbolType.VARIABLE);
     }
-    static function(name, type, parameters) {
-        return new Symbol(name, type, SymbolType.FUNCTION, undefined, parameters);
+    static builtinFunction(name, returnType, parameters, bytecode) {
+        return new Symbol(name, returnType, SymbolType.FUNCTION, undefined, parameters, bytecode);
+    }
+    static userFunction(node, functionId) {
+        const parameterTypes = node.parameters.map((parameter) => parameter.type);
+        const returnType = node.returnType ?? PrimitiveType.VOID;
+        const symbol = new Symbol(node.name, returnType, SymbolType.FUNCTION, node, parameterTypes);
+        symbol.setFunctionId(functionId);
+        return symbol;
+    }
+    setFunctionId(functionId) {
+        this.functionId = functionId;
+        this.bytecode = [encodeInt(BigInt(functionId)), Op.OP_INVOKE];
     }
     static class(name, type, parameters) {
         return new Symbol(name, type, SymbolType.CLASS, undefined, parameters);

package/dist/compiler.d.ts

@@ -1,10 +1,10 @@
 import { Artifact, CompilerOptions } from '@cashscript/utils';
 import { PathLike } from 'fs';
-import { Ast } from './ast/AST.js';
 import { CashScriptErrorListener } from './ast/error-listeners.js';
 export declare const DEFAULT_COMPILER_OPTIONS: CompilerOptions;
 export interface CompileOptions extends CompilerOptions {
     errorListener?: CashScriptErrorListener;
+    basePath?: string;
 }
 /**
  * Compile a CashScript source string to an {@link Artifact}.
@@ -24,4 +24,3 @@ export declare function compileString(code: string, compilerOptions?: CompileOpt
  * @throws If the file cannot be read, or if the source contains a compilation error.
  */
 export declare function compileFile(codeFile: PathLike, compilerOptions?: CompileOptions): Artifact;
-export declare function parseCode(code: string, errorListener?: CashScriptErrorListener): Ast;