Test & fix list focus.

Author: toinehartman

rascal-lsp/pom.xml

@@ -153,6 +153,12 @@
             <version>3.5.3</version>
           </dependency>
         </dependencies>
+        <configuration>
+          <systemPropertyVariables>
+            <forkMode>always</forkMode>
+            <log4j2.configurationFactory>org.rascalmpl.vscode.lsp.log.LogRedirectConfiguration</log4j2.configurationFactory>
+          </systemPropertyVariables>
+        </configuration>
       </plugin>
       <plugin>
         <groupId>org.rascalmpl</groupId>

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

@@ -101,6 +101,17 @@ private static boolean rightOfBegin(ISourceLocation loc, int line, int column) {
         return line == loc.getBeginLine() && column > loc.getBeginColumn();
     }
 
+    private static boolean rightOfEnd(ISourceLocation loc, int line, int column) {
+        if (!loc.hasLineColumn()) {
+            return false;
+        }
+
+        if (line > loc.getEndLine()) {
+            return true;
+        }
+        return line == loc.getEndLine() && column > loc.getEndColumn();
+    }
+
     /**
      * Produces a list of trees that are "in focus" at given line and column offset (UTF-32).
      *
@@ -180,14 +191,16 @@ public static IList computeFocusList(ITree tree, int startLine, int startColumn,
         final var startList = computeFocusList(tree, startLine, startColumn);
         final var endList = computeFocusList(tree, endLine, endColumn);
 
+        logger.trace("Focus at range start: {}", startList.length());
+        logger.trace("Focus at range end: {}", endList.length());
+
         final var commonSuffix = startList.intersect(endList);
-        if (commonSuffix.equals(startList) || commonSuffix.equals(endList)) {
-            // We do not have enough information to extend the focus
-            return commonSuffix;
-        }
+
+        logger.trace("Common focus suffix length: {}", commonSuffix.length());
         // The range spans multiple subtrees. The easy way out is not to focus farther down than
         // their smallest common subtree (i.e. `commonSuffix`) - let's see if we can do any better.
         if (TreeAdapter.isList((ITree) commonSuffix.get(0))) {
+            logger.trace("Focus range spans a (partial) list: {}", TreeAdapter.getType((ITree) commonSuffix.get(0)));
             return computeListRangeFocus(commonSuffix, startLine, startColumn, endLine, endColumn);
         }
 
@@ -210,9 +223,22 @@ private static IList computeListRangeFocus(final IList commonSuffix, int startLi
         // Find the elements in the list that are (partially) selected.
         final var selected = elements.stream()
             .map(ITree.class::cast)
-            .dropWhile(t -> !inside(TreeAdapter.getLocation(t), startLine, startColumn))
-            .takeWhile(t -> rightOfBegin(TreeAdapter.getLocation(t), endLine, endColumn))
+            .dropWhile(t -> {
+                final var l = TreeAdapter.getLocation(t);
+                // only include layout if the element before it is selected as well
+                return TreeAdapter.isLayout(t)
+                    ? rightOfBegin(l, startLine, startColumn)
+                    : rightOfEnd(l, startLine, startColumn);
+            })
+            .takeWhile(t -> {
+                final var l = TreeAdapter.getLocation(t);
+                // only include layout if the element after it is selected as well
+                return TreeAdapter.isLayout(t)
+                    ? rightOfEnd(l, endLine, endColumn)
+                    : rightOfBegin(l, endLine, endColumn);
+            })
             .collect(VF.listWriter());
+
         final int nSelected = selected.length();
 
         logger.trace("Range covers {} (of {}) elements in the parent list", nSelected, nElements);

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

@@ -27,6 +27,7 @@
 package engineering.swat.rascal.lsp.util;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.rascalmpl.vscode.lsp.util.locations.impl.TreeSearch.computeFocusList;
 
@@ -68,26 +69,57 @@ public static void setUpSuite() {
         tree = RascalServices.parseRascalModule(VF.sourceLocation(URI), CONTENTS.toCharArray());
     }
 
+    @Test
+    public void focusStartsWithLexical() {
+        final var focus = computeFocusList(tree, 8, 13);
+        final var first = (ITree) focus.get(0);
+        assertTrue(TreeAdapter.isLexical(first));
+    }
+
     @Test
     public void focusEndsWithModule() {
         final var focus = computeFocusList(tree, 6, 4);
-        final var last = focus.get(focus.length() - 1);
+        final var last = (ITree) focus.get(focus.length() - 1);
         assertEquals(tree, last);
     }
 
     @Test
-    public void listPartialRange() {
-        final var focus = computeFocusList(tree, 4, 8, 6, 8);
+    public void listRangePartial() {
+        final var focus = computeFocusList(tree, 5, 8, 6, 8);
         final var selection = (ITree) focus.get(0);
         final var originalList = (ITree) focus.get(1);
 
-        assertListLength(selection, 3);
-        assertListLength(originalList, 4);
+        assertValidListWithLength(selection, 2);
+        assertValidListWithLength(originalList, 4);
     }
 
+    @Test
+    public void listRangeStartsWithWhitespace() {
+        final var focus = computeFocusList(tree, 7, 0, 8, 15);
+        final var selection = (ITree) focus.get(0);
+        final var originalList = (ITree) focus.get(1);
+
+        assertValidListWithLength(selection, 1);
+        assertValidListWithLength(originalList, 4);
+    }
 
-    private static void assertListLength(final ITree list, int length) {
+    @Test
+    public void listRangeEndsWithWhitespace() {
+        final var focus = computeFocusList(tree, 4, 3, 7, 0);
+        final var selection = (ITree) focus.get(0);
+        final var originalList = (ITree) focus.get(1);
+
+        assertValidListWithLength(selection, 3);
+        assertValidListWithLength(originalList, 4);
+    }
+
+    private static void assertValidListWithLength(final ITree list, int length) {
         assertTrue(String.format("Not a list: %s", TreeAdapter.getType(list)), TreeAdapter.isList(list));
         assertEquals(TreeAdapter.yield(list), length, TreeAdapter.getListASTArgs(list).size());
+
+        // assert no layout padding
+        final var args = TreeAdapter.getArgs(list);
+        assertFalse("List tree malformed: starts with layout", TreeAdapter.isLayout((ITree) args.get(0)));
+        assertFalse("List tree malformed: ends with layout", TreeAdapter.isLayout((ITree) args.get(args.length() - 1)));
     }
 }