Parse wrapper code in the REPL during tab completion

Working towards using the real typer for completion

```
% qscala
Welcome to Scala version 2.11.7-20150526-102741-96571a9688 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_25).
Type in expressions to have them evaluated.
Type :help for more information.

scala> val x = ""
x: String = ""

scala> x.<console>:8: error: identifier expected but '}' found.
}
^
object $read {
  object $iw {
    object $iw {
      x.<error>
    }
  }
}

+              codePointBefore       concat             getBytes   isInstanceOf         regionMatches   startsWith    toString
asInstanceOf   codePointCount        contains           getChars   lastIndexOf          replace         subSequence   toUpperCase
charAt         codePoints            contentEquals      indexOf    length               replaceAll      substring     trim
chars          compareTo             endsWith           intern     matches              replaceFirst    toCharArray
codePointAt    compareToIgnoreCase   equalsIgnoreCase   isEmpty    offsetByCodePoints   split           toLowerCase

scala> :quit
```

Author: retronym

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

@@ -459,9 +459,12 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
     pos
   }
 
-  private def requestFromLine(line: String, synthetic: Boolean): Either[IR.Result, Request] = {
+  private def requestFromLine(line: String, synthetic: Boolean, forPresentationCompile: Boolean = false): Either[IR.Result, Request] = {
     val content = indentCode(line)
-    val trees = parse(content) match {
+    if (forPresentationCompile)
+      return Right(buildRequest(line, Nil))
+
+    val trees: List[global.Tree] = parse(content) match {
       case parse.Incomplete     => return Left(IR.Incomplete)
       case parse.Error          => return Left(IR.Error)
       case parse.Success(trees) => trees
@@ -529,7 +532,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
         // Rewriting    "foo ; bar ; 123"
         // to           "foo ; bar ; val resXX = 123"
         requestFromLine(rewrittenLine, synthetic) match {
-          case Right(req) => return Right(req withOriginalLine line)
+          case Right(req) if !forPresentationCompile => return Right(req withOriginalLine line)
           case x          => return x
         }
       case _ =>
@@ -569,6 +572,17 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
     }
   }
 
+  private[scala] def presentationCompile(line: String, synthetic: Boolean): Either[IR.Result, Request] = {
+    if (global == null) Left(IR.Error)
+    else requestFromLine(line, synthetic, forPresentationCompile = true) match {
+      case Left(result) => Left(result)
+      case Right(req)   =>
+       // null indicates a disallowed statement type; otherwise compile and
+       // fail if false (implying e.g. a type error)
+       if (req == null || !req.presentationCompile) Left(IR.Error) else Right(req)
+    }
+  }
+
   var code = ""
   var bound = false
   def compiled(script: String): CompiledScript = {
@@ -994,6 +1008,23 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set
       }
     }
 
+    lazy val presentationCompile: Boolean = {
+      reporter.reset()
+      val wrappedCode: String = ObjectSourceCode(handlers)
+      parseAndTypeCheck(wrappedCode)
+      reporter.hasErrors
+    }
+
+    private[this] def parseAndTypeCheck(code: String): global.CompilationUnit = {
+      val unit = global.newCompilationUnit(code)
+      val parser = global.newUnitParser(unit)
+      val parserPhase = global.syntaxAnalyzer.newPhase(NoPhase)
+      val run: global.Run = new global.Run()
+      run.parserPhase.asInstanceOf[GlobalPhase].applyPhase(unit)
+      println(showCode(unit.body))
+      unit
+    }
+
     lazy val resultSymbol = lineRep.resolvePathToSymbol(accessPath)
     def applyToResultMember[T](name: Name, f: Symbol => T) = exitingTyper(f(resultSymbol.info.nonPrivateDecl(name)))
 

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

@@ -295,7 +295,10 @@ class JLineCompletion(val intp: IMain) extends Completion with CompletionOutput
     override def complete(buf: String, cursor: Int): Candidates = {
       verbosity = if (isConsecutiveTabs(buf, cursor)) verbosity + 1 else 0
       repldbg(f"%ncomplete($buf, $cursor%d) last = ($lastBuf, $lastCursor%d), verbosity: $verbosity")
-
+      intp.presentationCompile(buf, false) match {
+        case Left(_) =>
+        case Right(request) =>
+      }
       // we don't try lower priority completions unless higher ones return no results.
       def tryCompletion(p: Parsed, completionFunction: Parsed => List[String]): Option[Candidates] = {
         val winners = completionFunction(p)