Runtime check of ascribed types

engine/runtime/src/main/java/org/enso/interpreter/node/callable/argument/ReadArgumentNode.java

@@ -1,10 +1,16 @@
 package org.enso.interpreter.node.callable.argument;
 
+import org.enso.interpreter.node.ExpressionNode;
+import org.enso.interpreter.node.expression.builtin.meta.IsValueOfTypeNode;
+import org.enso.interpreter.runtime.EnsoContext;
+import org.enso.interpreter.runtime.callable.function.Function;
+import org.enso.interpreter.runtime.data.Type;
+import org.enso.interpreter.runtime.error.PanicException;
+
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.NodeInfo;
 import com.oracle.truffle.api.profiles.ConditionProfile;
-import org.enso.interpreter.node.ExpressionNode;
-import org.enso.interpreter.runtime.callable.function.Function;
 
 /**
  * Reads and evaluates the expression provided as a function argument. It handles the case where
@@ -14,22 +20,31 @@
 public class ReadArgumentNode extends ExpressionNode {
   private final int index;
   @Child ExpressionNode defaultValue;
+  @Child IsValueOfTypeNode checkType;
   private final ConditionProfile defaultingProfile = ConditionProfile.createCountingProfile();
+  // XXX: Type in a Node is wrong!!!!!
+  private final Type expectedType;
 
-  private ReadArgumentNode(int position, ExpressionNode defaultValue) {
+  private ReadArgumentNode(int position, ExpressionNode defaultValue, Type expectedType) {
     this.index = position;
     this.defaultValue = defaultValue;
+    this.expectedType = expectedType;
+    if (expectedType != null) {
+      checkType = IsValueOfTypeNode.build();
+    }
   }
 
   /**
    * Creates an instance of this node.
    *
    * @param position the argument's position at the definition site
    * @param defaultValue the default value provided for that argument
+   * @param expectedType {@code null} or expected type to check input for
    * @return a node representing the argument at position {@code idx}
    */
-  public static ReadArgumentNode build(int position, ExpressionNode defaultValue) {
-    return new ReadArgumentNode(position, defaultValue);
+  public static ReadArgumentNode build(
+      int position, ExpressionNode defaultValue, Type expectedType) {
+    return new ReadArgumentNode(position, defaultValue, expectedType);
   }
 
   /**
@@ -47,15 +62,24 @@ public static ReadArgumentNode build(int position, ExpressionNode defaultValue)
   public Object executeGeneric(VirtualFrame frame) {
     Object arguments[] = Function.ArgumentsHelper.getPositionalArguments(frame.getArguments());
 
+    Object v;
     if (defaultValue == null) {
-      return arguments[index];
+      v = arguments[index];
+    } else {
+      // Note [Handling Argument Defaults]
+      if (defaultingProfile.profile(arguments.length <= index || arguments[index] == null)) {
+        v = defaultValue.executeGeneric(frame);
+      } else {
+        v = arguments[index];
+      }
     }
-
-    // Note [Handling Argument Defaults]
-    if (defaultingProfile.profile(arguments.length <= index || arguments[index] == null)) {
-      return defaultValue.executeGeneric(frame);
+    if (checkType != null && !checkType.execute(expectedType, v)) {
+      CompilerDirectives.transferToInterpreter();
+      var ctx = EnsoContext.get(this);
+      var err = ctx.getBuiltins().error().makeTypeError(expectedType, v, "" + v);
+      throw new PanicException(err, this);
     } else {
-      return arguments[index];
+      return v;
     }
   }
 

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/meta/IsValueOfTypeNode.java

@@ -1,5 +1,13 @@
 package org.enso.interpreter.node.expression.builtin.meta;
 
+import org.enso.interpreter.runtime.EnsoContext;
+import org.enso.interpreter.runtime.callable.UnresolvedSymbol;
+import org.enso.interpreter.runtime.data.Type;
+import org.enso.interpreter.runtime.library.dispatch.TypesLibrary;
+import org.enso.interpreter.runtime.number.EnsoBigInteger;
+import org.enso.interpreter.runtime.type.TypesGen;
+
+import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Fallback;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.interop.InteropLibrary;
@@ -9,85 +17,40 @@
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.NodeInfo;
 import com.oracle.truffle.api.profiles.ConditionProfile;
-import org.enso.interpreter.epb.runtime.PolyglotExceptionProxy;
-import org.enso.interpreter.epb.runtime.PolyglotProxy;
-import org.enso.interpreter.runtime.EnsoContext;
-import org.enso.interpreter.runtime.callable.UnresolvedSymbol;
-import org.enso.interpreter.runtime.callable.atom.AtomConstructor;
-import org.enso.interpreter.runtime.data.Type;
-import org.enso.interpreter.runtime.library.dispatch.TypesLibrary;
-import org.enso.interpreter.runtime.number.EnsoBigInteger;
-import org.enso.interpreter.runtime.type.TypesGen;
 
 /** An implementation of the payload check against the expected panic type. */
 @NodeInfo(shortName = "IsValueOfTypeNode")
 public abstract class IsValueOfTypeNode extends Node {
-  private @Child IsSameObjectNode isSameObject = IsSameObjectNode.build();
-  private @Child TypeOfNode typeOfNode = TypeOfNode.build();
-  private final ConditionProfile profile = ConditionProfile.createCountingProfile();
-
   public static IsValueOfTypeNode build() {
     return IsValueOfTypeNodeGen.create();
   }
 
   public abstract boolean execute(Object expectedType, Object payload);
 
-  @Specialization
-  boolean doPolyglotProxy(Object expectedType, PolyglotProxy proxy) {
-    Object tpeOfPayload = typeOfNode.execute(proxy);
-    return isSameObject.execute(expectedType, tpeOfPayload);
-  }
-
-  @Specialization(guards = "!isAnyType(expectedType)")
-  boolean doPolyglotExceptionProxy(Object expectedType, PolyglotExceptionProxy proxy) {
-    Object tpeOfPayload = typeOfNode.execute(proxy.getDelegate());
-    return isSameObject.execute(expectedType, tpeOfPayload);
-  }
-
-  @Specialization(guards = "isAnyType(expectedType)")
-  boolean doAnyType(Object expectedType, Object payload) {
-    return true;
-  }
-
-  @Specialization
-  boolean doLongCheck(Type expectedType, long payload) {
-    var numbers = EnsoContext.get(this).getBuiltins().number();
-    return checkParentTypes(numbers.getSmallInteger(), expectedType);
-  }
-
-  @Specialization
-  boolean doDoubleCheck(Type expectedType, double payload) {
-    var numbers = EnsoContext.get(this).getBuiltins().number();
-    return checkParentTypes(numbers.getDecimal(), expectedType);
-  }
-
-  @Specialization
-  boolean doBigIntegerCheck(Type expectedType, EnsoBigInteger value) {
-    var numbers = EnsoContext.get(this).getBuiltins().number();
-    return checkParentTypes(numbers.getBigInteger(), expectedType);
-  }
-
-  @Specialization
-  boolean doUresolvedSymbol(Type expectedType, UnresolvedSymbol value) {
-    var funTpe = EnsoContext.get(this).getBuiltins().function();
-    return expectedType == funTpe;
+  @Specialization(guards = {"types.hasType(payload)"})
+  boolean doTyped(
+      Object expectedType,
+      Object payload,
+      @CachedLibrary(limit = "3") TypesLibrary types,
+      @Cached Typed typed) {
+    return typed.execute(expectedType, payload);
   }
 
-  @ExplodeLoop
-  private boolean checkParentTypes(Type actual, Type expected) {
-    for (; ; ) {
-      if (actual == null) {
-        return false;
-      }
-      if (actual == expected) {
-        return true;
-      }
-      actual = actual.getSupertype();
-    }
+  @Specialization(guards = {"!types.hasType(payload)"})
+  boolean doPolyglot(
+      Object expectedType,
+      Object payload,
+      @CachedLibrary(limit = "3") TypesLibrary types,
+      @Cached Untyped typed) {
+    return typed.execute(expectedType, payload);
   }
 
-  @Specialization(guards = {"!isArrayType(expectedType)", "!isAnyType(expectedType)"})
-  boolean doType(Type expectedType, Object payload) {
+  private static boolean typeAndCheck(
+      Object payload,
+      Object expectedType,
+      TypeOfNode typeOfNode,
+      IsSameObjectNode isSameObject,
+      ConditionProfile profile) {
     Object tpeOfPayload = typeOfNode.execute(payload);
     if (profile.profile(isSameObject.execute(expectedType, tpeOfPayload))) {
       return true;
@@ -107,57 +70,116 @@ boolean doType(Type expectedType, Object payload) {
     return false;
   }
 
-  @Specialization(
-      guards = {
-        "isArrayType(expectedType)",
-        "interop.hasArrayElements(payload)",
-        "!types.hasType(payload)"
-      })
-  boolean doArray(
-      Object expectedType,
-      Object payload,
-      @CachedLibrary(limit = "3") InteropLibrary interop,
-      @CachedLibrary(limit = "3") TypesLibrary types) {
-    return true;
-  }
+  abstract static class Typed extends Node {
+    private @Child IsSameObjectNode isSameObject = IsSameObjectNode.build();
+    private @Child TypeOfNode typeOfNode = TypeOfNode.build();
+    private final ConditionProfile profile = ConditionProfile.createCountingProfile();
 
-  @Specialization(
-      guards = {
-        "isArrayType(expectedType)",
-        "interop.hasArrayElements(payload)",
-        "types.hasType(payload)"
-      })
-  public boolean doArrayViaType(
-      Object expectedType,
-      Object payload,
-      @CachedLibrary(limit = "3") InteropLibrary interop,
-      @CachedLibrary(limit = "3") TypesLibrary types) {
-    return EnsoContext.get(this).getBuiltins().array() == types.getType(payload);
-  }
+    abstract boolean execute(Object expectedType, Object payload);
 
-  @Specialization(guards = {"interop.isMetaObject(expectedType)", "!types.hasType(expectedType)"})
-  boolean doPolyglotType(
-      Object expectedType,
-      Object payload,
-      @CachedLibrary(limit = "3") InteropLibrary interop,
-      @CachedLibrary(limit = "3") TypesLibrary types) {
-    try {
-      return interop.isMetaInstance(expectedType, payload);
-    } catch (UnsupportedMessageException e) {
-      throw new IllegalStateException(e);
+    @Specialization(guards = "isAnyType(expectedType)")
+    boolean doAnyType(Object expectedType, Object payload) {
+      return true;
     }
-  }
 
-  boolean isAnyType(Object expectedType) {
-    return EnsoContext.get(this).getBuiltins().any() == expectedType;
-  }
+    @Specialization
+    boolean doLongCheck(Type expectedType, long payload) {
+      var numbers = EnsoContext.get(this).getBuiltins().number();
+      return checkParentTypes(numbers.getSmallInteger(), expectedType);
+    }
+
+    @Specialization
+    boolean doDoubleCheck(Type expectedType, double payload) {
+      var numbers = EnsoContext.get(this).getBuiltins().number();
+      return checkParentTypes(numbers.getDecimal(), expectedType);
+    }
+
+    @Specialization
+    boolean doBigIntegerCheck(Type expectedType, EnsoBigInteger value) {
+      var numbers = EnsoContext.get(this).getBuiltins().number();
+      return checkParentTypes(numbers.getBigInteger(), expectedType);
+    }
+
+    @Specialization
+    boolean doUresolvedSymbol(Type expectedType, UnresolvedSymbol value) {
+      var funTpe = EnsoContext.get(this).getBuiltins().function();
+      return expectedType == funTpe;
+    }
+
+    @ExplodeLoop
+    private boolean checkParentTypes(Type actual, Type expected) {
+      for (; ; ) {
+        if (actual == null) {
+          return false;
+        }
+        if (actual == expected) {
+          return true;
+        }
+        actual = actual.getSupertype();
+      }
+    }
 
-  boolean isArrayType(Object expectedType) {
-    return EnsoContext.get(this).getBuiltins().array() == expectedType;
+    @Specialization(guards = {"!isArrayType(expectedType)", "!isAnyType(expectedType)"})
+    boolean doType(
+        Type expectedType, Object payload, @CachedLibrary(limit = "3") TypesLibrary types) {
+      return typeAndCheck(payload, expectedType, typeOfNode, isSameObject, profile);
+    }
+
+    @Specialization(
+        guards = {
+          "isArrayType(expectedType)",
+          "interop.hasArrayElements(payload)",
+        })
+    public boolean doArrayViaType(
+        Object expectedType,
+        Object payload,
+        @CachedLibrary(limit = "3") InteropLibrary interop,
+        @CachedLibrary(limit = "3") TypesLibrary types) {
+      return EnsoContext.get(this).getBuiltins().array() == types.getType(payload);
+    }
+
+    @Fallback
+    boolean doOther(Object expectedType, Object payload) {
+      return false;
+    }
+
+    boolean isAnyType(Object expectedType) {
+      return EnsoContext.get(this).getBuiltins().any() == expectedType;
+    }
+
+    boolean isArrayType(Object expectedType) {
+      return EnsoContext.get(this).getBuiltins().array() == expectedType;
+    }
   }
 
-  @Fallback
-  public boolean doOther(Object expectedType, Object payload) {
-    return false;
+  abstract static class Untyped extends Node {
+    private @Child IsSameObjectNode isSameObject = IsSameObjectNode.build();
+    private @Child TypeOfNode typeOfNode = TypeOfNode.build();
+    private final ConditionProfile profile = ConditionProfile.createCountingProfile();
+
+    abstract boolean execute(Object expectedType, Object payload);
+
+    @Specialization(
+        guards = {
+          "interop.isMetaObject(expectedType)",
+          "isMetaInstance(interop, expectedType, payload)"
+        })
+    boolean doPolyglotType(
+        Object expectedType, Object payload, @CachedLibrary(limit = "3") InteropLibrary interop) {
+      return true;
+    }
+
+    static boolean isMetaInstance(InteropLibrary interop, Object expectedType, Object payload) {
+      try {
+        return interop.isMetaInstance(expectedType, payload);
+      } catch (UnsupportedMessageException ex) {
+        return false;
+      }
+    }
+
+    @Fallback
+    public boolean doOther(Object expectedType, Object payload) {
+      return typeAndCheck(payload, expectedType, typeOfNode, isSameObject, profile);
+    }
   }
 }