cashc 0.9.2 → 0.9.3

package/dist/ast/AstBuilder.d.ts

@@ -1,9 +1,8 @@
-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 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 } from '../grammar/CashScriptParser.js';
-import type { CashScriptVisitor } from '../grammar/CashScriptVisitor.js';
-export default class AstBuilder extends AbstractParseTreeVisitor<Node> implements CashScriptVisitor<Node> {
+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 } 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, StatementContext } from '../grammar/CashScriptParser.js';
+import CashScriptVisitor from '../grammar/CashScriptVisitor.js';
+export default class AstBuilder extends ParseTreeVisitor<Node> implements CashScriptVisitor<Node> {
     private tree;
     constructor(tree: ParseTree);
     defaultResult(): Node;
@@ -13,6 +12,7 @@ export default class AstBuilder extends AbstractParseTreeVisitor<Node> implement
     visitContractDefinition(ctx: ContractDefinitionContext): ContractNode;
     visitFunctionDefinition(ctx: FunctionDefinitionContext): FunctionDefinitionNode;
     visitParameter(ctx: ParameterContext): ParameterNode;
+    visitStatement(ctx: StatementContext): StatementNode;
     visitVariableDefinition(ctx: VariableDefinitionContext): VariableDefinitionNode;
     visitTupleAssignment(ctx: TupleAssignmentContext): TupleAssignmentNode;
     visitAssignStatement(ctx: AssignStatementContext): AssignNode;
@@ -39,4 +39,5 @@ export default class AstBuilder extends AbstractParseTreeVisitor<Node> implement
     createStringLiteral(ctx: LiteralContext): StringLiteralNode;
     createDateLiteral(ctx: LiteralContext): IntLiteralNode;
     createHexLiteral(ctx: LiteralContext): HexLiteralNode;
+    visitChildren(): Node;
 }

package/dist/ast/AstBuilder.js

@@ -1,6 +1,6 @@
+import { ParseTreeVisitor } from 'antlr4';
 import { hexToBin } from '@bitauth/libauth';
 import { parseType } from '@cashscript/utils';
-import { AbstractParseTreeVisitor } from 'antlr4ts/tree/AbstractParseTreeVisitor.js';
 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, } from './AST.js';
 import { Location } from './Location.js';
@@ -8,7 +8,7 @@ import { NumberUnit, } from './Globals.js';
 import { getPragmaName, PragmaName, getVersionOpFromCtx } from './Pragma.js';
 import { version } from '../index.js';
 import { ParseError, VersionError } from '../Errors.js';
-export default class AstBuilder extends AbstractParseTreeVisitor {
+export default class AstBuilder extends ParseTreeVisitor {
     constructor(tree) {
         super();
         this.tree = tree;
@@ -20,7 +20,7 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         return this.visit(this.tree);
     }
     visitSourceFile(ctx) {
-        ctx.pragmaDirective().forEach((pragma) => {
+        ctx.pragmaDirective_list().forEach((pragma) => {
             this.processPragma(pragma);
         });
         const contract = this.visit(ctx.contractDefinition());
@@ -29,31 +29,31 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         return sourceFileNode;
     }
     processPragma(ctx) {
-        const pragmaName = getPragmaName(ctx.pragmaName().text);
+        const pragmaName = getPragmaName(ctx.pragmaName().getText());
         if (pragmaName !== PragmaName.CASHSCRIPT)
             throw new Error(); // Shouldn't happen
         // Strip any -beta tags
         const actualVersion = version.replace(/-.*/g, '');
-        ctx.pragmaValue().versionConstraint().forEach((constraint) => {
+        ctx.pragmaValue().versionConstraint_list().forEach((constraint) => {
             const op = getVersionOpFromCtx(constraint.versionOperator());
-            const versionConstraint = `${op}${constraint.VersionLiteral().text}`;
+            const versionConstraint = `${op}${constraint.VersionLiteral().getText()}`;
             if (!semver.satisfies(actualVersion, versionConstraint)) {
                 throw new VersionError(actualVersion, versionConstraint);
             }
         });
     }
     visitContractDefinition(ctx) {
-        const name = ctx.Identifier().text;
-        const parameters = ctx.parameterList().parameter().map((p) => this.visit(p));
-        const functions = ctx.functionDefinition().map((f) => this.visit(f));
+        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 contract = new ContractNode(name, parameters, functions);
         contract.location = Location.fromCtx(ctx);
         return contract;
     }
     visitFunctionDefinition(ctx) {
-        const name = ctx.Identifier().text;
-        const parameters = ctx.parameterList().parameter().map((p) => this.visit(p));
-        const statements = ctx.statement().map((s) => this.visit(s));
+        const name = ctx.Identifier().getText();
+        const parameters = ctx.parameterList().parameter_list().map((p) => this.visit(p));
+        const statements = ctx.statement_list().map((s) => this.visit(s));
         const block = new BlockNode(statements);
         block.location = Location.fromCtx(ctx);
         const functionDefinition = new FunctionDefinitionNode(name, parameters, block);
@@ -61,16 +61,20 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         return functionDefinition;
     }
     visitParameter(ctx) {
-        const type = parseType(ctx.typeName().text);
-        const name = ctx.Identifier().text;
+        const type = parseType(ctx.typeName().getText());
+        const name = ctx.Identifier().getText();
         const parameter = new ParameterNode(type, name);
         parameter.location = Location.fromCtx(ctx);
         return parameter;
     }
+    visitStatement(ctx) {
+        // Statement nodes only have a single child, so we can just visit that child
+        return this.visit(ctx.getChild(0));
+    }
     visitVariableDefinition(ctx) {
-        const type = parseType(ctx.typeName().text);
-        const modifiers = ctx.modifier().map((modifier) => modifier.text);
-        const name = ctx.Identifier().text;
+        const type = parseType(ctx.typeName().getText());
+        const modifiers = ctx.modifier_list().map((modifier) => modifier.getText());
+        const name = ctx.Identifier().getText();
         const expression = this.visit(ctx.expression());
         const variableDefinition = new VariableDefinitionNode(type, modifiers, name, expression);
         variableDefinition.location = Location.fromCtx(ctx);
@@ -78,15 +82,18 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
     }
     visitTupleAssignment(ctx) {
         const expression = this.visit(ctx.expression());
-        const names = ctx.Identifier();
-        const types = ctx.typeName();
-        const [var1, var2] = names.map((name, i) => ({ name: name.text, type: parseType(types[i].text) }));
+        const names = ctx.Identifier_list();
+        const types = ctx.typeName_list();
+        const [var1, var2] = names.map((name, i) => ({
+            name: name.getText(),
+            type: parseType(types[i].getText()),
+        }));
         const tupleAssignment = new TupleAssignmentNode(var1, var2, expression);
         tupleAssignment.location = Location.fromCtx(ctx);
         return tupleAssignment;
     }
     visitAssignStatement(ctx) {
-        const identifier = new IdentifierNode(ctx.Identifier().text);
+        const identifier = new IdentifierNode(ctx.Identifier().getText());
         identifier.location = Location.fromToken(ctx.Identifier().symbol);
         const expression = this.visit(ctx.expression());
         const assign = new AssignNode(identifier, expression);
@@ -95,7 +102,7 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
     }
     visitTimeOpStatement(ctx) {
         const expression = this.visit(ctx.expression());
-        const timeOp = new TimeOpNode(ctx.TxVar().text, expression);
+        const timeOp = new TimeOpNode(ctx.TxVar().getText(), expression);
         timeOp.location = Location.fromCtx(ctx);
         return timeOp;
     }
@@ -114,7 +121,7 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         return branch;
     }
     visitBlock(ctx) {
-        const statements = ctx.statement().map((s) => this.visit(s));
+        const statements = ctx.statement_list().map((s) => this.visit(s));
         const block = new BlockNode(statements);
         block.location = Location.fromCtx(ctx);
         return block;
@@ -123,7 +130,7 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         return this.visit(ctx.expression());
     }
     visitCast(ctx) {
-        const type = parseType(ctx.typeName().text);
+        const type = parseType(ctx.typeName().getText());
         const expression = this.visit(ctx._castable);
         const size = ctx._size && this.visit(ctx._size);
         const cast = new CastNode(type, expression, size);
@@ -134,17 +141,17 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         return this.visit(ctx.functionCall());
     }
     visitFunctionCall(ctx) {
-        const identifier = new IdentifierNode(ctx.Identifier().text);
+        const identifier = new IdentifierNode(ctx.Identifier().getText());
         identifier.location = Location.fromToken(ctx.Identifier().symbol);
-        const parameters = ctx.expressionList().expression().map((e) => this.visit(e));
+        const parameters = ctx.expressionList().expression_list().map((e) => this.visit(e));
         const functionCall = new FunctionCallNode(identifier, parameters);
         functionCall.location = Location.fromCtx(ctx);
         return functionCall;
     }
     visitInstantiation(ctx) {
-        const identifier = new IdentifierNode(ctx.Identifier().text);
+        const identifier = new IdentifierNode(ctx.Identifier().getText());
         identifier.location = Location.fromToken(ctx.Identifier().symbol);
-        const parameters = ctx.expressionList().expression().map((e) => this.visit(e));
+        const parameters = ctx.expressionList().expression_list().map((e) => this.visit(e));
         const instantiation = new InstantiationNode(identifier, parameters);
         instantiation.location = Location.fromCtx(ctx);
         return instantiation;
@@ -157,7 +164,7 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         return tupleIndexOp;
     }
     visitNullaryOp(ctx) {
-        const operator = ctx.text;
+        const operator = ctx.getText();
         const nullaryOp = new NullaryOpNode(operator);
         nullaryOp.location = Location.fromCtx(ctx);
         return nullaryOp;
@@ -185,13 +192,13 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         return binaryOp;
     }
     visitArray(ctx) {
-        const elements = ctx.expression().map((e) => this.visit(e));
+        const elements = ctx.expression_list().map((e) => this.visit(e));
         const array = new ArrayNode(elements);
         array.location = Location.fromCtx(ctx);
         return array;
     }
     visitIdentifier(ctx) {
-        const identifier = new IdentifierNode(ctx.Identifier().text);
+        const identifier = new IdentifierNode(ctx.Identifier().getText());
         identifier.location = Location.fromCtx(ctx);
         return identifier;
     }
@@ -217,7 +224,7 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         throw new Error(); // Should not happen
     }
     createBooleanLiteral(ctx) {
-        const boolString = ctx.BooleanLiteral().text;
+        const boolString = ctx.BooleanLiteral().getText();
         const boolValue = boolString === 'true';
         const booleanLiteral = new BoolLiteralNode(boolValue);
         booleanLiteral.location = Location.fromCtx(ctx);
@@ -225,15 +232,15 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
     }
     createIntLiteral(ctx) {
         const numberCtx = ctx.numberLiteral();
-        const numberString = numberCtx.NumberLiteral().text;
-        const numberUnit = numberCtx.NumberUnit()?.text;
+        const numberString = numberCtx.NumberLiteral().getText();
+        const numberUnit = numberCtx.NumberUnit()?.getText();
         const numberValue = BigInt(numberString) * BigInt(numberUnit ? NumberUnit[numberUnit.toUpperCase()] : 1);
         const intLiteral = new IntLiteralNode(numberValue);
         intLiteral.location = Location.fromCtx(ctx);
         return intLiteral;
     }
     createStringLiteral(ctx) {
-        const rawString = ctx.StringLiteral().text;
+        const rawString = ctx.StringLiteral().getText();
         const stringValue = rawString.substring(1, rawString.length - 1);
         const quote = rawString.substring(0, 1);
         const stringLiteral = new StringLiteralNode(stringValue, quote);
@@ -241,7 +248,7 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         return stringLiteral;
     }
     createDateLiteral(ctx) {
-        const rawString = ctx.DateLiteral().text;
+        const rawString = ctx.DateLiteral().getText();
         const stringValue = rawString.substring(6, rawString.length - 2).trim();
         if (!/^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d$/.test(stringValue)) {
             throw new ParseError('Date should be in format `YYYY-MM-DDThh:mm:ss`', Location.fromCtx(ctx));
@@ -255,11 +262,16 @@ export default class AstBuilder extends AbstractParseTreeVisitor {
         return intLiteral;
     }
     createHexLiteral(ctx) {
-        const hexString = ctx.HexLiteral().text;
+        const hexString = ctx.HexLiteral().getText();
         const hexValue = hexToBin(hexString.substring(2));
         const hexLiteral = new HexLiteralNode(hexValue);
         hexLiteral.location = Location.fromCtx(ctx);
         return hexLiteral;
     }
+    // For safety reasons, we throw an error when the "default" visitChildren is called. *All* nodes
+    // must have a custom visit method, so that we can be sure that we've covered all cases.
+    visitChildren() {
+        throw new Error('Safety Warning: Unhandled node in AST builder');
+    }
 }
 //# sourceMappingURL=AstBuilder.js.map

package/dist/ast/Location.d.ts

@@ -1,5 +1,4 @@
-import type { ParserRuleContext } from 'antlr4ts/ParserRuleContext.js';
-import type { Token } from 'antlr4ts';
+import type { ParserRuleContext, Token } from 'antlr4';
 export declare class Location {
     start: Point;
     end: Point;

package/dist/ast/Location.js

@@ -6,14 +6,14 @@ export class Location {
     static fromCtx(ctx) {
         const stop = ctx.stop?.text ? ctx.stop : ctx.start;
         const textLength = (stop.text ?? '').length;
-        const start = new Point(ctx.start.line, ctx.start.charPositionInLine);
-        const end = new Point(stop.line, stop.charPositionInLine + textLength);
+        const start = new Point(ctx.start.line, ctx.start.column);
+        const end = new Point(stop.line, stop.column + textLength);
         return new Location(start, end);
     }
     static fromToken(token) {
         const textLength = (token.text ?? '').length;
-        const start = new Point(token.line, token.charPositionInLine);
-        const end = new Point(token.line, token.charPositionInLine + textLength);
+        const start = new Point(token.line, token.column);
+        const end = new Point(token.line, token.column + textLength);
         return new Location(start, end);
     }
     text(code) {

package/dist/ast/Pragma.d.ts

@@ -1,4 +1,4 @@
-import { VersionOperatorContext } from '../grammar/CashScriptParser.js';
+import type { VersionOperatorContext } from '../grammar/CashScriptParser.js';
 export declare enum PragmaName {
     CASHSCRIPT = "cashscript"
 }

package/dist/ast/Pragma.js

@@ -16,6 +16,6 @@ export function getPragmaName(name) {
     return PragmaName[name.toUpperCase()];
 }
 export function getVersionOpFromCtx(ctx) {
-    return (ctx ? ctx.text : '=');
+    return (ctx ? ctx.getText() : '=');
 }
 //# sourceMappingURL=Pragma.js.map

package/dist/ast/ThrowingErrorListener.d.ts

@@ -1,9 +1,9 @@
-import { ANTLRErrorListener, RecognitionException, Recognizer } from 'antlr4ts';
+import { ErrorListener, RecognitionException, Recognizer } from 'antlr4';
 /**
  * ANTLR Error Listener that immediately throws on error. This is used so that
  * ANTLR doesn't attempt any error recovery during lexing/parsing and fails early.
  */
-export default class ThrowingErrorListener implements ANTLRErrorListener<any> {
-    static readonly INSTANCE: ThrowingErrorListener;
-    syntaxError<T>(recognizer: Recognizer<T, any>, offendingSymbol: T, line: number, charPositionInLine: number, message: string, e?: RecognitionException): void;
+export default class ThrowingErrorListener<TSymbol> extends ErrorListener<TSymbol> {
+    static readonly INSTANCE: ThrowingErrorListener<unknown>;
+    syntaxError(recognizer: Recognizer<TSymbol>, offendingSymbol: TSymbol, line: number, charPositionInLine: number, message: string, e?: RecognitionException): void;
 }

package/dist/ast/ThrowingErrorListener.js

@@ -1,10 +1,12 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { ErrorListener } from 'antlr4';
 import { ParseError } from '../Errors.js';
 import { Point } from './Location.js';
 /**
  * ANTLR Error Listener that immediately throws on error. This is used so that
  * ANTLR doesn't attempt any error recovery during lexing/parsing and fails early.
  */
-export default class ThrowingErrorListener {
+export default class ThrowingErrorListener extends ErrorListener {
     syntaxError(recognizer, offendingSymbol, line, charPositionInLine, message, e) {
         const capitalisedMessage = message.charAt(0).toUpperCase() + message.slice(1);
         throw new ParseError(capitalisedMessage, new Point(line, charPositionInLine));

package/dist/compiler.js

@@ -1,12 +1,12 @@
+import { CharStream, CommonTokenStream } from 'antlr4';
 import { optimiseBytecode } from '@cashscript/utils';
-import { ANTLRInputStream, CommonTokenStream } from 'antlr4ts';
 import fs from 'fs';
 import { generateArtifact } from './artifact/Artifact.js';
 import AstBuilder from './ast/AstBuilder.js';
 import ThrowingErrorListener from './ast/ThrowingErrorListener.js';
 import GenerateTargetTraversal from './generation/GenerateTargetTraversal.js';
-import { CashScriptLexer } from './grammar/CashScriptLexer.js';
-import { CashScriptParser } from './grammar/CashScriptParser.js';
+import CashScriptLexer from './grammar/CashScriptLexer.js';
+import CashScriptParser from './grammar/CashScriptParser.js';
 import SymbolTableTraversal from './semantic/SymbolTableTraversal.js';
 import TypeCheckTraversal from './semantic/TypeCheckTraversal.js';
 import EnsureFinalRequireTraversal from './semantic/EnsureFinalRequireTraversal.js';
@@ -31,7 +31,7 @@ export function compileFile(codeFile) {
 }
 export function parseCode(code) {
     // Lexing (throwing on errors)
-    const inputStream = new ANTLRInputStream(code);
+    const inputStream = new CharStream(code);
     const lexer = new CashScriptLexer(inputStream);
     lexer.removeErrorListeners();
     lexer.addErrorListener(ThrowingErrorListener.INSTANCE);

package/dist/grammar/CashScriptLexer.d.ts

@@ -1,8 +1,5 @@
-import { ATN } from "antlr4ts/atn/ATN.js";
-import { CharStream } from "antlr4ts/CharStream.js";
-import { Lexer } from "antlr4ts/Lexer.js";
-import { Vocabulary } from "antlr4ts/Vocabulary.js";
-export declare class CashScriptLexer extends Lexer {
+import { ATN, CharStream, DFA, Lexer } from "antlr4";
+export default class CashScriptLexer extends Lexer {
     static readonly T__0 = 1;
     static readonly T__1 = 2;
     static readonly T__2 = 3;
@@ -74,23 +71,22 @@ export declare class CashScriptLexer extends Lexer {
     static readonly WHITESPACE = 69;
     static readonly COMMENT = 70;
     static readonly LINE_COMMENT = 71;
+    static readonly EOF: number;
     static readonly channelNames: string[];
+    static readonly literalNames: (string | null)[];
+    static readonly symbolicNames: (string | null)[];
     static readonly modeNames: string[];
     static readonly ruleNames: string[];
-    private static readonly _LITERAL_NAMES;
-    private static readonly _SYMBOLIC_NAMES;
-    static readonly VOCABULARY: Vocabulary;
-    get vocabulary(): Vocabulary;
     constructor(input: CharStream);
     get grammarFileName(): string;
+    get literalNames(): (string | null)[];
+    get symbolicNames(): (string | null)[];
     get ruleNames(): string[];
-    get serializedATN(): string;
+    get serializedATN(): number[];
     get channelNames(): string[];
     get modeNames(): string[];
-    private static readonly _serializedATNSegments;
-    private static readonly _serializedATNSegment0;
-    private static readonly _serializedATNSegment1;
-    static readonly _serializedATN: string;
-    static __ATN: ATN;
+    static readonly _serializedATN: number[];
+    private static __ATN;
     static get _ATN(): ATN;
+    static DecisionsToDFA: DFA[];
 }