Fix completion

Author: odersky

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1574,20 +1574,15 @@ object Parsers {
 
     /** SimpleType       ::=  SimpleType TypeArgs
      *                     |  SimpleType `#' id
-     *                     |  Singleton `.' id
+     *                     |  SimpleClassType
      *                     |  Singleton `.' type
-     *                     |  `(' ArgTypes `)'
      *                     |  `_' TypeBounds
      *                     |  Refinement
      *                     |  Literal
      *                     |  ‘$’ ‘{’ Block ‘}’
      */
     def simpleType(): Tree = simpleTypeRest {
-      if (in.token == LPAREN)
-        atSpan(in.offset) {
-          makeTupleOrParens(inParens(argTypes(namedOK = false, wildOK = true)))
-        }
-      else if (in.token == LBRACE)
+      if in.token == LBRACE then
         atSpan(in.offset) { RefinedTypeTree(EmptyTree, refinement()) }
       else if (isSimpleLiteral) { SingletonTypeTree(literal(inType = true)) }
       else if isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token) then
@@ -1611,21 +1606,30 @@ object Parsers {
       else if (isSplice)
         splice(isType = true)
       else
-        singletonCompletion(simpleRef())
+        simpleClassType()
     }
 
-    /** Singleton ::=  SimpleRef
-     *              |  Singleton ‘.’ id
+    /** SimpleClassType   ::=  [Singleton ‘.’] id
+     *                      |  ‘(’ ArgTypes ‘)’
+     *  Singleton         ::=  SimpleRef
+     *                      |  Singleton ‘.’ id
      */
-    def singletonCompletion(t: Tree): Tree =
-      if in.token == DOT then
-        in.nextToken()
-        if in.token == TYPE then
-          in.nextToken()
-          atSpan(startOffset(t)) { SingletonTypeTree(t) }
-        else
-          singletonCompletion(idSelector(t))
-      else convertToTypeId(t)
+    def simpleClassType(): Tree =
+      if in.token == LPAREN then
+        atSpan(in.offset) {
+          makeTupleOrParens(inParens(argTypes(namedOK = false, wildOK = true)))
+        }
+      else
+        def singletonCompletion(t: Tree): Tree =
+          if in.token == DOT then
+            in.nextToken()
+            if in.token == TYPE then
+              in.nextToken()
+              atSpan(startOffset(t)) { SingletonTypeTree(t) }
+            else
+              singletonCompletion(idSelector(t))
+          else convertToTypeId(t)
+        singletonCompletion(simpleRef())
 
     private def simpleTypeRest(t: Tree): Tree = in.token match {
       case HASH => simpleTypeRest(typeProjection(t))
@@ -3145,13 +3149,15 @@ object Parsers {
             mkTree(qual, ImportSelector(wildcardSelectorId()) :: Nil)
           case LBRACE =>
             mkTree(qual, inBraces(importSelectors(idOK = true)))
-          case _ =>
+          case IDENTIFIER | BACKQUOTED_IDENT =>
             val start = in.offset
             val name = ident()
             if in.token == DOT then
               importSelection(atSpan(startOffset(qual), start) { Select(qual, name) })
             else
               mkTree(qual, ImportSelector(atSpan(start) { Ident(name) }) :: Nil)
+          case _ =>
+            idSelector(qual) // this will produce an error, which can lead to a completion in the repl
 
       () => importSelection(simpleRef())
     }

compiler/test/dotty/tools/repl/TabcompleteTests.scala

@@ -100,7 +100,7 @@ class TabcompleteTests extends ReplTest {
   @Test def importScala = fromInitialState { implicit s =>
     val comp = tabComplete("import scala.")
     // check that there are no special symbols leaked: <byname>, <special-ops>, ...
-    assertEquals(comp.find(_.startsWith("<")), Some("<:<"))
+    assertEquals(Some("<:<"), comp.find(_.startsWith("<")))
     assert(!comp.contains("package"))
   }