Implement compiler logic for .slice() feature

Author: rkalis

packages/cashc/src/Errors.ts

@@ -19,6 +19,7 @@ import {
   StatementNode,
   ContractNode,
   ExpressionNode,
+  SliceNode,
 } from './ast/AST.js';
 import { Symbol, SymbolType } from './ast/SymbolTable.js';
 import { Location, Point } from './ast/Location.js';
@@ -73,7 +74,7 @@ export class InvalidSymbolTypeError extends CashScriptError {
   }
 }
 
-export class RedefinitionError extends CashScriptError {}
+export class RedefinitionError extends CashScriptError { }
 
 export class FunctionRedefinitionError extends RedefinitionError {
   constructor(
@@ -160,7 +161,7 @@ export class UnequalTypeError extends TypeError {
 
 export class UnsupportedTypeError extends TypeError {
   constructor(
-    node: BinaryOpNode | UnaryOpNode | TimeOpNode | TupleIndexOpNode,
+    node: BinaryOpNode | UnaryOpNode | TimeOpNode | TupleIndexOpNode | SliceNode,
     actual?: Type,
     expected?: Type,
   ) {
@@ -170,6 +171,8 @@ export class UnsupportedTypeError extends TypeError {
       } else {
         super(node, actual, expected, `Tried to call member 'split' on unsupported type '${actual}'`);
       }
+    } else if (node instanceof SliceNode) {
+      super(node, actual, expected, `Tried to call member 'slice' on unsupported type '${actual}'`);
     } else if (node instanceof BinaryOpNode) {
       super(node, actual, expected, `Tried to apply operator '${node.operator}' to unsupported type '${actual}'`);
     } else if (node instanceof UnaryOpNode && node.operator.startsWith('.')) {

packages/cashc/src/ast/AST.ts

@@ -79,7 +79,7 @@ export class ParameterNode extends Node implements Named, Typed {
   }
 }
 
-export abstract class StatementNode extends Node {}
+export abstract class StatementNode extends Node { }
 
 export class VariableDefinitionNode extends StatementNode implements Named, Typed {
   constructor(
@@ -235,6 +235,20 @@ export class TupleIndexOpNode extends ExpressionNode {
   }
 }
 
+export class SliceNode extends ExpressionNode {
+  constructor(
+    public element: ExpressionNode,
+    public start: ExpressionNode,
+    public end: ExpressionNode,
+  ) {
+    super();
+  }
+
+  accept<T>(visitor: AstVisitor<T>): T {
+    return visitor.visitSlice(this);
+  }
+}
+
 export class BinaryOpNode extends ExpressionNode {
   constructor(
     public left: ExpressionNode,

packages/cashc/src/ast/AstBuilder.ts

@@ -33,6 +33,7 @@ import {
   NullaryOpNode,
   ConsoleStatementNode,
   ConsoleParameterNode,
+  SliceNode,
 } from './AST.js';
 import { UnaryOperator, BinaryOperator, NullaryOperator } from './Operator.js';
 import type {
@@ -66,6 +67,7 @@ import type {
   ConsoleParameterContext,
   StatementContext,
   RequireMessageContext,
+  SliceContext,
 } from '../grammar/CashScriptParser.js';
 import CashScriptVisitor from '../grammar/CashScriptVisitor.js';
 import { Location } from './Location.js';
@@ -262,6 +264,15 @@ export default class AstBuilder
     return tupleIndexOp;
   }
 
+  visitSlice(ctx: SliceContext): SliceNode {
+    const element = this.visit(ctx._element);
+    const start = this.visit(ctx._start);
+    const end = this.visit(ctx._end);
+    const slice = new SliceNode(element, start, end);
+    slice.location = Location.fromCtx(ctx);
+    return slice;
+  }
+
   visitNullaryOp(ctx: NullaryOpContext): NullaryOpNode {
     const operator = ctx.getText() as NullaryOperator;
     const nullaryOp = new NullaryOpNode(operator);

packages/cashc/src/ast/AstTraversal.ts

@@ -27,6 +27,7 @@ import {
   NullaryOpNode,
   ConsoleStatementNode,
   ConsoleParameterNode,
+  SliceNode,
 } from './AST.js';
 import AstVisitor from './AstVisitor.js';
 
@@ -113,6 +114,13 @@ export default class AstTraversal extends AstVisitor<Node> {
     return node;
   }
 
+  visitSlice(node: SliceNode): Node {
+    node.element = this.visit(node.element);
+    node.start = this.visit(node.start);
+    node.end = this.visit(node.end);
+    return node;
+  }
+
   visitBinaryOp(node: BinaryOpNode): Node {
     node.left = this.visit(node.left);
     node.right = this.visit(node.right);

packages/cashc/src/ast/AstVisitor.ts

@@ -25,6 +25,7 @@ import {
   TupleAssignmentNode,
   NullaryOpNode,
   ConsoleStatementNode,
+  SliceNode,
 } from './AST.js';
 
 export default abstract class AstVisitor<T> {
@@ -42,6 +43,7 @@ export default abstract class AstVisitor<T> {
   abstract visitCast(node: CastNode): T;
   abstract visitFunctionCall(node: FunctionCallNode): T;
   abstract visitInstantiation(node: InstantiationNode): T;
+  abstract visitSlice(node: SliceNode): T;
   abstract visitTupleIndexOp(node: TupleIndexOpNode): T;
   abstract visitBinaryOp(node: BinaryOpNode): T;
   abstract visitUnaryOp(node: UnaryOpNode): T;

packages/cashc/src/generation/GenerateTargetTraversal.ts

@@ -46,6 +46,7 @@ import {
   NullaryOpNode,
   ConsoleParameterNode,
   ConsoleStatementNode,
+  SliceNode,
 } from '../ast/AST.js';
 import AstTraversal from '../ast/AstTraversal.js';
 import { GlobalFunction, Class } from '../ast/Globals.js';
@@ -537,6 +538,27 @@ export default class GenerateTargetTraversalWithLocation extends AstTraversal {
     return node;
   }
 
+  // element.slice(start, end) is equivalent to element.split(end)[0].split(start)[1]
+  visitSlice(node: SliceNode): Node {
+    node.element = this.visit(node.element);
+
+    const locationData = { location: node.location, positionHint: PositionHint.END };
+
+    this.visit(node.end);
+    this.emit(Op.OP_SPLIT, locationData);
+    this.emit(Op.OP_DROP, locationData);
+    this.popFromStack(2);
+    this.pushToStack('(value)');
+
+    this.visit(node.start);
+    this.emit(Op.OP_SPLIT, locationData);
+    this.emit(Op.OP_NIP, locationData);
+    this.popFromStack(2);
+    this.pushToStack('(value)');
+
+    return node;
+  }
+
   visitBinaryOp(node: BinaryOpNode): Node {
     node.left = this.visit(node.left);
     node.right = this.visit(node.right);

packages/cashc/src/print/OutputSourceCodeTraversal.ts

@@ -28,6 +28,7 @@ import {
   NullaryOpNode,
   ConsoleStatementNode,
   ConsoleParameterNode,
+  SliceNode,
 } from '../ast/AST.js';
 import AstTraversal from '../ast/AstTraversal.js';
 
@@ -216,6 +217,16 @@ export default class OutputSourceCodeTraversal extends AstTraversal {
     return node;
   }
 
+  visitSlice(node: SliceNode): Node {
+    node.element = this.visit(node.element);
+    this.addOutput('.slice(');
+    node.start = this.visit(node.start);
+    this.addOutput(', ');
+    node.end = this.visit(node.end);
+    this.addOutput(')');
+    return node;
+  }
+
   visitBinaryOp(node: BinaryOpNode): Node {
     if (node.operator.startsWith('.')) {
       node.left = this.visit(node.left);

packages/cashc/src/semantic/TypeCheckTraversal.ts

@@ -27,6 +27,7 @@ import {
   InstantiationNode,
   TupleAssignmentNode,
   NullaryOpNode,
+  SliceNode,
 } from '../ast/AST.js';
 import AstTraversal from '../ast/AstTraversal.js';
 import {
@@ -171,6 +172,21 @@ export default class TypeCheckTraversal extends AstTraversal {
     return node;
   }
 
+  visitSlice(node: SliceNode): Node {
+    node.element = this.visit(node.element);
+    node.start = this.visit(node.start);
+    node.end = this.visit(node.end);
+
+    expectAnyOfTypes(node, node.element.type, [new BytesType(), PrimitiveType.STRING]);
+    expectInt(node, node.start.type);
+    expectInt(node, node.end.type);
+
+    // TODO: Proper typing
+    node.type = node.element.type instanceof BytesType ? new BytesType() : PrimitiveType.STRING;
+
+    return node;
+  }
+
   visitBinaryOp(node: BinaryOpNode): Node {
     node.left = this.visit(node.left);
     node.right = this.visit(node.right);
@@ -325,7 +341,7 @@ export default class TypeCheckTraversal extends AstTraversal {
   }
 }
 
-type ExpectedNode = BinaryOpNode | UnaryOpNode | TimeOpNode | TupleIndexOpNode;
+type ExpectedNode = BinaryOpNode | UnaryOpNode | TimeOpNode | TupleIndexOpNode | SliceNode;
 function expectAnyOfTypes(node: ExpectedNode, actual?: Type, expectedTypes?: Type[]): void {
   if (!expectedTypes || expectedTypes.length === 0) return;
   if (expectedTypes.find((expected) => implicitlyCastable(actual, expected))) {