cashc 0.6.4 → 0.7.0

package/README.md

@@ -26,13 +26,11 @@ npm install -g cashc
 Usage: cashc [options] [source_file]
 
 Options:
-  --output, -o   Specify a file to output the generated artifact.       [string]
-  --hex, -h      Compile the contract to hex format rather than a full artifact
-                                                                       [boolean]
-  --asm, -A      Compile the contract to ASM format rather than a full artifact
-                                                                       [boolean]
-  --opcount, -c  Display the number of opcodes in the compiled bytecode[boolean]
-  --size, -s     Display the size in bytes of the compiled bytecode    [boolean]
-  --help         Show help                                             [boolean]
-  --version      Show version number                                   [boolean]
+  -V, --version        Output the version number.
+  -o, --output <path>  Specify a file to output the generated artifact.
+  -h, --hex            Compile the contract to hex format rather than a full artifact.
+  -A, --asm            Compile the contract to ASM format rather than a full artifact.
+  -c, --opcount        Display the number of opcodes in the compiled bytecode.
+  -s, --size           Display the size in bytes of the compiled bytecode.
+  -?, --help           Display help
 ```

package/dist/main/Errors.d.ts

@@ -1,7 +1,7 @@
-import { Type, PrimitiveType } from '@cashscript/utils';
-import { IdentifierNode, FunctionDefinitionNode, VariableDefinitionNode, ParameterNode, Node, FunctionCallNode, BinaryOpNode, UnaryOpNode, TimeOpNode, CastNode, AssignNode, BranchNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, StatementNode, ContractNode } from './ast/AST';
-import { Symbol, SymbolType } from './ast/SymbolTable';
-import { Location, Point } from './ast/Location';
+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 } from './ast/AST.js';
+import { Symbol, SymbolType } from './ast/SymbolTable.js';
+import { Location, Point } from './ast/Location.js';
 export declare class CashScriptError extends Error {
     node: Node;
     constructor(node: Node, message: string);
@@ -45,9 +45,9 @@ export declare class FinalRequireStatementError extends CashScriptError {
     constructor(node: StatementNode);
 }
 export declare class TypeError extends CashScriptError {
-    actual?: PrimitiveType | import("@cashscript/utils").ArrayType | import("@cashscript/utils").TupleType | import("@cashscript/utils").BytesType | Type[] | undefined;
-    expected?: PrimitiveType | import("@cashscript/utils").ArrayType | import("@cashscript/utils").TupleType | import("@cashscript/utils").BytesType | Type[] | undefined;
-    constructor(node: Node, actual?: PrimitiveType | import("@cashscript/utils").ArrayType | import("@cashscript/utils").TupleType | import("@cashscript/utils").BytesType | Type[] | undefined, expected?: PrimitiveType | import("@cashscript/utils").ArrayType | import("@cashscript/utils").TupleType | import("@cashscript/utils").BytesType | Type[] | undefined, message?: string);
+    actual?: Type | Type[] | undefined;
+    expected?: Type | Type[] | undefined;
+    constructor(node: Node, actual?: Type | Type[] | undefined, expected?: Type | Type[] | undefined, message?: string);
 }
 export declare class InvalidParameterTypeError extends TypeError {
     constructor(node: FunctionCallNode | RequireNode | InstantiationNode, actual: Type[], expected: Type[]);
@@ -67,9 +67,15 @@ export declare class CastSizeError extends CashScriptError {
 export declare class AssignTypeError extends TypeError {
     constructor(node: AssignNode | VariableDefinitionNode);
 }
+export declare class TupleAssignmentError extends CashScriptError {
+    constructor(node: ExpressionNode);
+}
 export declare class ConstantConditionError extends CashScriptError {
     constructor(node: BranchNode | RequireNode, res: boolean);
 }
+export declare class ConstantModificationError extends CashScriptError {
+    constructor(node: VariableDefinitionNode);
+}
 export declare class ArrayElementError extends CashScriptError {
     constructor(node: ArrayNode);
 }
@@ -79,6 +85,3 @@ export declare class IndexOutOfBoundsError extends CashScriptError {
 export declare class VersionError extends Error {
     constructor(actual: string, constraint: string);
 }
-export declare class UnverifiedCovenantError extends CashScriptError {
-    constructor(node: IdentifierNode);
-}

package/dist/main/Errors.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnverifiedCovenantError = exports.VersionError = exports.IndexOutOfBoundsError = exports.ArrayElementError = exports.ConstantConditionError = exports.AssignTypeError = exports.CastSizeError = exports.CastTypeError = exports.UnsupportedTypeError = exports.UnequalTypeError = exports.InvalidParameterTypeError = exports.TypeError = exports.FinalRequireStatementError = exports.EmptyFunctionError = exports.EmptyContractError = exports.UnusedVariableError = exports.VariableRedefinitionError = exports.FunctionRedefinitionError = exports.RedefinitionError = exports.InvalidSymbolTypeError = exports.UndefinedReferenceError = exports.ParseError = exports.CashScriptError = void 0;
+exports.VersionError = exports.IndexOutOfBoundsError = exports.ArrayElementError = exports.ConstantModificationError = exports.ConstantConditionError = exports.TupleAssignmentError = exports.AssignTypeError = exports.CastSizeError = exports.CastTypeError = exports.UnsupportedTypeError = exports.UnequalTypeError = exports.InvalidParameterTypeError = exports.TypeError = exports.FinalRequireStatementError = exports.EmptyFunctionError = exports.EmptyContractError = exports.UnusedVariableError = exports.VariableRedefinitionError = exports.FunctionRedefinitionError = exports.RedefinitionError = exports.InvalidSymbolTypeError = exports.UndefinedReferenceError = exports.ParseError = exports.CashScriptError = void 0;
 const utils_1 = require("@cashscript/utils");
-const AST_1 = require("./ast/AST");
-const Location_1 = require("./ast/Location");
+const AST_js_1 = require("./ast/AST.js");
+const Location_js_1 = require("./ast/Location.js");
 class CashScriptError extends Error {
     constructor(node, message) {
         if (node.location) {
@@ -17,7 +17,7 @@ class CashScriptError extends Error {
 exports.CashScriptError = CashScriptError;
 class ParseError extends Error {
     constructor(message, location) {
-        const start = location instanceof Location_1.Point ? location : location === null || location === void 0 ? void 0 : location.start;
+        const start = location instanceof Location_js_1.Point ? location : location === null || location === void 0 ? void 0 : location.start;
         if (start) {
             message += ` at ${start}`;
         }
@@ -97,7 +97,7 @@ class TypeError extends CashScriptError {
 exports.TypeError = TypeError;
 class InvalidParameterTypeError extends TypeError {
     constructor(node, actual, expected) {
-        const name = node instanceof AST_1.RequireNode ? 'require' : node.identifier.name;
+        const name = node instanceof AST_js_1.RequireNode ? 'require' : node.identifier.name;
         super(node, actual, expected, `Found parameters (${actual}) in call to function '${name}' where parameters (${expected}) were expected`);
     }
 }
@@ -112,7 +112,7 @@ class UnequalTypeError extends TypeError {
 exports.UnequalTypeError = UnequalTypeError;
 class UnsupportedTypeError extends TypeError {
     constructor(node, actual, expected) {
-        if (node instanceof AST_1.BinaryOpNode && node.operator.startsWith('.')) {
+        if (node instanceof AST_js_1.BinaryOpNode && node.operator.startsWith('.')) {
             if (expected === utils_1.PrimitiveType.INT) {
                 super(node, actual, expected, `Tried to call member 'split' with unsupported parameter type '${actual}'`);
             }
@@ -120,19 +120,23 @@ class UnsupportedTypeError extends TypeError {
                 super(node, actual, expected, `Tried to call member 'split' on unsupported type '${actual}'`);
             }
         }
-        else if (node instanceof AST_1.BinaryOpNode) {
+        else if (node instanceof AST_js_1.BinaryOpNode) {
             super(node, actual, expected, `Tried to apply operator '${node.operator}' to unsupported type '${actual}'`);
         }
-        else if (node instanceof AST_1.UnaryOpNode && node.operator.startsWith('.')) {
+        else if (node instanceof AST_js_1.UnaryOpNode && node.operator.startsWith('.')) {
             super(node, actual, expected, `Tried to access member '${node.operator}' on unsupported type '${actual}'`);
         }
-        else if (node instanceof AST_1.UnaryOpNode) {
+        else if (node instanceof AST_js_1.UnaryOpNode && node.operator.includes('[i]')) {
+            const [scope] = node.operator.split('[i]');
+            super(node, actual, expected, `Tried to index '${scope}''with unsupported type '${actual}'`);
+        }
+        else if (node instanceof AST_js_1.UnaryOpNode) {
             super(node, actual, expected, `Tried to apply operator '${node.operator}' to unsupported type '${actual}'`);
         }
-        else if (node instanceof AST_1.TimeOpNode) {
+        else if (node instanceof AST_js_1.TimeOpNode) {
             super(node, actual, expected, `Tried to apply operator '>=' on unsupported type '${actual}'`);
         }
-        else if (node instanceof AST_1.TupleIndexOpNode) {
+        else if (node instanceof AST_js_1.TupleIndexOpNode) {
             super(node, actual, expected, `Tried to index unsupported type '${actual}'`);
         }
         else {
@@ -155,17 +159,29 @@ class CastSizeError extends CashScriptError {
 exports.CastSizeError = CastSizeError;
 class AssignTypeError extends TypeError {
     constructor(node) {
-        const expected = node instanceof AST_1.AssignNode ? node.identifier.type : node.type;
+        const expected = node instanceof AST_js_1.AssignNode ? node.identifier.type : node.type;
         super(node, node.expression.type, expected, `Type '${node.expression.type}' can not be assigned to variable of type '${expected}'`);
     }
 }
 exports.AssignTypeError = AssignTypeError;
+class TupleAssignmentError extends CashScriptError {
+    constructor(node) {
+        super(node, 'Expression must return a tuple to use destructuring');
+    }
+}
+exports.TupleAssignmentError = TupleAssignmentError;
 class ConstantConditionError extends CashScriptError {
     constructor(node, res) {
         super(node, `Condition always evaluates to ${res}`);
     }
 }
 exports.ConstantConditionError = ConstantConditionError;
+class ConstantModificationError extends CashScriptError {
+    constructor(node) {
+        super(node, `Tried to modify immutable variable '${node.name}'`);
+    }
+}
+exports.ConstantModificationError = ConstantModificationError;
 class ArrayElementError extends CashScriptError {
     constructor(node) {
         super(node, 'Incorrect elements in array');
@@ -186,10 +202,4 @@ class VersionError extends Error {
     }
 }
 exports.VersionError = VersionError;
-class UnverifiedCovenantError extends CashScriptError {
-    constructor(node) {
-        super(node, `Covenant variable ${node.name} was used without un-nested signature check`);
-    }
-}
-exports.UnverifiedCovenantError = UnverifiedCovenantError;
 //# sourceMappingURL=Errors.js.map

package/dist/main/artifact/Artifact.d.ts

@@ -1,3 +1,3 @@
 import { Artifact, Script } from '@cashscript/utils';
-import { Ast } from '../ast/AST';
+import { Ast } from '../ast/AST.js';
 export declare function generateArtifact(ast: Ast, script: Script, source: string): Artifact;

package/dist/main/artifact/Artifact.js

@@ -2,20 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateArtifact = void 0;
 const utils_1 = require("@cashscript/utils");
-const __1 = require("..");
+const index_js_1 = require("../index.js");
 function generateArtifact(ast, script, source) {
     const { contract } = ast;
     const constructorInputs = contract.parameters
         .map((parameter) => ({ name: parameter.name, type: parameter.type.toString() }));
     const abi = contract.functions.map((func) => ({
         name: func.name,
-        covenant: func.preimageFields.length > 0,
         inputs: func.parameters.map((parameter) => ({
             name: parameter.name,
             type: parameter.type.toString(),
         })),
     }));
-    const bytecode = utils_1.scriptToAsm(script);
+    const bytecode = (0, utils_1.scriptToAsm)(script);
     return {
         contractName: contract.name,
         constructorInputs,
@@ -24,7 +23,7 @@ function generateArtifact(ast, script, source) {
         source,
         compiler: {
             name: 'cashc',
-            version: __1.version,
+            version: index_js_1.version,
         },
         updatedAt: new Date().toISOString(),
     };

package/dist/main/ast/AST.d.ts

@@ -1,9 +1,9 @@
 import { Type } from '@cashscript/utils';
-import { TimeOp, PreimageField } from './Globals';
-import AstVisitor from './AstVisitor';
-import { BinaryOperator, UnaryOperator } from './Operator';
-import { Location } from './Location';
-import { SymbolTable, Symbol } from './SymbolTable';
+import { TimeOp } from './Globals.js';
+import AstVisitor from './AstVisitor.js';
+import { BinaryOperator, NullaryOperator, UnaryOperator } from './Operator.js';
+import { Location } from './Location.js';
+import { SymbolTable, Symbol } from './SymbolTable.js';
 export declare type Ast = SourceFileNode;
 export declare abstract class Node {
     location?: Location;
@@ -32,10 +32,9 @@ export declare class FunctionDefinitionNode extends Node implements Named {
     name: string;
     parameters: ParameterNode[];
     body: BlockNode;
-    preimageFields: PreimageField[];
     symbolTable?: SymbolTable;
     opRolls: Map<string, IdentifierNode>;
-    constructor(name: string, parameters: ParameterNode[], body: BlockNode, preimageFields: PreimageField[]);
+    constructor(name: string, parameters: ParameterNode[], body: BlockNode);
     accept<T>(visitor: AstVisitor<T>): T;
 }
 export declare class ParameterNode extends Node implements Named, Typed {
@@ -48,9 +47,29 @@ export declare abstract class StatementNode extends Node {
 }
 export declare class VariableDefinitionNode extends StatementNode implements Named, Typed {
     type: Type;
+    modifier: string;
     name: string;
     expression: ExpressionNode;
-    constructor(type: Type, name: string, expression: ExpressionNode);
+    constructor(type: Type, modifier: string, name: string, expression: ExpressionNode);
+    accept<T>(visitor: AstVisitor<T>): T;
+}
+export declare class TupleAssignmentNode extends StatementNode {
+    var1: {
+        name: string;
+        type: Type;
+    };
+    var2: {
+        name: string;
+        type: Type;
+    };
+    tuple: ExpressionNode;
+    constructor(var1: {
+        name: string;
+        type: Type;
+    }, var2: {
+        name: string;
+        type: Type;
+    }, tuple: ExpressionNode);
     accept<T>(visitor: AstVisitor<T>): T;
 }
 export declare class AssignNode extends StatementNode {
@@ -124,6 +143,11 @@ export declare class UnaryOpNode extends ExpressionNode {
     constructor(operator: UnaryOperator, expression: ExpressionNode);
     accept<T>(visitor: AstVisitor<T>): T;
 }
+export declare class NullaryOpNode extends ExpressionNode {
+    operator: NullaryOperator;
+    constructor(operator: NullaryOperator);
+    accept<T>(visitor: AstVisitor<T>): T;
+}
 export declare class ArrayNode extends ExpressionNode {
     elements: ExpressionNode[];
     constructor(elements: ExpressionNode[]);

package/dist/main/ast/AST.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HexLiteralNode = exports.StringLiteralNode = exports.IntLiteralNode = exports.BoolLiteralNode = exports.LiteralNode = exports.IdentifierNode = exports.ArrayNode = exports.UnaryOpNode = exports.BinaryOpNode = exports.TupleIndexOpNode = exports.InstantiationNode = exports.FunctionCallNode = exports.CastNode = exports.ExpressionNode = exports.BlockNode = exports.BranchNode = exports.RequireNode = exports.TimeOpNode = exports.AssignNode = exports.VariableDefinitionNode = exports.StatementNode = exports.ParameterNode = exports.FunctionDefinitionNode = exports.ContractNode = exports.SourceFileNode = exports.Node = void 0;
+exports.HexLiteralNode = exports.StringLiteralNode = exports.IntLiteralNode = exports.BoolLiteralNode = exports.LiteralNode = exports.IdentifierNode = exports.ArrayNode = exports.NullaryOpNode = exports.UnaryOpNode = exports.BinaryOpNode = exports.TupleIndexOpNode = exports.InstantiationNode = exports.FunctionCallNode = exports.CastNode = exports.ExpressionNode = exports.BlockNode = exports.BranchNode = exports.RequireNode = exports.TimeOpNode = exports.AssignNode = exports.TupleAssignmentNode = exports.VariableDefinitionNode = exports.StatementNode = exports.ParameterNode = exports.FunctionDefinitionNode = exports.ContractNode = exports.SourceFileNode = exports.Node = void 0;
 const utils_1 = require("@cashscript/utils");
 class Node {
 }
@@ -28,12 +28,11 @@ class ContractNode extends Node {
 }
 exports.ContractNode = ContractNode;
 class FunctionDefinitionNode extends Node {
-    constructor(name, parameters, body, preimageFields) {
+    constructor(name, parameters, body) {
         super();
         this.name = name;
         this.parameters = parameters;
         this.body = body;
-        this.preimageFields = preimageFields;
         this.opRolls = new Map();
     }
     accept(visitor) {
@@ -56,9 +55,10 @@ class StatementNode extends Node {
 }
 exports.StatementNode = StatementNode;
 class VariableDefinitionNode extends StatementNode {
-    constructor(type, name, expression) {
+    constructor(type, modifier, name, expression) {
         super();
         this.type = type;
+        this.modifier = modifier;
         this.name = name;
         this.expression = expression;
     }
@@ -67,6 +67,18 @@ class VariableDefinitionNode extends StatementNode {
     }
 }
 exports.VariableDefinitionNode = VariableDefinitionNode;
+class TupleAssignmentNode extends StatementNode {
+    constructor(var1, var2, tuple) {
+        super();
+        this.var1 = var1;
+        this.var2 = var2;
+        this.tuple = tuple;
+    }
+    accept(visitor) {
+        return visitor.visitTupleAssignment(this);
+    }
+}
+exports.TupleAssignmentNode = TupleAssignmentNode;
 class AssignNode extends StatementNode {
     constructor(identifier, expression) {
         super();
@@ -192,6 +204,16 @@ class UnaryOpNode extends ExpressionNode {
     }
 }
 exports.UnaryOpNode = UnaryOpNode;
+class NullaryOpNode extends ExpressionNode {
+    constructor(operator) {
+        super();
+        this.operator = operator;
+    }
+    accept(visitor) {
+        return visitor.visitNullaryOp(this);
+    }
+}
+exports.NullaryOpNode = NullaryOpNode;
 class ArrayNode extends ExpressionNode {
     constructor(elements) {
         super();

package/dist/main/ast/AstBuilder.d.ts

@@ -1,12 +1,11 @@
-import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor';
-import { ParseTree } from 'antlr4ts/tree/ParseTree';
-import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, ExpressionNode, LiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode } from './AST';
-import { ContractDefinitionContext, FunctionDefinitionContext, VariableDefinitionContext, ParameterContext, AssignStatementContext, IfStatementContext, FunctionCallContext, CastContext, LiteralContext, SourceFileContext, BlockContext, TimeOpStatementContext, ArrayContext, ParenthesisedContext, FunctionCallExpressionContext, UnaryOpContext, BinaryOpContext, IdentifierContext, LiteralExpressionContext, TupleIndexOpContext, RequireStatementContext, PragmaDirectiveContext, PreimageFieldContext, InstantiationContext } from '../grammar/CashScriptParser';
-import { CashScriptVisitor } from '../grammar/CashScriptVisitor';
+import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor.js';
+import { ParseTree } from 'antlr4ts/tree/ParseTree.js';
+import { Node, SourceFileNode, ContractNode, ParameterNode, VariableDefinitionNode, FunctionDefinitionNode, AssignNode, IdentifierNode, BranchNode, CastNode, FunctionCallNode, UnaryOpNode, BinaryOpNode, BoolLiteralNode, IntLiteralNode, HexLiteralNode, StringLiteralNode, ExpressionNode, LiteralNode, BlockNode, TimeOpNode, ArrayNode, TupleIndexOpNode, RequireNode, InstantiationNode, TupleAssignmentNode, NullaryOpNode } from './AST.js';
+import { 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 } from '../grammar/CashScriptParser.js';
+import { CashScriptVisitor } from '../grammar/CashScriptVisitor.js';
 export default class AstBuilder extends AbstractParseTreeVisitor<Node> implements CashScriptVisitor<Node> {
     private tree;
     constructor(tree: ParseTree);
-    private preimageFields;
     defaultResult(): Node;
     build(): Node;
     visitSourceFile(ctx: SourceFileContext): SourceFileNode;
@@ -15,6 +14,7 @@ export default class AstBuilder extends AbstractParseTreeVisitor<Node> implement
     visitFunctionDefinition(ctx: FunctionDefinitionContext): FunctionDefinitionNode;
     visitParameter(ctx: ParameterContext): ParameterNode;
     visitVariableDefinition(ctx: VariableDefinitionContext): VariableDefinitionNode;
+    visitTupleAssignment(ctx: TupleAssignmentContext): TupleAssignmentNode;
     visitAssignStatement(ctx: AssignStatementContext): AssignNode;
     visitTimeOpStatement(ctx: TimeOpStatementContext): TimeOpNode;
     visitRequireStatement(ctx: RequireStatementContext): RequireNode;
@@ -26,10 +26,11 @@ export default class AstBuilder extends AbstractParseTreeVisitor<Node> implement
     visitFunctionCall(ctx: FunctionCallContext): FunctionCallNode;
     visitInstantiation(ctx: InstantiationContext): InstantiationNode;
     visitTupleIndexOp(ctx: TupleIndexOpContext): TupleIndexOpNode;
+    visitNullaryOp(ctx: NullaryOpContext): NullaryOpNode;
+    visitUnaryIntrospectionOp(ctx: UnaryIntrospectionOpContext): UnaryOpNode;
     visitUnaryOp(ctx: UnaryOpContext): UnaryOpNode;
     visitBinaryOp(ctx: BinaryOpContext): BinaryOpNode;
     visitArray(ctx: ArrayContext): ArrayNode;
-    visitPreimageField(ctx: PreimageFieldContext): IdentifierNode;
     visitIdentifier(ctx: IdentifierContext): IdentifierNode;
     visitLiteralExpression(ctx: LiteralExpressionContext): LiteralNode;
     createLiteral(ctx: LiteralContext): LiteralNode;