Vector should preserve warnings

CHANGELOG.md

@@ -467,6 +467,7 @@
 - [Import modules' extension methods only with unqualified imports][3906]
 - [Don't export polyglot symbols][3915]
 - [From/all import must not include module in name resolution][3931]
+- [Vector returns warnings of individual elements][3938]
 
 [3227]: https://github.com/enso-org/enso/pull/3227
 [3248]: https://github.com/enso-org/enso/pull/3248
@@ -538,6 +539,7 @@
 [3906]: https://github.com/enso-org/enso/pull/3906
 [3915]: https://github.com/enso-org/enso/pull/3915
 [3931]: https://github.com/enso-org/enso/pull/3931
+[3938]: https://github.com/enso-org/enso/pull/3938
 
 # Enso 2.0.0-alpha.18 (2021-10-12)
 

distribution/lib/Standard/Base/0.0.0-dev/src/Warning.enso

@@ -115,7 +115,7 @@ type Warning
         result = warnings.partition w-> predicate w.value
         matched = result.first
         remaining = result.second
-        Pair.new (Warning.set remaining value) matched
+        Pair.new (Warning.set value remaining) matched
 
     ## UNSTABLE
        A helper function which gathers warnings matching some predicate and passes

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

@@ -34,6 +34,7 @@
 import org.enso.interpreter.runtime.error.PanicException;
 import org.enso.interpreter.runtime.error.PanicSentinel;
 import org.enso.interpreter.runtime.error.Warning;
+import org.enso.interpreter.runtime.error.WarningsLibrary;
 import org.enso.interpreter.runtime.error.WithWarnings;
 import org.enso.interpreter.runtime.library.dispatch.TypesLibrary;
 import org.enso.interpreter.runtime.state.State;
@@ -183,6 +184,7 @@ Object doPolyglot(
       Object[] arguments,
       @CachedLibrary(limit = "10") TypesLibrary methods,
       @CachedLibrary(limit = "10") InteropLibrary interop,
+      @CachedLibrary(limit = "10") WarningsLibrary warnings,
       @Cached MethodResolverNode preResolveMethod,
       @Bind("getPolyglotCallType(self, symbol, interop, preResolveMethod)")
           HostMethodCallNode.PolyglotCallType polyglotCallType,
@@ -195,17 +197,21 @@ Object doPolyglot(
     boolean anyWarnings = false;
     ArrayRope<Warning> accumulatedWarnings = new ArrayRope<>();
     for (int i = 0; i < argExecutors.length; i++) {
-       var r = argExecutors[i].executeThunk(arguments[i + 1], state, TailStatus.NOT_TAIL);
-       args[i] = r;
+      var r = argExecutors[i].executeThunk(arguments[i + 1], state, TailStatus.NOT_TAIL);
       if (r instanceof DataflowError) {
         profiles[i].enter();
         return r;
-      } else if (r instanceof WithWarnings w) {
+      } else if (warnings.hasWarnings(r)) {
         warningProfiles[i].enter();
         anyWarnings = true;
-        accumulatedWarnings =
-            accumulatedWarnings.append(w.getReassignedWarnings(this));
-        args[i] = w.getValue();
+        try {
+          accumulatedWarnings = accumulatedWarnings.append(warnings.getWarnings(r, this));
+          args[i] = warnings.removeWarnings(r);
+        } catch (UnsupportedMessageException e) {
+          throw new IllegalStateException(e);
+        }
+      } else {
+        args[i] = r;
       }
     }
     Object res = hostMethodCallNode.execute(polyglotCallType, symbol.getName(), self, args);

engine/runtime/src/main/java/org/enso/interpreter/node/controlflow/caseexpr/CaseNode.java

@@ -4,6 +4,8 @@
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
+import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
 import com.oracle.truffle.api.nodes.NodeInfo;
 import org.enso.interpreter.node.ExpressionNode;
@@ -69,11 +71,16 @@ public Object doPanicSentinel(VirtualFrame frame, PanicSentinel sentinel) {
     throw sentinel;
   }
 
-  @Specialization
-  Object doWarning(VirtualFrame frame, WithWarnings object) {
-    ArrayRope<Warning> warnings = object.getReassignedWarnings(this);
-    Object result = doMatch(frame, object.getValue());
-    return WithWarnings.appendTo(result, warnings);
+  @Specialization(guards = {"object != null", "warnings.hasWarnings(object)"})
+  Object doWarning(
+      VirtualFrame frame, Object object, @CachedLibrary(limit = "3") WarningsLibrary warnings) {
+    try {
+      Warning[] ws = warnings.getWarnings(object, this);
+      Object result = doMatch(frame, warnings.removeWarnings(object), warnings);
+      return new WithWarnings(result, ws);
+    } catch (UnsupportedMessageException e) {
+      throw new IllegalStateException(e);
+    }
   }
 
   /**
@@ -84,9 +91,14 @@ Object doWarning(VirtualFrame frame, WithWarnings object) {
    * @return the result of executing the case expression on {@code object}
    */
   @Specialization(
-      guards = {"!isDataflowError(object)", "!isPanicSentinel(object)", "!isWarning(object)"})
+      guards = {
+        "!isDataflowError(object)",
+        "!isPanicSentinel(object)",
+        "!warnings.hasWarnings(object)"
+      })
   @ExplodeLoop
-  public Object doMatch(VirtualFrame frame, Object object) {
+  public Object doMatch(
+      VirtualFrame frame, Object object, @CachedLibrary(limit = "3") WarningsLibrary warnings) {
     State state = Function.ArgumentsHelper.getState(frame.getArguments());
     try {
       for (BranchNode branchNode : cases) {
@@ -109,10 +121,6 @@ boolean isPanicSentinel(Object sentinel) {
     return TypesGen.isPanicSentinel(sentinel);
   }
 
-  boolean isWarning(Object warning) {
-    return warning instanceof WithWarnings;
-  }
-
   /* Note [Branch Selection Control Flow]
    * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    * Truffle provides no easy way to return control flow from multiple paths. This is entirely due

engine/runtime/src/main/java/org/enso/interpreter/node/expression/atom/InstantiateNode.java

@@ -2,6 +2,7 @@
 
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
 import com.oracle.truffle.api.nodes.NodeInfo;
 import com.oracle.truffle.api.profiles.BranchProfile;
@@ -10,6 +11,7 @@
 import org.enso.interpreter.runtime.callable.atom.AtomConstructor;
 import org.enso.interpreter.runtime.data.ArrayRope;
 import org.enso.interpreter.runtime.error.Warning;
+import org.enso.interpreter.runtime.error.WarningsLibrary;
 import org.enso.interpreter.runtime.error.WithWarnings;
 import org.enso.interpreter.runtime.type.TypesGen;
 
@@ -21,6 +23,7 @@
 public class InstantiateNode extends ExpressionNode {
   private final AtomConstructor constructor;
   private @Children ExpressionNode[] arguments;
+  private @Child WarningsLibrary warnings = WarningsLibrary.getFactory().createDispatched(3);
   private @CompilationFinal(dimensions = 1) ConditionProfile[] profiles;
   private @CompilationFinal(dimensions = 1) ConditionProfile[] warningProfiles;
   private @CompilationFinal(dimensions = 1) BranchProfile[] sentinelProfiles;
@@ -70,11 +73,14 @@ public Object executeGeneric(VirtualFrame frame) {
       Object argument = arguments[i].executeGeneric(frame);
       if (profile.profile(TypesGen.isDataflowError(argument))) {
         return argument;
-      } else if (warningProfile.profile(argument instanceof WithWarnings)) {
+      } else if (warningProfile.profile(warnings.hasWarnings(argument))) {
         anyWarnings = true;
-        WithWarnings originalArg = (WithWarnings) argument;
-        accumulatedWarnings = accumulatedWarnings.append(originalArg.getReassignedWarnings(this));
-        argumentValues[i] = originalArg.getValue();
+        try {
+          accumulatedWarnings = accumulatedWarnings.append(warnings.getWarnings(argument, this));
+          argumentValues[i] = warnings.removeWarnings(argument);
+        } catch (UnsupportedMessageException e) {
+          throw new IllegalStateException(e);
+        }
       } else if (TypesGen.isPanicSentinel(argument)) {
         sentinelProfile.enter();
         throw TypesGen.asPanicSentinel(argument);

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

@@ -10,13 +10,15 @@
 import org.enso.interpreter.runtime.EnsoContext;
 import org.enso.interpreter.runtime.data.Vector;
 import org.enso.interpreter.runtime.error.DataflowError;
+import org.enso.interpreter.runtime.error.WarningsLibrary;
 
 @BuiltinMethod(
     type = "Vector",
     name = "at",
     description = "Returns an element of Vector at the specified index.")
 public class AtVectorNode extends Node {
   private @Child InteropLibrary interop = InteropLibrary.getFactory().createDispatched(3);
+  private @Child WarningsLibrary warnings = WarningsLibrary.getFactory().createDispatched(3);
   private @Child HostValueToEnsoNode convert = HostValueToEnsoNode.build();
 
   Object execute(Vector self, long index) {
@@ -31,7 +33,7 @@ Object execute(Vector self, long index) {
   private Object readElement(Vector self, long index) throws UnsupportedMessageException {
     try {
       long actualIndex = index < 0 ? index + self.length(interop) : index;
-      return self.readArrayElement(actualIndex, interop, convert);
+      return self.readArrayElement(actualIndex, interop, warnings, convert);
     } catch (InvalidArrayIndexException e) {
       EnsoContext ctx = EnsoContext.get(this);
       return DataflowError.withoutTrace(

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/text/util/ExpectStringNode.java

@@ -5,12 +5,15 @@
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.interop.UnsupportedMessageException;
+import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.nodes.Node;
 import org.enso.interpreter.runtime.EnsoContext;
 import org.enso.interpreter.runtime.builtin.Builtins;
 import org.enso.interpreter.runtime.callable.atom.Atom;
 import org.enso.interpreter.runtime.data.text.Text;
 import org.enso.interpreter.runtime.error.PanicException;
+import org.enso.interpreter.runtime.error.WarningsLibrary;
+import org.enso.interpreter.runtime.error.WithWarnings;
 
 public abstract class ExpectStringNode extends Node {
   private @Child InteropLibrary library = InteropLibrary.getFactory().createDispatched(10);
@@ -31,6 +34,15 @@ String doString(String str) {
     return str;
   }
 
+  @Specialization(guards = "warnings.hasWarnings(warning)")
+  String doWarning(Object warning, @CachedLibrary(limit = "3") WarningsLibrary warnings) {
+    try {
+      return execute(warnings.removeWarnings(warning));
+    } catch (UnsupportedMessageException e) {
+      throw new IllegalStateException(e);
+    }
+  }
+
   @Fallback
   String doFallback(Object str) {
     try {