Remove cases which are impossible to match

Author: rochala

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

@@ -90,29 +90,20 @@ object Completion:
 
     val completionSymbolKind: Mode =
       path match
-        case untpd.Ident(_) :: untpd.Import(_, _) :: _ => Mode.ImportOrExport
-        case untpd.Ident(_) :: (_: untpd.ImportSelector) :: _ => Mode.ImportOrExport
-        case untpd.Literal(Constants.Constant(_: String)) :: _ => Mode.Term // literal completions
+        case untpd.Ident(_) :: (_: untpd.ImportSelector) :: _ => Mode.ImportOrExport // import scala.@@
+        case untpd.Ident(_) :: (_: untpd.ImportOrExport) :: _ => Mode.ImportOrExport | Mode.Scope // import TrieMa@@
+
+        case untpd.Literal(Constants.Constant(_: String)) :: _ => Mode.Term | Mode.Scope // literal completions
         case (ref: untpd.RefTree) :: _ =>
-          if (ref.name.isTermName) Mode.Term
-          else if (ref.name.isTypeName) Mode.Type
-          else Mode.None
+          val maybeSelectMembers = if ref.isInstanceOf[untpd.Select] then Mode.Member else Mode.Scope
 
-        case (sel: untpd.ImportSelector) :: _ =>
-          if sel.imported.span.contains(pos.span) then Mode.ImportOrExport
-          else Mode.None // Can't help completing the renaming
+          if (ref.name.isTermName) Mode.Term | maybeSelectMembers
+          else if (ref.name.isTypeName) Mode.Type | maybeSelectMembers
+          else Mode.None
 
-        case (_: untpd.ImportOrExport) :: _ => Mode.ImportOrExport
         case _ => Mode.None
 
-    val completionKind: Mode =
-      path match
-        case Nil | (_: untpd.PackageDef) :: _ => Mode.None
-        case untpd.Ident(_) :: (_: untpd.ImportSelector) :: _ => Mode.Member
-        case (_: untpd.Select) :: _ => Mode.Member
-        case _ => Mode.Scope
-
-    completionSymbolKind | completionKind
+    completionSymbolKind
 
   /** When dealing with <errors> in varios palces we check to see if they are
    *  due to incomplete backticks. If so, we ensure we get the full prefix
@@ -141,18 +132,10 @@ object Completion:
       i + 1
 
     path match
-      case (sel: untpd.ImportSelector) :: _ =>
-        completionPrefix(sel.imported :: Nil, pos)
-
       case untpd.Ident(_) :: (sel: untpd.ImportSelector) :: _ if !sel.isGiven =>
         if sel.isWildcard then pos.source.content()(pos.point - 1).toString
         else completionPrefix(sel.imported :: Nil, pos)
 
-      case (tree: untpd.ImportOrExport) :: _ =>
-        tree.selectors.find(_.span.contains(pos.span)).map: selector =>
-          completionPrefix(selector :: Nil, pos)
-        .getOrElse("")
-
       // Foo.`se<TAB> will result in Select(Ident(Foo), <error>)
       case (select: untpd.Select) :: _ if select.name == nme.ERROR =>
         checkBacktickPrefix(select.source.content(), select.nameSpan.start, select.span.end)
@@ -211,7 +194,6 @@ object Completion:
       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 (_: untpd.ImportSelector) :: tpd.Import(expr, _) :: _                => completer.directMemberCompletions(expr)
       case _                                                                    => completer.scopeCompletions
 
     interactiv.println(i"""completion info with pos    = $pos,

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

@@ -542,14 +542,7 @@ class Completions(
         else false,
       )
       Some(search.searchMethods(query, buildTargetIdentifier, visitor).nn)
-    else
-      val filtered = indexedContext.scopeSymbols
-        .filter(sym => !sym.isConstructor && (!sym.is(Synthetic) || sym.is(Module)))
-
-      filtered.map { sym =>
-        visit(CompletionValue.Scope(sym.decodedName, sym, findSuffix(sym)))
-      }
-      Some(SymbolSearch.Result.INCOMPLETE)
+    else Some(SymbolSearch.Result.INCOMPLETE)
 
   end enrichWithSymbolSearch
 

presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionInterpolatorSuite.scala

@@ -558,18 +558,6 @@ class CompletionInterpolatorSuite extends BaseCompletionSuite:
       filter = _.contains("hello")
     )
 
-  @Test def `brace-token-error-pos` =
-    checkEditLine(
-      """|object Main {
-         |  val hello = ""
-         |  ___
-         |}
-         |""".stripMargin,
-      """s"Hello ${@@"""".stripMargin,
-      """s"Hello ${hello"""".stripMargin,
-      filter = _.contains("hello")
-    )
-
   @Test def `brace-token-error` =
     checkEditLine(
       """|object Main {

presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionKeywordSuite.scala

@@ -38,7 +38,7 @@ class CompletionKeywordSuite extends BaseCompletionSuite:
         |  // tr@@
         |}
         |""".stripMargin,
-      "transparentTrait - scala.annotation (commit: '')",
+      "",
       includeCommitCharacter = true
     )
 
@@ -57,7 +57,7 @@ class CompletionKeywordSuite extends BaseCompletionSuite:
         |  **/
         |}
         |""".stripMargin,
-     "transparentTrait - scala.annotation (commit: '')",
+     "",
       includeCommitCharacter = true
     )
 
@@ -412,8 +412,6 @@ class CompletionKeywordSuite extends BaseCompletionSuite:
         |}
       """.stripMargin,
       """|def
-         |derived - scala.CanEqual
-         |deprecated - scala.runtime.stdLibPatches.language
          |""".stripMargin,
     )
 
@@ -428,7 +426,6 @@ class CompletionKeywordSuite extends BaseCompletionSuite:
       """.stripMargin,
       """|val
          |var
-         |varargs - scala.annotation
          |""".stripMargin
     )
 
@@ -467,26 +464,16 @@ class CompletionKeywordSuite extends BaseCompletionSuite:
          |  def hello(u@@)
          |}""".stripMargin,
       """|using (commit: '')
-         |unsafe - scala.caps (commit: '')
-         |unsafeNulls - scala.runtime.stdLibPatches.language (commit: '')
-         |unused - scala.annotation (commit: '')
-         |unshared - scala.annotation.internal (commit: '')
          |""".stripMargin,
       includeCommitCharacter = true,
-      topLines = Some(5)
     )
 
   @Test def `not-using` =
     check(
       """|object A{
          |  def hello(a: String, u@@)
          |}""".stripMargin,
-      """|unsafe - scala.caps
-         |unsafeNulls - scala.runtime.stdLibPatches.language
-         |unused - scala.annotation
-         |unshared - scala.annotation.internal
-         |unspecialized - scala.annotation""".stripMargin,
-      topLines = Some(5)
+      "",
     )
 
   @Test def `extends-class` =

presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionPatternSuite.scala

@@ -54,9 +54,7 @@ class CompletionPatternSuite extends BaseCompletionSuite:
         |    case ma@@
         |  }
         |}""".stripMargin,
-      """|macros - scala.languageFeature.experimental
-         |macroImpl - scala.reflect.macros.internal
-         |""".stripMargin
+      ""
     )
 
   @Test def `bind2` =

presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala

@@ -1734,3 +1734,40 @@ class CompletionSuite extends BaseCompletionSuite:
       filter = _.contains("[")
     )
 
+  @Test def `empty-import` =
+    check(
+      """|import @@
+         |""".stripMargin,
+      """|java <root>
+         |javax <root>
+         |""".stripMargin,
+      filter = _.startsWith("java")
+    )
+
+  @Test def `empty-import-selector` =
+    check(
+      """|import java.@@
+         |""".stripMargin,
+      """|util java
+         |""".stripMargin,
+      filter = _.startsWith("util")
+    )
+
+  @Test def `empty-export` =
+    check(
+      """|export @@
+         |""".stripMargin,
+      """|java <root>
+         |javax <root>
+         |""".stripMargin,
+      filter = _.startsWith("java")
+    )
+
+  @Test def `empty-export-selector` =
+    check(
+      """|export java.@@
+         |""".stripMargin,
+      """|util java
+         |""".stripMargin,
+      filter = _.startsWith("util")
+    )