Add type inference / bounds checking for .slice()

Author: rkalis

packages/cashc/src/Errors.ts

@@ -254,13 +254,19 @@ export class ArrayElementError extends CashScriptError {
 
 export class IndexOutOfBoundsError extends CashScriptError {
   constructor(
-    node: TupleIndexOpNode | BinaryOpNode,
+    node: TupleIndexOpNode | BinaryOpNode | SliceNode,
   ) {
     if (node instanceof TupleIndexOpNode) {
       super(node, `Index ${node.index} out of bounds`);
-    } else if (node.operator === BinaryOperator.SPLIT && node.right instanceof IntLiteralNode) {
+    } else if (
+      node instanceof BinaryOpNode && node.operator === BinaryOperator.SPLIT && node.right instanceof IntLiteralNode
+    ) {
       const splitIndex = Number(node.right.value);
       super(node, `Split index ${splitIndex} out of bounds for type ${node.left.type}`);
+    } else if (node instanceof SliceNode) {
+      const start = node.start instanceof IntLiteralNode ? Number(node.start.value) : 'start';
+      const end = node.end instanceof IntLiteralNode ? Number(node.end.value) : 'end';
+      super(node, `Slice indexes (${start}, ${end}) out of bounds for type ${node.element.type}`);
     } else {
       super(node, 'Index out of bounds');
     }

packages/cashc/src/semantic/TypeCheckTraversal.ts

@@ -166,7 +166,6 @@ export default class TypeCheckTraversal extends AstTraversal {
     }
 
     node.type = node.index === 0 ? (node.tuple.type as TupleType).leftType : (node.tuple.type as TupleType).rightType;
-
     return node;
   }
 
@@ -179,9 +178,7 @@ export default class TypeCheckTraversal extends AstTraversal {
     expectInt(node, node.start.type);
     expectInt(node, node.end.type);
 
-    // TODO: Proper typing
-    node.type = node.element.type instanceof BytesType ? new BytesType() : PrimitiveType.STRING;
-
+    node.type = inferSliceType(node);
     return node;
   }
 
@@ -385,6 +382,10 @@ function expectParameters(node: NodeWithParameters, actual: Type[], expected: Ty
 
 // We only call this function for the split operator, so we assume that the node.op is SPLIT
 function inferTupleType(node: BinaryOpNode): Type {
+  if (node.right instanceof IntLiteralNode && Number(node.right.value) < 0) {
+    throw new IndexOutOfBoundsError(node);
+  }
+
   // string.split() -> string, string
   if (node.left.type === PrimitiveType.STRING) {
     return new TupleType(PrimitiveType.STRING, PrimitiveType.STRING);
@@ -406,10 +407,6 @@ function inferTupleType(node: BinaryOpNode): Type {
     return new TupleType(new BytesType(splitIndex), new BytesType());
   }
 
-  if (splitIndex < 0) {
-    throw new IndexOutOfBoundsError(node);
-  }
-
   if (splitIndex > expressionType.bound) {
     throw new IndexOutOfBoundsError(node);
   }
@@ -420,3 +417,48 @@ function inferTupleType(node: BinaryOpNode): Type {
     new BytesType(expressionType.bound! - splitIndex),
   );
 }
+
+function inferSliceType(node: SliceNode): Type {
+  if (node.start instanceof IntLiteralNode && Number(node.start.value) < 0) {
+    throw new IndexOutOfBoundsError(node);
+  }
+
+  if (node.end instanceof IntLiteralNode && Number(node.end.value) < 0) {
+    throw new IndexOutOfBoundsError(node);
+  }
+
+  // string.slice() -> string
+  if (node.element.type === PrimitiveType.STRING) {
+    return PrimitiveType.STRING;
+  }
+
+  // If the expression is not a bytes type, then it must be a different compatible type (e.g. sig/pubkey)
+  const expressionType = node.element.type instanceof BytesType ? node.element.type : new BytesType();
+
+  if (expressionType.bound !== undefined) {
+    if (node.start instanceof IntLiteralNode && Number(node.start.value) >= expressionType.bound) {
+      throw new IndexOutOfBoundsError(node);
+    }
+
+    if (node.end instanceof IntLiteralNode && Number(node.end.value) > expressionType.bound) {
+      throw new IndexOutOfBoundsError(node);
+    }
+  }
+
+  // bytes.slice(variable, variable) -> bytes
+  // bytes.slice(NumberLiteral, variable) -> bytes
+  // bytes.slice(variable, NumberLiteral) -> bytes
+  if (!(node.start instanceof IntLiteralNode) || !(node.end instanceof IntLiteralNode)) {
+    return new BytesType();
+  }
+
+  const start = Number(node.start.value);
+  const end = Number(node.end.value);
+
+  if (start > end) {
+    throw new IndexOutOfBoundsError(node);
+  }
+
+  // bytes.slice(NumberLiteral start, NumberLiteral end) -> bytes(end - start)
+  return new BytesType(end - start);
+}

packages/cashc/test/compiler/AssignTypeError/slice_invalid_bounded_assign_type.cash

@@ -0,0 +1,6 @@
+contract Test(bytes8 b) {
+    function spend() {
+        bytes2 x = b.slice(2, 6);
+        require(x != b);
+    }
+}

packages/cashc/test/compiler/IndexOutOfBoundsError/slice_index_end_out_of_bounds.cash

@@ -0,0 +1,6 @@
+contract Test(bytes8 b) {
+    function spend() {
+        bytes x = b.slice(6, 12);
+        require(x != b);
+    }
+}

packages/cashc/test/compiler/IndexOutOfBoundsError/slice_index_negative.cash

@@ -0,0 +1,6 @@
+contract Test(bytes8 b) {
+    function spend() {
+        bytes x = b.slice(4, -4);
+        require(x != b);
+    }
+}

packages/cashc/test/compiler/IndexOutOfBoundsError/slice_index_start_end_reversed.cash

@@ -0,0 +1,6 @@
+contract Test(bytes8 b) {
+    function spend() {
+        bytes x = b.slice(6, 2);
+        require(x != b);
+    }
+}

packages/cashc/test/generation/fixtures.ts

@@ -887,7 +887,7 @@ export const fixtures: Fixture[] = [
       bytecode: '14 OP_SPLIT OP_DROP OP_0 14 OP_NUM2BIN OP_EQUAL',
       debug: {
         bytecode: '01147f750001148087',
-        sourceMap: '3:34:3:36;:20::37:1;;4:31:4:32:0;:23::33:1;;:8::35',
+        sourceMap: '3:36:3:38;:22::39:1;;4:31:4:32:0;:23::33:1;;:8::35',
         logs: [],
         requires: [
           {

packages/cashc/test/valid-contract-files/slice_optimised.cash

@@ -1,6 +1,6 @@
 contract Slice(bytes32 data) {
     function spend() {
-        bytes pkh = data.slice(0, 20);
+        bytes20 pkh = data.slice(0, 20);
         require(pkh == bytes20(0));
     }
 }