Removing Unsafe.set_atom_field

distribution/lib/Standard/Base/0.0.0-dev/src/Data/List.enso

@@ -7,7 +7,7 @@ import project.Data.Vector.Vector
 import project.Error.Error
 import project.Function.Function
 import project.Nothing.Nothing
-import project.Runtime.Unsafe
+import project.Meta
 
 from project.Data.Boolean import Boolean, True, False
 
@@ -209,9 +209,18 @@ type List
     map self f = case self of
         Nil -> Nil
         Cons h t ->
-            res = Cons (f h) Nil
-            map_helper t res f
-            res
+            go : List -> Any -> (Any -> Any) -> Nothing
+            go list fill = case list of
+                Nil -> fill Nil
+                Cons h t ->
+                    v = f h
+                    res = Meta.lazy_atom (e -> Cons v e)
+                    fill (res.at 0)
+                    @Tail_Call go t (res.at 1)
+            v = f h
+            res = Meta.lazy_atom (e -> Cons v e)
+            go t (res.at 1)
+            res.at 0
 
     ## Applies a function to each element of the list.
 
@@ -379,21 +388,3 @@ type Empty_Error
     to_display_text : Text
     to_display_text self = "The List is empty."
 
-## PRIVATE
-   A helper for the `map` function.
-
-   Arguments:
-   - list: The list to map over.
-   - cons: The current field to set.
-   - f: The function to apply to the value.
-
-   Uses unsafe field mutation under the hood, to rewrite `map` in
-   a tail-recursive manner. The mutation is purely internal and does not leak
-   to the user-facing API.
-map_helper : List -> Any -> (Any -> Any) -> Nothing
-map_helper list cons f = case list of
-    Nil -> Unsafe.set_atom_field cons 1 Nil
-    Cons h t ->
-        res = Cons (f h) Nil
-        Unsafe.set_atom_field cons 1 res
-        @Tail_Call map_helper t res f

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

@@ -273,6 +273,9 @@ get_constructor_name atom_constructor = @Builtin_Method "Meta.get_constructor_na
 new_atom : Any -> Array -> Atom
 new_atom constructor fields = @Builtin_Method "Meta.new_atom"
 
+lazy_atom : (Any -> Atom) -> Atom
+lazy_atom constructor fields = @Builtin_Method "Meta.lazy_atom"
+
 ## UNSTABLE
    ADVANCED
 

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

@@ -0,0 +1,163 @@
+package org.enso.interpreter.node.expression.builtin.meta;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.dsl.Cached;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.interop.ArityException;
+import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.interop.TruffleObject;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
+import com.oracle.truffle.api.interop.UnsupportedTypeException;
+import com.oracle.truffle.api.library.CachedLibrary;
+import com.oracle.truffle.api.library.ExportLibrary;
+import com.oracle.truffle.api.library.ExportMessage;
+import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.nodes.RootNode;
+import org.enso.interpreter.dsl.BuiltinMethod;
+import org.enso.interpreter.runtime.EnsoContext;
+import org.enso.interpreter.runtime.callable.argument.ArgumentDefinition;
+import org.enso.interpreter.runtime.callable.argument.CallArgumentInfo;
+import org.enso.interpreter.runtime.callable.atom.Atom;
+import org.enso.interpreter.runtime.callable.function.Function;
+import org.enso.interpreter.runtime.callable.function.FunctionSchema;
+import org.enso.interpreter.runtime.data.Array;
+import org.enso.interpreter.runtime.data.Vector;
+import org.enso.interpreter.runtime.error.PanicException;
+
+@BuiltinMethod(
+    type = "Meta",
+    name = "lazy_atom",
+    description = "Creates a new atom with given constructor and fields.",
+    autoRegister = false)
+public abstract class LazyAtomInstanceNode extends Node {
+
+  static LazyAtomInstanceNode build() {
+    return LazyAtomInstanceNodeGen.create();
+  }
+
+  abstract Vector execute(Object factory);
+
+  @Specialization(guards = "iop.isExecutable(factory)")
+  Vector doExecute(
+    Object factory,
+    @CachedLibrary(limit="3") InteropLibrary iop,
+    @Cached SwapAtomFieldNode swapNode
+  ) {
+    var ctx = EnsoContext.get(this);
+    var lazy = new HoleInAtom();
+    try {
+      var r = iop.execute(factory, lazy);
+      if (r instanceof Atom a) {
+        var i = swapNode.findHoleIndex(a, lazy);
+        if (i >= 0) {
+          var function = swapNode.createFn(a, i, lazy);
+          return Vector.fromArray(new Array(a, function));
+        }
+      }
+      throw new PanicException(ctx.getBuiltins().error().makeUninitializedStateError(r), this);
+    } catch (UnsupportedTypeException ex) {
+      throw raise(RuntimeException.class, ex);
+    } catch (ArityException ex) {
+      throw raise(RuntimeException.class, ex);
+    } catch (UnsupportedMessageException ex) {
+      throw raise(RuntimeException.class, ex);
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  private static <E extends Exception> E raise(Class<E> type, Throwable t) throws E {
+    throw (E)t;
+  }
+
+  @ExportLibrary(InteropLibrary.class)
+  static final class HoleInAtom implements TruffleObject {
+    HoleInAtom() {
+    }
+
+    @ExportMessage
+    String toDisplayString(boolean pure) {
+      return "Meta.lazy_atom";
+    }
+  }
+  static final class SwapAtomFieldNode extends RootNode {
+    private final FunctionSchema schema;
+    @CompilerDirectives.CompilationFinal
+    private int lastIndex = -1;
+
+    private SwapAtomFieldNode() {
+      super(null);
+      this.schema = new FunctionSchema(FunctionSchema.CallerFrameAccess.NONE, new ArgumentDefinition[]{
+        new ArgumentDefinition(0, "instance", ArgumentDefinition.ExecutionMode.EXECUTE),
+        new ArgumentDefinition(1, "lazy_index", ArgumentDefinition.ExecutionMode.EXECUTE),
+        new ArgumentDefinition(2, "lazy", ArgumentDefinition.ExecutionMode.EXECUTE),
+        new ArgumentDefinition(3, "value", ArgumentDefinition.ExecutionMode.EXECUTE)
+      }, new boolean[]{
+        true, true, true, false
+      }, new CallArgumentInfo[0]);
+    }
+
+    static SwapAtomFieldNode create() {
+      return new SwapAtomFieldNode();
+    }
+
+    int findHoleIndex(Atom atom, HoleInAtom lazy) {
+      var arr = atom.getFields();
+      if (lastIndex >= 0 && lastIndex < arr.length) {
+        if (arr[lastIndex] == lazy) {
+          return lastIndex;
+        }
+      }
+      int index = findHoleIndexLoop(arr, lazy);
+      if (index == -1) {
+        return -1;
+      }
+      if (lastIndex == -1) {
+        lastIndex = index;
+        CompilerDirectives.transferToInterpreterAndInvalidate();
+        return index;
+      } else {
+        if (lastIndex != -2) {
+          CompilerDirectives.transferToInterpreterAndInvalidate();
+          lastIndex = -2;
+        }
+      }
+      return index;
+    }
+
+    @CompilerDirectives.TruffleBoundary
+    private int findHoleIndexLoop(Object[] arr, HoleInAtom lazy) {
+        for (int i = 0; i < arr.length; i++) {
+          if (arr[i] == lazy) {
+            return i;
+          }
+        }
+        return -1;
+    }
+
+    Function createFn(Atom atom, int index, HoleInAtom lazy) {
+      var preArgs = new Object[]{atom, index, lazy, null};
+      return new Function(
+              getCallTarget(),
+              null,
+              schema,
+              preArgs,
+              new Object[]{}
+      );
+    }
+
+    @Override
+    public Object execute(VirtualFrame frame) {
+      var args = Function.ArgumentsHelper.getPositionalArguments(frame.getArguments());
+      if (args[0] instanceof Atom replace) {
+        if (args[1] instanceof Integer n) {
+          var fields = replace.getFields();
+          if (fields[n.intValue()] == args[2]) {
+            fields[n.intValue()] = args[3];
+          }
+        }
+      }
+      return EnsoContext.get(this).getBuiltins().nothing();
+    }
+  }
+}

engine/runtime/src/test/java/org/enso/interpreter/test/DebuggingEnsoTest.java

@@ -613,69 +613,6 @@ public String toString() {
     }
   }
 
-  // TODO[PM]: Re-enable (https://www.pivotaltracker.com/story/show/183854585)
-  @Test
-  @Ignore
-  public void unsafeRecursiveAtom() throws Exception {
-    Engine eng = Engine.newBuilder()
-      .allowExperimentalOptions(true)
-      .option(
-        RuntimeOptions.LANGUAGE_HOME_OVERRIDE,
-        Paths.get("../../test/micro-distribution/component").toFile().getAbsolutePath()
-      ).build();
-    Context ctx = Context.newBuilder()
-      .engine(eng)
-      .allowIO(true)
-      .allowHostClassLoading(true)
-      .allowHostClassLookup((c) -> true)
-      .build();
-    final Map<String, Language> langs = ctx.getEngine().getLanguages();
-    org.junit.Assert.assertNotNull("Enso found: " + langs, langs.get("enso"));
-
-    final URI onceUri = new URI("memory://once.enso");
-    final Source onesSrc = Source.newBuilder("enso", """
-        import Standard.Base.Runtime.Unsafe
-
-        type Gen
-            Empty
-            Generator a:Int tail:Gen
-
-        ones : Gen
-        ones =
-            g = Gen.Generator 1 Gen.Empty
-            Unsafe.set_atom_field g 1 g
-            g
-
-        next g = case g of
-            Gen.Generator a tail -> a
-            Gen.Empty -> -1
-        """, "ones.enso")
-            .uri(onceUri)
-            .buildLiteral();
-
-    var module = ctx.eval(onesSrc);
-    var ones = module.invokeMember("eval_expression", "ones");
-    var next = module.invokeMember("eval_expression", "next");
-
-
-    final var dbg = Debugger.find(eng);
-    final var values = new HashSet<String>();
-    try (var session = dbg.startSession((event) -> {
-      final DebugValue gVariable = findDebugValue(event, "g");
-      if (gVariable != null) {
-        final String str = gVariable.toDisplayString(false);
-        assertNotNull("The string shall always be computed for " + gVariable, str);
-        values.add(str);
-      }
-      event.getSession().suspendNextExecution();
-    })) {
-      session.suspendNextExecution();
-      var one = next.execute(ones);
-      Assert.assertEquals("First element from list of ones", 1, one.asInt());
-    }
-    Assert.assertEquals("Some values of g variable found: " + values, 1, values.size());
-  }
-
   private static DebugValue findDebugValue(SuspendedEvent event, final String n) throws DebugException {
     for (var v : event.getTopStackFrame().getScope().getDeclaredValues()) {
       if (v.getName().contains(n)) {

project/FrgaalJavaCompiler.scala

@@ -118,7 +118,11 @@ object FrgaalJavaCompiler {
     }
 
     val (withTarget, noTarget) = sources0.partition(checkTarget)
-    val in = findUnder(3, noTarget.tail.fold(asPath(noTarget.head))(asCommon).asInstanceOf[Path])
+    val in = if (noTarget.isEmpty) {
+      None
+    } else {
+      Some(findUnder(3, noTarget.tail.fold(asPath(noTarget.head))(asCommon).asInstanceOf[Path]))
+    }
     val generated = if (withTarget.isEmpty) {
       None
     } else {
@@ -133,8 +137,9 @@ object FrgaalJavaCompiler {
       def storeArray(name: String, values : Seq[String]) = {
         values.zipWithIndex.foreach { case (value, idx) => ensoProperties.setProperty(s"$name.$idx", value) }
       }
-
-      ensoProperties.setProperty("input", in.toString())
+      if (in.isDefined) {
+        ensoProperties.setProperty("input", in.get.toString())
+      }
       if (generated.isDefined) {
         ensoProperties.setProperty("generated", generated.get.toString())
       }