Address review comments

Author: Duhemm

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

@@ -166,38 +166,59 @@ object Interactive {
   private def computeCompletions(pos: SourcePosition, path: List[Tree])(implicit ctx: Context): (Int, List[Symbol]) = {
     val completions = Scopes.newScope.openForMutations
 
+    type Mode = Int
+    object Mode {
+      /** No symbol should be included */
+      val None: Mode = 0
+
+      /** Term symbols are allowed */
+      val Term: Mode = 1
+
+      /** Type symbols are allowed */
+      val Type: Mode = 2
+
+      /** Both term and type symbols are allowed */
+      val Import: Mode = Term | Type
+
+      /** Does `m0` include `m1`? */
+      def is(m0: Mode, m1: Mode): Boolean = (m0 & m1) == m1
+    }
+
     /**
      * The information about the current completion.
      *
-     * @param position The position where the completion result should be inserted.
-     * @param prefix   A prefix that potential completion results must match.
-     * @param termOnly If set, only terms should be considered as completion results.
-     * @param typeOnly If set, only types should be considered as completion results.
-     * @param inImport If set, indicates that this is the completion of an import node.
+     * @param offset The offset where the completion result should be inserted.
+     * @param prefix A prefix that potential completion results must match.
+     * @param mode   The completion mode.
      */
-    case class CompletionInfo(position: Int, prefix: String, termOnly: Boolean, typeOnly: Boolean, inImport: Boolean)
+    case class CompletionInfo(offset: Int, prefix: String, mode: Mode)
 
     /**
      * Extract basic info about completion location and the kind of symbols to include.
      *
      * @param path     The path to the position where completion happens
      * @param inImport If set, indicates that this is the completion of an import node. When
      *                 completing imports, both types and terms are always included.
-     * @return The completion info
+     * @return The information about completion (offset, kinds of symbol, etc.)
      */
     def completionInfo(path: List[Tree], inImport: Boolean): CompletionInfo = path match {
       case (ref: RefTree) :: _ =>
         if (ref.name == nme.ERROR)
-          CompletionInfo(ref.pos.point, "", false, false, inImport)
-        else
+          CompletionInfo(ref.pos.point, "", Mode.None)
+        else {
+          val mode =
+            if (inImport) Mode.Import
+            else if (ref.name.isTermName) Mode.Term
+            else Mode.Type
+
           CompletionInfo(
             ref.pos.point,
             ref.name.toString.take(pos.pos.point - ref.pos.point),
-            !inImport && ref.name.isTermName, // Types and terms are always accepted in imports
-            !inImport && ref.name.isTypeName,
-            inImport)
+            mode)
+        }
+
       case _ =>
-        CompletionInfo(0, "", false, false, false)
+        CompletionInfo(0, "", Mode.None)
     }
 
     val info = path match {
@@ -208,7 +229,7 @@ object Interactive {
 
       case (imp: Import) :: _ =>
         imp.selectors.find(_.pos.contains(pos.pos)) match {
-          case None      => CompletionInfo(imp.expr.pos.point, "", false, false, true)
+          case None      => CompletionInfo(imp.expr.pos.point, "", Mode.Import)
           case Some(sel) => completionInfo(sel.asInstanceOf[tpd.Tree] :: Nil, /* inImport = */ true)
         }
 
@@ -228,18 +249,20 @@ object Interactive {
      *  as completion results. However, if a user explicitly writes all '$' characters in an
      *  identifier, we should complete the rest.
      */
-    def include(sym: Symbol) =
+    def include(sym: Symbol) = {
       sym.name.startsWith(info.prefix) &&
       !sym.name.toString.drop(info.prefix.length).contains('$') &&
       !sym.isPrimaryConstructor &&
       (!sym.is(Package) || !sym.moduleClass.exists) &&
       !sym.is(allOf(Mutable, Accessor)) &&
-      (!info.termOnly || sym.isTerm) &&
-      (!info.typeOnly || sym.isType)
+      (
+           (Mode.is(info.mode, Mode.Term) && sym.isTerm)
+        || (Mode.is(info.mode, Mode.Type) && sym.isType)
+      )
+    }
 
     def enter(sym: Symbol) =
       if (include(sym)) completions.enter(sym)
-
     def add(sym: Symbol) =
       if (sym.exists && !completions.lookup(sym.name).exists) enter(sym)
 
@@ -313,7 +336,7 @@ object Interactive {
 
     def getMemberCompletions(qual: Tree): Unit = {
       addAccessibleMembers(qual.tpe)
-      if (!info.inImport) {
+      if (!Mode.is(info.mode, Mode.Import)) {
         // Implicit conversions do not kick in when importing
         implicitConversionTargets(qual)(ctx.fresh.setExploreTyperState())
           .foreach(addAccessibleMembers(_))
@@ -328,7 +351,7 @@ object Interactive {
     }
 
     val completionList =
-      if (!info.inImport) completions.toList
+      if (!Mode.is(info.mode, Mode.Import)) completions.toList
       else {
         // In imports, show only the type symbols when there are multiple options with the same name
         completions.toList.groupBy(_.name.stripModuleClassSuffix.toSimpleName).mapValues {
@@ -338,7 +361,7 @@ object Interactive {
       }
 
     interactiv.println(i"completion with pos = $pos, prefix = $info.prefix, termOnly = $info.termOnly, typeOnly = $info.typeOnly = $completionList%, %")
-    (info.position, completionList)
+    (info.offset, completionList)
   }
 
   /** Possible completions of members of `prefix` which are accessible when called inside `boundary` */

language-server/test/dotty/tools/languageserver/CompletionTest.scala

@@ -159,4 +159,11 @@ class CompletionTest {
         assertTrue("bar was not deprecated", result.getDeprecated)
       })
   }
+
+  @Test def i4397: Unit = {
+    code"""class Foo {
+          |  .${m1}
+          |}""".withSource
+      .completion(m1, Set())
+  }
 }