Better errors for Any/AnyRef issues.

When an error occurs because some type does not conform
to AnyRef (and an AnyRef-derived type would have sufficed)
try to say something useful about the situation.

This commit also initializes scope members before printing
error messages because the + version seems more useful than
the - version (taken from one of the checkfile diffs.)

-  def <init>: <?>
-  def methodIntIntInt: <?>
+  def <init>(): X
+  def methodIntIntInt(x: scala.Int,y: scala.Int): scala.Int

2 files changed, 39 insertions, 8 deletions

diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index 98d42b724c..c21ebfe997 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -218,6 +218,32 @@ trait Definitions extends api.StandardDefinitions {
       case _            => null
     }
 
+    /** Fully initialize the symbol, type, or scope.
+     */
+    def fullyInitializeSymbol(sym: Symbol): Symbol = {
+      sym.initialize
+      fullyInitializeType(sym.info)
+      fullyInitializeType(sym.tpe)
+      sym
+    }
+    def fullyInitializeType(tp: Type): Type = {
+      tp.typeParams foreach fullyInitializeSymbol
+      tp.paramss.flatten foreach fullyInitializeSymbol
+      tp
+    }
+    def fullyInitializeScope(scope: Scope): Scope = {
+      scope.sorted foreach fullyInitializeSymbol
+      scope
+    }
+    /** Is this type equivalent to Any, AnyVal, or AnyRef? */
+    def isTrivialTopType(tp: Type) = (
+         tp =:= AnyClass.tpe
+      || tp =:= AnyValClass.tpe
+      || tp =:= AnyRefClass.tpe
+    )
+    /** Does this type have a parent which is none of Any, AnyVal, or AnyRef? */
+    def hasNonTrivialParent(tp: Type) = tp.parents exists (t => !isTrivialTopType(tp))
+
     private def fixupAsAnyTrait(tpe: Type): Type = tpe match {
       case ClassInfoType(parents, decls, clazz) =>
         if (parents.head.typeSymbol == AnyClass) tpe
@@ -383,7 +409,7 @@ trait Definitions extends api.StandardDefinitions {
     def isRepeated(param: Symbol)          = isRepeatedParamType(param.tpe)
     def isCastSymbol(sym: Symbol)          = sym == Any_asInstanceOf || sym == Object_asInstanceOf
 
-    def isJavaVarArgsMethod(m: Symbol)       = m.isMethod && isJavaVarArgs(m.info.params)
+    def isJavaVarArgsMethod(m: Symbol)      = m.isMethod && isJavaVarArgs(m.info.params)
     def isJavaVarArgs(params: Seq[Symbol])  = params.nonEmpty && isJavaRepeatedParamType(params.last.tpe)
     def isScalaVarArgs(params: Seq[Symbol]) = params.nonEmpty && isScalaRepeatedParamType(params.last.tpe)
     def isVarArgsList(params: Seq[Symbol])  = params.nonEmpty && isRepeatedParamType(params.last.tpe)
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index b13b893635..c266e26895 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -1010,7 +1010,11 @@ trait Types extends api.Types { self: SymbolTable =>
     def toLongString = {
       val str = toString
       if (str == "type") widen.toString
-      else if ((str endsWith ".type") && !typeSymbol.isModuleClass) str + " (with underlying type " + widen + ")"
+      else if ((str endsWith ".type") && !typeSymbol.isModuleClass)
+        widen match {
+          case RefinedType(_, _)                      => "" + widen
+          case _                                      => s"$str (with underlying type $widen)"
+        }
       else str
     }
 
@@ -1632,7 +1636,7 @@ trait Types extends api.Types { self: SymbolTable =>
 
     override def safeToString: String = parentsString(parents) + (
       (if (settings.debug.value || parents.isEmpty || (decls.elems ne null))
-        decls.mkString("{", "; ", "}") else "")
+        fullyInitializeScope(decls).mkString("{", "; ", "}") else "")
     )
   }
 
@@ -1819,7 +1823,6 @@ trait Types extends api.Types { self: SymbolTable =>
            false
        }))
     }
-
     override def kind = "RefinedType"
   }
 
@@ -2005,9 +2008,11 @@ trait Types extends api.Types { self: SymbolTable =>
     /** A nicely formatted string with newlines and such.
      */
     def formattedToString: String =
-      parents.mkString("\n        with ") +
-      (if (settings.debug.value || parents.isEmpty || (decls.elems ne null))
-        decls.mkString(" {\n  ", "\n  ", "\n}") else "")
+      parents.mkString("\n        with ") + (
+        if (settings.debug.value || parents.isEmpty || (decls.elems ne null))
+         fullyInitializeScope(decls).mkString(" {\n  ", "\n  ", "\n}")
+        else ""
+      )
   }
 
   object ClassInfoType extends ClassInfoTypeExtractor
@@ -2466,7 +2471,7 @@ trait Types extends api.Types { self: SymbolTable =>
 
     def refinementString = (
       if (sym.isStructuralRefinement) (
-        decls filter (sym => sym.isPossibleInRefinement && sym.isPublic)
+        fullyInitializeScope(decls) filter (sym => sym.isPossibleInRefinement && sym.isPublic)
           map (_.defString)
           mkString("{", "; ", "}")
       )