Merge pull request scala#4766 from retronym/topic/completely-tweaks

Improvements to REPL completion for annotations and string interpolation

Author: lrytz

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -2680,7 +2680,10 @@ self =>
           case t if t == SUPERTYPE || t == SUBTYPE || t == COMMA || t == RBRACE || isStatSep(t) =>
             TypeDef(mods | Flags.DEFERRED, name, tparams, typeBounds())
           case _ =>
-            syntaxErrorOrIncompleteAnd("`=', `>:', or `<:' expected", skipIt = true)(EmptyTree)
+            syntaxErrorOrIncompleteAnd("`=', `>:', or `<:' expected", skipIt = true)(
+              // assume a dummy type def so as to have somewhere to stash the annotations
+              TypeDef(mods, tpnme.ERROR, Nil, EmptyTree)
+            )
         }
       }
     }
@@ -2713,7 +2716,10 @@ self =>
         case CASEOBJECT =>
           objectDef(pos, (mods | Flags.CASE) withPosition (Flags.CASE, tokenRange(in.prev /*scanner skips on 'case' to 'object', thus take prev*/)))
         case _ =>
-          syntaxErrorOrIncompleteAnd("expected start of definition", skipIt = true)(EmptyTree)
+          syntaxErrorOrIncompleteAnd("expected start of definition", skipIt = true)(
+            // assume a class definition so as to have somewhere to stash the annotations
+            atPos(pos)(gen.mkClassDef(mods, tpnme.ERROR, Nil, Template(Nil, noSelfType, Nil)))
+          )
       }
     }
 

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -3558,6 +3558,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
     def typedAnnotation(ann: Tree, mode: Mode = EXPRmode): AnnotationInfo = {
       var hasError: Boolean = false
       val pending = ListBuffer[AbsTypeError]()
+      def ErroneousAnnotation = new ErroneousAnnotation().setOriginal(ann)
 
       def finish(res: AnnotationInfo): AnnotationInfo = {
         if (hasError) {

src/reflect/scala/reflect/internal/AnnotationInfos.scala

@@ -404,7 +404,7 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable =>
 
   object UnmappableAnnotation extends CompleteAnnotationInfo(NoType, Nil, Nil)
 
-  object ErroneousAnnotation extends CompleteAnnotationInfo(ErrorType, Nil, Nil)
+  class ErroneousAnnotation() extends CompleteAnnotationInfo(ErrorType, Nil, Nil)
 
   /** Extracts symbol of thrown exception from AnnotationInfo.
     *

src/reflect/scala/reflect/internal/Positions.scala

@@ -252,7 +252,14 @@ trait Positions extends api.Positions { self: SymbolTable =>
             super.traverse(t)
           } else t match {
             case mdef: MemberDef =>
-              traverseTrees(mdef.mods.annotations)
+              val annTrees = mdef.mods.annotations match {
+                case Nil if mdef.symbol != null =>
+                  // After typechecking, annotations are mvoed from the modifiers
+                  // to the annotation on the symbol of the anotatee.
+                  mdef.symbol.annotations.map(_.original)
+                case anns => anns
+              }
+              traverseTrees(annTrees)
             case _ =>
           }
       }

src/reflect/scala/reflect/runtime/JavaUniverseForce.scala

@@ -106,7 +106,6 @@ trait JavaUniverseForce { self: runtime.JavaUniverse  =>
     this.AnnotationInfo
     this.Annotation
     this.UnmappableAnnotation
-    this.ErroneousAnnotation
     this.ThrownException
     this.typeNames
     this.tpnme

src/repl/scala/tools/nsc/interpreter/PresentationCompilerCompleter.scala

@@ -36,7 +36,7 @@ class PresentationCompilerCompleter(intp: IMain) extends Completion with ScalaCo
     // secret handshakes
     val slashPrint  = """.*// *print *""".r
     val slashTypeAt = """.*// *typeAt *(\d+) *(\d+) *""".r
-    val Cursor = IMain.DummyCursorFragment
+    val Cursor = IMain.DummyCursorFragment + " "
 
     def print(result: Result) = {
       val offset = result.preambleLength

test/junit/scala/tools/nsc/interpreter/CompletionTest.scala

@@ -51,6 +51,25 @@ class CompletionTest {
     assertEquals(List("prefix_aaa", "prefix_nnn", "prefix_zzz"), completer.complete( """class C { def prefix_nnn = 0; def prefix_zzz = 0; def prefix_aaa = 0; prefix_""").candidates)
   }
 
+  @Test
+  def annotations(): Unit = {
+    val intp = newIMain()
+    val completer = new PresentationCompilerCompleter(intp)
+    checkExact(completer, "def foo[@specialize", " A]")("specialized")
+    checkExact(completer, "def foo[@specialize")("specialized")
+    checkExact(completer, """@deprecatedN""", """ class Foo""")("deprecatedName")
+    checkExact(completer, """@deprecateN""")("deprecatedName")
+    checkExact(completer, """{@deprecateN""")("deprecatedName")
+  }
+
+  @Test
+  def incompleteStringInterpolation(): Unit = {
+    val intp = newIMain()
+    val completer = new PresentationCompilerCompleter(intp)
+    checkExact(completer, """val x_y_z = 1; s"${x_""", "}\"")("x_y_z")
+    checkExact(completer, """val x_y_z = 1; s"${x_""", "\"")("x_y_z")
+  }
+
   @Test
   def symbolically(): Unit = {
     val intp = newIMain()