JavaScript Type reading of cyclic types from Java -> TypeScript process (#6126)

Author: jkschneider

.idea/icon.png

@@ -268,14 +268,14 @@ public String toString() {
     }
 
     public static boolean isLocalAndHasNoChanges(@Nullable SourceFile before, @Nullable SourceFile after) {
-        try {
-            return (before == after) ||
-                    (before != null && after != null &&
-                            // Remote source files are fetched on `printAll`, let's avoid that cost.
-                            !(before instanceof Remote) && !(after instanceof Remote) &&
-                            before.printAll().equals(after.printAll()));
-        } catch (Exception e) {
+//        try {
+//            return (before == after) ||
+//                    (before != null && after != null &&
+//                            // Remote source files are fetched on `printAll`, let's avoid that cost.
+//                            !(before instanceof Remote) && !(after instanceof Remote) &&
+//                            before.printAll().equals(after.printAll()));
+//        } catch (Exception e) {
             return false;
-        }
+//        }
     }
 }

rewrite-core/src/main/java/org/openrewrite/Result.java

@@ -502,8 +502,8 @@ public static <T> List<T> insertAll(@Nullable List<T> ls, int index, @Nullable L
      * @param <T>   The type of elements in the list.
      * @return The array representation of the list, or null if the list is empty.
      */
-    public static <T> T @Nullable [] arrayOrNullIfEmpty(@Nullable List<T> list, T[] array) {
-        if (list == null || list.isEmpty()) {
+    public static <T> T @Nullable [] arrayOrNullIfEmpty(@Nullable List<T> list, T @Nullable [] array) {
+        if (list == null || array == null || list.isEmpty()) {
             return null;
         }
         return list.toArray(array);

rewrite-core/src/main/java/org/openrewrite/internal/ListUtils.java

@@ -33,6 +33,7 @@
 import org.openrewrite.tree.ParsingEventListener;
 import org.openrewrite.tree.ParsingExecutionContextView;
 
+import java.io.PrintStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.Duration;
@@ -42,6 +43,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
@@ -62,6 +64,9 @@ public class RewriteRpc {
     private final AtomicInteger batchSize = new AtomicInteger(200);
     private Duration timeout = Duration.ofSeconds(30);
     private Supplier<? extends @Nullable RuntimeException> livenessCheck = () -> null;
+    private final AtomicReference<PrintStream> log = new AtomicReference<>();
+    private final AtomicReference<TraceGetObject> traceGetObject = new AtomicReference<>(
+            new TraceGetObject(false, false));
 
     final PreparedRecipeCache preparedRecipes = new PreparedRecipeCache();
 
@@ -102,13 +107,21 @@ public RewriteRpc(JsonRpc jsonRpc, Environment marketplace) {
                 this::getObject, this::getCursor));
         jsonRpc.rpc("Generate", new Generate.Handler(localObjects, preparedRecipes,
                 this::getObject));
-        jsonRpc.rpc("GetObject", new GetObject.Handler(batchSize, remoteObjects, localObjects, localRefs));
+        jsonRpc.rpc("GetObject", new GetObject.Handler(batchSize, remoteObjects, localObjects,
+                localRefs, log, () -> traceGetObject.get().isSend()));
         jsonRpc.rpc("GetRecipes", new JsonRpcMethod<Void>() {
             @Override
             protected Object handle(Void noParams) {
                 return marketplace.listRecipeDescriptors();
             }
         });
+        jsonRpc.rpc("TraceGetObject", new JsonRpcMethod<TraceGetObject>() {
+            @Override
+            protected Boolean handle(TraceGetObject request) {
+                traceGetObject.set(request);
+                return true;
+            }
+        });
         jsonRpc.rpc("GetLanguages", new JsonRpcMethod<Void>() {
             @Override
             protected Object handle(Void noParams) {
@@ -150,7 +163,17 @@ public RewriteRpc batchSize(int batchSize) {
         return this;
     }
 
+    public RewriteRpc log(@Nullable PrintStream logFile) {
+        //noinspection DataFlowIssue
+        this.log.set(logFile);
+        return this;
+    }
+
     public void shutdown() {
+        //noinspection ConstantValue
+        if (log.get() != null) {
+            log.get().close();
+        }
         jsonRpc.shutdown();
     }
 
@@ -312,7 +335,10 @@ public boolean tryAdvance(Consumer<? super SourceFile> action) {
                 SourceFile sourceFile = null;
                 parsingListener.startedParsing(input);
                 try {
-                    sourceFile = parser.requirePrintEqualsInput(getObject(id, sourceFileType), input, relativeTo, ctx);
+                    // input.getRelativePath(relativeTo)
+                    sourceFile = getObject(id, sourceFileType);
+                    // TODO this should be handled on the remote side.
+//                    sourceFile = parser.requirePrintEqualsInput(sourceFile, input, relativeTo, ctx);
                 } catch (Exception e) {
                     sourceFile = ParseError.build(parser, input, relativeTo, ctx, e);
                 } finally {
@@ -355,18 +381,25 @@ public String print(Tree tree, Cursor parent) {
 
     public String print(Tree tree, Cursor parent, Print.@Nullable MarkerPrinter markerPrinter) {
         localObjects.put(tree.getId().toString(), tree);
+        SourceFile sourceFile = tree instanceof SourceFile ? (SourceFile) tree : parent.firstEnclosingOrThrow(SourceFile.class);
         return send(
                 "Print",
                 new Print(
                         tree.getId().toString(),
-                        (tree instanceof SourceFile ? tree : parent.firstEnclosingOrThrow(SourceFile.class))
-                                .getClass().getName(),
+                        sourceFile.getSourcePath(),
+                        sourceFile.getClass().getName(),
                         markerPrinter
                 ),
                 String.class
         );
     }
 
+    public RewriteRpc traceGetObject(boolean receive, boolean send) {
+        this.traceGetObject.set(new TraceGetObject(receive, send));
+        send("TraceGetObject", new TraceGetObject(receive, send), Boolean.class);
+        return this;
+    }
+
     @VisibleForTesting
     @Nullable
     List<String> getCursorIds(@Nullable Cursor cursor) {
@@ -391,20 +424,22 @@ public <T> T getObject(String id, @Nullable String sourceFileType) {
         RpcReceiveQueue q = new RpcReceiveQueue(
                 remoteRefs,
                 () -> send("GetObject", new GetObject(id, sourceFileType), GetObjectResponse.class),
-                sourceFileType
+                sourceFileType,
+                log.get()
         );
         Object remoteObject = q.receive(localObject, null);
         if (q.take().getState() != END_OF_OBJECT) {
             throw new IllegalStateException("Expected END_OF_OBJECT");
         }
 
+        //noinspection ConstantValue
         if (remoteObject != null) {
             // We are now in sync with the remote state of the object.
             remoteObjects.put(id, requireNonNull(remoteObject));
             localObjects.put(id, remoteObject);
         }
 
-        //noinspection unchecked,DataFlowIssue
+        //noinspection unchecked
         return (T) remoteObject;
     }
 

rewrite-core/src/main/java/org/openrewrite/rpc/RewriteRpc.java

@@ -26,9 +26,8 @@
 import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
-import lombok.RequiredArgsConstructor;
 import lombok.Value;
-import lombok.experimental.NonFinal;
+import lombok.With;
 import org.jspecify.annotations.Nullable;
 import org.openrewrite.Tree;
 
@@ -39,7 +38,6 @@
  */
 @Value
 @NoArgsConstructor(force = true, access = AccessLevel.PRIVATE, onConstructor_ = @JsonCreator)
-@RequiredArgsConstructor
 public class RpcObjectData {
     private static final ObjectMapper mapper = JsonMapper.builder()
             // to be able to construct classes that have @Data and a single field
@@ -86,13 +84,18 @@ public class RpcObjectData {
      * useful in debugging asymmetries between senders/receivers.
      */
     @Nullable
-    @NonFinal
-    String trace = Trace.traceSender();
+    String trace;
 
-    public RpcObjectData withTrace() {
-        RpcObjectData d = new RpcObjectData(state, valueType, value, ref);
-        d.trace = null;
-        return d;
+    public RpcObjectData(State state, @Nullable String valueType, @Nullable Object value, @Nullable Integer ref, boolean trace) {
+        this.state = state;
+        this.valueType = valueType;
+        this.value = value;
+        this.ref = ref;
+        this.trace = trace ? Trace.traceSender() : null;
+    }
+
+    public RpcObjectData withoutTrace() {
+        return new RpcObjectData(state, valueType, value, ref, false);
     }
 
     public <V> @Nullable V getValue() {

rewrite-core/src/main/java/org/openrewrite/rpc/RpcObjectData.java

@@ -18,6 +18,7 @@
 import org.jspecify.annotations.Nullable;
 import org.objenesis.ObjenesisStd;
 
+import java.io.PrintStream;
 import java.util.*;
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -32,11 +33,13 @@ public class RpcReceiveQueue {
     private final Map<Integer, Object> refs;
     private final Supplier<List<RpcObjectData>> pull;
     private final @Nullable String sourceFileType;
+    private final @Nullable PrintStream log;
 
     public RpcReceiveQueue(Map<Integer, Object> refs, Supplier<List<RpcObjectData>> pull,
-                           @Nullable String sourceFileType) {
+                           @Nullable String sourceFileType, @Nullable PrintStream log) {
         this.refs = refs;
         this.sourceFileType = sourceFileType;
+        this.log = log;
         this.batch = new ArrayDeque<>();
         this.pull = pull;
     }
@@ -93,7 +96,7 @@ public <T> T receive(@Nullable T before) {
     @SuppressWarnings("DataFlowIssue")
     public <T> T receive(@Nullable T before, @Nullable UnaryOperator<T> onChange) {
         RpcObjectData message = take();
-        Trace.traceReceiver(message);
+        Trace.traceReceiver(message, log);
         Integer ref = null;
         switch (message.getState()) {
             case NO_CHANGE:
@@ -150,6 +153,7 @@ public <T> T receive(@Nullable T before, @Nullable UnaryOperator<T> onChange) {
     @SuppressWarnings("DataFlowIssue")
     public <T> List<T> receiveList(@Nullable List<T> before, @Nullable UnaryOperator<T> onChange) {
         RpcObjectData msg = take();
+        Trace.traceReceiver(msg, log);
         switch (msg.getState()) {
             case NO_CHANGE:
                 return before;

rewrite-core/src/main/java/org/openrewrite/rpc/RpcReceiveQueue.java

@@ -32,16 +32,18 @@ public class RpcSendQueue {
     private final Consumer<List<RpcObjectData>> drain;
     private final IdentityHashMap<Object, Integer> refs;
     private final @Nullable String sourceFileType;
+    private final boolean trace;
 
     private @Nullable Object before;
 
     public RpcSendQueue(int batchSize, ThrowingConsumer<List<RpcObjectData>> drain, IdentityHashMap<Object, Integer> refs,
-                        @Nullable String sourceFileType) {
+                        @Nullable String sourceFileType, boolean trace) {
         this.batchSize = batchSize;
         this.batch = new ArrayList<>(batchSize);
         this.drain = drain;
         this.refs = refs;
         this.sourceFileType = sourceFileType;
+        this.trace = trace;
     }
 
     public void put(RpcObjectData rpcObjectData) {
@@ -103,14 +105,14 @@ public <T> void send(@Nullable T after, @Nullable T before, @Nullable Runnable o
         Object beforeVal = Reference.getValue(before);
 
         if (beforeVal == afterVal) {
-            put(new RpcObjectData(NO_CHANGE, null, null, null));
+            put(new RpcObjectData(NO_CHANGE, null, null, null, trace));
         } else if (beforeVal == null) {
             add(after, onChange);
         } else if (afterVal == null) {
-            put(new RpcObjectData(DELETE, null, null, null));
+            put(new RpcObjectData(DELETE, null, null, null, trace));
         } else {
             RpcCodec<Object> afterCodec = RpcCodec.forInstance(afterVal, sourceFileType);
-            put(new RpcObjectData(CHANGE, getValueType(afterVal), onChange == null && afterCodec == null ? afterVal : null, null));
+            put(new RpcObjectData(CHANGE, getValueType(afterVal), onChange == null && afterCodec == null ? afterVal : null, null, trace));
             doChange(after, before, onChange, afterCodec);
         }
     }
@@ -133,9 +135,9 @@ <T> void sendList(@Nullable List<T> after,
                 } else {
                     T aBefore = before == null ? null : before.get(beforePos);
                     if (aBefore == anAfter) {
-                        put(new RpcObjectData(NO_CHANGE, null, null, null));
+                        put(new RpcObjectData(NO_CHANGE, null, null, null, trace));
                     } else {
-                        put(new RpcObjectData(CHANGE, getValueType(anAfter), null, null));
+                        put(new RpcObjectData(CHANGE, getValueType(anAfter), null, null, trace));
                         doChange(anAfter, aBefore, onChangeRun, RpcCodec.forInstance(anAfter, sourceFileType));
                     }
                 }
@@ -155,7 +157,7 @@ private <T> Map<Object, Integer> putListPositions(List<T> after, @Nullable List<
             Integer beforePos = beforeIdx.get(id.apply(t));
             positions.add(beforePos == null ? ADDED_LIST_ITEM : beforePos);
         }
-        put(new RpcObjectData(CHANGE, null, positions, null));
+        put(new RpcObjectData(CHANGE, null, positions, null, trace));
         return beforeIdx;
     }
 
@@ -164,7 +166,7 @@ private void add(Object after, @Nullable Runnable onChange) {
         Integer ref = null;
         if (after instanceof Reference) {
             if (refs.containsKey(afterVal)) {
-                put(new RpcObjectData(ADD, null, null, refs.get(afterVal)));
+                put(new RpcObjectData(ADD, null, null, refs.get(afterVal), trace));
                 // No onChange call because the remote will be using an instance from its ref cache
                 return;
             }
@@ -173,7 +175,7 @@ private void add(Object after, @Nullable Runnable onChange) {
         }
         RpcCodec<Object> afterCodec = RpcCodec.forInstance(afterVal, sourceFileType);
         put(new RpcObjectData(ADD, getValueType(afterVal),
-                onChange == null && afterCodec == null ? afterVal : null, ref));
+                onChange == null && afterCodec == null ? afterVal : null, ref, trace));
         doChange(afterVal, null, onChange, afterCodec);
     }
 

rewrite-core/src/main/java/org/openrewrite/rpc/RpcSendQueue.java

@@ -16,6 +16,7 @@
 package org.openrewrite.rpc;
 
 import org.jspecify.annotations.Nullable;
+import org.openrewrite.PathUtils;
 
 import java.io.File;
 import java.io.IOException;
@@ -32,21 +33,17 @@
 public class Trace {
     private static final Trace.StackElementSourceLookup sourceLookup = new Trace.StackElementSourceLookup();
 
-    public static boolean TRACE_SENDER = false;
-    public static @Nullable PrintStream TRACE_RECEIVER = null;
-
-    public static void traceReceiver(RpcObjectData message) {
-        PrintStream logFile = TRACE_RECEIVER;
+    public static void traceReceiver(RpcObjectData message, @Nullable PrintStream logFile) {
         if (logFile != null && message.getTrace() != null) {
-            logFile.println(message.withTrace());
+            logFile.println(message.withoutTrace());
             logFile.println("  " + message.getTrace());
             logFile.println("  " + trace("Receiver"));
             logFile.flush();
         }
     }
 
-    public static @Nullable String traceSender() {
-        return TRACE_SENDER ? trace("Sender") : null;
+    public static String traceSender() {
+        return trace("Sender");
     }
 
     private static String trace(String type) {