@herb-tools/language-server 0.8.10 → 0.9.0

package/src/diagnostics.ts

@@ -4,6 +4,7 @@ import { Visitor } from "@herb-tools/core"
 
 import type {
   Node,
+  SerializedLocation,
   ERBCaseNode,
   ERBCaseMatchNode,
   ERBIfNode,
@@ -20,12 +21,13 @@ import type {
   ERBInNode,
 } from "@herb-tools/core"
 
-import { isHTMLTextNode } from "@herb-tools/core"
+import { isHTMLTextNode, isERBIfNode, isERBElseNode } from "@herb-tools/core"
 
 import { ParserService } from "./parser_service"
 import { LinterService } from "./linter_service"
 import { DocumentService } from "./document_service"
 import { ConfigService } from "./config_service"
+import { lspRangeFromLocation } from "./range_utils"
 
 export class Diagnostics {
   private readonly connection: Connection
@@ -253,18 +255,9 @@ export class UnreachableCodeCollector extends Visitor {
     )
   }
 
-  private addDiagnostic(location: { start: { line: number; column: number }, end: { line: number; column: number } }, message: string): void {
+  private addDiagnostic(location: SerializedLocation, message: string): void {
     const diagnostic: Diagnostic = {
-      range: {
-        start: {
-          line: this.toZeroBased(location.start.line),
-          character: location.start.column
-        },
-        end: {
-          line: this.toZeroBased(location.end.line),
-          character: location.end.column
-        }
-      },
+      range: lspRangeFromLocation(location),
       message,
       severity: DiagnosticSeverity.Hint,
       tags: [DiagnosticTag.Unnecessary],
@@ -298,27 +291,29 @@ export class UnreachableCodeCollector extends Visitor {
   private markIfChainAsProcessed(node: ERBIfNode): void {
     this.processedIfNodes.add(node)
     this.traverseSubsequentNodes(node.subsequent, (current) => {
-      if (current.type === 'AST_ERB_IF_NODE') {
-        this.processedIfNodes.add(current as ERBIfNode)
+      if (isERBIfNode(current)) {
+        this.processedIfNodes.add(current)
       }
     })
   }
 
   private markElseNodesInIfChain(node: ERBIfNode): void {
     this.traverseSubsequentNodes(node.subsequent, (current) => {
-      if (current.type === 'AST_ERB_ELSE_NODE') {
-        this.processedElseNodes.add(current as ERBElseNode)
+      if (isERBElseNode(current)) {
+        this.processedElseNodes.add(current)
       }
     })
   }
 
-  private traverseSubsequentNodes(startNode: Node | null, callback: (node: Node) => void): void {
-    let current = startNode
+  private traverseSubsequentNodes(startNode: Node | null, callback: (node: ERBIfNode | ERBElseNode) => void): void {
+    let current: Node | null = startNode
     while (current) {
-      callback(current)
-
-      if ('subsequent' in current) {
-        current = (current as any).subsequent
+      if (isERBIfNode(current)) {
+        callback(current)
+        current = current.subsequent
+      } else if (isERBElseNode(current)) {
+        callback(current)
+        break
       } else {
         break
       }
@@ -331,21 +326,17 @@ export class UnreachableCodeCollector extends Visitor {
     }
 
     this.traverseSubsequentNodes(node.subsequent, (current) => {
-      if (!('statements' in current) || !Array.isArray((current as any).statements)) {
-        return
-      }
-
-      if (this.statementsHaveContent((current as any).statements)) {
+      if (this.statementsHaveContent(current.statements)) {
         return
       }
 
-      const blockType = current.type === 'AST_ERB_IF_NODE' ? 'elsif' : 'else'
-      const nextSubsequent = 'subsequent' in current ? (current as any).subsequent : null
+      const blockType = isERBIfNode(current) ? 'elsif' : 'else'
+      const nextSubsequent = isERBIfNode(current) ? current.subsequent : null
 
       if (nextSubsequent) {
-        this.checkEmptyStatementsWithEndLocation(current, (current as any).statements, blockType, nextSubsequent)
+        this.checkEmptyStatementsWithEndLocation(current, current.statements, blockType, nextSubsequent)
       } else {
-        this.checkEmptyStatements(current, (current as any).statements, blockType)
+        this.checkEmptyStatements(current, current.statements, blockType)
       }
     })
   }
@@ -357,17 +348,12 @@ export class UnreachableCodeCollector extends Visitor {
 
     let hasContent = false
     this.traverseSubsequentNodes(node.subsequent, (current) => {
-      if ('statements' in current && Array.isArray((current as any).statements)) {
-        if (this.statementsHaveContent((current as any).statements)) {
-          hasContent = true
-        }
+      if (this.statementsHaveContent(current.statements)) {
+        hasContent = true
       }
     })
 
     return !hasContent
   }
 
-  private toZeroBased(line: number): number {
-    return line - 1
-  }
 }

package/src/document_highlight_service.ts

@@ -0,0 +1,267 @@
+import { DocumentHighlight, DocumentHighlightKind, Range, Position } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
+import { Visitor } from "@herb-tools/core"
+import { ParserService } from "./parser_service"
+
+import { isERBIfNode, isERBElseNode, isHTMLOpenTagNode } from "@herb-tools/core"
+import { erbTagToRange, tokenToRange, nodeToRange, openTagRanges, isPositionInRange, rangeSize } from "./range_utils"
+
+import type {
+  Node,
+  ERBNode,
+  ERBContentNode,
+  HTMLElementNode,
+  HTMLConditionalElementNode,
+  HTMLAttributeNode,
+  HTMLCommentNode,
+  ERBIfNode,
+  ERBUnlessNode,
+  ERBCaseNode,
+  ERBCaseMatchNode,
+  ERBBeginNode,
+  ERBRescueNode,
+} from "@herb-tools/core"
+
+export class DocumentHighlightCollector extends Visitor {
+  public groups: Range[][] = []
+  private processedIfNodes: Set<ERBIfNode> = new Set()
+
+  visitERBNode(node: ERBNode): void {
+    if ('end_node' in node && node.end_node) {
+      this.addGroup([erbTagToRange(node), erbTagToRange(node.end_node)])
+    }
+  }
+
+  visitERBContentNode(node: ERBContentNode): void {
+    this.addGroup([tokenToRange(node.tag_opening), tokenToRange(node.tag_closing)])
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLCommentNode(node: HTMLCommentNode): void {
+    this.addGroup([tokenToRange(node.comment_start), tokenToRange(node.comment_end)])
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const ranges: (Range | null)[] = []
+
+    if (node.open_tag && isHTMLOpenTagNode(node.open_tag)) {
+      ranges.push(...openTagRanges(node.open_tag))
+    } else if (node.open_tag) {
+      ranges.push(nodeToRange(node.open_tag))
+    }
+
+    if (node.close_tag) {
+      ranges.push(nodeToRange(node.close_tag))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLAttributeNode(node: HTMLAttributeNode): void {
+    const ranges: (Range | null)[] = []
+
+    if (node.name) {
+      ranges.push(nodeToRange(node.name))
+    }
+
+    if (node.equals) {
+      ranges.push(tokenToRange(node.equals))
+    }
+
+    if (node.value) {
+      ranges.push(nodeToRange(node.value))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitHTMLConditionalElementNode(node: HTMLConditionalElementNode): void {
+    const ranges: (Range | null)[] = []
+
+    if (node.open_conditional) {
+      ranges.push(erbTagToRange(node.open_conditional))
+    }
+
+    if (node.open_tag) {
+      ranges.push(...openTagRanges(node.open_tag))
+    }
+
+    if (node.close_tag) {
+      ranges.push(nodeToRange(node.close_tag))
+    }
+
+    if (node.close_conditional) {
+      ranges.push(erbTagToRange(node.close_conditional))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitERBIfNode(node: ERBIfNode): void {
+    if (this.processedIfNodes.has(node)) {
+      this.visitChildNodes(node)
+      return
+    }
+
+    this.markIfChainAsProcessed(node)
+
+    const ranges: (Range | null)[] = []
+    ranges.push(erbTagToRange(node))
+
+    let current: Node | null = node.subsequent
+
+    while (current) {
+      if (isERBIfNode(current)) {
+        ranges.push(erbTagToRange(current))
+        current = current.subsequent
+      } else if (isERBElseNode(current)) {
+        ranges.push(erbTagToRange(current))
+        break
+      } else {
+        break
+      }
+    }
+
+    if (node.end_node) {
+      ranges.push(erbTagToRange(node.end_node))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitERBUnlessNode(node: ERBUnlessNode): void {
+    const ranges: (Range | null)[] = []
+    ranges.push(erbTagToRange(node))
+
+    if (node.else_clause) {
+      ranges.push(erbTagToRange(node.else_clause))
+    }
+
+    if (node.end_node) {
+      ranges.push(erbTagToRange(node.end_node))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitERBCaseNode(node: ERBCaseNode): void {
+    this.visitERBAnyCaseNode(node)
+  }
+
+  visitERBCaseMatchNode(node: ERBCaseMatchNode): void {
+    this.visitERBAnyCaseNode(node)
+  }
+
+  visitERBAnyCaseNode(node: ERBCaseNode | ERBCaseMatchNode): void {
+    const ranges: (Range | null)[] = []
+    ranges.push(erbTagToRange(node))
+
+    for (const condition of node.conditions) {
+      ranges.push(erbTagToRange(condition as ERBNode))
+    }
+
+    if (node.else_clause) {
+      ranges.push(erbTagToRange(node.else_clause))
+    }
+
+    if (node.end_node) {
+      ranges.push(erbTagToRange(node.end_node))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  visitERBBeginNode(node: ERBBeginNode): void {
+    const ranges: (Range | null)[] = []
+    ranges.push(erbTagToRange(node))
+
+    let rescue: ERBRescueNode | null = node.rescue_clause
+
+    while (rescue) {
+      ranges.push(erbTagToRange(rescue))
+      rescue = rescue.subsequent
+    }
+
+    if (node.else_clause) {
+      ranges.push(erbTagToRange(node.else_clause))
+    }
+
+    if (node.ensure_clause) {
+      ranges.push(erbTagToRange(node.ensure_clause))
+    }
+
+    if (node.end_node) {
+      ranges.push(erbTagToRange(node.end_node))
+    }
+
+    this.addGroup(ranges)
+    this.visitChildNodes(node)
+  }
+
+  private markIfChainAsProcessed(node: ERBIfNode): void {
+    this.processedIfNodes.add(node)
+
+    let current: Node | null = node.subsequent
+
+    while (current) {
+      if (isERBIfNode(current)) {
+        this.processedIfNodes.add(current)
+        current = current.subsequent
+      } else {
+        break
+      }
+    }
+  }
+
+  private addGroup(ranges: (Range | null)[]): void {
+    const filtered = ranges.filter((r): r is Range => r !== null)
+    if (filtered.length >= 2) {
+      this.groups.push(filtered)
+    }
+  }
+}
+
+export class DocumentHighlightService {
+  private parserService: ParserService
+
+  constructor(parserService: ParserService) {
+    this.parserService = parserService
+  }
+
+  getDocumentHighlights(textDocument: TextDocument, position: Position): DocumentHighlight[] {
+    const parseResult = this.parserService.parseDocument(textDocument)
+    const collector = new DocumentHighlightCollector()
+    collector.visit(parseResult.document)
+
+    let bestGroup: Range[] | null = null
+    let bestSize = Infinity
+
+    for (const group of collector.groups) {
+      const matchingRange = group.find(range => isPositionInRange(position, range))
+
+      if (matchingRange) {
+        const size = rangeSize(matchingRange)
+
+        if (size < bestSize) {
+          bestSize = size
+          bestGroup = group
+        }
+      }
+    }
+
+    if (bestGroup) {
+      return bestGroup.map(range => DocumentHighlight.create(range, DocumentHighlightKind.Text))
+    }
+
+    return []
+  }
+
+}

package/src/document_save_service.ts

@@ -11,6 +11,15 @@ export class DocumentSaveService {
   private autofixService: AutofixService
   private formattingService: FormattingService
 
+  /**
+   * Tracks documents that were recently autofixed via applyFixesAndFormatting
+   * (triggered by onDocumentFormatting). When editor.formatOnSave is enabled,
+   * onDocumentFormatting fires BEFORE willSaveWaitUntil. If applyFixesAndFormatting
+   * already applied autofix, applyFixes must skip to avoid conflicting edits
+   * (since this.documents hasn't been updated between the two events).
+   */
+  private recentlyAutofixedViaFormatting = new Set<string>()
+
   constructor(connection: Connection, settings: Settings, autofixService: AutofixService, formattingService: FormattingService) {
     this.connection = connection
     this.settings = settings
@@ -30,6 +39,11 @@ export class DocumentSaveService {
 
     if (!fixOnSave) return []
 
+    if (this.recentlyAutofixedViaFormatting.delete(document.uri)) {
+      this.connection.console.log(`[DocumentSave] applyFixes skipping: already autofixed via formatting`)
+      return []
+    }
+
     return this.autofixService.autofix(document)
   }
 
@@ -48,6 +62,10 @@ export class DocumentSaveService {
 
     if (fixOnSave) {
       autofixEdits = await this.autofixService.autofix(document)
+
+      if (autofixEdits.length > 0) {
+        this.recentlyAutofixedViaFormatting.add(document.uri)
+      }
     }
 
     if (!formatterEnabled) return autofixEdits
@@ -56,12 +74,6 @@ export class DocumentSaveService {
       return this.formattingService.formatOnSave(document, reason)
     }
 
-    const autofixedDocument: TextDocument = {
-      ...document,
-      uri: document.uri,
-      getText: () => autofixEdits[0].newText,
-    }
-
-    return this.formattingService.formatOnSave(autofixedDocument, reason)
+    return this.formattingService.formatOnSave(document, reason, autofixEdits[0].newText)
   }
 }