Code completions - reworks - part 2

prolativ · prolativ · commit 3140bdedb26b · 2021-02-15T15:00:04.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/interactive/Completion.scala b/compiler/src/dotty/tools/dotc/interactive/Completion.scala
@@ -106,31 +106,25 @@ object Completion {
       case _ => 0
     }
 
-  /** Create a new `CompletionBuffer` for completing at `pos`. */
-  private def completionBuffer(path: List[Tree], pos: SourcePosition): CompletionBuffer = {
+  private def computeCompletions(pos: SourcePosition, path: List[Tree])(using Context): (Int, List[Completion]) = {
     val mode = completionMode(path, pos)
     val prefix = completionPrefix(path, pos)
-    new CompletionBuffer(mode, prefix, pos)
-  }
-
-  private def computeCompletions(pos: SourcePosition, path: List[Tree])(using Context): (Int, List[Completion]) = {
-
-    val offset = completionOffset(path)
-    val buffer = completionBuffer(path, pos)
+    val completer = new Completer(mode, prefix, pos)
 
     val scope = path match {
-        case Select(qual, _) :: _                              => buffer.selectionCompletions(path, qual)
-        case Import(expr, _) :: _                              => buffer.directMemberCompletions(expr)
-        case (_: untpd.ImportSelector) :: Import(expr, _) :: _ => buffer.directMemberCompletions(expr)
-        case _                                                 => buffer.scopeCompletions
+        case Select(qual, _) :: _                              => completer.selectionCompletions(path, qual)
+        case Import(expr, _) :: _                              => completer.directMemberCompletions(expr)
+        case (_: untpd.ImportSelector) :: Import(expr, _) :: _ => completer.directMemberCompletions(expr)
+        case _                                                 => completer.scopeCompletions
       }
 
     val completionList = scope.getCompletions
+    val offset = completionOffset(path)
 
     interactiv.println(i"""completion with pos     = $pos,
-                          |                prefix  = ${buffer.prefix},
-                          |                term    = ${buffer.mode.is(Mode.Term)},
-                          |                type    = ${buffer.mode.is(Mode.Type)}
+                          |                prefix  = ${completer.prefix},
+                          |                term    = ${completer.mode.is(Mode.Term)},
+                          |                type    = ${completer.mode.is(Mode.Type)}
                           |                results = $completionList%, %""")
     (offset, completionList)
   }
@@ -156,7 +150,12 @@ object Completion {
         ""
     }
 
-  private class CompletionBuffer(val mode: Mode, val prefix: String, pos: SourcePosition) {
+  /** Computes code completions depending on the context in which completion is requested
+   * @param mode    Should complete names of terms, types or both
+   * @param prefix  The prefix that all suggested completions should start with
+   * @param pos     Cursor position where completion was requested
+   */
+  private class Completer(val mode: Mode, val prefix: String, pos: SourcePosition) {
     /** Completions for terms and types that are currently in scope:
      *  the members of the current class and the symbols that have been imported, recursively adding completions from outer scopes
      */
@@ -167,13 +166,15 @@ object Completion {
           val grouped = elems.groupBy(f)
           keys.map(key => key -> grouped(key))
 
-      val grouped = ctx.outersIterator.toList.reverse.orderedGroupBy(_.owner).filter(_._1.exists)
-      val imported = grouped.map { (owner, contexts) =>
+      val contextsByOwner = ctx.outersIterator.toList
+        .reverse.orderedGroupBy(_.owner)
+        .filter(_._1.exists)
+      val imported = contextsByOwner.map { (_, contexts) =>
         contexts.collect { case context if context.isImportContext =>
           importedCompletions(using context)
         }.foldLeft(CompletionScope.empty)(_.mergeDiscardingAmbiguities(_))
       }
-      val members = grouped.map { (owner, _) =>
+      val members = contextsByOwner.map { (owner, _) =>
         if owner.isClass then
           CompletionScope.from(accessibleMembers(owner.thisType))
         else CompletionScope.empty
@@ -209,7 +210,10 @@ object Completion {
           val types = imp.site.member(name.toTypeName).alternatives.map(denot => nameInScope.toTypeName -> denot)
           CompletionScope.fromNamed(terms ++ types)
 
-        val givenImports = CompletionScope.fromNamed(imp.importedImplicits.map(x => (x.implicitName, x.underlyingRef.denot.asSingleDenotation)))
+        val namedImportedImplicits = imp.importedImplicits.map { ref =>
+          (ref.implicitName, ref.underlyingRef.denot.asSingleDenotation)
+        }
+        val givenImports = CompletionScope.fromNamed(namedImportedImplicits)
 
         val wildcardMembers =
           if imp.selectors.exists(_.imported.name == nme.WILDCARD) then
@@ -243,8 +247,8 @@ object Completion {
         case _: MethodOrPoly => tpe
         case _ => ExprType(tpe)
 
-      def tryApplyingReceiver(termRef: TermRef): Option[SingleDenotation] =
-        ctx.typer.tryApplyingReceiver(termRef, qual)
+      def tryApplyingReceiverToExtension(termRef: TermRef): Option[SingleDenotation] =
+        ctx.typer.tryApplyingExtensionMethod(termRef, qual)
           .map { tree =>
             val tpe = asDefLikeType(tree.tpe.dealias)
             termRef.denot.asSingleDenotation.mapInfo(_ => tpe)
@@ -259,15 +263,16 @@ object Completion {
               case name: TermName if name.startsWith(matchingNamePrefix) => Some((denot, name))
               case _ => None
 
-        types.flatMap{ tpe =>
+        types.flatMap { tpe =>
           tpe.membersBasedOnFlags(required = ExtensionMethod, excluded = EmptyFlags)
             .collect { case DenotWithMatchingName(denot, name) => TermRef(tpe, denot.symbol) -> name }
         }
 
       // There are four possible ways for an extension method to be applicable
 
       // 1. The extension method is visible under a simple name, by being defined or inherited or imported in a scope enclosing the reference.
-      val extMethodsInScope = scopeCompletions.nameToDenots.toList.flatMap {
+      val termCompleter = new Completer(Mode.Term, prefix, pos)
+      val extMethodsInScope = termCompleter.scopeCompletions.nameToDenots.toList.flatMap {
         case (name, denots) => denots.collect { case d: SymDenotation => (d.termRef, name.asTermName) }
       }
 
@@ -287,8 +292,8 @@ object Completion {
       val extMethodsWithAppliedReceiver = availableExtMethods.flatMap {
         case (termRef, termName) =>
           if termRef.symbol.is(ExtensionMethod) && !qual.tpe.isBottomType then
-            val applied = tryApplyingReceiver(termRef)
-            applied.map{ denot =>
+            val applied = tryApplyingReceiverToExtension(termRef)
+            applied.map { denot =>
               val sym = denot.symbol.asTerm.copy(name = termName)
               denot.derivedSingleDenotation(sym, denot.info)
             }
@@ -326,23 +331,17 @@ object Completion {
     /** @param site The type to inspect.
      *  @return The members of `site` that are accessible and pass the include filter.
      */
-    private def accessibleMembers(site: Type)(using Context): Seq[SingleDenotation] = site match {
-      case site: NamedType if site.symbol.is(Package) =>
-        extension (tpe: Type)
-          def accessibleMembers = tpe.allMembers.toList.filter(denot => denot.symbol.isAccessibleFrom(site, superAccess = false))
-
-        val packageDecls = site.accessibleMembers
-        val packageObjectsDecls = packageDecls.filter(_.symbol.isPackageObject).flatMap(_.symbol.thisType.accessibleMembers)
-
-        packageDecls ++ packageObjectsDecls
-      case _ =>
-        def appendMemberSyms(name: Name, buf: mutable.Buffer[SingleDenotation]): Unit =
-          try buf ++= site.member(name).alternatives
-          catch { case ex: TypeError => }
-        site.memberDenots(completionsFilter, appendMemberSyms).collect {
-          case mbr if include(mbr.symbol, mbr.symbol.name)
-                      && mbr.symbol.isAccessibleFrom(site, superAccess = true) => mbr
-        }
+    private def accessibleMembers(site: Type)(using Context): Seq[SingleDenotation] = {
+      def appendMemberSyms(name: Name, buf: mutable.Buffer[SingleDenotation]): Unit =
+        try
+          buf ++= site.member(name).alternatives
+        catch
+          case ex: TypeError =>
+
+      site.memberDenots(completionsFilter, appendMemberSyms).collect {
+        case mbr if include(mbr.symbol, mbr.symbol.name)
+                    && mbr.symbol.isAccessibleFrom(site) => mbr
+      }
     }
 
     /**
@@ -367,27 +366,60 @@ object Completion {
       def isStable = true
     }
 
-    extension (scope: CompletionScope)
-      private def withDenots(denotations: Seq[SingleDenotation], name: Name)(using Context): CompletionScope = {
-        val denots = denotations.filter(denot => include(denot.symbol, name))
-        val shortName = name.stripModuleClassSuffix
-
-        if denots.nonEmpty then
-          CompletionScope(scope.nameToDenots + (shortName -> denots.toList))
-        else
-          scope
+    object CompletionScope {
+      def from(denotations: Seq[SingleDenotation])(using Context): CompletionScope = {
+        val mappings = denotations
+          .filter(den => include(den.symbol, den.name))
+          .toList
+          .groupBy(_.name)
+          .map((name, denots) => name.stripModuleClassSuffix -> denots)
+        CompletionScope(mappings)
       }
 
-    extension (scope: CompletionScope.type)
-      private def from(denots: Seq[SingleDenotation])(using Context): CompletionScope = {
-        val mappings = denots.filter(den => include(den.symbol, den.name)).toList.groupBy(_.name).map( (name, denots) => name.stripModuleClassSuffix -> denots)
+      def fromNamed(namedDenotations: Seq[(Name, SingleDenotation)])(using Context): CompletionScope = {
+        val mappings = namedDenotations
+          .filter((name, denot) => include(denot.symbol, name))
+          .toList
+          .groupBy(_._1)
+          .map((name, namedDenots) => name.stripModuleClassSuffix -> namedDenots.map(_._2))
         CompletionScope(mappings)
       }
 
-      private def fromNamed(namedDenots: Seq[(Name, SingleDenotation)])(using Context): CompletionScope = {
-        val mappings = namedDenots.filter((name, den) => include(den.symbol, name)).toList.groupBy(_._1).map( (name, namedDens) => name.stripModuleClassSuffix -> namedDens.map(_._2))
+      val empty = CompletionScope()
+    }
+
+    /** A wrapper over a map from names to their denotations
+     *  taking care of filtering out not matching completions
+     *  and enabling easy resolving of conflicts between different denotations with the same name
+     */
+    case class CompletionScope private(nameToDenots: Map[Name, List[SingleDenotation]] = Map.empty) {
+
+      // Merge two scopes using mappings from `that` instead of from `this` in case of name clashes
+      def mergeShadowedBy(that: CompletionScope) = CompletionScope(this.nameToDenots ++ that.nameToDenots)
+
+      // Merge two scopes but discard mappings for names that appear in both scopes
+      def mergeDiscardingAmbiguities(that: CompletionScope) =
+        val mappings = (this.nameToDenots.toList ++ that.nameToDenots.toList)
+          .groupBy(_._1)
+          .collect {
+            case (name, (_, denots) :: Nil)  => name -> denots
+          }
         CompletionScope(mappings)
+
+      /**
+       * Return the list of symbols that should be included in completion results.
+       *
+       * If several symbols share the same name, the type symbols appear before term symbols inside
+       * the same `Completion`.
+       */
+      def getCompletions(using Context): List[Completion] = {
+        nameToDenots.toList.groupBy(_._1.toTermName.show).map { (name, namedDenots) =>
+          val typesFirst = namedDenots.flatMap(_._2).sortWith((s1, s2) => s1.isType && !s2.isType)
+          val desc = description(typesFirst)
+          Completion(name, desc, typesFirst.map(_.symbol))
+        }.toList
       }
+    }
   }
 
   /**
@@ -411,35 +443,5 @@ object Completion {
     /** Both term and type symbols are allowed */
     val Import: Mode = new Mode(4) | Term | Type
   }
-
-  private object CompletionScope  {
-    val empty = CompletionScope()
-  }
-
-  private case class CompletionScope(nameToDenots: Map[Name, List[SingleDenotation]] = Map.empty) {
-    def mergeShadowedBy(that: CompletionScope) = CompletionScope(this.nameToDenots ++ that.nameToDenots)
-
-    def mergeDiscardingAmbiguities(that: CompletionScope) =
-      val mappings = (this.nameToDenots.toList ++ that.nameToDenots.toList)
-        .groupBy(_._1)
-        .collect {
-          case (name, (_, denots) :: Nil)  => name -> denots
-        }
-      CompletionScope(mappings)
-
-    /**
-     * Return the list of symbols that should be included in completion results.
-     *
-     * If several symbols share the same name, the type symbols appear before term symbols inside
-     * the same `Completion`.
-     */
-    def getCompletions(using Context): List[Completion] = {
-      nameToDenots.toList.groupBy(_._1.toTermName.show).map { (name, namedDenots) =>
-        val typesFirst = namedDenots.flatMap(_._2).sortWith((s1, s2) => s1.isType && !s2.isType)
-        val desc = description(typesFirst)
-        Completion(name, desc, typesFirst.map(_.symbol))
-      }.toList
-    }
-  }
 }
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -38,6 +38,8 @@ import Constants.{Constant, IntTag, LongTag}
 import Denotations.SingleDenotation
 import annotation.{constructorOnly, threadUnsafe}
 
+import scala.util.control.NonFatal
+
 object Applications {
   import tpd._
 
@@ -2140,11 +2142,11 @@ trait Applications extends Compatibility {
    *
    *  return the tree representing methodRef partially applied to the receiver and all the implicit parameters preceding it (A, B, C)
    *  with the type parameters of the extension (T1, T2) inferred.
-   *  A failure is returned if the implicit search fails for any of the leading implicit parameters or if the receiver has a wrong type
+   *  None is returned if the implicit search fails for any of the leading implicit parameters or if the receiver has a wrong type
    *  (note that in general the type of the receiver might depend on the exact types of the found instances of the proceding implicits).
    *  No implicit search is tried for implicits following the receiver or for parameters of the def (D, E).
    */
-  private def applyWithoutPostreceiverImplicits(methodRef: TermRef, receiver: Tree)(using Context): scala.util.Try[Tree] =
+  def tryApplyingExtensionMethod(methodRef: TermRef, receiver: Tree)(using Context): Option[Tree] =
       // Drop all parameters sections of an extension method following the receiver; the return type after truncation is not important
     def truncateExtension(tp: Type)(using Context): Type = tp match
       case poly: PolyType =>
@@ -2154,27 +2156,28 @@ trait Applications extends Compatibility {
       case meth: MethodType =>
         meth.newLikeThis(meth.paramNames, meth.paramInfos, defn.AnyType)
 
+    def replaceCallee(inTree: Tree, replacement: Tree)(using Context): Tree = inTree match
+      case Apply(fun, args) => Apply(replaceCallee(fun, replacement), args)
+      case TypeApply(fun, args) => TypeApply(replaceCallee(fun, replacement), args)
+      case _: Ident => replacement
+
     val truncatedSym = methodRef.symbol.asTerm.copy(owner = defn.RootPackage, name = Names.termName(""), info = truncateExtension(methodRef.info))
     val truncatedRef = ref(truncatedSym).withSpan(receiver.span)
     val newCtx = ctx.fresh.setNewScope.setReporter(new reporting.ThrowingReporter(ctx.reporter))
-    scala.util.Try {
-      inContext(newCtx) {
+
+    try
+      val appliedTree = inContext(newCtx) {
         ctx.enter(truncatedSym)
         ctx.typer.extMethodApply(truncatedRef, receiver, WildcardType)
       }
-    }.filter(tree => tree.tpe.exists && !tree.tpe.isError)
-
-  def tryApplyingReceiver(methodRef: TermRef, receiver: Tree)(using Context): Option[Tree] =
-    def replaceCallee(inTree: Tree, replacement: Tree)(using Context): Tree = inTree match
-      case Apply(fun, args) => Apply(replaceCallee(fun, replacement), args)
-      case TypeApply(fun, args) => TypeApply(replaceCallee(fun, replacement), args)
-      case _: Ident => replacement
-
-    applyWithoutPostreceiverImplicits(methodRef, receiver)
-      .toOption
-      .map(tree => replaceCallee(tree, ref(methodRef)))
+      if appliedTree.tpe.exists && !appliedTree.tpe.isError then
+        Some(replaceCallee(appliedTree, ref(methodRef)))
+      else
+        None
+    catch
+      case NonFatal(_) => None
 
   def isApplicableExtensionMethod(methodRef: TermRef, receiverType: Type)(using Context): Boolean =
     methodRef.symbol.is(ExtensionMethod) && !receiverType.isBottomType &&
-      applyWithoutPostreceiverImplicits(methodRef, Typed(EmptyTree, TypeTree(receiverType))).isSuccess
+      tryApplyingExtensionMethod(methodRef, Typed(EmptyTree, TypeTree(receiverType))).nonEmpty
 }
diff --git a/compiler/test/dotty/tools/repl/TabcompleteTests.scala b/compiler/test/dotty/tools/repl/TabcompleteTests.scala
@@ -107,15 +107,15 @@ class TabcompleteTests extends ReplTest {
   @Test def `null` = fromInitialState { implicit s =>
     val comp = tabComplete("null.")
     assertEquals(
-      List("!=", "##", "==", "asInstanceOf", "clone", "eq", "equals", "finalize", "getClass", "hashCode",
+      List("!=", "##", "==", "asInstanceOf", "eq", "equals", "getClass", "hashCode",
           "isInstanceOf", "ne", "notify", "notifyAll", "synchronized", "toString", "wait"),
       comp.distinct.sorted)
   }
 
   @Test def anyRef = fromInitialState { implicit s =>
     val comp = tabComplete("(null: AnyRef).")
     assertEquals(
-      List("!=", "##", "->", "==", "asInstanceOf", "clone", "ensuring", "eq", "equals", "finalize", "formatted",
+      List("!=", "##", "->", "==", "asInstanceOf", "ensuring", "eq", "equals", "formatted",
           "getClass", "hashCode", "isInstanceOf", "ne", "nn", "notify", "notifyAll", "synchronized", "toString", "wait", "→"),
       comp.distinct.sorted)
   }
diff --git a/language-server/test/dotty/tools/languageserver/CompletionTest.scala b/language-server/test/dotty/tools/languageserver/CompletionTest.scala
