Give some feedback on invalid :type expressions.

2 files changed, 26 insertions, 10 deletions

diff --git a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala
index 7884a7ac47..d83076f0be 100644
--- a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala
@@ -419,10 +419,14 @@ class ILoop(in0: Option[BufferedReader], protected val out: PrintWriter)
     try newJavap()
     catch { case _: Exception => null }
 
+  // TODO: unsolved types shouldn't make it out of this alive.
+  //
+  // scala> :t Some(Set(1)) getOrElse Set("abc")
+  // scala.collection.immutable.Set[_ >: ? <: ?]
   private def typeCommand(line: String): Result = {
-    intp.typeOfExpression(line) match {
+    intp.typeOfExpression(line, false) match {
       case Some(tp) => tp.toString
-      case _        => "Failed to determine type."
+      case _        => "" // the error message was already printed
     }
   }
 
diff --git a/src/compiler/scala/tools/nsc/interpreter/IMain.scala b/src/compiler/scala/tools/nsc/interpreter/IMain.scala
index 517e6ee6d0..3f91f3c0d6 100644
--- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala
@@ -978,7 +978,7 @@ class IMain(val settings: Settings, protected val out: PrintWriter) extends Impo
   // 2) A path loadable via getModule.
   // 3) Try interpreting it as an expression.
   private var typeOfExpressionDepth = 0
-  def typeOfExpression(expr: String): Option[Type] = {
+  def typeOfExpression(expr: String, silent: Boolean = true): Option[Type] = {
     repldbg("typeOfExpression(" + expr + ")")
     if (typeOfExpressionDepth > 2) {
       repldbg("Terminating typeOfExpression recursion for expression: " + expr)
@@ -988,23 +988,35 @@ class IMain(val settings: Settings, protected val out: PrintWriter) extends Impo
     def asQualifiedImport = {
       val name = expr.takeWhile(_ != '.')
       importedTermNamed(name) flatMap { sym =>
-        typeOfExpression(sym.fullName + expr.drop(name.length))
+        typeOfExpression(sym.fullName + expr.drop(name.length), true)
       }
     }
     def asModule = safeModule(expr) map (_.tpe)
-    def asExpr = beSilentDuring {
+    def asExpr = {
       val lhs = freshInternalVarName()
-      val line = "lazy val " + lhs + " = { " + expr + " } "
+      val line = "lazy val " + lhs + " =\n" + expr
 
       interpret(line, true) match {
-        case IR.Success => typeOfExpression(lhs)
+        case IR.Success => typeOfExpression(lhs, true)
         case _          => None
       }
     }
+    def evaluate() = {
+      typeOfExpressionDepth += 1
+      try typeOfTerm(expr) orElse asModule orElse asExpr orElse asQualifiedImport
+      finally typeOfExpressionDepth -= 1
+    }
+
+    // Don't presently have a good way to suppress undesirable success output
+    // while letting errors through, so it is first trying it silently: if there
+    // is an error, and errors are desired, then it re-evaluates non-silently
+    // to induce the error message.
+    beSilentDuring(evaluate()) orElse {
+      if (!silent)
+        evaluate()
 
-    typeOfExpressionDepth += 1
-    try typeOfTerm(expr) orElse asModule orElse asExpr orElse asQualifiedImport
-    finally typeOfExpressionDepth -= 1
+      None
+    }
   }
   // def compileAndTypeExpr(expr: String): Option[Typer] = {
   //   class TyperRun extends Run {