handle cases where multiple mappings of the same phsyical file shadow

eachother

fixes the following case:
file /foo/bar.cfc
mappings foo.bar and whatever.foo.bar
multiple mappings means there are 2 classfiles for one physical file
breakpoint requests for foo/bar.cfc arrive
sets up jvm breakpoints for one of the classfiles, but not the others

we want to set breakpoints in all related classfiles. presumably
their line mappings will all be the same. the same breakpointIDs
(client visible) should be used for the same line in the same physical
file, across multiple classfiles (so line 2 gets ID x in foo.bar.class
and whatever.foo.bar.class)

Author: softwareCobbler

luceedebug/src/main/java/luceedebug/Agent.java

@@ -173,6 +173,9 @@ private static Map<String, Integer> linearizedCoreInjectClasses() {
             result.put("luceedebug.coreinject.LuceeVm", 0);
             result.put("luceedebug.coreinject.ValTracker$CleanerRunner", 0);
             result.put("luceedebug.coreinject.ExprEvaluator", 0);
+            
+            result.put("luceedebug.coreinject.Iife", 0);
+            result.put("luceedebug.coreinject.Iife$Supplier2", 0);
 
             result.put("luceedebug.coreinject.ExprEvaluator$Evaluator", 0);
             result.put("luceedebug.coreinject.ExprEvaluator$Lucee6Evaluator", 1);

luceedebug/src/main/java/luceedebug/DapServer.java

@@ -390,8 +390,8 @@ public CompletableFuture<SetBreakpointsResponse> setBreakpoints(SetBreakpointsAr
         }
 
         var result = new ArrayList<Breakpoint>();
-        for (var cfBreakpoint : luceeVm_.bindBreakpoints(path, lines, exprs)) {
-            result.add(map_cfBreakpoint_to_lsp4jBreakpoint(cfBreakpoint));
+        for (IBreakpoint bp : luceeVm_.bindBreakpoints(path, lines, exprs)) {
+            result.add(map_cfBreakpoint_to_lsp4jBreakpoint(bp));
         }
 
         var response = new SetBreakpointsResponse();

luceedebug/src/main/java/luceedebug/OriginalAndTransformedString.java

@@ -7,4 +7,13 @@ public OriginalAndTransformedString(String original, String transformed) {
         this.original = original;
         this.transformed = transformed;
     }
+
+    @Override
+    public boolean equals(Object v) {
+        if (v instanceof OriginalAndTransformedString) {
+            var other = (OriginalAndTransformedString)v;
+            return other.original.equals(original) && other.transformed.equals(transformed);
+        }
+        return false;
+    }
 }

luceedebug/src/main/java/luceedebug/coreinject/Iife.java

@@ -0,0 +1,22 @@
+package luceedebug.coreinject;
+
+class Iife {
+    @FunctionalInterface
+    public interface Supplier2<T> {
+        T get() throws Throwable;
+    }
+    
+    @SuppressWarnings("unchecked")
+    static public <T extends Throwable, R> R rethrowUnchecked(Object e) throws T {
+        throw (T) e;
+    }
+
+    static public <T> T iife(Supplier2<T> f) {
+        try {
+            return f.get();
+        }
+        catch (Throwable e) {
+            return rethrowUnchecked(e);
+        }
+    }
+}

luceedebug/src/main/java/luceedebug/coreinject/LuceeVm.java

@@ -2,11 +2,13 @@
 
 import java.lang.ref.Cleaner;
 import java.lang.ref.WeakReference;
+import java.util.Collection;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -24,6 +26,8 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
+import static luceedebug.coreinject.Iife.iife;
+
 import luceedebug.*;
 
 public class LuceeVm implements ILuceeVm {
@@ -122,6 +126,20 @@ private static class ReplayableCfBreakpointRequest {
          * and ask it if it itself is bound? Does `isEnabled` yield that, or is that just "we asked for it to be enabled"?
          */
         final BreakpointRequest maybeNull_jdwpBreakpointRequest;
+
+        @Override
+        public boolean equals(Object vv) {
+            if (!(vv instanceof ReplayableCfBreakpointRequest)) {
+                return false;
+            }
+            var v = (ReplayableCfBreakpointRequest)vv;
+
+            return ideAbsPath.equals(v.ideAbsPath)
+                && serverAbsPath.equals(v.serverAbsPath)
+                && line == v.line
+                && id == v.id
+                && expr.equals(v.expr);
+        }
 
         ReplayableCfBreakpointRequest(String ideAbsPath, String serverAbsPath, int line, int id, String expr) {
             this.ideAbsPath = ideAbsPath;
@@ -141,15 +159,15 @@ private static class ReplayableCfBreakpointRequest {
             this.maybeNull_jdwpBreakpointRequest = jdwpBreakpointRequest;
         }
 
-        static List<BreakpointRequest> getJdwpRequests(ArrayList<ReplayableCfBreakpointRequest> vs) {
+        static List<BreakpointRequest> getJdwpRequests(Collection<ReplayableCfBreakpointRequest> vs) {
             return vs
                 .stream()
                 .filter(v -> v.maybeNull_jdwpBreakpointRequest != null)
                 .map(v -> v.maybeNull_jdwpBreakpointRequest)
                 .collect(Collectors.toList());
         }
 
-        static BpLineAndId[] getLineInfo(ArrayList<ReplayableCfBreakpointRequest> vs) {
+        static BpLineAndId[] getLineInfo(Collection<ReplayableCfBreakpointRequest> vs) {
             return vs
                 .stream()
                 .map(v -> new BpLineAndId(v.ideAbsPath, v.serverAbsPath, v.line, v.id, v.expr))
@@ -159,8 +177,16 @@ static BpLineAndId[] getLineInfo(ArrayList<ReplayableCfBreakpointRequest> vs) {
 
     private final ThreadMap threadMap_ = new ThreadMap();
     private final ExecutorService stepHandlerExecutor = Executors.newSingleThreadExecutor();
-    private final ConcurrentHashMap</*canonical sourceAbsPath*/ String, ArrayList<ReplayableCfBreakpointRequest>> replayableBreakpointRequestsByAbsPath_ = new ConcurrentHashMap<>();
-    private final ConcurrentHashMap</*canonical absPath*/ String, KlassMap> klassMap_ = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap</*canonical sourceAbsPath*/ String, Set<ReplayableCfBreakpointRequest>> replayableBreakpointRequestsByAbsPath_ = new ConcurrentHashMap<>();
+    
+    /**
+     * Mapping of "abspath on disk" -> "class file info"
+     * Where a single path on disk can map to zero-or-more associated class files.
+     * Usually there is only 1 classfile per abspath, but runtime mappings can mean that a single file
+     * like "/app/foo.cfc" maps to "myapp.foo" as well as "someOtherMapping.foo", where each mapping
+     * is represented by a separate classfile.
+     */
+    private final ConcurrentHashMap</*canonical absPath*/ String, Set<KlassMap>> klassMap_ = new ConcurrentHashMap<>();
     private long JDWP_WORKER_CLASS_ID = 0;
     private ThreadReference JDWP_WORKER_THREADREF = null;
 
@@ -570,8 +596,12 @@ private void trackClassRef(ReferenceType refType) {
 
             final var klassMap = maybeNull_klassMap; // definitely non-null
 
-            var replayableBreakpointRequests = replayableBreakpointRequestsByAbsPath_.get(klassMap.sourceName.transformed);
-            klassMap_.put(klassMap.sourceName.transformed, klassMap);
+            Set<ReplayableCfBreakpointRequest> replayableBreakpointRequests = replayableBreakpointRequestsByAbsPath_.get(klassMap.sourceName.transformed);
+
+            klassMap_
+                .computeIfAbsent(klassMap.sourceName.transformed, _z -> new HashSet<>())
+                .add(klassMap);
+
             if (replayableBreakpointRequests != null) {
                 rebindBreakpoints(klassMap.sourceName.transformed, replayableBreakpointRequests);
             }
@@ -737,16 +767,22 @@ static KlassMap maybeNull_tryBuildKlassMap(Config config, ReferenceType refType)
             // unreachable
             return null;
         }
+
+        @Override
+        public boolean equals(Object e) {
+            if (e instanceof KlassMap) {
+                return ((KlassMap)e).sourceName.equals(this.sourceName);
+            }
+            return false;
+        }
     }
 
     private AtomicInteger breakpointID = new AtomicInteger();
     private int nextBreakpointID() {
         return breakpointID.incrementAndGet();
     }
 
-    public void rebindBreakpoints(String serverAbsPath, ArrayList<ReplayableCfBreakpointRequest> cfBpRequests) {
-        System.out.println("Rebinding breakpoints for " + serverAbsPath);
-
+    public void rebindBreakpoints(String serverAbsPath, Collection<ReplayableCfBreakpointRequest> cfBpRequests) {
         var changedBreakpoints = __internal__bindBreakpoints(serverAbsPath, ReplayableCfBreakpointRequest.getLineInfo(cfBpRequests));
 
         if (breakpointsChangedCallback != null) {
@@ -777,8 +813,25 @@ private BpLineAndId[] freshBpLineAndIdRecordsFromLines(OriginalAndTransformedStr
         }
 
         var result = new BpLineAndId[lines.length];
+
+        Set<ReplayableCfBreakpointRequest> bpInfo = replayableBreakpointRequestsByAbsPath_.get(absPath.transformed);
+
         for (var i = 0; i < lines.length; ++i) {
-            result[i] = new BpLineAndId(absPath.original, absPath.transformed, lines[i], nextBreakpointID(), exprs[i]);
+            final int line = lines[i];
+
+            int id = iife(() -> {
+                if (bpInfo == null) {
+                    return nextBreakpointID();
+                }
+                for (var z : bpInfo) {
+                    if (z.line == line) {
+                        return z.id;
+                    }
+                }
+                return nextBreakpointID();
+            });
+
+            result[i] = new BpLineAndId(absPath.original, absPath.transformed, line, id, exprs[i]);
         }
         return result;
     }
@@ -792,12 +845,12 @@ public IBreakpoint[] bindBreakpoints(OriginalAndTransformedString absPath, int[]
      * i.e. the IDE might say "/foo/bar/baz.cfc" but we are only aware of "/app-host-container/foo/bar/baz.cfc" or etc. 
      */
     private IBreakpoint[] __internal__bindBreakpoints(String serverAbsPath, BpLineAndId[] lineInfo) {
-        final var klassMap = klassMap_.get(serverAbsPath);
+        final Set<KlassMap> klassMapSet = klassMap_.get(serverAbsPath);
 
-        if (klassMap == null) {
-            var replayable = new ArrayList<ReplayableCfBreakpointRequest>();
+        if (klassMapSet == null) {
+            var replayable = replayableBreakpointRequestsByAbsPath_.computeIfAbsent(serverAbsPath, _z -> new HashSet<>());
 
-            var result = new Breakpoint[lineInfo.length];
+            IBreakpoint[] result = new Breakpoint[lineInfo.length];
             for (int i = 0; i < lineInfo.length; i++) {
                 final var ideAbsPath = lineInfo[i].ideAbsPath;
                 final var shadow_serverAbsPath = lineInfo[i].serverAbsPath; // should be same as first arg to this method, kind of redundant
@@ -809,12 +862,19 @@ private IBreakpoint[] __internal__bindBreakpoints(String serverAbsPath, BpLineAn
                 replayable.add(new ReplayableCfBreakpointRequest(ideAbsPath, shadow_serverAbsPath, line, id, expr));
             }
 
-            replayableBreakpointRequestsByAbsPath_.put(serverAbsPath, replayable);
-
             return result;
         }
 
-        return __internal__idempotentBindBreakpoints(klassMap, lineInfo);
+        IBreakpoint[] bpListPerMapping = new IBreakpoint[0];
+
+        clearExistingBreakpoints(serverAbsPath);
+
+        for (KlassMap mapping : klassMapSet) {
+            bpListPerMapping = __internal__idempotentBindBreakpoints(mapping, lineInfo);
+        }
+
+        // return just the last one
+        return bpListPerMapping;
     }
 
 
@@ -823,9 +883,7 @@ private IBreakpoint[] __internal__bindBreakpoints(String serverAbsPath, BpLineAn
      * Seems we're not allowed to inspect the jdwp-native id, but we can attach our own
      */
     private IBreakpoint[] __internal__idempotentBindBreakpoints(KlassMap klassMap, BpLineAndId[] lineInfo) {
-        clearExistingBreakpoints(klassMap.sourceName.transformed);
-        
-        final var replayable = new ArrayList<ReplayableCfBreakpointRequest>();
+        final var replayable = replayableBreakpointRequestsByAbsPath_.computeIfAbsent(klassMap.sourceName.transformed, _z -> new HashSet<>());
         final var result = new ArrayList<IBreakpoint>();
 
         for (int i = 0; i < lineInfo.length; ++i) {
@@ -864,7 +922,7 @@ private IBreakpoint[] __internal__idempotentBindBreakpoints(KlassMap klassMap, B
      * returns an array of the line numbers the old breakpoints were bound to
      */
     private void clearExistingBreakpoints(String absPath) {
-        var replayable = replayableBreakpointRequestsByAbsPath_.get(absPath);
+        Set<ReplayableCfBreakpointRequest> replayable = replayableBreakpointRequestsByAbsPath_.get(absPath);
 
         // "just do it" in all cases
         replayableBreakpointRequestsByAbsPath_.remove(absPath);
@@ -1030,7 +1088,9 @@ public String dumpAsJSON(int dapVariablesReference) {
     public String[] getTrackedCanonicalFileNames() {
         final var result = new ArrayList<String>();
         for (var klassMap : klassMap_.values()) {
-            result.add(klassMap.sourceName.transformed);
+            for (var mapping : klassMap) {
+                result.add(mapping.sourceName.transformed);
+            }
         }
         return result.toArray(size -> new String[size]);
     }