intermediate work towards a new starr for value classes.

6 files changed, 118 insertions, 72 deletions

diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala
index ce0505bf44..792c8ad215 100644
--- a/src/compiler/scala/reflect/internal/Definitions.scala
+++ b/src/compiler/scala/reflect/internal/Definitions.scala
@@ -21,7 +21,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
    *  methods.
    */
   private type PolyMethodCreator = List[Symbol] => (Option[List[Type]], Type)
-  
+
   private def enterNewClass(owner: Symbol, name: TypeName, parents: List[Type], flags: Long = 0L): Symbol = {
     val clazz = owner.newClassSymbol(name, NoPosition, flags)
     clazz setInfoAndEnter ClassInfoType(parents, newScope, clazz)
@@ -104,7 +104,6 @@ trait Definitions extends reflect.api.StandardDefinitions {
     def isGetClass(sym: Symbol) =
       (sym.name == nme.getClass_) && (sym.paramss.isEmpty || sym.paramss.head.isEmpty)
 
-    lazy val AnyValClass  = valueCache(tpnme.AnyVal)
     lazy val UnitClass    = valueCache(tpnme.Unit)
     lazy val ByteClass    = valueCache(tpnme.Byte)
     lazy val ShortClass   = valueCache(tpnme.Short)
@@ -166,7 +165,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
     lazy val RuntimePackage       = getRequiredModule("scala.runtime")
     lazy val RuntimePackageClass  = RuntimePackage.moduleClass
-    
+
     lazy val JavaLangEnumClass = getRequiredClass("java.lang.Enum")
 
     // convenient one-argument parameter lists
@@ -178,10 +177,10 @@ trait Definitions extends reflect.api.StandardDefinitions {
     private def booltype    = BooleanClass.typeConstructor
     private def inttype     = IntClass.typeConstructor
     private def stringtype  = StringClass.typeConstructor
-    
+
     // Java types
     def javaTypeName(jclazz: Class[_]): TypeName = newTypeName(jclazz.getName)
-    
+
     def javaTypeToValueClass(jtype: Class[_]): Symbol = jtype match {
       case java.lang.Void.TYPE      => UnitClass
       case java.lang.Byte.TYPE      => ByteClass
@@ -207,6 +206,23 @@ trait Definitions extends reflect.api.StandardDefinitions {
       case _            => null
     }
 
+    private def fixupAsAnyTrait(clazz: Symbol): Symbol = {
+      clazz setInfo fixupAsAnyTrait(clazz.info)
+      clazz
+    }
+
+    private def fixupAsAnyTrait(tpe: Type): Type = tpe match {
+      case ClassInfoType(parents, decls, clazz) =>
+        if (parents.head.typeSymbol == AnyClass) tpe
+        else {
+          assert(parents.head.typeSymbol == ObjectClass, parents)
+          ClassInfoType(AnyClass.tpe :: parents.tail, decls, clazz)
+        }
+      case PolyType(tparams, restpe) =>
+        PolyType(tparams, fixupAsAnyTrait(restpe))
+//      case _ => tpe
+    }
+
     // top types
     lazy val AnyClass             = enterNewClass(ScalaPackageClass, tpnme.Any, Nil, ABSTRACT)
     lazy val AnyRefClass          = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectClass.typeConstructor)
@@ -214,6 +230,18 @@ trait Definitions extends reflect.api.StandardDefinitions {
     lazy val AnyCompanionClass    = getRequiredClass("scala.AnyCompanion") initFlags (SEALED | ABSTRACT | TRAIT)
     lazy val AnyValCompanionClass = getRequiredClass("scala.AnyValCompanion") initFlags (SEALED | ABSTRACT | TRAIT)
 
+    private var oldValueScheme = true
+
+    lazy val AnyValClass          = ScalaPackageClass.info member tpnme.AnyVal orElse {
+//      println("new anyval")
+      oldValueScheme = true
+      val anyval = enterNewClass(ScalaPackageClass, tpnme.AnyVal, anyparam, 0L)
+      val av_constr = anyval.newClassConstructor(NoPosition)
+      anyval.info.decls enter av_constr
+      anyval
+    }
+      lazy val AnyVal_getClass = enterNewMethod(AnyValClass, nme.getClass_, Nil, getClassReturnType(AnyValClass.tpe))
+
     // bottom types
     lazy val RuntimeNothingClass  = getClass(fulltpnme.RuntimeNothing)
     lazy val RuntimeNullClass     = getClass(fulltpnme.RuntimeNull)
@@ -274,7 +302,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
       def Predef_identity = getMember(PredefModule, nme.identity)
       def Predef_conforms = getMember(PredefModule, nme.conforms)
       def Predef_wrapRefArray = getMember(PredefModule, nme.wrapRefArray)
-      
+
     /** Is `sym` a member of Predef with the given name?
      *  Note: DON't replace this by sym == Predef_conforms/etc, as Predef_conforms is a `def`
      *  which does a member lookup (it can't be a lazy val because we might reload Predef
@@ -316,7 +344,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
     lazy val SingletonClass        = enterNewClass(ScalaPackageClass, tpnme.Singleton, anyparam, ABSTRACT | TRAIT | FINAL)
     lazy val SerializableClass     = getRequiredClass("scala.Serializable")
     lazy val JavaSerializableClass = getClass(sn.JavaSerializable)
-    lazy val ComparableClass       = getRequiredClass("java.lang.Comparable")
+    lazy val ComparableClass       = fixupAsAnyTrait(getRequiredClass("java.lang.Comparable"))
     lazy val JavaCloneableClass    = getRequiredClass("java.lang.Cloneable")
     lazy val RemoteInterfaceClass  = getRequiredClass("java.rmi.Remote")
     lazy val RemoteExceptionClass  = getRequiredClass("java.rmi.RemoteException")
@@ -426,7 +454,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
       case m: ClassManifest[_] =>
         val sym  = manifestToSymbol(m)
         val args = m.typeArguments
-      
+
         if ((sym eq NoSymbol) || args.isEmpty) sym.tpe
         else appliedType(sym.typeConstructor, args map manifestToType)
       case _ =>
@@ -436,7 +464,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
     def manifestToSymbol(m: ClassManifest[_]): Symbol = m match {
       case x: scala.reflect.AnyValManifest[_] =>
         getMember(ScalaPackageClass, newTypeName("" + x))
-      case _                                  => 
+      case _                                  =>
         val name = m.erasure.getName
         if (name endsWith nme.MODULE_SUFFIX_STRING)
           getModuleIfDefined(name stripSuffix nme.MODULE_SUFFIX_STRING)
@@ -496,7 +524,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
       case DoubleClass  => nme.wrapDoubleArray
       case BooleanClass => nme.wrapBooleanArray
       case UnitClass    => nme.wrapUnitArray
-      case _        => 
+      case _        =>
         if ((elemtp <:< AnyRefClass.tpe) && !isPhantomClass(elemtp.typeSymbol)) nme.wrapRefArray
         else nme.genericWrapArray
     }
@@ -640,7 +668,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
         case _ => false
       })
     }
-    
+
     // members of class scala.Any
     lazy val Any_==       = enterNewMethod(AnyClass, nme.EQ, anyparam, booltype, FINAL)
     lazy val Any_!=       = enterNewMethod(AnyClass, nme.NE, anyparam, booltype, FINAL)
@@ -662,12 +690,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
     lazy val Any_isInstanceOf = newT1NullaryMethod(AnyClass, nme.isInstanceOf_, FINAL)(_ => booltype)
     lazy val Any_asInstanceOf = newT1NullaryMethod(AnyClass, nme.asInstanceOf_, FINAL)(_.typeConstructor)
 
-    // AnyVal_getClass is defined here. Once we have a new strap, it could also be
-    // defined directly in the AnyVal trait. Right now this does not work, because
-    // strap complains about overriding a final getClass method in Any.
-    lazy val AnyVal_getClass = newMethod(AnyValClass, nme.getClass_, Nil, getClassReturnType(AnyValClass.tpe))
-
-    // A type function from T => Class[U], used to determine the return
+  // A type function from T => Class[U], used to determine the return
     // type of getClass calls.  The returned type is:
     //
     //  1. If T is a value type, Class[T].
@@ -708,7 +731,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
     lazy val Object_ne = enterNewMethod(ObjectClass, nme.ne, anyrefparam, booltype, FINAL)
     lazy val Object_isInstanceOf = newT1NoParamsMethod(ObjectClass, nme.isInstanceOf_Ob, FINAL | SYNTHETIC)(_ => booltype)
     lazy val Object_asInstanceOf = newT1NoParamsMethod(ObjectClass, nme.asInstanceOf_Ob, FINAL | SYNTHETIC)(_.typeConstructor)
-    lazy val Object_synchronized = newPolyMethod(1, ObjectClass, nme.synchronized_, FINAL)(tps => 
+    lazy val Object_synchronized = newPolyMethod(1, ObjectClass, nme.synchronized_, FINAL)(tps =>
       (Some(List(tps.head.typeConstructor)), tps.head.typeConstructor)
     )
     lazy val String_+ = enterNewMethod(StringClass, nme.raw.PLUS, anyparam, stringtype, FINAL)
@@ -816,10 +839,10 @@ trait Definitions extends reflect.api.StandardDefinitions {
       while (result.isAliasType) result = result.info.typeSymbol
       result
     }
-    
+
     def getRequiredModule(fullname: String): Symbol =
       getModule(newTermNameCached(fullname))
-    def getRequiredClass(fullname: String): Symbol = 
+    def getRequiredClass(fullname: String): Symbol =
       getClass(newTypeNameCached(fullname))
 
     def getClassIfDefined(fullname: String): Symbol =
@@ -868,15 +891,15 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
     private def newAlias(owner: Symbol, name: TypeName, alias: Type): Symbol =
       owner.newAliasType(name) setInfoAndEnter alias
-    
+
     private def specialPolyClass(name: TypeName, flags: Long)(parentFn: Symbol => Type): Symbol = {
       val clazz   = enterNewClass(ScalaPackageClass, name, Nil)
       val tparam  = clazz.newSyntheticTypeParam("T0", flags)
       val parents = List(AnyRefClass.tpe, parentFn(tparam))
-      
+
       clazz setInfo GenPolyType(List(tparam), ClassInfoType(parents, newScope, clazz))
     }
-    
+
     def newPolyMethod(typeParamCount: Int, owner: Symbol, name: TermName, flags: Long)(createFn: PolyMethodCreator): Symbol = {
       val msym    = owner.newMethod(name.encode, NoPosition, flags)
       val tparams = msym.newSyntheticTypeParams(typeParamCount)
@@ -887,7 +910,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
       msym setInfoAndEnter polyType(tparams, mtpe)
     }
-    
+
     /** T1 means one type parameter.
      */
     def newT1NullaryMethod(owner: Symbol, name: TermName, flags: Long)(createFn: Symbol => Type): Symbol = {
@@ -999,7 +1022,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
       RootClass.info.decls enter EmptyPackage
       RootClass.info.decls enter RootPackage
-      
+
       val forced = List( // force initialization of every symbol that is entered as a side effect
         AnnotationDefaultAttr, // #2264
         RepeatedParamClass,
@@ -1029,13 +1052,18 @@ trait Definitions extends reflect.api.StandardDefinitions {
         Object_synchronized,
         Object_isInstanceOf,
         Object_asInstanceOf,
+        //AnyVal_getClass,
         String_+,
-        AnyVal_getClass
+        ComparableClass
       )
 
-      /** Removing the anyref parent they acquire from having a source file.
+      /* Removing the anyref parent they acquire from having a source file.
        */
-      setParents(AnyValClass, List(NotNullClass.tpe, AnyClass.tpe))
+      if (oldValueScheme) {
+        setParents(AnyValClass, List(NotNullClass.tpe, AnyClass.tpe))
+      } else {
+        AnyVal_getClass // force it!
+      }
       ScalaValueClasses foreach { sym =>
         setParents(sym, anyvalparam)
       }
diff --git a/src/compiler/scala/reflect/internal/transform/Erasure.scala b/src/compiler/scala/reflect/internal/transform/Erasure.scala
index 38a60587a4..4775541855 100644
--- a/src/compiler/scala/reflect/internal/transform/Erasure.scala
+++ b/src/compiler/scala/reflect/internal/transform/Erasure.scala
@@ -62,10 +62,10 @@ trait Erasure {
   protected def rebindInnerClass(pre: Type, cls: Symbol): Type = {
     if (cls.owner.isClass) cls.owner.tpe else pre // why not cls.isNestedClass?
   }
-  
-  protected def unboxInlineType(clazz: Symbol): Type = 
+
+  protected def unboxInlineType(clazz: Symbol): Type =
     clazz.primaryConstructor.info.params.head.tpe
-    
+
   protected def eraseInlineClassRef(clazz: Symbol): Type = {
     scalaErasure(unboxInlineType(clazz))
   }
@@ -87,7 +87,7 @@ trait Erasure {
           else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass || sym == NotNullClass) erasedTypeRef(ObjectClass)
           else if (sym == UnitClass) erasedTypeRef(BoxedUnitClass)
           else if (sym.isRefinementClass) apply(mergeParents(tp.parents))
-          else if (sym.isInlineClass) eraseInlineClassRef(sym)
+          //else if (sym.isInlineClass) eraseInlineClassRef(sym)
           else if (sym.isClass) typeRef(apply(rebindInnerClass(pre, sym)), sym, List())  // #2585
           else apply(sym.info) // alias type or abstract type
         case PolyType(tparams, restpe) =>
diff --git a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
index 662e03d155..81a6659b3c 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeInfo.scala
@@ -45,4 +45,11 @@ abstract class TreeInfo extends reflect.internal.TreeInfo {
   
   def isInterface(mods: HasFlags, body: List[Tree]) = 
     mods.hasTraitFlag && (body forall isInterfaceMember)
+
+  def isAllowedInAnyTrait(stat: Tree): Boolean = stat match {    
+    case _: ValDef => false
+    case Import(_, _) | EmptyTree => true
+    case _: DefTree => true
+    case _ => false
+  }
 }
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index 3ee8b62bc6..acb4e9b122 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -38,7 +38,7 @@ trait ParsersCommon extends ScannersCommon {
     def freshTypeName(prefix: String): TypeName
     def deprecationWarning(off: Int, msg: String): Unit
     def accept(token: Int): Int
-  
+
     /** Methods inParensOrError and similar take a second argument which, should
      *  the next token not be the expected opener (e.g. LPAREN) will be returned
      *  instead of the contents of the groupers.  However in all cases accept(LPAREN)
@@ -1141,7 +1141,7 @@ self =>
     private def interpolatedString(): Tree = atPos(in.offset) {
       val start = in.offset
       val interpolator = in.name
-      
+
       val partsBuf = new ListBuffer[Tree]
       val exprBuf = new ListBuffer[Tree]
       in.nextToken()
@@ -1153,7 +1153,7 @@ self =>
         }
       }
       if (in.token == STRINGLIT) partsBuf += literal()
-      
+
       val t1 = atPos(o2p(start)) { Ident(nme.StringContext) }
       val t2 = atPos(start) { Apply(t1, partsBuf.toList) }
       t2 setPos t2.pos.makeTransparent
@@ -2765,8 +2765,10 @@ self =>
         }
         else {
           val parents = (
-            if (!isInterface(mods, body) && !isScalaArray(name)) parents0 :+ scalaScalaObjectConstr
-            else if (parents0.isEmpty) List(scalaAnyRefConstr)
+            if (parents0.isEmpty) List(scalaAnyRefConstr)
+            /*if (!isInterface(mods, body) && !isScalaArray(name))
+              parents0 /* :+ scalaScalaObjectConstr*/
+            else*/
             else parents0
           ) ++ caseParents()
           Template(parents, self, constrMods, vparamss, argss, body, o2p(tstart))
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 2f31347829..5f156b98e8 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -113,7 +113,7 @@ trait Namers extends MethodSynthesis {
     private def contextFile = context.unit.source.file
     private def typeErrorHandler[T](tree: Tree, alt: T): PartialFunction[Throwable, T] = {
       case ex: TypeError =>
-        // H@ need to ensure that we handle only cyclic references 
+        // H@ need to ensure that we handle only cyclic references
         TypeSigError(tree, ex)
         alt
     }
@@ -296,7 +296,7 @@ trait Namers extends MethodSynthesis {
       val pos         = tree.pos
       val isParameter = tree.mods.isParameter
       val flags       = tree.mods.flags & mask
-      
+
       tree match {
         case TypeDef(_, _, _, _) if isParameter     => owner.newTypeParameter(name.toTypeName, pos, flags)
         case TypeDef(_, _, _, _)                    => owner.newTypeSymbol(name.toTypeName, pos, flags)
@@ -705,6 +705,13 @@ trait Namers extends MethodSynthesis {
         if (needsCycleCheck && !typer.checkNonCyclic(tree.pos, tp))
           sym setInfo ErrorType
       }
+      tree match {
+        case cdef: ClassDef =>
+          if (!treeInfo.isInterface(sym, cdef.impl.body) && sym != ArrayClass &&
+              (sym.info.parents forall (_.typeSymbol != AnyValClass)))
+          ensureParent(sym, ScalaObjectClass)
+        case _ =>
+      }
     }
 
     def moduleClassTypeCompleter(tree: Tree) = {
@@ -837,10 +844,6 @@ trait Namers extends MethodSynthesis {
 
       val parents = typer.parentTypes(templ) map checkParent
 
-// not yet:
-//      if (!treeInfo.isInterface(clazz, templ.body) && clazz != ArrayClass)
-//        ensureParent(ScalaObjectClass)
-
       enterSelf(templ.self)
 
       val decls = newScope
@@ -1313,6 +1316,22 @@ trait Namers extends MethodSynthesis {
       }
     }
 
+    def includeParent(tpe: Type, parent: Symbol): Type = tpe match {
+      case PolyType(tparams, restpe) =>
+        PolyType(tparams, includeParent(restpe, parent))
+      case ClassInfoType(parents, decls, clazz) =>
+        if (parents exists (_.typeSymbol == parent)) tpe
+        else ClassInfoType(parents :+ parent.tpe, decls, clazz)
+      case _ =>
+        tpe
+    }
+
+    def ensureParent(clazz: Symbol, parent: Symbol) = {
+      val info0 = clazz.info
+      val info1 = includeParent(info0, parent)
+      if (info0 ne info1) clazz setInfo info1
+    }
+
     class LogTransitions[S](onEnter: S => String, onExit: S => String) {
       val enabled = settings.debug.value
       @inline final def apply[T](entity: S)(body: => T): T = {
@@ -1390,25 +1409,9 @@ trait Namers extends MethodSynthesis {
       if (sym.info.typeSymbol == FunctionClass(0) && sym.isValueParameter && sym.owner.isCaseClass)
         fail(ByNameParameter)
 
-      def includeParent(tpe: Type, parent: Symbol): Type = tpe match {
-        case PolyType(tparams, restpe) =>
-          PolyType(tparams, includeParent(restpe, parent))
-        case ClassInfoType(parents, decls, clazz) =>
-          if (parents exists (_.typeSymbol == parent)) tpe
-          else ClassInfoType(parents :+ parent.tpe, decls, clazz)
-        case _ =>
-          tpe
-      }
-
-      def ensureParent(parent: Symbol) = {
-        val info0 = sym.info
-        val info1 = includeParent(info0, parent)
-        if (info0 ne info1) sym setInfo info1
-      }
-
-      if (sym.isClass && sym.hasAnnotation(ScalaInlineClass) && !phase.erasedTypes) {
+     if (sym.isClass && sym.hasAnnotation(ScalaInlineClass) && !phase.erasedTypes) {
         if (!sym.isSubClass(AnyValClass))
-          ensureParent(NotNullClass)
+          ensureParent(sym, NotNullClass)
 
         sym setFlag FINAL
       }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index b6f555e42a..680a298230 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -154,7 +154,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
       case ErrorType =>
         fun
     }
-    
+
     def inferView(tree: Tree, from: Type, to: Type, reportAmbiguous: Boolean): Tree =
       inferView(tree, from, to, reportAmbiguous, true)
 
@@ -274,7 +274,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
       }
       tp match {
         case TypeRef(pre, sym, args) =>
-          checkNotLocked(sym) && 
+          checkNotLocked(sym) &&
           ((!sym.isNonClassType) || checkNonCyclic(pos, appliedType(pre.memberInfo(sym), args), sym))
           // @M! info for a type ref to a type parameter now returns a polytype
           // @M was: checkNonCyclic(pos, pre.memberInfo(sym).subst(sym.typeParams, args), sym)
@@ -939,7 +939,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
             adaptType()
           else if (inExprModeButNot(mode, FUNmode) && tree.symbol != null && tree.symbol.isMacro && !tree.isDef) {
             val tree1 = expandMacro(tree)
-            if (tree1.isErroneous) tree1 else typed(tree1, mode, pt) 
+            if (tree1.isErroneous) tree1 else typed(tree1, mode, pt)
           } else if ((mode & (PATTERNmode | FUNmode)) == (PATTERNmode | FUNmode))
             adaptConstrPattern()
           else if (inAllModes(mode, EXPRmode | FUNmode) &&
@@ -1084,7 +1084,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         // Note: implicit arguments are still inferred (this kind of "chaining" is allowed)
       )
     }
-    
+
     def adaptToMember(qual: Tree, searchTemplate: Type): Tree =
       adaptToMember(qual, searchTemplate, true, true)
     def adaptToMember(qual: Tree, searchTemplate: Type, reportAmbiguous: Boolean): Tree =
@@ -1099,12 +1099,12 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         }
         inferView(qual, qual.tpe, searchTemplate, reportAmbiguous, saveErrors) match {
           case EmptyTree  => qual
-          case coercion   => 
+          case coercion   =>
             if (settings.logImplicitConv.value)
               unit.echo(qual.pos,
                 "applied implicit conversion from %s to %s = %s".format(
                   qual.tpe, searchTemplate, coercion.symbol.defString))
-            
+
             typedQualifier(atPos(qual.pos)(new ApplyImplicitView(coercion, List(qual))))
         }
       }
@@ -1205,6 +1205,8 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
             supertpt = TypeTree(supertpt1.tpe.parents.head) setPos supertpt.pos.focus
           }
         }
+        if (supertpt.tpe.typeSymbol == AnyClass && firstParent.isTrait && firstParent != AnyValClass)
+          supertpt.tpe = AnyRefClass.tpe
 
         // Determine
         //  - supertparams: Missing type parameters from supertype
@@ -1407,6 +1409,10 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         _.typedTemplate(cdef.impl, parentTypes(cdef.impl))
       }
       val impl2 = finishMethodSynthesis(impl1, clazz, context)
+      if (clazz.isTrait && clazz.info.parents.nonEmpty && clazz.info.parents.head.typeSymbol == AnyClass)
+        for (stat <- impl2.body)
+          if (!treeInfo.isAllowedInAnyTrait(stat))
+            unit.error(stat.pos, "this statement is not allowed in trait extending from class Any: "+stat)
       if ((clazz != ClassfileAnnotationClass) &&
           (clazz isNonBottomSubClass ClassfileAnnotationClass))
         restrictionWarning(cdef.pos, unit,
@@ -2889,10 +2895,10 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
     def packSymbols(hidden: List[Symbol], tp: Type): Type =
       if (hidden.isEmpty) tp
       else existentialTransform(hidden, tp)(existentialAbstraction)
-      
+
     def isReferencedFrom(ctx: Context, sym: Symbol): Boolean =
-      ctx.owner.isTerm && 
-      (ctx.scope.exists { dcl => dcl.isInitialized && (dcl.info contains sym) }) || 
+      ctx.owner.isTerm &&
+      (ctx.scope.exists { dcl => dcl.isInitialized && (dcl.info contains sym) }) ||
       {
         var ctx1 = ctx.outer
         while ((ctx1 != NoContext) && (ctx1.scope eq ctx.scope)) ctx1 = ctx1.outer
@@ -3879,7 +3885,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           reallyExists(sym) &&
           ((mode & PATTERNmode | FUNmode) != (PATTERNmode | FUNmode) || !sym.isSourceMethod || sym.hasFlag(ACCESSOR))
         }
-        
+
         if (defSym == NoSymbol) {
           var defEntry: ScopeEntry = null // the scope entry of defSym, if defined in a local scope
 
@@ -4370,7 +4376,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
 
         case ReferenceToBoxed(idt @ Ident(_)) =>
           val id1 = typed1(idt, mode, pt) match { case id: Ident => id }
-          treeCopy.ReferenceToBoxed(tree, id1) setType AnyRefClass.tpe         
+          treeCopy.ReferenceToBoxed(tree, id1) setType AnyRefClass.tpe
 
         case Literal(value) =>
           tree setType (