Avoid whole source reparsing when the IDE performs a simple edit

CHANGELOG.md

@@ -232,6 +232,7 @@
 - [Fixed compiler issue related to module cache.][3367]
 - [Fixed execution of defaulted arguments of Atom Constructors][3358]
 - [Converting Enso Date to java.time.LocalDate and back][3374]
+- [Incremental Reparsing of a Simple Edits][3508]
 - [Functions with all-defaulted arguments now execute automatically][3414]
 - [Provide `tagValues` for function arguments in the language server][3422]
 - [Delay construction of Truffle nodes to speed initialization][3429]
@@ -255,6 +256,7 @@
 [3360]: https://github.com/enso-org/enso/pull/3360
 [3367]: https://github.com/enso-org/enso/pull/3367
 [3374]: https://github.com/enso-org/enso/pull/3374
+[3508]: https://github.com/enso-org/enso/pull/3508
 [3412]: https://github.com/enso-org/enso/pull/3412
 [3414]: https://github.com/enso-org/enso/pull/3414
 [3417]: https://github.com/enso-org/enso/pull/3417

build.sbt

@@ -1322,8 +1322,10 @@ lazy val `runtime-instrument-runtime-server` = (project in file("engine/runtime-
 lazy val `runtime-with-instruments`  = (project in file("engine/runtime-with-instruments"))
   .configs(Benchmark)
   .settings(
+    frgaalJavaCompilerSetting,
     inConfig(Compile)(truffleRunOptionsSettings),
     inConfig(Benchmark)(Defaults.testSettings),
+    commands += WithDebugCommand.withDebug,
     Benchmark / javacOptions --= Seq("-source", frgaalSourceLevel),
     Test / javaOptions ++= Seq(
       "-Dgraalvm.locatorDisabled=true",
@@ -1335,6 +1337,8 @@ lazy val `runtime-with-instruments`  = (project in file("engine/runtime-with-ins
     ),
     libraryDependencies ++= Seq(
       "org.scalatest"      %% "scalatest"             % scalatestVersion  % Test,
+      "org.graalvm.truffle" % "truffle-api"           % graalVersion      % Test,
+      "org.graalvm.truffle" % "truffle-dsl-processor" % graalVersion      % Test,
     ),
     // Note [Unmanaged Classpath]
     Test / unmanagedClasspath += (baseDirectory.value / ".." / ".." / "app" / "gui" / "view" / "graph-editor" / "src" / "builtin" / "visualization" / "native" / "inc"),

engine/runtime-instrument-id-execution/src/main/java/org/enso/interpreter/instrument/IdExecutionInstrument.java

@@ -1,6 +1,7 @@
 package org.enso.interpreter.instrument;
 
 import com.oracle.truffle.api.CallTarget;
+import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.Truffle;
 import com.oracle.truffle.api.frame.FrameInstance;
 import com.oracle.truffle.api.frame.FrameInstanceVisitor;
@@ -9,25 +10,25 @@
 import com.oracle.truffle.api.interop.InteropException;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.nodes.Node;
-import com.oracle.truffle.api.nodes.RootNode;
-import org.enso.interpreter.instrument.execution.LocationFilter;
+import com.oracle.truffle.api.source.SourceSection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
 import org.enso.interpreter.instrument.execution.Timer;
 import org.enso.interpreter.instrument.profiling.ExecutionTime;
 import org.enso.interpreter.instrument.profiling.ProfilingInfo;
-import org.enso.interpreter.node.EnsoRootNode;
 import org.enso.interpreter.node.ExpressionNode;
-import org.enso.interpreter.node.MethodRootNode;
 import org.enso.interpreter.node.callable.FunctionCallInstrumentationNode;
 import org.enso.interpreter.runtime.control.TailCallException;
 import org.enso.interpreter.runtime.error.PanicException;
 import org.enso.interpreter.runtime.error.PanicSentinel;
 import org.enso.interpreter.runtime.tag.IdentifiedTag;
 import org.enso.interpreter.runtime.type.Types;
-import org.enso.logger.masking.MaskedString;
-import org.enso.pkg.QualifiedName;
+import org.enso.interpreter.runtime.Module;
 
-import java.util.*;
 import java.util.function.Consumer;
+import org.enso.interpreter.node.ClosureRootNode;
+import org.enso.interpreter.runtime.tag.AvoidIdInstrumentationTag;
 
 /** An instrument for getting values from AST-identified expressions. */
 @TruffleInstrument.Registration(
@@ -231,6 +232,8 @@ public void onReturnExceptional(EventContext context, VirtualFrame frame, Throwa
             context, frame, new PanicSentinel(panicException, context.getInstrumentedNode()));
       } else if (exception instanceof PanicSentinel) {
         onReturnValue(context, frame, exception);
+      } else if (UNWIND_HELPER.patchedValue(exception) != null) {
+        onReturnValue(context, frame, UNWIND_HELPER.patchedValue(exception));
       }
     }
 
@@ -278,8 +281,8 @@ private UUID getNodeId(Node node) {
   /**
    * Attach a new listener to observe identified nodes within given function.
    *
+   * @param module module that contains the code
    * @param entryCallTarget the call target being observed.
-   * @param locationFilter the location filter.
    * @param cache the precomputed expression values.
    * @param methodCallsCache the storage tracking the executed method calls.
    * @param syncState the synchronization state of runtime updates.
@@ -292,8 +295,8 @@ private UUID getNodeId(Node node) {
    */
   @Override
   public EventBinding<ExecutionEventListener> bind(
+      Module module,
       CallTarget entryCallTarget,
-      LocationFilter locationFilter,
       RuntimeCache cache,
       MethodCallsCache methodCallsCache,
       UpdatesSynchronizationState syncState,
@@ -302,12 +305,17 @@ public EventBinding<ExecutionEventListener> bind(
       Consumer<IdExecutionInstrument.ExpressionValue> onComputedCallback,
       Consumer<IdExecutionInstrument.ExpressionValue> onCachedCallback,
       Consumer<Exception> onExceptionalCallback) {
-    SourceSectionFilter filter =
-        SourceSectionFilter.newBuilder()
-            .tagIs(StandardTags.ExpressionTag.class, StandardTags.CallTag.class)
-            .tagIs(IdentifiedTag.class)
-            .sourceSectionEquals(locationFilter.getSections())
-            .build();
+    var builder = SourceSectionFilter.newBuilder()
+          .tagIs(StandardTags.ExpressionTag.class, StandardTags.CallTag.class)
+          .tagIs(IdentifiedTag.class)
+          .tagIsNot(AvoidIdInstrumentationTag.class)
+          .sourceIs(module::isModuleSource);
+
+    if (entryCallTarget instanceof RootCallTarget r && r.getRootNode() instanceof ClosureRootNode c && c.getSourceSection() != null) {
+      SourceSection s = c.getSourceSection();
+      builder.lineIn(SourceSectionFilter.IndexRange.between(s.getStartLine(), s.getEndLine() + 1));
+    }
+    SourceSectionFilter filter = builder.build();
 
     return env.getInstrumenter()
         .attachExecutionEventListener(

engine/runtime-with-instruments/src/test/java/org/enso/interpreter/test/NodeCountingTestInstrument.java

@@ -0,0 +1,86 @@
+package org.enso.interpreter.test;
+
+import com.oracle.truffle.api.instrumentation.EventContext;
+import com.oracle.truffle.api.instrumentation.ExecutionEventNode;
+import com.oracle.truffle.api.instrumentation.ExecutionEventNodeFactory;
+import com.oracle.truffle.api.instrumentation.SourceSectionFilter;
+import com.oracle.truffle.api.instrumentation.TruffleInstrument;
+import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.source.SourceSection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.function.Function;
+import static org.junit.Assert.fail;
+
+/** Testing instrument to control newly created nodes. */
+@TruffleInstrument.Registration(
+    id = NodeCountingTestInstrument.INSTRUMENT_ID,
+    services = NodeCountingTestInstrument.class)
+public class NodeCountingTestInstrument extends TruffleInstrument {
+  public static final String INSTRUMENT_ID = "node-count-test";
+  private Map<Node, Node> all = new ConcurrentHashMap<>();
+  private Map<Class, List<Node>> counter = new ConcurrentHashMap<>();
+  private Env env;
+
+  @Override
+  protected void onCreate(Env env) {
+    env.registerService(this);
+    this.env = env;
+  }
+
+  public void enable() {
+    this.env
+        .getInstrumenter()
+        .attachExecutionEventFactory(SourceSectionFilter.ANY, new CountingFactory());
+  }
+
+  public Map<Class, List<Node>> assertNewNodes(String msg, int min, int max) {
+    Map<Class, List<Node>> prev = counter;
+    long value = prev.values().stream().mapToInt(List::size).sum();
+
+    Function<String, String> dump =
+        (txt) -> {
+          var sb = new StringBuilder(txt);
+          prev.values().stream()
+              .forEach(
+                  (t) -> {
+                    t.forEach(
+                        (n) -> {
+                          dumpNode("", n, sb);
+                        });
+                  });
+          return sb.toString();
+        };
+
+    if (value < min) {
+      fail(dump.apply(msg + ". Minimal size should be " + min + ", but was: " + value + " in"));
+    }
+    if (value > max) {
+      fail(dump.apply(msg + ". Maximal size should be " + max + ", but was: " + value + " in"));
+    }
+    counter = new ConcurrentHashMap<>();
+    return prev;
+  }
+
+  private void dumpNode(String indent, Node n, StringBuilder sb) {
+    sb.append("\n").append(indent);
+    sb.append(n.getClass().getName());
+    final SourceSection ss = n.getSourceSection();
+    if (ss != null) {
+      sb.append(" @ ").append(ss.getSource().getName()).append(":").append(ss.getStartLine());
+    }
+  }
+
+  private final class CountingFactory implements ExecutionEventNodeFactory {
+    @Override
+    public ExecutionEventNode create(EventContext context) {
+      final Node node = context.getInstrumentedNode();
+      if (all.put(node, node) == null) {
+        counter.computeIfAbsent(node.getClass(), (__) -> new CopyOnWriteArrayList<>()).add(node);
+      }
+      return null;
+    }
+  }
+}