Refactor selection logic and improve candidate retrieval methods

Author: dandehoon

src/expandSelection.ts

@@ -50,18 +50,37 @@ export class SelectionProvider {
     endIndex: number,
     document: vscode.TextDocument,
   ): { start: number; end: number } | null {
-    // Get all valid candidates from finders
-    const candidates = [
-      findToken(text, startIndex, endIndex, document),
-      findNearestQuotePair(text, startIndex, endIndex),
-      findNearestScope(text, startIndex, endIndex),
-      findLineExpansion(text, startIndex, endIndex, document),
-    ].filter((c) => !!c);
+    // Get all valid candidates from finders as a map
+    const candidateMap: Record<string, { start: number; end: number } | null> =
+      {
+        token: findToken(text, startIndex, endIndex, document),
+        quote: findNearestQuotePair(text, startIndex, endIndex),
+        scope: findNearestScope(text, startIndex, endIndex),
+        line: findLineExpansion(text, startIndex, endIndex, document),
+      };
 
-    // Return the smallest valid expansion
+    // Return the smallest valid expansion, with priority logic
     let best: { start: number; end: number } | null = null;
     let smallest = Infinity;
-    for (const candidate of candidates) {
+
+    // Priority: if scope or quote candidate exists and line candidate is not fully contained, ignore line candidate
+    const line = candidateMap.line;
+    const scope = candidateMap.scope;
+    const quote = candidateMap.quote;
+    let ignoreLine = false;
+    if (line) {
+      if (
+        (scope && !(line.start >= scope.start && line.end <= scope.end)) ||
+        (quote && !(line.start >= quote.start && line.end <= quote.end))
+      ) {
+        candidateMap.line = null;
+      }
+    }
+
+    for (const [_, candidate] of Object.entries(candidateMap)) {
+      if (!candidate) {
+        continue;
+      }
       const range = this.getTrimmedRange(text, candidate.start, candidate.end);
       const size = range.end - range.start;
       if (

src/finders/line.ts

@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 import { SelectionCandidate } from '../types';
-import { isValidExpansion } from './util';
+import { getCandidate } from './util';
 
 /**
  * Finds line expansion candidate that spans from start of line containing startIndex
@@ -25,30 +25,39 @@ export function findLineExpansion(
     new vscode.Position(endPos.line, document.lineAt(endPos.line).text.length),
   );
 
-  // Extract the content from start of first line to end of last line
-  const fullContent = text.substring(startLineStart, endLineEnd);
-
-  // Trim the content to remove leading and trailing whitespace
-  const trimmedContent = fullContent.trim();
-
-  if (trimmedContent.length === 0) {
+  // Get the full candidate first
+  const fullCandidate = getCandidate(
+    startIndex,
+    endIndex,
+    startLineStart,
+    endLineEnd,
+    text,
+  );
+  if (!fullCandidate) {
     return null;
   }
 
-  // Calculate the actual start and end positions of the trimmed content
-  const leadingWhitespace = fullContent.length - fullContent.trimStart().length;
-  const trailingWhitespace = fullContent.length - fullContent.trimEnd().length;
-
-  const trimmedStart = startLineStart + leadingWhitespace;
-  const trimmedEnd = endLineEnd - trailingWhitespace;
-
-  // Only return if it would expand the selection (not if selection already matches exactly)
-  if (!isValidExpansion(startIndex, endIndex, trimmedStart, trimmedEnd)) {
-    return null;
+  // Check for trailing semicolon or comma in the trimmed candidate
+  const lastChar = text[fullCandidate.end - 1];
+  const startLine = document.positionAt(fullCandidate.start).line;
+  const endLine = document.positionAt(fullCandidate.end).line;
+
+  if (
+    (lastChar === ';' || lastChar === ',') &&
+    fullCandidate.end > endIndex &&
+    startLine === endLine
+  ) {
+    const candidate = getCandidate(
+      startIndex,
+      endIndex,
+      fullCandidate.start,
+      fullCandidate.end - 1,
+      text,
+    );
+    if (candidate) {
+      return candidate;
+    }
   }
 
-  return {
-    start: trimmedStart,
-    end: trimmedEnd,
-  };
+  return fullCandidate;
 }

src/finders/quote.ts

@@ -1,5 +1,5 @@
 import { SelectionCandidate } from '../types';
-import { isValidExpansion } from './util';
+import { getCandidate } from './util';
 
 /**
  * Finds all quote pairs (", ', `) and returns the nearest containing candidate
@@ -24,26 +24,27 @@ export function findNearestQuotePair(
           if (text[j] === '\\' && !escaped) {
             escaped = true;
           } else if (text[j] === quote && !escaped) {
-            const candidate: SelectionCandidate = {
-              start: i,
-              end: j + 1,
-            };
-            const size = candidate.end - candidate.start;
-            // Check if this candidate contains the current selection
-            if (
-              isValidExpansion(
-                startIndex,
-                endIndex,
-                candidate.start,
-                candidate.end,
-              )
-            ) {
-              // Keep track of the smallest containing candidate
+            // Try content inside quotes first
+            const innerCandidate = getCandidate(
+              startIndex,
+              endIndex,
+              i + 1,
+              j,
+              text,
+            );
+            let candidate = innerCandidate;
+            if (!candidate) {
+              // Fallback to full quote including delimiters
+              candidate = getCandidate(startIndex, endIndex, i, j + 1, text);
+            }
+            if (candidate) {
+              const size = candidate.end - candidate.start;
               if (size < smallestSize) {
                 smallestSize = size;
                 nearestCandidate = candidate;
               }
             }
+
             i = j; // Skip to after this quote pair
             break;
           } else {

src/finders/scope.ts

@@ -1,5 +1,21 @@
 import { SelectionCandidate } from '../types';
-import { isValidExpansion } from './util';
+import { getCandidate } from './util';
+
+function getScopeCandidate(
+  start: number,
+  end: number,
+  startIndex: number,
+  endIndex: number,
+  text: string,
+): SelectionCandidate | null {
+  // Try content inside scope
+  const inner = getCandidate(startIndex, endIndex, start + 1, end, text);
+  if (inner) {
+    return inner;
+  }
+  // Try scope including delimiters
+  return getCandidate(startIndex, endIndex, start, end + 1, text);
+}
 
 /**
  * Finds all balanced scopes ([], {}, (), <>) and returns the nearest containing candidate
@@ -13,7 +29,6 @@ export function findNearestScope(
     { open: '[', close: ']' },
     { open: '{', close: '}' },
     { open: '(', close: ')' },
-    { open: '<', close: '>' },
   ];
 
   let nearestCandidate: SelectionCandidate | null = null;
@@ -27,16 +42,14 @@ export function findNearestScope(
         stack.push(i);
       } else if (text[i] === close && stack.length > 0) {
         const start = stack.pop()!;
-        const candidate: SelectionCandidate = {
+        const candidate = getScopeCandidate(
           start,
-          end: i + 1,
-        };
-
-        // Check if this candidate contains the current selection
-        if (
-          isValidExpansion(startIndex, endIndex, candidate.start, candidate.end)
-        ) {
-          // Keep track of the smallest containing candidate
+          i,
+          startIndex,
+          endIndex,
+          text,
+        );
+        if (candidate) {
           const size = candidate.end - candidate.start;
           if (size < smallestSize) {
             smallestSize = size;

src/finders/token.ts

@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 import { SelectionCandidate } from '../types';
-import { isValidExpansion } from './util';
+import { getCandidate } from './util';
 
 /**
  * Finds word boundaries using different regex patterns for extended token detection
@@ -35,12 +35,15 @@ export function findToken(
       const wordStart = document.offsetAt(wordRange.start);
       const wordEnd = document.offsetAt(wordRange.end);
 
-      // Check if this would be a valid expansion
-      if (isValidExpansion(startIndex, endIndex, wordStart, wordEnd)) {
-        return {
-          start: wordStart,
-          end: wordEnd,
-        };
+      const candidate = getCandidate(
+        startIndex,
+        endIndex,
+        wordStart,
+        wordEnd,
+        text,
+      );
+      if (candidate) {
+        return candidate;
       }
     }
   }

src/finders/util.ts

@@ -1,12 +1,33 @@
-export function isValidExpansion(
+export function getCandidate(
   startIndex: number,
   endIndex: number,
   rangeStart: number,
   rangeEnd: number,
-): boolean {
-  return (
-    startIndex >= rangeStart &&
-    endIndex <= rangeEnd &&
-    !(startIndex === rangeStart && endIndex === rangeEnd)
-  );
+  text: string,
+): { start: number; end: number } | null {
+  const content = text.substring(rangeStart, rangeEnd);
+  const trimmedContent = content.trim();
+  if (trimmedContent.length === 0) {
+    // If only whitespace, use the original range
+    if (
+      startIndex >= rangeStart &&
+      endIndex <= rangeEnd &&
+      !(startIndex === rangeStart && endIndex === rangeEnd)
+    ) {
+      return { start: rangeStart, end: rangeEnd };
+    }
+    return null;
+  }
+  const leadingWhitespace = content.length - content.trimStart().length;
+  const trailingWhitespace = content.length - content.trimEnd().length;
+  const trimmedStart = rangeStart + leadingWhitespace;
+  const trimmedEnd = rangeEnd - trailingWhitespace;
+  if (
+    startIndex >= trimmedStart &&
+    endIndex <= trimmedEnd &&
+    !(startIndex === trimmedStart && endIndex === trimmedEnd)
+  ) {
+    return { start: trimmedStart, end: trimmedEnd };
+  }
+  return null;
 }

src/test/suite/expandSelection.test.ts

@@ -306,6 +306,6 @@ suite('ExpandSelection Test Suite', () => {
 
     assert.ok(result);
     const selectedText = text.substring(result.start, result.end);
-    assert.strictEqual(selectedText, '"  hello world  "');
+    assert.strictEqual(selectedText, 'hello world'); // Should prefer content inside quotes
   });
 });

src/test/suite/finders/line.test.ts

@@ -101,7 +101,7 @@ suite('Line Finder Tests', () => {
 
     assert.ok(result);
     const selectedText = text.substring(result.start, result.end);
-    assert.strictEqual(selectedText, 'const value = 123;'); // Trimmed
+    assert.strictEqual(selectedText, 'const value = 123'); // Without trailing semicolon
   });
 
   test('handles multi-line with complex indentation', () => {
@@ -133,7 +133,10 @@ suite('Line Finder Tests', () => {
 
     const result = findLineExpansion(text, 1, 5, mockDoc);
 
-    assert.strictEqual(result, null);
+    // Should return an empty candidate with start/end positions
+    assert.ok(result);
+    assert.strictEqual(result.start, 0);
+    assert.strictEqual(result.end, 7);
   });
 
   test('content start and end equal start and end', () => {