Unify completion pos usage, fix presentation compiler crash in interpolator

Author: rochala

presentation-compiler/src/main/dotty/tools/pc/AutoImportsProvider.scala

@@ -67,7 +67,7 @@ final class AutoImportsProvider(
     val results = symbols.result.filter(isExactMatch(_, name))
 
     if results.nonEmpty then
-      val correctedPos = CompletionPos.infer(pos, params, path).sourcePos
+      val correctedPos = CompletionPos.infer(pos, params, path).toSourcePosition
       val mkEdit =
         path match
           // if we are in import section just specify full name

presentation-compiler/src/main/dotty/tools/pc/completions/AmmoniteIvyCompletions.scala

@@ -13,7 +13,7 @@ object AmmoniteIvyCompletions:
       completionPos: CompletionPos,
       text: String
   )(using Context): List[CompletionValue] =
-    val pos = completionPos.sourcePos
+    val pos = completionPos.originalCursorPosition
     val query = selector.collectFirst {
       case sel: ImportSelector
           if sel.sourcePos.encloses(pos) && sel.sourcePos.`end` > pos.`end` =>

presentation-compiler/src/main/dotty/tools/pc/completions/CompletionPos.scala

@@ -6,52 +6,54 @@ import java.net.URI
 import scala.meta.pc.OffsetParams
 
 import dotty.tools.dotc.ast.untpd.*
-import dotty.tools.dotc.ast.untpd.ImportSelector
 import dotty.tools.dotc.core.Contexts.*
-import dotty.tools.dotc.core.StdNames.*
-import dotty.tools.dotc.util.Chars
 import dotty.tools.dotc.util.SourcePosition
-import dotty.tools.dotc.util.Spans
+import dotty.tools.dotc.util.Spans.*
 import dotty.tools.dotc.interactive.Completion
 import dotty.tools.pc.utils.MtagsEnrichments.*
 
 import org.eclipse.lsp4j as l
-import scala.annotation.tailrec
+
+case object Cursor:
+  val value = "CURSOR"
 
 case class CompletionPos(
-    start: Int,
-    end: Int,
-    query: String,
-    cursorPos: SourcePosition,
-    sourceUri: URI
+  queryStart: Int,
+  identEnd: Int,
+  query: String,
+  originalCursorPosition: SourcePosition,
+  sourceUri: URI
 ):
-
-  def sourcePos: SourcePosition = cursorPos.withSpan(Spans.Span(start, end))
-  def stripSuffixEditRange: l.Range = new l.Range(cursorPos.offsetToPos(start), cursorPos.offsetToPos(end))
-  def toEditRange: l.Range = cursorPos.withStart(start).withEnd(cursorPos.point).toLsp
-
-end CompletionPos
+  def queryEnd: Int = originalCursorPosition.point
+  def point: Int = originalCursorPosition.point
+  def stripSuffixEditRange: l.Range = new l.Range(originalCursorPosition.offsetToPos(queryStart), originalCursorPosition.offsetToPos(identEnd))
+  def toEditRange: l.Range = originalCursorPosition.withStart(queryStart).withEnd(originalCursorPosition.point).toLsp
+  def toSourcePosition: SourcePosition = originalCursorPosition.withSpan(Span(queryStart, queryEnd, point))
 
 object CompletionPos:
 
   def infer(
-      cursorPos: SourcePosition,
+      sourcePosition: SourcePosition,
       offsetParams: OffsetParams,
       adjustedPath: List[Tree]
   )(using Context): CompletionPos =
-    infer(cursorPos, offsetParams.uri().nn, offsetParams.text().nn, adjustedPath)
+    infer(sourcePosition, offsetParams.uri().nn, String(sourcePosition.source.content()), adjustedPath)
 
   def infer(
-      cursorPos: SourcePosition,
+      sourcePos: SourcePosition,
       uri: URI,
       text: String,
       adjustedPath: List[Tree]
   )(using Context): CompletionPos =
-    val identEnd = inferIdentEnd(cursorPos, text)
-    val query = Completion.completionPrefix(adjustedPath, cursorPos)
-    val start = cursorPos.point - query.length()
+    val identEnd = adjustedPath match
+      case (ident: Ident) :: _ if ident.toString.contains(Cursor.value) =>
+        ident.span.end - Cursor.value.length
+      case _ => sourcePos.end
 
-    CompletionPos(start, identEnd, query.nn, cursorPos, uri)
+    val query = Completion.completionPrefix(adjustedPath, sourcePos)
+    val start = sourcePos.end - query.length()
+
+    CompletionPos(start, identEnd, query.nn, sourcePos, uri)
   end infer
 
   /**
@@ -76,12 +78,4 @@ object CompletionPos:
     (i, tabIndented)
   end inferIndent
 
-  /**
-   * Returns the end offset of the identifier starting as the given offset position.
-   */
-  private def inferIdentEnd(pos: SourcePosition, text: String): Int =
-    var i = pos.point
-    while i < text.length() && Chars.isIdentifierPart(text.charAt(i)) do i += 1
-    i
-
 end CompletionPos

presentation-compiler/src/main/dotty/tools/pc/completions/CompletionProvider.scala

@@ -61,11 +61,10 @@ class CompletionProvider(
         val locatedCtx = Interactive.contextOfPath(tpdPath)(using newctx)
         val indexedCtx = IndexedContext(locatedCtx)
 
-        val completionPos =
-          CompletionPos.infer(pos, params, adjustedPath)(using locatedCtx)
+        val completionPos = CompletionPos.infer(pos, params, adjustedPath)(using locatedCtx)
 
         val autoImportsGen = AutoImports.generator(
-          completionPos.sourcePos,
+          completionPos.toSourcePosition,
           text,
           unit.tpdTree,
           unit.comments,
@@ -75,7 +74,6 @@ class CompletionProvider(
 
         val (completions, searchResult) =
           new Completions(
-            pos,
             text,
             locatedCtx,
             search,
@@ -120,7 +118,7 @@ class CompletionProvider(
    *   val a = 1
    *   @@
    * }}}
-   * it's required to modify actual code by addition Ident.
+   * it's required to modify actual code by additional Ident.
    *
    * Otherwise, completion poisition doesn't point at any tree
    * because scala parser trim end position to the last statement pos.
@@ -168,7 +166,7 @@ class CompletionProvider(
         additionalEdits: List[TextEdit] = Nil,
         range: Option[LspRange] = None
     ): CompletionItem =
-      val oldText = params.text().nn.substring(completionPos.start, completionPos.end)
+      val oldText = String(params.text().nn.substring(completionPos.queryStart, completionPos.identEnd))
       val editRange = if newText.startsWith(oldText) then completionPos.stripSuffixEditRange
         else completionPos.toEditRange
 
@@ -231,6 +229,7 @@ class CompletionProvider(
             case Some(edits) =>
               edits match
                 case AutoImportEdits(Some(nameEdit), other) =>
+                  println(nameEdit)
                   mkItem(nameEdit.getNewText().nn, other.toList, range = Some(nameEdit.getRange().nn))
                 case _ =>
                   mkItem(
@@ -279,6 +278,3 @@ class CompletionProvider(
     end match
   end completionItems
 end CompletionProvider
-
-case object Cursor:
-  val value = "CURSOR"

presentation-compiler/src/main/dotty/tools/pc/completions/Completions.scala

@@ -37,7 +37,6 @@ import dotty.tools.dotc.core.Denotations.SingleDenotation
 import dotty.tools.dotc.interactive.Interactive
 
 class Completions(
-    pos: SourcePosition,
     text: String,
     ctx: Context,
     search: SymbolSearch,
@@ -56,7 +55,7 @@ class Completions(
   given context: Context = ctx
 
   private lazy val coursierComplete = new CoursierComplete(BuildInfo.scalaVersion)
-  private lazy val completionMode = Completion.completionMode(adjustedPath, pos)
+  private lazy val completionMode = Completion.completionMode(adjustedPath, completionPos.originalCursorPosition)
 
   private lazy val shouldAddSnippet =
     path match
@@ -83,8 +82,8 @@ class Completions(
       if !sym.name.endsWith(Cursor.value) then false
       else
         val realNameLength = sym.decodedName.length() - Cursor.value.length()
-        sym.source == pos.source &&
-        sym.span.start + realNameLength == pos.span.end
+        sym.source == completionPos.originalCursorPosition.source &&
+        sym.span.start + realNameLength == completionPos.point
 
     val generalExclude =
       isUninterestingSymbol(sym) ||
@@ -107,7 +106,7 @@ class Completions(
   end includeSymbol
 
   def completions(): (List[CompletionValue], SymbolSearch.Result) =
-    val (advanced, exclusive) = advancedCompletions(path, pos, completionPos)
+    val (advanced, exclusive) = advancedCompletions(path, completionPos.originalCursorPosition, completionPos)
     val (all, result) =
       if exclusive then (advanced, SymbolSearch.Result.COMPLETE)
       else
@@ -116,19 +115,19 @@ class Completions(
         val allAdvanced = advanced ++ keywords
         path match
           // should not show completions for toplevel
-          case Nil | (_: PackageDef) :: _ if pos.source.file.extension != "sc" =>
+          case Nil | (_: PackageDef) :: _ if completionPos.originalCursorPosition.source.file.extension != "sc" =>
             (allAdvanced, SymbolSearch.Result.COMPLETE)
           case Select(qual, _) :: _ if qual.typeOpt.isErroneous =>
             (allAdvanced, SymbolSearch.Result.COMPLETE)
           case Select(qual, _) :: _ =>
-            val compilerCompletions = Completion.rawCompletions(pos, completionMode, completionPos.query, path, adjustedPath)
+            val compilerCompletions = Completion.rawCompletions(completionPos.originalCursorPosition, completionMode, completionPos.query, path, adjustedPath)
             val (compiler, result) = compilerCompletions
               .toList
               .flatMap(toCompletionValues)
               .filterInteresting(qual.typeOpt.widenDealias)
             (allAdvanced ++ compiler, result)
           case _ =>
-            val compilerCompletions = Completion.rawCompletions(pos, completionMode, completionPos.query, path, adjustedPath)
+            val compilerCompletions = Completion.rawCompletions(completionPos.originalCursorPosition, completionMode, completionPos.query, path, adjustedPath)
             val (compiler, result) = compilerCompletions
               .toList
               .flatMap(toCompletionValues)
@@ -393,10 +392,10 @@ class Completions(
         val values = FilenameCompletions.contribute(filename, td)
         (values, true)
       case (lit @ Literal(Constant(_: String))) :: _ =>
+        println("COMpletion")
         val completions = InterpolatorCompletions
           .contribute(
             text,
-            pos,
             completionPos,
             indexedContext,
             lit,
@@ -651,7 +650,7 @@ class Completions(
 
   private def isNotLocalForwardReference(sym: Symbol)(using Context): Boolean =
     !sym.isLocalToBlock ||
-      !sym.srcPos.isAfter(pos) ||
+      !sym.srcPos.isAfter(completionPos.originalCursorPosition) ||
       sym.is(Param)
 
   private def computeRelevancePenalty(
@@ -670,7 +669,7 @@ class Completions(
     def symbolRelevance(sym: Symbol): Int =
       var relevance = 0
       // symbols defined in this file are more relevant
-      if pos.source != sym.source || sym.is(Package) then
+      if completionPos.originalCursorPosition.source != sym.source || sym.is(Package) then
         relevance |= IsNotDefinedInFile
 
       // fields are more relevant than non fields (such as method)

presentation-compiler/src/main/dotty/tools/pc/completions/InterpolatorCompletions.scala

@@ -12,6 +12,7 @@ import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Flags.*
 import dotty.tools.dotc.core.Symbols.Symbol
+import dotty.tools.dotc.util.Spans
 import dotty.tools.dotc.core.Types.Type
 import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.pc.CompilerSearchVisitor
@@ -24,7 +25,6 @@ object InterpolatorCompletions:
 
   def contribute(
       text: String,
-      pos: SourcePosition,
       completionPos: CompletionPos,
       indexedContext: IndexedContext,
       lit: Literal,
@@ -35,12 +35,12 @@ object InterpolatorCompletions:
       config: PresentationCompilerConfig,
       buildTargetIdentifier: String
   )(using Context, ReportContext) =
-    InterpolationSplice(pos.span.point, text.toCharArray().nn, text) match
+    InterpolationSplice(completionPos.queryEnd, text.toCharArray().nn, text) match
       case Some(interpolator) =>
         InterpolatorCompletions.contributeScope(
           text,
           lit,
-          pos,
+          completionPos,
           interpolator,
           indexedContext,
           completions,
@@ -55,7 +55,6 @@ object InterpolatorCompletions:
           lit,
           path,
           text,
-          pos,
           completionPos,
           completions,
           snippetsEnabled,
@@ -106,7 +105,6 @@ object InterpolatorCompletions:
       lit: Literal,
       path: List[Tree],
       text: String,
-      cursor: SourcePosition,
       completionPos: CompletionPos,
       completions: Completions,
       areSnippetsSupported: Boolean,
@@ -166,7 +164,7 @@ object InterpolatorCompletions:
                 label,
                 Some(newText(name, suffix.toEditOpt, identOrSelect)),
                 Nil,
-                Some(cursor.withStart(identOrSelect.span.start).toLsp),
+                Some(completionPos.originalCursorPosition.withStart(identOrSelect.span.start).toLsp),
                 // Needed for VS Code which will not show the completion otherwise
                 Some(identOrSelect.name.toString() + "." + label),
                 denot.symbol,
@@ -219,7 +217,7 @@ object InterpolatorCompletions:
   private def contributeScope(
       text: String,
       lit: Literal,
-      position: SourcePosition,
+      completionPos: CompletionPos,
       interpolator: InterpolationSplice,
       indexedContext: IndexedContext,
       completions: Completions,
@@ -230,14 +228,10 @@ object InterpolatorCompletions:
   )(using ctx: Context, reportsContext: ReportContext): List[CompletionValue] =
     val litStartPos = lit.span.start
     val litEndPos = lit.span.end - Cursor.value.length()
-    val span = position.span
-    val nameStart =
-      span.withStart(span.start - interpolator.name.size)
-    val nameRange = position.withSpan(nameStart).toLsp
-    val hasClosingBrace: Boolean = text.charAt(span.point) == '}'
-    val hasOpeningBrace: Boolean = text.charAt(
-      span.start - interpolator.name.size - 1
-    ) == '{'
+    val nameStart = Spans.Span(completionPos.point - interpolator.name.size, completionPos.queryEnd)
+    val nameRange = completionPos.originalCursorPosition.withSpan(nameStart).toLsp
+    val hasClosingBrace: Boolean = text.charAt(completionPos.point) == '}'
+    val hasOpeningBrace: Boolean = text.charAt(nameStart.start - 1) == '{'
 
     def additionalEdits(): List[l.TextEdit] =
       val interpolatorEdit =

presentation-compiler/src/main/dotty/tools/pc/completions/KeywordsCompletions.scala

@@ -21,7 +21,7 @@ object KeywordsCompletions:
       comments: List[Comment]
   )(using ctx: Context): List[CompletionValue] =
     lazy val notInComment =
-      checkIfNotInComment(completionPos.cursorPos, comments)
+      checkIfNotInComment(completionPos.originalCursorPosition, comments)
 
     path match
       case Nil | (_: PackageDef) :: _ if completionPos.query.isEmpty() =>
@@ -33,8 +33,7 @@ object KeywordsCompletions:
       case _ =>
         val isExpression = this.isExpression(path)
         val isBlock = this.isBlock(path)
-        val isDefinition =
-          this.isDefinition(path, completionPos.query, completionPos.cursorPos)
+        val isDefinition = this.isDefinition(path, completionPos.query, completionPos.originalCursorPosition)
         val isMethodBody = this.isMethodBody(path)
         val isTemplate = this.isTemplate(path)
         val isPackage = this.isPackage(path)
@@ -191,10 +190,10 @@ object KeywordsCompletions:
         case untpdTree: untpd.Tree =>
           collectTypeAndModuleDefs(untpdTree, {
             case typeDef: (untpd.TypeDef | untpd.ModuleDef) =>
-              typeDef.span.exists && typeDef.span.end < pos.sourcePos.span.start
+              typeDef.span.exists && typeDef.span.end < pos.queryStart
             case _ => false
           })
-          .filter(tree => tree.span.exists && tree.span.end < pos.start)
+          .filter(tree => tree.span.exists && tree.span.end < pos.queryStart)
           .maxByOption(_.span.end)
         case _ => None
       }
@@ -208,7 +207,7 @@ object KeywordsCompletions:
         template.derived.isEmpty
       )
 
-    val untpdPath = NavigateAST.untypedPath(pos.cursorPos.span)
+    val untpdPath = NavigateAST.untypedPath(pos.originalCursorPosition.span)
 
     findLastSatisfyingTree(untpdPath).orElse { enclosing match
       case (typeDef: TypeDef) :: _ if typeDef.symbol.isEnumClass => untpdPath.headOption

presentation-compiler/src/main/dotty/tools/pc/completions/MatchCaseCompletions.scala

@@ -519,8 +519,8 @@ class MatchCaseExtractor(
                 name.toString().replace(Cursor.value, "")
               ) && (text
               .charAt(
-                completionPos.start - 1
-              ) == ' ' || text.charAt(completionPos.start - 1) == '.') =>
+                completionPos.queryStart - 1
+              ) == ' ' || text.charAt(completionPos.queryStart - 1) == '.') =>
           Some(qualifier)
         case _ => None
   end MatchExtractor

presentation-compiler/src/main/dotty/tools/pc/completions/ScalaCliCompletions.scala

@@ -26,7 +26,7 @@ class ScalaCliCompletions(
 
   def contribute(dependency: String) =
     val completions = coursierComplete.complete(dependency)
-    val (editStart, editEnd) = CoursierComplete.inferEditRange(pos.point, text)
+    val (editStart, editEnd) = CoursierComplete.inferEditRange(pos.end, text)
     val editRange = pos.withStart(editStart).withEnd(editEnd).toLsp
     completions
       .map(insertText =>