Add extra type inference and type checking for SPLIT

- If split() is called with a number literal (e.g.) x.split(12), we
  infer one or both sides of the split
- Extend type checking to use this new type information
- Add tests

Author: rkalis

packages/cashc/src/Errors.ts

@@ -20,9 +20,11 @@ import {
   ContractNode,
   ExpressionNode,
   SliceNode,
+  IntLiteralNode,
 } from './ast/AST.js';
 import { Symbol, SymbolType } from './ast/SymbolTable.js';
 import { Location, Point } from './ast/Location.js';
+import { BinaryOperator } from './ast/Operator.js';
 
 export class CashScriptError extends Error {
   node: Node;
@@ -252,9 +254,16 @@ export class ArrayElementError extends CashScriptError {
 
 export class IndexOutOfBoundsError extends CashScriptError {
   constructor(
-    node: TupleIndexOpNode,
+    node: TupleIndexOpNode | BinaryOpNode,
   ) {
-    super(node, `Index ${node.index} out of bounds`);
+    if (node instanceof TupleIndexOpNode) {
+      super(node, `Index ${node.index} out of bounds`);
+    } else if (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 {
+      super(node, 'Index out of bounds');
+    }
   }
 }
 

packages/cashc/src/ast/AST.ts

@@ -98,8 +98,9 @@ export class VariableDefinitionNode extends StatementNode implements Named, Type
 
 export class TupleAssignmentNode extends StatementNode {
   constructor(
-    public var1: { name: string, type: Type },
-    public var2: { name: string, type: Type },
+    // TODO: Use an IdentifierNode instead of a custom type
+    public left: { name: string, type: Type },
+    public right: { name: string, type: Type },
     public tuple: ExpressionNode,
   ) {
     super();

packages/cashc/src/generation/GenerateTargetTraversal.ts

@@ -252,8 +252,8 @@ export default class GenerateTargetTraversalWithLocation extends AstTraversal {
   visitTupleAssignment(node: TupleAssignmentNode): Node {
     node.tuple = this.visit(node.tuple);
     this.popFromStack(2);
-    this.pushToStack(node.var1.name);
-    this.pushToStack(node.var2.name);
+    this.pushToStack(node.left.name);
+    this.pushToStack(node.right.name);
     return node;
   }
 

packages/cashc/src/print/OutputSourceCodeTraversal.ts

@@ -110,7 +110,7 @@ export default class OutputSourceCodeTraversal extends AstTraversal {
   }
 
   visitTupleAssignment(node: TupleAssignmentNode): Node {
-    this.addOutput(`${node.var1.type} ${node.var1.name}, ${node.var2.type} ${node.var2.name} = `, true);
+    this.addOutput(`${node.left.type} ${node.left.name}, ${node.right.type} ${node.right.name} = `, true);
     this.visit(node.tuple);
     this.addOutput(';\n');
 

packages/cashc/src/semantic/SymbolTableTraversal.ts

@@ -124,7 +124,7 @@ export default class SymbolTableTraversal extends AstTraversal {
   }
 
   visitTupleAssignment(node: TupleAssignmentNode): Node {
-    [node.var1, node.var2].forEach(({ name, type }) => {
+    [node.left, node.right].forEach(({ name, type }) => {
       if (this.symbolTables[0].get(name)) {
         throw new VariableRedefinitionError(new VariableDefinitionNode(type, [], name, node.tuple));
       }

packages/cashc/src/semantic/TypeCheckTraversal.ts

@@ -28,6 +28,7 @@ import {
   TupleAssignmentNode,
   NullaryOpNode,
   SliceNode,
+  IntLiteralNode,
 } from '../ast/AST.js';
 import AstTraversal from '../ast/AstTraversal.js';
 import {
@@ -57,17 +58,13 @@ export default class TypeCheckTraversal extends AstTraversal {
     if (!(node.tuple instanceof BinaryOpNode) || node.tuple.operator !== BinaryOperator.SPLIT) {
       throw new TupleAssignmentError(node.tuple);
     }
-    const tupleType = node.tuple.left.type;
-    for (const variable of [node.var1, node.var2]) {
-      if (!implicitlyCastable(tupleType, variable.type)) {
-        // Ignore if both are of type byte. problem: bytes16 can be typed to bytes32
-        if (tupleType instanceof BytesType && variable.type instanceof BytesType) {
-          return node;
-        }
-        throw new AssignTypeError(
-          new VariableDefinitionNode(variable.type, [], variable.name, node.tuple),
-        );
-      }
+
+    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),
+      );
     }
     return node;
   }
@@ -240,12 +237,7 @@ export default class TypeCheckTraversal extends AstTraversal {
       case BinaryOperator.SPLIT:
         expectAnyOfTypes(node, node.left.type, [new BytesType(), PrimitiveType.STRING]);
         expectInt(node, node.right.type);
-
-        // Result of split are two unbounded bytes types (could be improved to do type inference)
-        node.type = new TupleType(
-          node.left.type instanceof BytesType ? new BytesType() : PrimitiveType.STRING,
-          node.left.type instanceof BytesType ? new BytesType() : PrimitiveType.STRING,
-        );
+        node.type = inferTupleType(node);
         return node;
       default:
         return node;
@@ -346,9 +338,7 @@ export default class TypeCheckTraversal extends AstTraversal {
 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))) {
-    return;
-  }
+  if (expectedTypes.find((expected) => implicitlyCastable(actual, expected))) return;
 
   throw new UnsupportedTypeError(node, actual, expectedTypes[0]);
 }
@@ -392,3 +382,37 @@ function expectParameters(node: NodeWithParameters, actual: Type[], expected: Ty
     throw new InvalidParameterTypeError(node, actual, expected);
   }
 }
+
+// We only call this function for the split operator, so we assume that the node.op is SPLIT
+function inferTupleType(node: BinaryOpNode): Type {
+  // string.split() -> string, string
+  if (node.left.type === PrimitiveType.STRING) {
+    return new TupleType(PrimitiveType.STRING, PrimitiveType.STRING);
+  }
+
+  // If the expression is not a bytes type, then it must be a different compatible type (e.g. sig/pubkey)
+  // We treat this as an unbounded bytes type for the purposes of splitting
+  const expressionType = node.left.type instanceof BytesType ? node.left.type : new BytesType();
+
+  // bytes.split(variable) -> bytes, bytes
+  if (!(node.right instanceof IntLiteralNode)) {
+    return new TupleType(new BytesType(), new BytesType());
+  }
+
+  const splitIndex = Number(node.right.value);
+
+  // bytes.split(NumberLiteral) -> bytes(NumberLiteral), bytes
+  if (expressionType.bound === undefined) {
+    return new TupleType(new BytesType(splitIndex), new BytesType());
+  }
+
+  if (splitIndex > expressionType.bound) {
+    throw new IndexOutOfBoundsError(node);
+  }
+
+  // bytesX.split(NumberLiteral) -> bytes(NumberLiteral), bytes(X - NumberLiteral)
+  return new TupleType(
+    new BytesType(splitIndex),
+    new BytesType(expressionType.bound! - splitIndex),
+  );
+}

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

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

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

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

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

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

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

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