DRAFT

Author: jpbempel

dd-java-agent/agent-debugger/src/main/java/com/datadog/debugger/symbol/Scope.java

@@ -4,6 +4,17 @@
 import java.util.List;
 
 public class Scope {
+
+  public static class LineRange {
+    final int start;
+    final int end;
+
+    public LineRange(int start, int end) {
+      this.start = start;
+      this.end = end;
+    }
+  }
+
   @Json(name = "scope_type")
   private final ScopeType scopeType;
 
@@ -16,6 +27,12 @@ public class Scope {
   @Json(name = "end_line")
   private final int endLine;
 
+  @Json(name = "has_injectible_lines")
+  private final boolean hasInjectibleLines;
+
+  @Json(name = "injectible_lines")
+  private final List<LineRange> injectibleLines;
+
   private final String name;
 
   @Json(name = "language_specifics")
@@ -30,6 +47,8 @@ public Scope(
       int startLine,
       int endLine,
       String name,
+      boolean hasInjectibleLines,
+      List<LineRange> injectibleLines,
       LanguageSpecifics languageSpecifics,
       List<Symbol> symbols,
       List<Scope> scopes) {
@@ -38,6 +57,8 @@ public Scope(
     this.startLine = startLine;
     this.endLine = endLine;
     this.name = name;
+    this.hasInjectibleLines = hasInjectibleLines;
+    this.injectibleLines = injectibleLines;
     this.languageSpecifics = languageSpecifics;
     this.symbols = symbols;
     this.scopes = scopes;
@@ -63,6 +84,14 @@ public String getName() {
     return name;
   }
 
+  public boolean hasInjectibleLines() {
+    return hasInjectibleLines;
+  }
+
+  public List<LineRange> getInjectibleLines() {
+    return injectibleLines;
+  }
+
   public LanguageSpecifics getLanguageSpecifics() {
     return languageSpecifics;
   }
@@ -110,6 +139,8 @@ public static class Builder {
     private final int startLine;
     private final int endLine;
     private String name;
+    private boolean hasInjectibleLines;
+    private List<LineRange> injectibleLines;
     private LanguageSpecifics languageSpecifics;
     private List<Symbol> symbols;
     private List<Scope> scopes;
@@ -126,6 +157,16 @@ public Builder name(String name) {
       return this;
     }
 
+    public Builder hasInjectibleLines(boolean hasInjectibleLines) {
+      this.hasInjectibleLines = hasInjectibleLines;
+      return this;
+    }
+
+    public Builder injectibleLines(List<LineRange> injectibleLines) {
+      this.injectibleLines = injectibleLines;
+      return this;
+    }
+
     public Builder languageSpecifics(LanguageSpecifics languageSpecifics) {
       this.languageSpecifics = languageSpecifics;
       return this;
@@ -143,7 +184,7 @@ public Builder scopes(List<Scope> scopes) {
 
     public Scope build() {
       return new Scope(
-          scopeType, sourceFile, startLine, endLine, name, languageSpecifics, symbols, scopes);
+          scopeType, sourceFile, startLine, endLine, name, hasInjectibleLines, injectibleLines, languageSpecifics, symbols, scopes);
     }
   }
 }

dd-java-agent/agent-debugger/src/main/java/com/datadog/debugger/symbol/SymbolExtractor.java

@@ -10,9 +10,11 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.Label;
@@ -124,6 +126,8 @@ private static List<Scope> extractMethods(ClassNode classNode, String sourceFile
               .name(method.name)
               .scopes(varScopes)
               .symbols(methodSymbols)
+              .hasInjectibleLines(!methodLineInfo.ranges.isEmpty())
+              .injectibleLines(methodLineInfo.ranges)
               .languageSpecifics(methodSpecifics)
               .build();
       methodScopes.add(methodScope);
@@ -431,26 +435,44 @@ private static Scope maxScope(Scope scope1, Scope scope2) {
         : scope1;
   }
 
-  private static int getFirstLine(MethodNode methodNode) {
-    AbstractInsnNode node = methodNode.instructions.getFirst();
-    while (node != null) {
-      if (node.getType() == AbstractInsnNode.LINE) {
-        LineNumberNode lineNumberNode = (LineNumberNode) node;
-        return lineNumberNode.line;
+  static List<Scope.LineRange> buildRanges(List<Integer> sortedLineNo) {
+    if (sortedLineNo.isEmpty()) {
+      return Collections.emptyList();
+    }
+    List<Scope.LineRange> ranges = new ArrayList<>();
+    int start = sortedLineNo.get(0);
+    int previous = start;
+    int i = 1;
+    while (i < sortedLineNo.size()) {
+      int currentLine = sortedLineNo.get(i);
+      while (currentLine == previous + 1) {
+        i++;
+        previous++;
+        if (i < sortedLineNo.size()) {
+          currentLine = sortedLineNo.get(i);
+        }
       }
-      node = node.getNext();
+      ranges.add(new Scope.LineRange(start, previous));
+      start = currentLine;
+      previous = start;
+      i++;
     }
-    return 0;
+    ranges.add(new Scope.LineRange(start, previous));
+    return ranges;
   }
 
   private static MethodLineInfo extractMethodLineInfo(MethodNode methodNode) {
     Map<Label, Integer> map = new HashMap<>();
-    int startLine = getFirstLine(methodNode);
-    int maxLine = startLine;
+    List<Integer> lineNo = new ArrayList<>();
+    Set<Integer> dedupSet = new HashSet<>();
     AbstractInsnNode node = methodNode.instructions.getFirst();
+    int maxLine = 0;
     while (node != null) {
       if (node.getType() == AbstractInsnNode.LINE) {
         LineNumberNode lineNumberNode = (LineNumberNode) node;
+        if (dedupSet.add(lineNumberNode.line)) {
+          lineNo.add(lineNumberNode.line);
+        }
         maxLine = Math.max(lineNumberNode.line, maxLine);
       }
       if (node.getType() == AbstractInsnNode.LABEL) {
@@ -461,7 +483,10 @@ private static MethodLineInfo extractMethodLineInfo(MethodNode methodNode) {
       }
       node = node.getNext();
     }
-    return new MethodLineInfo(startLine, maxLine, map);
+    lineNo.sort(Integer::compareTo);
+    int startLine = lineNo.isEmpty() ? 0 : lineNo.get(0);
+    List<Scope.LineRange> ranges = buildRanges(lineNo);
+    return new MethodLineInfo(startLine, maxLine, map, ranges);
   }
 
   private static ClassNode parseClassFile(byte[] classfileBuffer) {
@@ -475,11 +500,14 @@ public static class MethodLineInfo {
     final int start;
     final int end;
     final Map<Label, Integer> lineMap;
+    final List<Scope.LineRange> ranges;
 
-    public MethodLineInfo(int start, int end, Map<Label, Integer> lineMap) {
+    public MethodLineInfo(int start, int end, Map<Label, Integer> lineMap, List<Scope.LineRange> ranges) {
       this.start = start;
       this.end = end;
       this.lineMap = lineMap;
+
+      this.ranges = ranges;
     }
   }
 }

dd-java-agent/agent-debugger/src/test/java/com/datadog/debugger/symbol/SymbolExtractorTest.java

@@ -0,0 +1,26 @@
+package com.datadog.debugger.symbol;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SymbolExtractorTest {
+
+  void ranges() {
+    List<Scope.LineRange> ranges = SymbolExtractor.buildRanges(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+    assertEquals(1, ranges.size());
+    assertEquals(1, ranges.get(0).start);
+    assertEquals(10, ranges.get(0).end);
+    ranges = SymbolExtractor.buildRanges(Arrays.asList(1, 3, 5, 7, 9));
+    assertEquals(5, ranges.size());
+    assertEquals(1, ranges.get(0).start);
+    assertEquals(1, ranges.get(0).end);
+    assertEquals(1, ranges.get(0).start);
+    assertEquals(1, ranges.get(0).end);
+  }
+
+  private static void assertLineRange(Scope.LineRange range, int expectedStart, int expectedEnd) {
+
+  }
+}