Fix 791

src/dotty/tools/dotc/Compiler.scala

@@ -52,6 +52,7 @@ class Compiler {
            new ClassOf),
       List(new PatternMatcher,
            new ExplicitOuter,
+           new ExplicitSelf,
            new Splitter),
       List(new VCInlineMethods,
            new SeqLiterals,

src/dotty/tools/dotc/core/TypeErasure.scala

@@ -234,7 +234,11 @@ object TypeErasure {
             case nil =>
               bestSoFar
           }
-          loop(tp1.baseClasses, defn.ObjectClass).typeRef
+          val t = loop(tp1.baseClasses, defn.ObjectClass)
+          if (t eq defn.AnyValClass)
+            // while AnyVal is a valid common super class for primitives it does not exist after erasure
+            defn.ObjectType
+          else t.typeRef
       }
   }
 

src/dotty/tools/dotc/core/Types.scala

@@ -2530,7 +2530,7 @@ object Types {
     def selfType(implicit ctx: Context): Type = {
       if (selfTypeCache == null)
         selfTypeCache = {
-          def fullRef = fullyAppliedRef(cls.typeRef, cls.typeParams)
+          def fullRef = fullyAppliedRef
           val given = givenSelfType
           val raw =
             if (!given.exists) fullRef
@@ -2561,6 +2561,9 @@ object Types {
         base
     }
 
+    /** The class type with all type parameters */
+    def fullyAppliedRef(implicit ctx: Context): Type = fullyAppliedRef(cls.typeRef, cls.typeParams)
+
     def rebase(tp: Type)(implicit ctx: Context): Type =
       if ((prefix eq cls.owner.thisType) || !cls.owner.isClass || ctx.erasedTypes) tp
       else tp.substThis(cls.owner.asClass, prefix)

src/dotty/tools/dotc/transform/Erasure.scala

@@ -625,8 +625,10 @@ object Erasure extends TypeTestsCasts{
         assert(false, s"failure creating bridge from ${newDefSym} to ${parentSym}, reason: $reason")
         ???
       }
+      var excluded = NoBridgeFlags
+      if (!newDefSym.is(Flags.Protected)) excluded |= Flags.Protected // needed to avoid "weaker access" assertion failures in expandPrivate
       val bridge = ctx.newSymbol(currentClass,
-        parentSym.name, parentSym.flags &~ NoBridgeFlags | Flags.Bridge, parentSym.info, coord = newDefSym.owner.coord).asTerm
+        parentSym.name, parentSym.flags &~ excluded | Flags.Bridge, parentSym.info, coord = newDefSym.owner.coord).asTerm
       bridge.enteredAfter(ctx.phase.prev.asInstanceOf[DenotTransformer]) // this should be safe, as we're executing in context of next phase
       ctx.debuglog(s"generating bridge from ${newDefSym} to $bridge")
 

src/dotty/tools/dotc/transform/ExpandPrivate.scala

@@ -45,7 +45,7 @@ class ExpandPrivate extends MiniPhaseTransform with IdentityDenotTransformer { t
         }
         val fail = sym.allOverriddenSymbols.findSymbol(x => !hasWeakerAccess(x))
         if (fail.exists) {
-          assert(false, i"${sym.showFullName} has weaker access that superclass method ${fail.showFullName}")
+          assert(false, i"${sym.showFullName}: ${sym.info} has weaker access than superclass method ${fail.showFullName}: ${fail.info}")
         }
       case _ =>
     }

src/dotty/tools/dotc/transform/ExplicitSelf.scala

@@ -0,0 +1,37 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts.Context
+import Types._
+import TreeTransforms._
+import Decorators._
+import ast.Trees._
+import Flags._
+
+/** Transform references of the form
+ *
+ *     C.this.m
+ *
+ *  where `C` is a class with explicit self type and `C` is not a
+ *  subclass of the owner of `m` to
+ *
+ *     C.this.asInstanceOf[S].m
+ *
+ *  where `S` is the self type of `C`.
+ */
+class ExplicitSelf extends MiniPhaseTransform { thisTransform =>
+  import ast.tpd._
+
+  override def phaseName = "explicitSelf"
+
+  override def transformSelect(tree: Select)(implicit ctx: Context, info: TransformerInfo): Tree = tree match {
+    case Select(thiz: This, name) if name.isTermName =>
+      val cls = thiz.symbol.asClass
+      val cinfo = cls.classInfo
+      if (cinfo.givenSelfType.exists && !cls.derivesFrom(tree.symbol.owner))
+        cpy.Select(tree)(thiz.asInstance(cinfo.selfType), name)
+      else tree
+    case _ => tree
+  }
+}

src/dotty/tools/dotc/typer/Applications.scala

@@ -1117,7 +1117,7 @@ trait Applications extends Compatibility { self: Typer =>
       case cdef: CaseDef => tpd.cpy.CaseDef(cdef)(body = adapt(cdef.body, pt))
       case _ => adaptInterpolated(tree, pt, tree)
     }
-    harmonizeWith(trees)(_.tpe, adapt)
+    if (ctx.isAfterTyper) trees else harmonizeWith(trees)(_.tpe, adapt)
   }
 
   /** If all `types` are numeric value types, and they are not all the same type,

tests/run/OrType.scala

@@ -0,0 +1,11 @@
+class B(val x: Int)
+class C(val x: Double)
+
+object Test{
+  def bar(x: B | C): Int | Double = x.x
+  def main(args: Array[String]): Unit = {
+    val b = new B(1)
+    val c = new C(1)
+    bar(if (b.hashCode > c.hashCode) b else c)
+  }
+}

tests/run/i789.check

@@ -0,0 +1 @@
+atPhase: 2

tests/run/i789.scala

@@ -0,0 +1,20 @@
+    trait Periods { self: Context =>
+
+      def atPhase(id: Int): Unit = println(s"atPhase: $id")
+
+    }
+
+    class Phase(val id: Int)
+
+    trait Phases { self: Context =>
+      def atPhase(phase: Phase): Unit = self.atPhase(phase.id)
+    }
+
+    trait Context extends Phases with Periods
+
+    object Test extends Context {
+
+      def main(args: Array[String]) = atPhase(new Phase(2))
+
+    }
+