Fix breakpoints in classes with inner/anonymous classes

Author: georgewfraser

src/main/java/org/javacs/debug/JavaDebugServer.java

@@ -159,7 +159,10 @@ private Breakpoint enableBreakpoint(Source source, SourceBreakpoint b) {
         }
         // Check for breakpoint in loaded classes
         for (var type : loadedTypesMatching(source.path)) {
-            return enableBreakpointImmediately(source, b, type);
+            var ok = enableBreakpointImmediately(source, b, type);
+            if (ok != null) {
+                return ok;
+            }
         }
         // If class hasn't been loaded, add breakpoint to pending list
         return enableBreakpointLater(source, b);
@@ -206,10 +209,7 @@ private Breakpoint enableDisabledBreakpoint(Source source, BreakpointRequest b)
 
     private Breakpoint enableBreakpointImmediately(Source source, SourceBreakpoint b, ReferenceType type) {
         if (!tryEnableBreakpointImmediately(source, b, type)) {
-            var failed = new Breakpoint();
-            failed.verified = false;
-            failed.message = source.name + ":" + b.line + " could not be found or had no code on it";
-            return failed;
+            return null;
         }
         var ok = new Breakpoint();
         ok.verified = true;
@@ -226,6 +226,9 @@ private boolean tryEnableBreakpointImmediately(Source source, SourceBreakpoint b
             LOG.info(String.format("No locations in %s for breakpoint %s:%d", type.name(), source.path, b.line));
             return false;
         }
+        if (locations.isEmpty()) {
+            return false;
+        }
         for (var l : locations) {
             LOG.info(String.format("Create breakpoint %s:%d", source.path, l.lineNumber()));
             var req = vm.eventRequestManager().createBreakpointRequest(l);
@@ -384,48 +387,36 @@ private void enablePendingBreakpointsIn(ReferenceType type) {
         // Look for pending breakpoints that can be enabled
         var enabled = new ArrayList<Breakpoint>();
         for (var b : pendingBreakpoints) {
-            if (b.source.path.endsWith(path)) {
-                enablePendingBreakpoint(b, type);
+            if (b.source.path.endsWith(path) && enablePendingBreakpoint(b, type)) {
                 enabled.add(b);
             }
         }
         pendingBreakpoints.removeAll(enabled);
     }
 
-    private void enablePendingBreakpoint(Breakpoint b, ReferenceType type) {
+    private boolean enablePendingBreakpoint(Breakpoint b, ReferenceType type) {
+        List<Location> locations;
         try {
-            var locations = type.locationsOfLine(b.line);
-            for (var line : locations) {
-                var req = vm.eventRequestManager().createBreakpointRequest(line);
-                req.setSuspendPolicy(EventRequest.SUSPEND_ALL);
-                req.enable();
-            }
-            if (locations.isEmpty()) {
-                LOG.info("No locations at " + b.source.path + ":" + b.line);
-                var failed = new BreakpointEventBody();
-                failed.reason = "changed";
-                failed.breakpoint = b;
-                b.verified = false;
-                b.message = b.source.name + ":" + b.line + " could not be found or had no code on it";
-                client.breakpoint(failed);
-                return;
-            }
-            LOG.info("Enable breakpoint at " + b.source.path + ":" + b.line);
-            var ok = new BreakpointEventBody();
-            ok.reason = "changed";
-            ok.breakpoint = b;
-            b.verified = true;
-            b.message = null;
-            client.breakpoint(ok);
+            locations = type.locationsOfLine(b.line);
         } catch (AbsentInformationException __) {
-            LOG.info("Absent information at " + b.source.path + ":" + b.line);
-            var failed = new BreakpointEventBody();
-            failed.reason = "changed";
-            failed.breakpoint = b;
-            b.verified = false;
-            b.message = b.source.name + ":" + b.line + " could not be found or had no code on it";
-            client.breakpoint(failed);
+            return false;
+        }
+        if (locations.isEmpty()) {
+            return false;
         }
+        for (var line : locations) {
+            var req = vm.eventRequestManager().createBreakpointRequest(line);
+            req.setSuspendPolicy(EventRequest.SUSPEND_ALL);
+            req.enable();
+        }
+        LOG.info("Enable breakpoint at " + b.source.path + ":" + b.line);
+        var ok = new BreakpointEventBody();
+        ok.reason = "changed";
+        ok.breakpoint = b;
+        b.verified = true;
+        b.message = null;
+        client.breakpoint(ok);
+        return true;
     }
 
     private String relativePath(ReferenceType type) {

src/test/examples/debug/InnerClasses$Inner$1.class

@@ -0,0 +1,20 @@
+public class InnerClasses {
+    public static void main(String[] args) {
+        System.out.println("at main");
+        new Inner().run();
+    }
+
+    // An inner class:
+    private static class Inner {
+        public void run() {
+            System.out.println("at Inner.run");
+            // An anonymous class:
+            new Runnable() {
+                @Override
+                public void run() {
+                    System.out.println("at Runnable.run");
+                }
+            }.run();
+        }
+    }
+}

src/test/examples/debug/InnerClasses$Inner.class

@@ -361,5 +361,23 @@ public void printCollections() throws IOException, InterruptedException {
         process.waitFor();
     }
 
+    @Test
+    public void setBreakpointInnerClasses() throws IOException, InterruptedException {
+        launchProcess("InnerClasses");
+        // Attach to the process
+        attach(5005);
+        // Set breakpoints
+        setBreakpoint("InnerClasses", 3); // at main
+        setBreakpoint("InnerClasses", 10); // at Inner.run
+        setBreakpoint("InnerClasses", 15); // at Runnable.run
+        server.configurationDone();
+        // Should stop 3 times
+        for (int i = 0; i < 3; i++) {
+            stoppedEvents.take();
+            server.continue_(new ContinueArguments());
+        }
+        process.waitFor();
+    }
+
     private static final Logger LOG = Logger.getLogger("main");
 }