improvement: Look up isAccessible lazily

Author: tgodzik

Diff for: compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -48,6 +48,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)
+      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
@@ -220,11 +230,11 @@ 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 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)},
@@ -358,7 +368,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
@@ -369,14 +379,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[Name, 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 +445,7 @@ object Completion:
         }
       }
 
-      resultMappings
+      CompletionResult(resultMappings, renames.toMap)
     end scopeCompletions
 
     /** Widen only those types which are applied or are exactly nothing
@@ -472,13 +487,16 @@ 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[Name, Name]
 
       if imp == null then
-        Map.empty
+        CompletionResult(Map.empty, Map.empty)
       else
         def fromImport(name: Name, nameInScope: Name): Seq[(Name, SingleDenotation)] =
+          if name != nameInScope then
+            renames(name) = nameInScope
           imp.site.member(name).alternatives
             .collect { case denot if include(denot, nameInScope) => nameInScope -> denot }
 
@@ -506,7 +524,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 */
@@ -584,7 +603,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)
 
@@ -686,6 +705,7 @@ object Completion:
 
   private type CompletionMap = Map[Name, Seq[SingleDenotation]]
 
+  case class CompletionResult(names: Map[Name, Seq[SingleDenotation]], renames: Map[Name, Name])
   /**
    * The completion mode: defines what kinds of symbols should be included in the completion
    * results.

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

@@ -11,11 +11,13 @@ import dotty.tools.dotc.core.Contexts.*
 import dotty.tools.dotc.core.Flags.*
 import dotty.tools.dotc.core.Names.*
 import dotty.tools.dotc.core.Symbols.*
+import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.dotc.util.Spans
 import dotty.tools.pc.utils.InteractiveEnrichments.*
 
 import org.eclipse.lsp4j as l
+import dotty.tools.dotc.config.PathResolver.ppcp
 
 object AutoImports:
 
@@ -40,7 +42,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: Name)(using Context): SymbolIdent = Direct(name.decoded)
 
     def fullIdent(symbol: Symbol)(using Context): SymbolIdent =
       val symbols = symbol.ownersIterator.toList
@@ -49,11 +51,11 @@ object AutoImports:
 
       symbols match
         case head :: tail =>
-          tail.foldLeft(direct(head.nameBackticked))((acc, next) =>
+          tail.foldLeft(direct(head.name))((acc, next) =>
             Select(acc, next.nameBackticked)
           )
         case Nil =>
-          SymbolIdent.direct("<no symbol>")
+          SymbolIdent.direct(nme.NoSymbol)
 
   end SymbolIdent
 
@@ -62,20 +64,20 @@ object AutoImports:
 
   object ImportSel:
     final case class Direct(sym: Symbol) extends ImportSel
-    final case class Rename(sym: Symbol, rename: String) extends ImportSel
+    final case class Rename(sym: Symbol, rename: Name) extends ImportSel
 
   case class SymbolImport(
       sym: Symbol,
       ident: SymbolIdent,
       importSel: Option[ImportSel]
   ):
 
-    def name: String = ident.value
+    def name(using Context): String = ident.value
 
   object SymbolImport:
 
     def simple(sym: Symbol)(using Context): SymbolImport =
-      SymbolImport(sym, SymbolIdent.direct(sym.nameBackticked), None)
+      SymbolImport(sym, SymbolIdent.direct(sym.name), None)
 
   /**
    * Returns AutoImportsGenerator
@@ -97,8 +99,8 @@ object AutoImports:
 
     import indexedContext.ctx
 
-    val importPos = autoImportPosition(pos, text, tree, comments)
-    val renameConfig: Map[Symbol, String] = AutoImport.renameConfigMap(config)
+    val importPos = autoImportPosition(pos, text, tree, comments) // TODO: add rename config
+    val renameConfig: Map[Symbol, Name] =  Map.empty //AutoImport.renameConfigMap(config).collect { case (k, v) => k -> indexedContext.find(v) }
 
     val renames =
       (sym: Symbol) =>
@@ -143,7 +145,7 @@ object AutoImports:
       val pos: SourcePosition,
       importPosition: AutoImportPosition,
       indexedContext: IndexedContext,
-      renames: Symbol => Option[String]
+      renames: Symbol => Option[Name]
   ):
 
     import indexedContext.ctx
@@ -190,7 +192,7 @@ object AutoImports:
               )
             else
               (
-                SymbolIdent.direct(symbol.nameBackticked),
+                SymbolIdent.direct(symbol.name),
                 Some(ImportSel.Direct(symbol)),
               )
           end val
@@ -205,7 +207,7 @@ object AutoImports:
           renames(owner) match
             case Some(rename) =>
               val importSel =
-                if rename != owner.showName then
+                if rename != owner.name then
                   Some(ImportSel.Rename(owner, rename)).filter(_ =>
                     !indexedContext.hasRename(owner, rename)
                   )
@@ -223,14 +225,18 @@ object AutoImports:
                 importSel
               )
             case None =>
+              val reverse = symbol.ownersIterator.toList.reverse
+              val fullName = reverse.drop(1).foldLeft(SymbolIdent.direct(reverse.head.name)){
+                case (acc, sym) => SymbolIdent.Select(acc, sym.nameBackticked(false))
+              } // TODO fullName should work
               SymbolImport(
                 symbol,
-                SymbolIdent.direct(symbol.fullNameBackticked),
+                SymbolIdent.Select(SymbolIdent.direct(owner.name), symbol.nameBackticked(false)),
                 None
               )
           end match
         case IndexedContext.Result.InScope =>
-          val direct = renames(symbol).getOrElse(symbol.nameBackticked)
+          val direct = renames(symbol).getOrElse(symbol.name)
           SymbolImport(symbol, SymbolIdent.direct(direct), None)
       end match
     end inferSymbolImport
@@ -267,13 +273,13 @@ object AutoImports:
     end renderImports
 
     private def importName(sym: Symbol): String =
-      if indexedContext.importContext.toplevelClashes(sym) then
+      if indexedContext.toplevelClashes(sym) 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 Some(renamed) => (renamed.decoded :: acc, true)
             case None if !sym.isPackageObject => (sym.nameBackticked(false) :: acc, false)
             case None => (acc, false)
         }._1.mkString(".")

Diff for: 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)

Diff for: 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) =

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

@@ -49,7 +49,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
@@ -96,7 +96,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,
@@ -134,7 +134,7 @@ object HoverProvider:
             .map(_.docstring())
             .mkString("\n")
 
-          val expresionTypeOpt = 
+          val expresionTypeOpt =
             if symbol.name == StdNames.nme.??? then
               InferExpectedType(search, driver, params).infer()
             else printer.expressionType(exprTpw)