Use BuiltinRootNode.ArgNode to extract argument for a builtin method

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

@@ -1,9 +1,14 @@
 package org.enso.interpreter.node.expression.builtin;
 
+import com.oracle.truffle.api.interop.TruffleObject;
 import org.enso.interpreter.dsl.BuiltinType;
 
 @BuiltinType(name = "Standard.Base.Any.Any")
-public class Any extends Builtin {
+public final class Any extends Builtin {
+  public Any() {
+    super(TruffleObject.class);
+  }
+
   @Override
   public Class<? extends Builtin> getSuperType() {
     return null;

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

@@ -10,7 +10,11 @@
 // Before moving this definition to the `bool` package, as we should, one would have to address that
 // problem first.
 @BuiltinType(name = "Standard.Base.Data.Boolean.Boolean")
-public class Boolean extends Builtin {
+public final class Boolean extends Builtin {
+  public Boolean() {
+    super(java.lang.Boolean.class);
+  }
+
   @Override
   protected List<Cons> getDeclaredConstructors() {
     return List.of(new Cons("False"), new Cons("True"));

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

@@ -33,15 +33,33 @@ private AtomConstructor build(EnsoLanguage language, ModuleScope.Builder scope,
     }
   }
 
+  private final Class<?> representationType;
   private final String name;
 
-  public Builtin() {
-    name = this.getClass().getSimpleName().replaceAll("([^_A-Z])([A-Z])", "$1_$2");
+  protected Builtin(String representationType) {
+    this(findType(representationType));
+  }
+
+  protected Builtin(Class<?> representationType) {
+    this.representationType = representationType;
+    this.name = this.getClass().getSimpleName().replaceAll("([^_A-Z])([A-Z])", "$1_$2");
+  }
+
+  private static Class<?> findType(String fqn) {
+    try {
+      return Class.forName(fqn);
+    } catch (ClassNotFoundException ex) {
+      throw new IllegalArgumentException(ex);
+    }
   }
 
   private @CompilerDirectives.CompilationFinal Type type;
   private @CompilerDirectives.CompilationFinal(dimensions = 1) AtomConstructor[] constructors;
 
+  public final boolean isRepresentedBy(Class<?> clazz) {
+    return representationType == clazz;
+  }
+
   protected Class<? extends Builtin> getSuperType() {
     return Any.class;
   }

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

@@ -1,21 +1,39 @@
 package org.enso.interpreter.node.expression.builtin;
 
+import com.oracle.truffle.api.CompilerDirectives;
+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.frame.VirtualFrame;
+import com.oracle.truffle.api.interop.TruffleObject;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
+import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.NodeInfo;
 import com.oracle.truffle.api.nodes.RootNode;
 import org.enso.interpreter.EnsoLanguage;
+import org.enso.interpreter.runtime.EnsoContext;
+import org.enso.interpreter.runtime.data.EnsoMultiValue;
+import org.enso.interpreter.runtime.data.Type;
+import org.enso.interpreter.runtime.data.hash.EnsoHashMap;
+import org.enso.interpreter.runtime.data.hash.HashMapInsertAllNode;
+import org.enso.interpreter.runtime.error.DataflowError;
+import org.enso.interpreter.runtime.error.PanicException;
+import org.enso.interpreter.runtime.error.PanicSentinel;
+import org.enso.interpreter.runtime.warning.AppendWarningNode;
+import org.enso.interpreter.runtime.warning.WarningsLibrary;
+import org.enso.interpreter.runtime.warning.WithWarnings;
 import org.enso.pkg.QualifiedName;
 
 /** Root node for use by all the builtin functions. */
 @NodeInfo(shortName = "BuiltinRoot", description = "Root node for builtin functions.")
 public abstract class BuiltinRootNode extends RootNode {
+  private QualifiedName moduleName;
+  private QualifiedName typeName;
+
   protected BuiltinRootNode(EnsoLanguage language) {
     super(language);
   }
 
-  protected QualifiedName moduleName = null;
-  protected QualifiedName typeName = null;
-
   /** Get the module name where the builtin is defined. */
   public QualifiedName getModuleName() {
     return moduleName;
@@ -52,4 +70,161 @@ public void setTypeName(QualifiedName typeName) {
    */
   @Override
   public abstract String getName();
+
+  protected static final class ArgContext {
+    private TruffleObject returnValue;
+    private EnsoHashMap warnings;
+
+    public ArgContext() {}
+
+    public TruffleObject getReturnValue() {
+      return returnValue;
+    }
+
+    public boolean hasWarnings() {
+      return this.warnings != null;
+    }
+
+    private void addWarnings(
+        VirtualFrame frame, HashMapInsertAllNode insertNode, EnsoHashMap newWarnings) {
+      if (this.warnings == null) {
+        this.warnings = newWarnings;
+      } else {
+        int maxWarnings = EnsoContext.get(insertNode).getWarningsLimit();
+        this.warnings = insertNode.executeInsertAll(frame, this.warnings, newWarnings, maxWarnings);
+      }
+    }
+  }
+
+  protected abstract static class ArgNode extends Node {
+    private static final byte IS_SELF = 0x01;
+    private static final byte IS_ARRAY = 0x02;
+    private static final byte REQUIRES_CAST = 0x04;
+    private static final byte CHECK_ERRORS = 0x08;
+    private static final byte CHECK_PANIC_SENTINEL = 0x10;
+    private static final byte CHECK_WARNINGS = 0x20;
+    private final byte flags;
+    @CompilerDirectives.CompilationFinal private Type ensoType;
+
+    @Child private WarningsLibrary warnings;
+    @Child private AppendWarningNode appendWarningNode;
+    @Child private HashMapInsertAllNode mapInsertAllNode;
+
+    ArgNode(byte flags) {
+      this.flags = flags;
+      if (is(CHECK_WARNINGS)) {
+        this.warnings = WarningsLibrary.getFactory().createDispatched(5);
+      }
+    }
+
+    private boolean is(byte what) {
+      return (flags & what) != 0;
+    }
+
+    @SuppressWarnings("unchecked")
+    public final <T> T processArgument(
+        VirtualFrame frame, Class<T> type, Object value, ArgContext context) {
+      assert value != null;
+      if (is(CHECK_ERRORS) && value instanceof DataflowError err) {
+        context.returnValue = err;
+        return null;
+      }
+      if (is(CHECK_PANIC_SENTINEL) && value instanceof PanicSentinel sentinel) {
+        throw sentinel.getPanic();
+      }
+      if (warnings != null) {
+        if (value instanceof WithWarnings ww) {
+          if (mapInsertAllNode == null) {
+            CompilerDirectives.transferToInterpreterAndInvalidate();
+            this.mapInsertAllNode = insert(HashMapInsertAllNode.build());
+          }
+          if (this.mapInsertAllNode != null) {
+            try {
+              context.addWarnings(frame, mapInsertAllNode, warnings.getWarnings(value, false));
+              value = warnings.removeWarnings(value);
+            } catch (UnsupportedMessageException ex) {
+              throw raise(RuntimeException.class, ex);
+            }
+          }
+        }
+      }
+      if (is(REQUIRES_CAST)) {
+        var ctx = EnsoContext.get(this);
+        if (this.ensoType == null) {
+          CompilerDirectives.transferToInterpreterAndInvalidate();
+          var builtin = ctx.getBuiltins().getByRepresentationType(type);
+          if (builtin == null) {
+            this.ensoType = ctx.getBuiltins().any();
+          } else {
+            this.ensoType = builtin.getType();
+          }
+        }
+        var conv = executeConversion(value);
+        if (conv == null) {
+          CompilerDirectives.transferToInterpreter();
+          var err = ctx.getBuiltins().error().makeTypeError(this.ensoType, value, type.getName());
+          throw new PanicException(err, this);
+        }
+        return type.cast(conv);
+      } else {
+        return type.cast(value);
+      }
+    }
+
+    public final Object processWarnings(VirtualFrame frame, Object result, ArgContext context) {
+      assert context.warnings != null;
+      if (this.appendWarningNode == null) {
+        CompilerDirectives.transferToInterpreterAndInvalidate();
+        this.appendWarningNode = insert(AppendWarningNode.build());
+      }
+      return appendWarningNode.executeAppend(frame, result, context.warnings);
+    }
+
+    abstract Object executeConversion(Object obj);
+
+    @Specialization
+    final Object extractMultiValue(EnsoMultiValue emv, @Cached EnsoMultiValue.CastToNode castTo) {
+      var extracted = castTo.findTypeOrNull(ensoType, emv, false, false);
+      return extracted;
+    }
+
+    @Fallback
+    final Object justReturnIt(Object obj) {
+      return obj;
+    }
+
+    public static ArgNode create(
+        boolean isSelf,
+        boolean isArray,
+        boolean requiresCast,
+        boolean checkErrors,
+        boolean checkPanicSentinel,
+        boolean checkWarnings) {
+      byte flags = 0x00;
+      if (isSelf) {
+        flags |= IS_SELF;
+      }
+      if (isArray) {
+        flags |= IS_ARRAY;
+      }
+      if (requiresCast) {
+        flags |= REQUIRES_CAST;
+      }
+      if (checkErrors) {
+        flags |= CHECK_ERRORS;
+      }
+      if (checkPanicSentinel) {
+        flags |= CHECK_PANIC_SENTINEL;
+      }
+      if (checkWarnings) {
+        flags |= CHECK_WARNINGS;
+      }
+      return BuiltinRootNodeFactory.ArgNodeGen.create(flags);
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  private static <E extends Exception> E raise(Class<E> clazz, Throwable t) throws E {
+    throw (E) t;
+  }
 }

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

@@ -1,9 +1,14 @@
 package org.enso.interpreter.node.expression.builtin;
 
 import org.enso.interpreter.dsl.BuiltinType;
+import org.enso.interpreter.runtime.error.DataflowError;
 
 @BuiltinType(name = "Standard.Base.Error.Error")
-public class Error extends Builtin {
+public final class Error extends Builtin {
+  public Error() {
+    super(DataflowError.class);
+  }
+
   @Override
   protected Class<? extends Builtin> getSuperType() {
     return null;

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

@@ -3,7 +3,11 @@
 import org.enso.interpreter.dsl.BuiltinType;
 
 @BuiltinType(name = "Standard.Base.Nothing.Nothing")
-public class Nothing extends Builtin {
+public final class Nothing extends Builtin {
+  public Nothing() {
+    super(Void.class);
+  }
+
   @Override
   public boolean containsValues() {
     return false;

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

@@ -3,4 +3,8 @@
 import org.enso.interpreter.dsl.BuiltinType;
 
 @BuiltinType
-public class Polyglot extends Builtin {}
+public final class Polyglot extends Builtin {
+  public Polyglot() {
+    super(Object.class);
+  }
+}

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

@@ -9,6 +9,10 @@
 public abstract class UniquelyConstructibleBuiltin extends Builtin {
   private @CompilerDirectives.CompilationFinal AtomConstructor uniqueConstructor;
 
+  protected UniquelyConstructibleBuiltin() {
+    super(Object.class);
+  }
+
   public final AtomConstructor getUniqueConstructor() {
     return uniqueConstructor;
   }

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/debug/Debug.java

@@ -4,4 +4,8 @@
 import org.enso.interpreter.node.expression.builtin.Builtin;
 
 @BuiltinType
-public class Debug extends Builtin {}
+public class Debug extends Builtin {
+  public Debug() {
+    super(Object.class);
+  }
+}

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/error/NumberParseError.java

@@ -8,6 +8,10 @@
 
 @BuiltinType
 public final class NumberParseError extends Builtin {
+  public NumberParseError() {
+    super(Object.class);
+  }
+
   @Override
   protected final List<Cons> getDeclaredConstructors() {
     return List.of(new Cons("Error", "text"));

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/error/Panic.java

@@ -2,9 +2,14 @@
 
 import org.enso.interpreter.dsl.BuiltinType;
 import org.enso.interpreter.node.expression.builtin.Builtin;
+import org.enso.interpreter.runtime.error.PanicException;
 
 @BuiltinType(name = "Standard.Base.Panic.Panic")
-public class Panic extends Builtin {
+public final class Panic extends Builtin {
+  public Panic() {
+    super(PanicException.class);
+  }
+
   @Override
   public boolean containsValues() {
     return true;

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/error/ProblemBehavior.java

@@ -6,7 +6,10 @@
 import org.enso.interpreter.runtime.data.atom.AtomConstructor;
 
 @BuiltinType(name = "Standard.Base.Errors.Problem_Behavior.Problem_Behavior")
-public class ProblemBehavior extends Builtin {
+public final class ProblemBehavior extends Builtin {
+  public ProblemBehavior() {
+    super(Object.class);
+  }
 
   @Override
   protected List<Cons> getDeclaredConstructors() {

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/function/Function.java

@@ -4,7 +4,11 @@
 import org.enso.interpreter.node.expression.builtin.Builtin;
 
 @BuiltinType(name = "Standard.Base.Function.Function")
-public class Function extends Builtin {
+public final class Function extends Builtin {
+  public Function() {
+    super(org.enso.interpreter.runtime.callable.function.Function.class);
+  }
+
   @Override
   public boolean containsValues() {
     return true;

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/io/PrintlnNode.java

@@ -41,6 +41,7 @@ Object doPrintText(
       Object message,
       Object nl,
       @Shared("interop") @CachedLibrary(limit = "10") InteropLibrary strings) {
+
     EnsoContext ctx = EnsoContext.get(this);
     try {
       print(ctx.getOut(), strings.asString(message), strings.asString(nl));