Checking ascribed expression types for existence

CHANGELOG.md

@@ -947,6 +947,7 @@
   projects next to each other][7634]
 - [Support runtime checks of intersection types][7769]
 - [Merge `Small_Integer` and `Big_Integer` types][7636]
+- [Inline type ascriptions][7796]
 
 [3227]: https://github.com/enso-org/enso/pull/3227
 [3248]: https://github.com/enso-org/enso/pull/3248
@@ -1086,6 +1087,7 @@
 [7634]: https://github.com/enso-org/enso/pull/7634
 [7769]: https://github.com/enso-org/enso/pull/7769
 [7636]: https://github.com/enso-org/enso/pull/7636
+[7796]: https://github.com/enso-org/enso/pull/7796
 
 # Enso 2.0.0-alpha.18 (2021-10-12)
 

docs/syntax/types.md

@@ -87,7 +87,6 @@ working with types. These are listed below.
 |   `;`    |         `< :`, `> =`         |  -2   |  Left  | Concatenates the left and right operand typesets to create a new typeset.   |
 |   `\|`   | `> <:`, `> !`, `> in`, `> :` |   5   |  Left  | Computes the union of the left and right operand typesets.                  |
 |   `&`    |            `> \|`            |   6   |  Left  | Computes the intersection of the left and right operand typesets.           |
-|   `\`    |            `> &`             |   7   |  Left  | Computes the subtraction of the right typeset from the left typeset.        |
 |   `:=`   |     `< :`, `> =`, `> ;`      |  -1   |  Left  | Creates a typeset member by assigning a value to a label.                   |
 
 <!-- prettier-ignore-end -->
@@ -108,7 +107,6 @@ bind (`=`) has a relative level of -3 in this ordering.
 (declare-fun tsConcat () Int) ; `;`
 (declare-fun tsUnion () Int)  ; `|`
 (declare-fun tsInter () Int)  ; `&`
-(declare-fun minus () Int)    ; `\`
 (declare-fun tsMember () Int) ; `:=`
 
 (assert (> ascrip bind))
@@ -265,8 +263,6 @@ of typesets. Their syntax is as follows:
   arguments.
 - **Intersection - `&`:** The resultant typeset may contain values that are
   members of _both_ its arguments.
-- **Subtraction - `\`:** The resultant typeset may contain values that are in
-  the first argument's set but not in the second.
 
 > The actionables for this section are:
 >

docs/types/hierarchy.md

@@ -194,10 +194,8 @@ They are as follows:
   product types.
 - **Union - `|`:** This operator creates a typeset that contains the members in
   the union of its operands.
-- **Intersection - `|`:** This operator creates a typeset that contains the
+- **Intersection - `&`:** This operator creates a typeset that contains the
   members in the intersection of its operands.
-- **Subtraction - `\`:** This operator creates a typeset that contains all of
-  the members in the left operand that do not occur in the right operand.
 
 For information on the syntactic usage of these operators, please see the
 section on [type operators](#../syntax/types.md#type-operators) in the syntax

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

@@ -99,7 +99,8 @@ Object doDataflowError(
       @Shared("indirectInvokeFunctionNode") @Cached IndirectInvokeFunctionNode invokeFunctionNode,
       @Cached ConditionProfile profile) {
     Function function =
-        methodResolverNode.execute(EnsoContext.get(this).getBuiltins().dataflowError(), symbol);
+        methodResolverNode.executeResolution(
+            EnsoContext.get(this).getBuiltins().dataflowError(), symbol);
     if (profile.profile(function == null)) {
       return self;
     } else {

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

@@ -12,6 +12,7 @@
 import org.enso.interpreter.runtime.callable.function.Function;
 import org.enso.interpreter.runtime.control.TailCallException;
 import org.enso.interpreter.runtime.data.ArrayRope;
+import org.enso.interpreter.runtime.data.EnsoMultiValue;
 import org.enso.interpreter.runtime.data.Type;
 import org.enso.interpreter.runtime.data.text.Text;
 import org.enso.interpreter.runtime.error.DataflowError;
@@ -152,6 +153,27 @@ Object doPanicSentinel(
     throw that;
   }
 
+  @Specialization
+  Object doMultiValue(
+      VirtualFrame frame,
+      State state,
+      UnresolvedConversion conversion,
+      Object self,
+      EnsoMultiValue that,
+      Object[] arguments) {
+    var type = extractType(self);
+    var result = that.castTo(type);
+    if (result == null) {
+      throw new PanicException(
+          EnsoContext.get(this)
+              .getBuiltins()
+              .error()
+              .makeNoSuchConversion(type, self, conversion),
+          this);
+    }
+    return result;
+  }
+
   @Specialization
   Object doWarning(
       VirtualFrame frame,

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

@@ -162,7 +162,7 @@ Object doFunctionalDispatchCachedSymbol(
 
   Function resolveFunction(
       UnresolvedSymbol symbol, Type selfTpe, MethodResolverNode methodResolverNode) {
-    Function function = methodResolverNode.execute(selfTpe, symbol);
+    Function function = methodResolverNode.executeResolution(selfTpe, symbol);
     if (function == null) {
       return null;
     }
@@ -288,10 +288,11 @@ Object doMultiValue(
     var fnAndType = self.resolveSymbol(methodResolverNode, symbol);
     if (fnAndType != null) {
       var unwrapSelf = self.castTo(fnAndType.getRight());
-      assert unwrapSelf != null;
-      assert arguments[0] == self;
-      arguments[0] = unwrapSelf;
-      return execute(frame, state, symbol, unwrapSelf, arguments);
+      if (unwrapSelf != null) {
+        assert arguments[0] == self;
+        arguments[0] = unwrapSelf;
+      }
+      return invokeFunctionNode.execute(fnAndType.getLeft(), frame, state, arguments);
     }
     throw methodNotFound(symbol, self);
   }
@@ -305,7 +306,7 @@ Object doDataflowError(
       Object[] arguments,
       @Shared("methodResolverNode") @Cached MethodResolverNode methodResolverNode) {
     Function function =
-        methodResolverNode.execute(EnsoContext.get(this).getBuiltins().dataflowError(), symbol);
+        methodResolverNode.executeResolution(EnsoContext.get(this).getBuiltins().dataflowError(), symbol);
     if (errorReceiverProfile.profile(function == null)) {
       return self;
     } else {
@@ -352,9 +353,10 @@ Function resolveWarningFunction(
           e);
     }
 
-    Type typeOfSymbol = symbol.resolveDeclaringType(this, types.getType(selfWithoutWarnings));
-    Builtins builtins = EnsoContext.get(this).getBuiltins();
-    if (typeOfSymbol == builtins.any()) {
+    var selfType = types.getType(selfWithoutWarnings);
+    var fnAndType = symbol.resolveFor(this, selfType);
+    var builtins = EnsoContext.get(this).getBuiltins();
+    if (fnAndType != null && fnAndType.getRight() == builtins.any()) {
       return symbol
           .getScope()
           .lookupMethodDefinition(builtins.warning().getEigentype(), symbol.getName());

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

@@ -9,6 +9,7 @@
 import org.enso.interpreter.EnsoLanguage;
 import org.enso.interpreter.node.BaseNode.TailStatus;
 import org.enso.interpreter.node.EnsoRootNode;
+import org.enso.interpreter.node.ExpressionNode;
 import org.enso.interpreter.node.callable.ApplicationNode;
 import org.enso.interpreter.node.callable.InvokeCallableNode.DefaultsExecutionMode;
 import org.enso.interpreter.node.callable.thunk.ThunkExecutorNode;
@@ -55,6 +56,13 @@ public abstract class ReadArgumentCheckNode extends Node {
     this.name = name;
   }
 
+  /**
+   *
+   */
+  public static ExpressionNode wrap(ExpressionNode original, ReadArgumentCheckNode check) {
+    return new TypeCheckExpressionNode(original, check);
+  }
+
   /** Executes check or conversion of the value.abstract
    * @param frame frame requesting the conversion
    * @param value the value to convert
@@ -289,16 +297,28 @@ private Pair<Function, Type> findConversion(Type from) {
     ApplicationNode findConversionNode(Type from) {
       var convAndType = findConversion(from);
 
-      if (convAndType != null && NodeUtil.findParent(this, ReadArgumentNode.class) instanceof ReadArgumentNode ran) {
-        CompilerAsserts.neverPartOfCompilation();
-        var convNode = LiteralNode.build(convAndType.getLeft());
-        var intoNode = LiteralNode.build(convAndType.getRight());
-        var valueNode = ran.plainRead();
-        var args = new CallArgument[]{
-          new CallArgument(null, intoNode),
-          new CallArgument(null, valueNode)
-        };
-        return ApplicationNode.build(convNode, args, DefaultsExecutionMode.EXECUTE);
+      if (convAndType != null) {
+        if (NodeUtil.findParent(this, ReadArgumentNode.class) instanceof ReadArgumentNode ran) {
+          CompilerAsserts.neverPartOfCompilation();
+          var convNode = LiteralNode.build(convAndType.getLeft());
+          var intoNode = LiteralNode.build(convAndType.getRight());
+          var valueNode = ran.plainRead();
+          var args = new CallArgument[]{
+            new CallArgument(null, intoNode),
+            new CallArgument(null, valueNode)
+          };
+          return ApplicationNode.build(convNode, args, DefaultsExecutionMode.EXECUTE);
+        } else if (NodeUtil.findParent(this, TypeCheckExpressionNode.class) instanceof TypeCheckExpressionNode tcen) {
+          CompilerAsserts.neverPartOfCompilation();
+          var convNode = LiteralNode.build(convAndType.getLeft());
+          var intoNode = LiteralNode.build(convAndType.getRight());
+          var valueNode = tcen.original;
+          var args = new CallArgument[]{
+            new CallArgument(null, intoNode),
+            new CallArgument(null, valueNode)
+          };
+          return ApplicationNode.build(convNode, args, DefaultsExecutionMode.EXECUTE);
+        }
       }
       return null;
     }
@@ -378,4 +398,29 @@ public Object execute(VirtualFrame frame) {
       return result;
     }
   }
+
+  private static final class TypeCheckExpressionNode extends ExpressionNode {
+    @Child
+    private ExpressionNode original;
+    @Child
+    private ReadArgumentCheckNode check;
+
+    TypeCheckExpressionNode(ExpressionNode original, ReadArgumentCheckNode check) {
+      this.check = check;
+      this.original = original;
+    }
+
+    @Override
+    public Object executeGeneric(VirtualFrame frame) {
+      var value = original.executeGeneric(frame);
+      var result = check.handleCheckOrConversion(frame, value);
+      return result;
+    }
+
+    @Override
+    public boolean isInstrumentable() {
+      return false;
+    }
+  }
+
 }

engine/runtime/src/main/java/org/enso/interpreter/node/callable/resolver/MethodResolverNode.java

@@ -11,6 +11,7 @@
 import org.enso.interpreter.runtime.callable.function.Function;
 import org.enso.interpreter.runtime.data.Type;
 import org.enso.interpreter.runtime.error.PanicException;
+import org.graalvm.collections.Pair;
 
 @GenerateUncached
 @ReportPolymorphism
@@ -22,15 +23,20 @@ EnsoContext getContext() {
     return EnsoContext.get(this);
   }
 
-  public abstract Function execute(Type type, UnresolvedSymbol symbol);
+  public abstract Pair<Function, Type> execute(Type type, UnresolvedSymbol symbol);
 
-  public Function expectNonNull(Object self, Type type, UnresolvedSymbol symbol) {
+  public final Function executeResolution(Type type, UnresolvedSymbol symbol) {
+    var pair = execute(type, symbol);
+    return pair == null ? null : pair.getLeft();
+  }
+
+  public final Function expectNonNull(Object self, Type type, UnresolvedSymbol symbol) {
     var result = execute(type, symbol);
     if (result == null) {
       throw new PanicException(
           EnsoContext.get(this).getBuiltins().error().makeNoSuchMethod(self, symbol), this);
     }
-    return result;
+    return result.getLeft();
   }
 
   @Specialization(
@@ -40,17 +46,17 @@ public Function expectNonNull(Object self, Type type, UnresolvedSymbol symbol) {
         "cachedType == type"
       },
       limit = "CACHE_SIZE")
-  Function resolveCached(
+  Pair<Function, Type> resolveCached(
       Type type,
       UnresolvedSymbol symbol,
       @Cached("symbol") UnresolvedSymbol cachedSymbol,
       @Cached("type") Type cachedType,
-      @Cached("resolveUncached(cachedType, cachedSymbol)") Function function) {
+      @Cached("resolveUncached(cachedType, cachedSymbol)") Pair<Function, Type> function) {
     return function;
   }
 
   @Specialization(replaces = "resolveCached")
-  Function resolveUncached(Type self, UnresolvedSymbol symbol) {
+  Pair<Function, Type> resolveUncached(Type self, UnresolvedSymbol symbol) {
     return symbol.resolveFor(this, self);
   }
 }