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

4 files changed, 117 insertions, 50 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
index 773d9a6f50..b7195b0349 100644
--- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
@@ -85,10 +85,33 @@ trait ContextErrors {
 
     def typeErrorMsg(found: Type, req: Type, possiblyMissingArgs: Boolean) = {
       def missingArgsMsg = if (possiblyMissingArgs) "\n possible cause: missing arguments for method or constructor" else ""
+
       "type mismatch" + foundReqMsg(found, req) + missingArgsMsg
     }
   }
 
+  def notAnyRefMessage(found: Type): String = {
+    val tp        = found.widen
+    def name      = tp.typeSymbol.nameString
+    def parents   = tp.parents filterNot isTrivialTopType
+    def onlyAny   = tp.parents forall (_.typeSymbol == AnyClass)
+    def parents_s = ( if (parents.isEmpty) tp.parents else parents ) mkString ", "
+    def what = (
+      if (tp.typeSymbol.isAbstractType) {
+        val descr = if (onlyAny) "unbounded" else "bounded only by " + parents_s
+        s"$name is $descr, which means AnyRef is not a known parent"
+      }
+      else if (tp.typeSymbol.isAnonOrRefinementClass)
+        s"the parents of this type ($parents_s) extend Any, not AnyRef"
+      else
+        s"$name extends Any, not AnyRef"
+    )
+    if (isPrimitiveValueType(found)) "" else "\n" +
+       s"""|Note that $what.
+           |Such types can participate in value classes, but instances
+           |cannot appear in singleton types or in reference comparisons.""".stripMargin
+  }
+
   import ErrorUtils._
 
   trait TyperContextErrors {
@@ -296,12 +319,17 @@ trait ContextErrors {
               else
                 ""
             )
-            companion + semicolon
+            val notAnyRef = (
+              if (ObjectClass.info.member(name).exists) notAnyRefMessage(target)
+              else ""
+            )
+            companion + notAnyRef + semicolon
           }
+          def targetStr = targetKindString + target.directObjectString
           withAddendum(qual.pos)(
-              if (name == nme.CONSTRUCTOR) target + " does not have a constructor"
-              else nameString + " is not a member of " + targetKindString + target.directObjectString + addendum
-            )
+            if (name == nme.CONSTRUCTOR) s"$target does not have a constructor"
+            else s"$nameString is not a member of $targetStr$addendum"
+          )
         }
         issueNormalTypeError(sel, errMsg)
         // the error has to be set for the copied tree, otherwise
@@ -1095,44 +1123,42 @@ trait ContextErrors {
                                pre1: String, pre2: String, trailer: String)
                                (isView: Boolean, pt: Type, tree: Tree)(implicit context0: Context) = {
       if (!info1.tpe.isErroneous && !info2.tpe.isErroneous) {
-        val coreMsg =
-          pre1+" "+info1.sym.fullLocationString+" of type "+info1.tpe+"\n "+
-          pre2+" "+info2.sym.fullLocationString+" of type "+info2.tpe+"\n "+
-          trailer
-        val errMsg =
-          if (isView) {
-            val found = pt.typeArgs(0)
-            val req = pt.typeArgs(1)
-            def defaultExplanation =
-              "Note that implicit conversions are not applicable because they are ambiguous:\n "+
-              coreMsg+"are possible conversion functions from "+ found+" to "+req
-
-            def explanation = {
-              val sym = found.typeSymbol
-              // Explain some common situations a bit more clearly.
-              if (AnyRefClass.tpe <:< req) {
-                if (sym == AnyClass || sym == UnitClass) {
-                  "Note: " + sym.name + " is not implicitly converted to AnyRef.  You can safely\n" +
-                  "pattern match `x: AnyRef` or cast `x.asInstanceOf[AnyRef]` to do so."
-                }
-                else boxedClass get sym match {
-                  case Some(boxed)  =>
-                    "Note: an implicit exists from " + sym.fullName + " => " + boxed.fullName + ", but\n" +
-                    "methods inherited from Object are rendered ambiguous.  This is to avoid\n" +
-                    "a blanket implicit which would convert any " + sym.fullName + " to any AnyRef.\n" +
-                    "You may wish to use a type ascription: `x: " + boxed.fullName + "`."
-                  case _ =>
-                    defaultExplanation
-                }
-              }
-              else defaultExplanation
-            }
-
-            typeErrorMsg(found, req, infer.isPossiblyMissingArgs(found, req)) + "\n" + explanation
-          } else {
-            "ambiguous implicit values:\n "+coreMsg + "match expected type "+pt
+        def coreMsg =
+           s"""| $pre1 ${info1.sym.fullLocationString} of type ${info1.tpe}
+               | $pre2 ${info2.sym.fullLocationString} of type ${info2.tpe}
+               | $trailer""".stripMargin
+        def viewMsg = {
+          val found :: req :: _ = pt.typeArgs
+          def explanation = {
+            val sym = found.typeSymbol
+            // Explain some common situations a bit more clearly. Some other
+            // failures which have nothing to do with implicit conversions
+            // per se, but which manifest as implicit conversion conflicts
+            // involving Any, are further explained from foundReqMsg.
+            if (AnyRefClass.tpe <:< req) (
+              if (sym == AnyClass || sym == UnitClass) (
+                 s"""|Note: ${sym.name} is not implicitly converted to AnyRef.  You can safely
+                     |pattern match `x: AnyRef` or cast `x.asInstanceOf[AnyRef]` to do so.""".stripMargin
+              )
+              else boxedClass get sym map (boxed =>
+                 s"""|Note: an implicit exists from ${sym.fullName} => ${boxed.fullName}, but
+                     |methods inherited from Object are rendered ambiguous.  This is to avoid
+                     |a blanket implicit which would convert any ${sym.fullName} to any AnyRef.
+                     |You may wish to use a type ascription: `x: ${boxed.fullName}`.""".stripMargin
+              ) getOrElse ""
+            )
+            else
+               s"""|Note that implicit conversions are not applicable because they are ambiguous:
+                   |${coreMsg}are possible conversion functions from $found to $req""".stripMargin
           }
-        context.issueAmbiguousError(AmbiguousTypeError(tree, tree.pos, errMsg))
+          typeErrorMsg(found, req, infer.isPossiblyMissingArgs(found, req)) + (
+            if (explanation == "") "" else "\n" + explanation
+          )
+        }
+        context.issueAmbiguousError(AmbiguousTypeError(tree, tree.pos,
+          if (isView) viewMsg
+          else s"ambiguous implicit values:\n${coreMsg}match expected type $pt")
+        )
       }
     }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala
index f0dca64a00..f8a5c401df 100644
--- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala
@@ -252,6 +252,13 @@ trait TypeDiagnostics {
     }
     ""    // no elaborable variance situation found
   }
+
+  // For found/required errors where AnyRef would have sufficed:
+  // explain in greater detail.
+  def explainAnyVsAnyRef(found: Type, req: Type): String = {
+    if (AnyRefClass.tpe <:< req) notAnyRefMessage(found) else ""
+  }
+
   // TODO - figure out how to avoid doing any work at all
   // when the message will never be seen.  I though context.reportErrors
   // being false would do that, but if I return "<suppressed>" under
@@ -261,7 +268,10 @@ trait TypeDiagnostics {
       ";\n found   : " + found.toLongString + existentialContext(found) + explainAlias(found) +
        "\n required: " + req + existentialContext(req) + explainAlias(req)
     )
-    withDisambiguation(Nil, found, req)(baseMessage) + explainVariance(found, req)
+    (   withDisambiguation(Nil, found, req)(baseMessage)
+      + explainVariance(found, req)
+      + explainAnyVsAnyRef(found, req)
+    )
   }
 
   case class TypeDiag(tp: Type, sym: Symbol) extends Ordered[TypeDiag] {
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("{", "; ", "}")
       )