Great moments in code reuse:

  def isRootOrEmptyPackageClass(s: Symbol) = s.isRoot || s.isEmptyPackageClass
  def isRootOrEmpty                        = (this == EmptyPackageClass) || (this == RootClass)
  def isEffectiveRoot                      = isRoot || isEmptyPackageClass
  // last one actually not quite identical
  def isUnqualified(n: Name)               = n match { case nme.ROOT | nme.EMPTY_PACKAGE_NAME => true ; case _ => false }

I was responsible for at least half of these. Now it's only
isEffectiveRoot.

Also, I have always found it warty that we have to specify Nothing
and Any as upper bounds. I gave the TypeBounds companion object a few
obvious methods:

  def empty: TypeBounds           = apply(NothingClass.tpe, AnyClass.tpe)
  def upper(hi: Type): TypeBounds = apply(NothingClass.tpe, hi)
  def lower(lo: Type): TypeBounds = apply(lo, AnyClass.tpe)

It's a lovable patch.  No review.

1 files changed, 4 insertions, 7 deletions

diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index 6d7d75984c..253ebb708d 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -741,12 +741,9 @@ abstract class ClassfileParser {
                     case variance @ ('+' | '-' | '*') =>
                       index += 1
                       val bounds = variance match {
-                        case '+' => TypeBounds(definitions.NothingClass.tpe,
-                                               sig2type(tparams, skiptvs))
-                        case '-' => TypeBounds(sig2type(tparams, skiptvs),
-                                               definitions.AnyClass.tpe)
-                        case '*' => TypeBounds(definitions.NothingClass.tpe,
-                                               definitions.AnyClass.tpe)
+                        case '+' => TypeBounds.upper(sig2type(tparams, skiptvs))
+                        case '-' => TypeBounds.lower(sig2type(tparams, skiptvs))
+                        case '*' => TypeBounds.empty
                       }
                       val newtparam = sym.newExistential(sym.pos, newTypeName("?"+i)) setInfo bounds
                       existentials += newtparam
@@ -824,7 +821,7 @@ abstract class ClassfileParser {
         if (sig(index) != ':') // guard against empty class bound
           ts += objToAny(sig2type(tparams, skiptvs))
       }
-      TypeBounds(definitions.NothingClass.tpe, intersectionType(ts.toList, sym))
+      TypeBounds.upper(intersectionType(ts.toList, sym))
     }
 
     var tparams = classTParams