Rewrite using line start offsets (h/t @DavyLandman)

Author: toinehartman

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/locations/impl/ArrayLineOffsetMap.java

@@ -28,7 +28,6 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.stream.IntStream;
 
 import org.apache.commons.lang3.tuple.Pair;
 import org.rascalmpl.vscode.lsp.util.locations.LineColumnOffsetMap;
@@ -37,13 +36,13 @@ public class ArrayLineOffsetMap implements LineColumnOffsetMap {
     private final IntArray lines;
     private final ArrayList<IntArray> wideColumnOffsets;
     private final ArrayList<IntArray> wideColumnOffsetsInverse;
-    private final IntArray lineLengths;
+    private final IntArray lineStartOffsets;
 
-    public ArrayLineOffsetMap(IntArray lines, ArrayList<IntArray> wideColumnOffsets, ArrayList<IntArray> wideColumnOffsetsInverse, IntArray lineLengths) {
+    public ArrayLineOffsetMap(IntArray lines, ArrayList<IntArray> wideColumnOffsets, ArrayList<IntArray> wideColumnOffsetsInverse, IntArray lineStartOffsets) {
         this.lines = lines;
         this.wideColumnOffsets = wideColumnOffsets;
         this.wideColumnOffsetsInverse = wideColumnOffsetsInverse;
-        this.lineLengths = lineLengths;
+        this.lineStartOffsets = lineStartOffsets;
     }
 
     @Override
@@ -83,27 +82,8 @@ public int translateInverseColumn(int line, int column, boolean isEnd) {
     public Pair<Integer, Integer> calculateInverseOffsetLength(int beginLine, int beginColumn, int endLine, int endColumn) {
         assert beginLine <= endLine : "beginLine cannot be larger than endLine";
 
-        int startOffset = 0;
-        int endOffset = 0;
-
-        for (int line = 0; line <= endLine; line++) {
-            int lineLength = translateInverseColumn(line, lineLengths.data[line], true);
-            if (line < beginLine) {
-                startOffset += lineLength;
-                endOffset += lineLength;
-            } else if (line == beginLine) {
-                startOffset += translateInverseColumn(line, beginColumn, false);
-                endOffset += line == endLine
-                    ? translateInverseColumn(line, endColumn, true)
-                    : lineLength;
-            } else if (line < endLine) {
-                // beginLine < line < endLine
-                endOffset += lineLength;
-            } else {
-                // line == endLine && beginLine != endLine
-                endOffset += translateInverseColumn(line, endColumn, true);
-            }
-        }
+        int startOffset = lineStartOffsets.get(beginLine) + translateInverseColumn(beginLine, beginColumn, false);
+        int endOffset = lineStartOffsets.get(endLine) + translateInverseColumn(endLine, endColumn, true);
 
         return Pair.of(startOffset, endOffset - startOffset);
     }
@@ -113,22 +93,18 @@ public static LineColumnOffsetMap build(String contents) {
         int line = 0;
         int column = 0;
         char prev = '\0';
-        int lineLength = 0;
         GrowingIntArray linesWithSurrogate = new GrowingIntArray();
         ArrayList<IntArray> linesMap = new ArrayList<>(0);
         ArrayList<IntArray> inverseLinesMap = new ArrayList<>(0);
         GrowingIntArray currentLine = new GrowingIntArray();
-        GrowingIntArray lineLengths = new GrowingIntArray();
+        GrowingIntArray lineStartOffsets = new GrowingIntArray();
 
+        lineStartOffsets.add(0);
         for(int i = 0, n = contents.length() ; i < n ; i++) {
             char c = contents.charAt(i);
             if (c == '\n' || c == '\r') {
                 if (c != prev && (prev == '\r' || prev == '\n')) {
-                    lineLength += 1; // 2 for \r\n
                     continue; // multichar newline skip it
-                } else {
-                    lineLengths.add(lineLength + 1);
-                    lineLength = 0;
                 }
                 if (!currentLine.isEmpty()) {
                     linesWithSurrogate.add(line);
@@ -138,15 +114,14 @@ public static LineColumnOffsetMap build(String contents) {
                 }
                 line++;
                 column = 0;
+                lineStartOffsets.add(i + 1);
             }
             else {
                 column++;
-                lineLength++;
                 if (Character.isHighSurrogate(c) && (i + 1) < n && Character.isLowSurrogate(contents.charAt(i + 1))) {
                     // full surrogate pair, register it, and skip the next char
                     currentLine.add(column);
                     i++;
-                    lineLength++;
                 }
             }
             prev = c;
@@ -157,14 +132,13 @@ public static LineColumnOffsetMap build(String contents) {
             linesMap.add(currentLine.build());
             inverseLinesMap.add(currentLine.buildInverse());
         }
-        lineLengths.add(lineLength);
         if (linesMap.isEmpty()) {
-            return EMPTY_MAP(lineLengths.build());
+            return EMPTY_MAP(lineStartOffsets.build());
         }
-        return new ArrayLineOffsetMap(linesWithSurrogate.build(), linesMap, inverseLinesMap, lineLengths.build());
+        return new ArrayLineOffsetMap(linesWithSurrogate.build(), linesMap, inverseLinesMap, lineStartOffsets.build());
     }
 
-    private static LineColumnOffsetMap EMPTY_MAP(IntArray lineLengths) {
+    private static LineColumnOffsetMap EMPTY_MAP(IntArray lineStartOffsets) {
         return new LineColumnOffsetMap(){
             @Override
             public int translateColumn(int line, int column, boolean atEnd) {
@@ -176,8 +150,8 @@ public int translateInverseColumn(int line, int column, boolean isEnd) {
             }
             @Override
             public Pair<Integer, Integer> calculateInverseOffsetLength(int beginLine, int beginColumn, int endLine, int endColumn) {
-                final int beginOffset = beginColumn + IntStream.of(lineLengths.data).limit(beginLine).sum();
-                final int endOffset = endColumn + IntStream.of(lineLengths.data).limit(endLine).sum();
+                final int beginOffset = beginColumn + lineStartOffsets.get(beginLine);
+                final int endOffset = endColumn + lineStartOffsets.get(endLine);
                 return Pair.of(beginOffset, endOffset - beginOffset);
             }
 
@@ -232,6 +206,13 @@ public IntArray(int[] data, int length) {
             this.length = length;
         }
 
+        public int get(int i) {
+            if (i < 0 || i >= length) {
+                throw new IndexOutOfBoundsException(String.format("Cannot get element at %d; IntArray has %d elements", i, this.length));
+            }
+            return data[i];
+        }
+
         /**
          * search for key, assume it's sorted data
          * @return >= 0 in case of exact match, below 0 is the insert point

rascal-lsp/src/test/java/engineering/swat/rascal/lsp/util/LineColumnOffsetMapTests.java

@@ -74,7 +74,7 @@ public void singleWideCharInverse() {
         assertEquals(4, map.translateInverseColumn(0, 5, false));
         assertEquals(Pair.of(2, 1), map.calculateInverseOffsetLength(0, 2, 0, 4));
         assertEquals(Pair.of(3, 1), map.calculateInverseOffsetLength(0, 4, 0, 5));
-        assertEquals(Pair.of(0, 11), map.calculateInverseOffsetLength(0, 0, 1, 6));
+        assertEquals(Pair.of(0, 11), map.calculateInverseOffsetLength(0, 0, 1, 5));
     }