improvement: Rework IndexedContext to reuse the previously calculated scopes (scala#22898)

It turns out the work being done in IndexedContext was already done in
Completions, but better, since it doesn't try to read files as the
separate logic does.

There is still some improvement to be done to not calculate it twice,
but in order to keep this PR as simple as possible I will skip that for
now.

Author: tgodzik

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -46,6 +46,16 @@ case class Completion(label: String, description: String, symbols: List[Symbol])
 
 object Completion:
 
+  def scopeContext(pos: SourcePosition)(using Context): CompletionResult =
+    val tpdPath = Interactive.pathTo(ctx.compilationUnit.tpdTree, pos.span)
+    val completionContext = Interactive.contextOfPath(tpdPath).withPhase(Phases.typerPhase)
+    inContext(completionContext):
+      val untpdPath = Interactive.resolveTypedOrUntypedPath(tpdPath, pos)
+      val mode = completionMode(untpdPath, pos, forSymbolSearch = true)
+      val rawPrefix = completionPrefix(untpdPath, pos)
+      val completer = new Completer(mode, pos, untpdPath, _ => true)
+      completer.scopeCompletions
+
   /** Get possible completions from tree at `pos`
    *
    *  @return offset and list of symbols for possible completions
@@ -58,7 +68,6 @@ object Completion:
       val mode = completionMode(untpdPath, pos)
       val rawPrefix = completionPrefix(untpdPath, pos)
       val completions = rawCompletions(pos, mode, rawPrefix, tpdPath, untpdPath)
-
       postProcessCompletions(untpdPath, completions, rawPrefix)
 
   /** Get possible completions from tree at `pos`
@@ -87,7 +96,7 @@ object Completion:
    *
    * Otherwise, provide no completion suggestion.
    */
-  def completionMode(path: List[untpd.Tree], pos: SourcePosition): Mode = path match
+  def completionMode(path: List[untpd.Tree], pos: SourcePosition, forSymbolSearch: Boolean = false): Mode = path match
     // Ignore `package foo@@` and `package foo.bar@@`
     case ((_: tpd.Select) | (_: tpd.Ident)):: (_ : tpd.PackageDef) :: _  => Mode.None
     case GenericImportSelector(sel) =>
@@ -100,11 +109,14 @@ object Completion:
     case untpd.Literal(Constants.Constant(_: String)) :: _ => Mode.Term | Mode.Scope // literal completions
     case (ref: untpd.RefTree) :: _ =>
       val maybeSelectMembers = if ref.isInstanceOf[untpd.Select] then Mode.Member else Mode.Scope
-
-      if (ref.name.isTermName) Mode.Term | maybeSelectMembers
+      if (forSymbolSearch) then Mode.Term | Mode.Type | maybeSelectMembers
+      else if (ref.name.isTermName) Mode.Term | maybeSelectMembers
       else if (ref.name.isTypeName) Mode.Type | maybeSelectMembers
       else Mode.None
 
+    case (_: tpd.TypeTree | _: tpd.MemberDef) :: _ if forSymbolSearch => Mode.Type | Mode.Term
+    case (_: tpd.CaseDef) :: _ if forSymbolSearch => Mode.Type | Mode.Term
+    case Nil if forSymbolSearch =>  Mode.Type | Mode.Term
     case _ => Mode.None
 
   /** When dealing with <errors> in varios palces we check to see if they are
@@ -227,14 +239,14 @@ object Completion:
     val result = adjustedPath match
       // Ignore synthetic select from `This` because in code it was `Ident`
       // See example in dotty.tools.languageserver.CompletionTest.syntheticThis
-      case tpd.Select(qual @ tpd.This(_), _) :: _ if qual.span.isSynthetic      => completer.scopeCompletions
+      case tpd.Select(qual @ tpd.This(_), _) :: _ if qual.span.isSynthetic      => completer.scopeCompletions.names
       case StringContextApplication(qual) =>
-        completer.scopeCompletions ++ completer.selectionCompletions(qual)
+        completer.scopeCompletions.names ++ completer.selectionCompletions(qual)
       case tpd.Select(qual, _) :: _               if qual.typeOpt.hasSimpleKind =>
         completer.selectionCompletions(qual)
       case tpd.Select(qual, _) :: _                                             => Map.empty
       case (tree: tpd.ImportOrExport) :: _                                      => completer.directMemberCompletions(tree.expr)
-      case _                                                                    => completer.scopeCompletions
+      case _                                                                    => completer.scopeCompletions.names
 
     interactiv.println(i"""completion info with pos    = $pos,
                           |                     term   = ${completer.mode.is(Mode.Term)},
@@ -335,6 +347,7 @@ object Completion:
          (completionMode.is(Mode.Term) && (sym.isTerm || sym.is(ModuleClass))
       || (completionMode.is(Mode.Type) && (sym.isType || sym.isStableMember)))
     )
+  end isValidCompletionSymbol
 
   given ScopeOrdering(using Context): Ordering[Seq[SingleDenotation]] with
     val order =
@@ -368,7 +381,7 @@ object Completion:
      *    (even if the import follows it syntactically)
      *  - a more deeply nested import shadowing a member or a local definition causes an ambiguity
      */
-    def scopeCompletions(using context: Context): CompletionMap =
+    def scopeCompletions(using context: Context): CompletionResult =
 
       /** Temporary data structure representing denotations with the same name introduced in a given scope
        *  as a member of a type, by a local definition or by an import clause
@@ -379,14 +392,19 @@ object Completion:
           ScopedDenotations(denots.filter(includeFn), ctx)
 
       val mappings = collection.mutable.Map.empty[Name, List[ScopedDenotations]].withDefaultValue(List.empty)
+      val renames = collection.mutable.Map.empty[Symbol, Name]
       def addMapping(name: Name, denots: ScopedDenotations) =
         mappings(name) = mappings(name) :+ denots
 
       ctx.outersIterator.foreach { case ctx @ given Context =>
         if ctx.isImportContext then
-          importedCompletions.foreach { (name, denots) =>
+          val imported = importedCompletions
+          imported.names.foreach { (name, denots) =>
             addMapping(name, ScopedDenotations(denots, ctx, include(_, name)))
           }
+          imported.renames.foreach { (name, newName) =>
+            renames(name) = newName
+          }
         else if ctx.owner.isClass then
           accessibleMembers(ctx.owner.thisType)
             .groupByName.foreach { (name, denots) =>
@@ -430,7 +448,6 @@ object Completion:
           // most deeply nested member or local definition if not shadowed by an import
           case Some(local) if local.ctx.scope == first.ctx.scope =>
             resultMappings += name -> local.denots
-
           case None if isSingleImport || isImportedInDifferentScope || isSameSymbolImportedDouble =>
             resultMappings += name -> first.denots
           case None if notConflictingWithDefaults =>
@@ -440,7 +457,7 @@ object Completion:
         }
       }
 
-      resultMappings
+      CompletionResult(resultMappings, renames.toMap)
     end scopeCompletions
 
     /** Widen only those types which are applied or are exactly nothing
@@ -474,15 +491,20 @@ object Completion:
     /** Completions introduced by imports directly in this context.
      *  Completions from outer contexts are not included.
      */
-    private def importedCompletions(using Context): CompletionMap =
+    private def importedCompletions(using Context): CompletionResult =
       val imp = ctx.importInfo
+      val renames = collection.mutable.Map.empty[Symbol, Name]
 
       if imp == null then
-        Map.empty
+        CompletionResult(Map.empty, Map.empty)
       else
         def fromImport(name: Name, nameInScope: Name): Seq[(Name, SingleDenotation)] =
           imp.site.member(name).alternatives
-            .collect { case denot if include(denot, nameInScope) => nameInScope -> denot }
+            .collect { case denot if include(denot, nameInScope) =>
+               if name != nameInScope then
+                 renames(denot.symbol) = nameInScope
+               nameInScope -> denot
+            }
 
         val givenImports = imp.importedImplicits
           .map { ref => (ref.implicitName: Name, ref.underlyingRef.denot.asSingleDenotation) }
@@ -508,7 +530,8 @@ object Completion:
               fromImport(original.toTypeName, nameInScope.toTypeName)
             }.toSeq.groupByName
 
-        givenImports ++ wildcardMembers ++ explicitMembers
+        val results = givenImports ++ wildcardMembers ++ explicitMembers
+        CompletionResult(results, renames.toMap)
     end importedCompletions
 
     /** Completions from implicit conversions including old style extensions using implicit classes */
@@ -562,7 +585,7 @@ object Completion:
 
       // 1. The extension method is visible under a simple name, by being defined or inherited or imported in a scope enclosing the reference.
       val termCompleter = new Completer(Mode.Term, pos, untpdPath, matches)
-      val extMethodsInScope = termCompleter.scopeCompletions.toList.flatMap:
+      val extMethodsInScope = termCompleter.scopeCompletions.names.toList.flatMap:
         case (name, denots) => denots.collect:
           case d: SymDenotation if d.isTerm && d.termRef.symbol.is(Extension) => (d.termRef, name.asTermName)
 
@@ -664,6 +687,7 @@ object Completion:
 
   private type CompletionMap = Map[Name, Seq[SingleDenotation]]
 
+  case class CompletionResult(names: Map[Name, Seq[SingleDenotation]], renames: Map[Symbol, Name])
   /**
    * The completion mode: defines what kinds of symbols should be included in the completion
    * results.

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

@@ -40,7 +40,7 @@ object AutoImports:
     case class Select(qual: SymbolIdent, name: String) extends SymbolIdent:
       def value: String = s"${qual.value}.$name"
 
-    def direct(name: String): SymbolIdent = Direct(name)
+    def direct(name: String)(using Context): SymbolIdent = Direct(name)
 
     def fullIdent(symbol: Symbol)(using Context): SymbolIdent =
       val symbols = symbol.ownersIterator.toList
@@ -70,7 +70,7 @@ object AutoImports:
       importSel: Option[ImportSel]
   ):
 
-    def name: String = ident.value
+    def name(using Context): String = ident.value
 
   object SymbolImport:
 
@@ -189,10 +189,13 @@ object AutoImports:
                 ownerImport.importSel,
               )
             else
-              (
-                SymbolIdent.direct(symbol.nameBackticked),
-                Some(ImportSel.Direct(symbol)),
-              )
+              renames(symbol) match
+                case Some(rename) => (SymbolIdent.direct(rename), None)
+                case None =>
+                  (
+                    SymbolIdent.direct(symbol.nameBackticked),
+                    Some(ImportSel.Direct(symbol)),
+                  )
           end val
 
           SymbolImport(
@@ -223,9 +226,13 @@ object AutoImports:
                 importSel
               )
             case None =>
+              val reverse = symbol.ownersIterator.toList.reverse
+              val fullName = reverse.drop(1).foldLeft(SymbolIdent.direct(reverse.head.nameBackticked)){
+                case (acc, sym) => SymbolIdent.Select(acc, sym.nameBackticked(false))
+              }
               SymbolImport(
                 symbol,
-                SymbolIdent.direct(symbol.fullNameBackticked),
+                SymbolIdent.Direct(symbol.fullNameBackticked),
                 None
               )
           end match
@@ -252,7 +259,6 @@ object AutoImports:
         val topPadding =
           if importPosition.padTop then "\n"
           else ""
-
         val formatted = imports
           .map {
             case ImportSel.Direct(sym) => importName(sym)
@@ -267,15 +273,16 @@ object AutoImports:
     end renderImports
 
     private def importName(sym: Symbol): String =
-      if indexedContext.importContext.toplevelClashes(sym) then
+      if indexedContext.toplevelClashes(sym, inImportScope = true) then
         s"_root_.${sym.fullNameBackticked(false)}"
       else
         sym.ownersIterator.zipWithIndex.foldLeft((List.empty[String], false)) { case ((acc, isDone), (sym, idx)) =>
           if(isDone || sym.isEmptyPackage || sym.isRoot) (acc, true)
           else indexedContext.rename(sym) match
-            case Some(renamed) => (renamed :: acc, true)
-            case None if !sym.isPackageObject => (sym.nameBackticked(false) :: acc, false)
-            case None => (acc, false)
+            // we can't import first part
+            case Some(renamed) if idx != 0 => (renamed :: acc, true)
+            case _ if !sym.isPackageObject => (sym.nameBackticked(false) :: acc, false)
+            case _ => (acc, false)
         }._1.mkString(".")
   end AutoImportsGenerator
 

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

@@ -44,8 +44,8 @@ final class AutoImportsProvider(
     val path =
       Interactive.pathTo(newctx.compilationUnit.tpdTree, pos.span)(using newctx)
 
-    val indexedContext = IndexedContext(
-      Interactive.contextOfPath(path)(using newctx)
+    val indexedContext = IndexedContext(pos)(
+      using Interactive.contextOfPath(path)(using newctx)
     )
     import indexedContext.ctx
 
@@ -96,7 +96,7 @@ final class AutoImportsProvider(
                 text,
                 tree,
                 unit.comments,
-                indexedContext.importContext,
+                indexedContext,
                 config
               )
             (sym: Symbol) => generator.forSymbol(sym)

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

@@ -51,7 +51,7 @@ final class ExtractMethodProvider(
     given locatedCtx: Context =
       val newctx = driver.currentCtx.fresh.setCompilationUnit(unit)
       Interactive.contextOfPath(path)(using newctx)
-    val indexedCtx = IndexedContext(locatedCtx)
+    val indexedCtx = IndexedContext(pos)(using locatedCtx)
     val printer =
       ShortenedTypePrinter(search, IncludeDefaultParam.Never)(using indexedCtx)
     def prettyPrint(tpe: Type) =

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

@@ -47,7 +47,7 @@ object HoverProvider:
     val path = unit
       .map(unit => Interactive.pathTo(unit.tpdTree, pos.span))
       .getOrElse(Interactive.pathTo(driver.openedTrees(uri), pos))
-    val indexedContext = IndexedContext(ctx)
+    val indexedContext = IndexedContext(pos)(using ctx)
 
     def typeFromPath(path: List[Tree]) =
       if path.isEmpty then NoType else path.head.typeOpt
@@ -94,7 +94,7 @@ object HoverProvider:
 
       val printerCtx = Interactive.contextOfPath(path)
       val printer = ShortenedTypePrinter(search, IncludeDefaultParam.Include)(
-        using IndexedContext(printerCtx)
+        using IndexedContext(pos)(using printerCtx)
       )
       MetalsInteractive.enclosingSymbolsWithExpressionType(
         enclosing,
@@ -131,7 +131,12 @@ object HoverProvider:
             .flatMap(symTpe => search.symbolDocumentation(symTpe._1, contentType))
             .map(_.docstring())
             .mkString("\n")
-          printer.expressionType(exprTpw) match
+
+          val expresionTypeOpt =
+            if symbol.name == nme.??? then
+              InferExpectedType(search, driver, params).infer()
+            else printer.expressionType(exprTpw)
+          expresionTypeOpt match
             case Some(expressionType) =>
               val forceExpressionType =
                 !pos.span.isZeroExtent || (