cashc 0.12.1 → 0.12.2

package/dist/ast/error-listeners.d.ts

@@ -0,0 +1,22 @@
+import { ErrorListener, Recognizer } from 'antlr4';
+export interface CashScriptErrorListener {
+    syntaxError(recognizer: unknown, offendingSymbol: unknown, line: number, charPositionInLine: number, message: string, e?: unknown): void;
+}
+/**
+ * Error listener that forwards syntax errors to another listener and stores the first error.
+ */
+export declare class ForwardingErrorListener extends ErrorListener<unknown> implements CashScriptErrorListener {
+    private readonly errorListener;
+    private firstError?;
+    constructor(errorListener: CashScriptErrorListener);
+    syntaxError(recognizer: unknown, offendingSymbol: unknown, line: number, charPositionInLine: number, message: string, e?: unknown): void;
+    throwFirstError(): void;
+}
+/**
+ * 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 declare class ThrowingErrorListener<TSymbol> extends ErrorListener<TSymbol> {
+    static readonly INSTANCE: ThrowingErrorListener<unknown>;
+    syntaxError(_recognizer: Recognizer<TSymbol>, _offendingSymbol: TSymbol, line: number, charPositionInLine: number, message: string): void;
+}

package/dist/ast/error-listeners.js

@@ -0,0 +1,35 @@
+import { ErrorListener } from 'antlr4';
+import { ParseError } from '../Errors.js';
+import { Point } from './Location.js';
+/**
+ * Error listener that forwards syntax errors to another listener and stores the first error.
+ */
+export class ForwardingErrorListener extends ErrorListener {
+    constructor(errorListener) {
+        super();
+        this.errorListener = errorListener;
+    }
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, message, e) {
+        this.firstError ??= createParseError(line, charPositionInLine, message);
+        this.errorListener.syntaxError(recognizer, offendingSymbol, line, charPositionInLine, message, e);
+    }
+    throwFirstError() {
+        if (this.firstError)
+            throw this.firstError;
+    }
+}
+/**
+ * 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 class ThrowingErrorListener extends ErrorListener {
+    syntaxError(_recognizer, _offendingSymbol, line, charPositionInLine, message) {
+        throw createParseError(line, charPositionInLine, message);
+    }
+}
+ThrowingErrorListener.INSTANCE = new ThrowingErrorListener();
+function createParseError(line, charPositionInLine, message) {
+    const capitalisedMessage = message.charAt(0).toUpperCase() + message.slice(1);
+    return new ParseError(capitalisedMessage, new Point(line, charPositionInLine));
+}
+//# sourceMappingURL=error-listeners.js.map

package/dist/compiler.d.ts

@@ -1,6 +1,10 @@
 import { Artifact } from '@cashscript/utils';
 import { PathLike } from 'fs';
 import { Ast } from './ast/AST.js';
-export declare function compileString(code: string): Artifact;
-export declare function compileFile(codeFile: PathLike): Artifact;
-export declare function parseCode(code: string): Ast;
+import { CashScriptErrorListener } from './ast/error-listeners.js';
+export interface CompileOptions {
+    errorListener?: CashScriptErrorListener;
+}
+export declare function compileString(code: string, compilerOptions?: CompileOptions): Artifact;
+export declare function compileFile(codeFile: PathLike, compilerOptions?: CompileOptions): Artifact;
+export declare function parseCode(code: string, errorListener?: CashScriptErrorListener): Ast;

package/dist/compiler.js

@@ -1,19 +1,19 @@
 import { CharStream, CommonTokenStream } from 'antlr4';
 import { binToHex } from '@bitauth/libauth';
-import { generateSourceMap, optimiseBytecode, optimiseBytecodeOld, scriptToAsm, scriptToBytecode, sourceMapToLocationData } from '@cashscript/utils';
+import { generateSourceMap, optimiseBytecode, optimiseBytecodeOld, scriptToAsm, scriptToBytecode, sourceMapToLocationData, } from '@cashscript/utils';
 import fs from 'fs';
 import { generateArtifact } from './artifact/Artifact.js';
 import AstBuilder from './ast/AstBuilder.js';
-import ThrowingErrorListener from './ast/ThrowingErrorListener.js';
+import { ForwardingErrorListener, ThrowingErrorListener } from './ast/error-listeners.js';
 import GenerateTargetTraversal from './generation/GenerateTargetTraversal.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';
-export function compileString(code) {
+export function compileString(code, compilerOptions = {}) {
     // Lexing + parsing
-    let ast = parseCode(code);
+    let ast = parseCode(code, compilerOptions.errorListener);
     // Semantic analysis
     ast = ast.accept(new SymbolTableTraversal());
     ast = ast.accept(new TypeCheckTraversal());
@@ -39,22 +39,24 @@ export function compileString(code) {
     };
     return generateArtifact(ast, optimisationResult.script, code, debug);
 }
-export function compileFile(codeFile) {
+export function compileFile(codeFile, compilerOptions = {}) {
     const code = fs.readFileSync(codeFile, { encoding: 'utf-8' });
-    return compileString(code);
+    return compileString(code, compilerOptions);
 }
-export function parseCode(code) {
+export function parseCode(code, errorListener = ThrowingErrorListener.INSTANCE) {
+    const syntaxErrorListener = new ForwardingErrorListener(errorListener);
     // Lexing (throwing on errors)
     const inputStream = new CharStream(code);
     const lexer = new CashScriptLexer(inputStream);
     lexer.removeErrorListeners();
-    lexer.addErrorListener(ThrowingErrorListener.INSTANCE);
+    lexer.addErrorListener(syntaxErrorListener);
     const tokenStream = new CommonTokenStream(lexer);
     // Parsing (throwing on errors)
     const parser = new CashScriptParser(tokenStream);
     parser.removeErrorListeners();
-    parser.addErrorListener(ThrowingErrorListener.INSTANCE);
+    parser.addErrorListener(syntaxErrorListener);
     const parseTree = parser.sourceFile();
+    syntaxErrorListener.throwFirstError();
     // AST building
     const ast = new AstBuilder(parseTree).build();
     return ast;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './Errors.js';
 export * as utils from '@cashscript/utils';
-export { compileFile, compileString } from './compiler.js';
-export declare const version = "0.12.1";
+export { compileFile, compileString, type CompileOptions } from './compiler.js';
+export * from './ast/error-listeners.js';
+export declare const version = "0.12.2";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from './Errors.js';
 export * as utils from '@cashscript/utils';
 export { compileFile, compileString } from './compiler.js';
-export const version = '0.12.1';
+export * from './ast/error-listeners.js';
+export const version = '0.12.2';
 //# sourceMappingURL=index.js.map

package/dist/semantic/SymbolTableTraversal.js

@@ -80,11 +80,13 @@ export default class SymbolTableTraversal extends AstTraversal {
         return node;
     }
     visitTupleAssignment(node) {
-        [node.left, node.right].forEach(({ name, type }) => {
+        [node.left, node.right].forEach((variable) => {
+            const definition = createTupleVariableDefinition(node, variable);
+            const { name } = variable;
             if (this.symbolTables[0].get(name)) {
-                throw new VariableRedefinitionError(new VariableDefinitionNode(type, [], name, node.tuple));
+                throw new VariableRedefinitionError(definition);
             }
-            this.symbolTables[0].set(Symbol.variable(new VariableDefinitionNode(type, [], name, node.tuple)));
+            this.symbolTables[0].set(Symbol.variable(definition));
         });
         node.tuple = this.visit(node.tuple);
         return node;
@@ -127,4 +129,9 @@ export default class SymbolTableTraversal extends AstTraversal {
         return node;
     }
 }
+function createTupleVariableDefinition(node, variable) {
+    const definition = new VariableDefinitionNode(variable.type, [], variable.name, node.tuple);
+    definition.location = node.location;
+    return definition;
+}
 //# sourceMappingURL=SymbolTableTraversal.js.map

package/dist/semantic/TypeCheckTraversal.js

@@ -17,7 +17,9 @@ export default class TypeCheckTraversal extends AstTraversal {
         }
         const assignmentType = new TupleType(node.left.type, node.right.type);
         if (!implicitlyCastable(node.tuple.type, assignmentType)) {
-            throw new AssignTypeError(new VariableDefinitionNode(assignmentType, [], node.left.name, node.tuple));
+            const syntheticAssignment = new VariableDefinitionNode(assignmentType, [], node.left.name, node.tuple);
+            syntheticAssignment.location = node.location;
+            throw new AssignTypeError(syntheticAssignment);
         }
         return node;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashc",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "description": "Compile Bitcoin Cash contracts to Bitcoin Cash Script or artifacts",
   "keywords": [
     "bitcoin",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^3.1.0-next.8",
-    "@cashscript/utils": "^0.12.1",
+    "@cashscript/utils": "^0.12.2",
     "antlr4": "^4.13.2",
     "commander": "^14.0.0",
     "semver": "^7.7.2"
@@ -65,5 +65,5 @@
     "url-join": "^5.0.0",
     "vitest": "^4.0.15"
   },
-  "gitHead": "e2e12ba611bc0499891fb817e611eddd891c2313"
+  "gitHead": "5cde1601fe522646e5b85766b17a4b6387c7c4b5"
 }

package/dist/ast/ThrowingErrorListener.d.ts

@@ -1,9 +0,0 @@
-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<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,17 +0,0 @@
-/* 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.
- */
-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));
-    }
-}
-ThrowingErrorListener.INSTANCE = new ThrowingErrorListener();
-export default ThrowingErrorListener;
-//# sourceMappingURL=ThrowingErrorListener.js.map