1 files changed, 13 insertions, 7 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
index 257ab243b4..95c79eb97e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
@@ -9,7 +9,6 @@ package typechecker
 
 import scala.collection.mutable.ListBuffer
 import symtab.Flags._
-import util.Position
 
 /** This phase adds super accessors for all super calls that
  *  either appear in a trait or have as a target a member of some outer class.
@@ -27,6 +26,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
   // inherits abstract value `global' and class `Phase' from Transform
 
   import global._
+  import definitions.{ IntClass, UnitClass, ByNameParamClass, Any_asInstanceOf, Object_## }
 
   /** the following two members override abstract members in Transform */
   val phaseName: String = "superaccessors"
@@ -45,7 +45,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
 
     private def transformArgs(args: List[Tree], params: List[Symbol]) =
       ((args, params).zipped map { (arg, param) =>
-        if (param.tpe.typeSymbol == definitions.ByNameParamClass)
+        if (param.tpe.typeSymbol == ByNameParamClass)
           withInvalidOwner { checkPackedConforms(transform(arg), param.tpe.typeArgs.head) }
         else transform(arg)
       }) :::
@@ -71,15 +71,21 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
             other = linked.info.decl(sym.name.toTermName).filter(_.isModule)
           if (other != NoSymbol)
             unit.error(sym.pos, "name clash: "+sym.owner+" defines "+sym+
-                       "\nand its companion "+sym.owner.linkedModuleOfClass+" also defines "+
+                       "\nand its companion "+sym.owner.companionModule+" also defines "+
                        other)
         }
       }
 
-    private def transformSuperSelect(tree: Tree) = tree match {
-      case Select(sup @ Super(_, mix), name) =>
+    private def transformSuperSelect(tree: Tree): Tree = tree match {
+      // Intercept super.## and translate it to this.##
+      // which is fine since it's final.
+      case Select(sup @ Super(_, _), nme.HASHHASH)  =>
+        Select(gen.mkAttributedThis(sup.symbol), Object_##) setType IntClass.tpe
+
+      case Select(sup @ Super(_, mix), name)  =>
         val sym = tree.symbol
         val clazz = sup.symbol
+
         if (sym.isDeferred) {
           val member = sym.overridingSymbol(clazz);
           if (mix != nme.EMPTY.toTypeName || member == NoSymbol ||
@@ -339,7 +345,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
       }
       if (isDependentType) {
         val preciseTpe = expectedTpe.asSeenFrom(singleType(NoPrefix, obj), ownerClass) //typeRef(singleType(NoPrefix, obj), v.tpe.symbol, List())
-        TypeApply(Select(res, definitions.Any_asInstanceOf),
+        TypeApply(Select(res, Any_asInstanceOf),
                   List(TypeTree(preciseTpe)))
       } else res
     }
@@ -365,7 +371,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
       if (protAcc == NoSymbol) {
         protAcc = clazz.newMethod(field.pos, nme.protSetterName(field.originalName))
         protAcc.setInfo(MethodType(protAcc.newSyntheticValueParams(List(clazz.typeOfThis, field.tpe)),
-                                   definitions.UnitClass.tpe))
+                                   UnitClass.tpe))
         clazz.info.decls.enter(protAcc)
         val code = DefDef(protAcc, {
           val obj :: value :: Nil = protAcc.paramss.head;