Merge branch 'master' into existentialTypesMigrateErrorMessage

Author: raindeerr

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -316,25 +316,35 @@ trait Symbols { this: Context =>
             newNakedSymbol[original.ThisName](original.coord)
         }
       val ttmap1 = ttmap.withSubstitution(originals, copies)
-      (originals, copies).zipped foreach {(original, copy) =>
-        copy.denot = original.denot // preliminary denotation, so that we can access symbols in subsequent transform
-      }
-      (originals, copies).zipped foreach {(original, copy) =>
+      (originals, copies).zipped foreach { (original, copy) =>
         val odenot = original.denot
         val oinfo = original.info match {
           case ClassInfo(pre, _, parents, decls, selfInfo) =>
             assert(original.isClass)
             ClassInfo(pre, copy.asClass, parents, decls.cloneScope, selfInfo)
           case oinfo => oinfo
         }
+
+        val completer = new LazyType {
+          def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
+            denot.info = oinfo // needed as otherwise we won't be able to go from Sym -> parents & etc
+                               // Note that this is a hack, but hack commonly used in Dotty
+                               // The same thing is done by other completers all the time
+            denot.info = ttmap1.mapType(oinfo)
+            denot.annotations = odenot.annotations.mapConserve(ttmap1.apply)
+          }
+        }
+
         copy.denot = odenot.copySymDenotation(
           symbol = copy,
           owner = ttmap1.mapOwner(odenot.owner),
-          initFlags = odenot.flags &~ Frozen | Fresh,
-          info = ttmap1.mapType(oinfo),
+          initFlags = odenot.flags &~ (Frozen | Touched) | Fresh,
+          info = completer,
           privateWithin = ttmap1.mapOwner(odenot.privateWithin), // since this refers to outer symbols, need not include copies (from->to) in ownermap here.
-          annotations = odenot.annotations.mapConserve(ttmap1.apply))
+          annotations = odenot.annotations)
+
       }
+
       copies
     }
 

compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -81,14 +81,19 @@ class ExplicitOuter extends MiniPhaseTransform with InfoTransformer { thisTransf
         !needsOuterAlways(cls) &&
         impl.existsSubTree(referencesOuter(cls, _)))
       ensureOuterAccessors(cls)
-    if (hasOuter(cls)) {
+
+    val clsHasOuter = hasOuter(cls)
+    if (clsHasOuter || cls.mixins.exists(needsOuterIfReferenced)) {
       val newDefs = new mutable.ListBuffer[Tree]
-      if (isTrait)
-        newDefs += DefDef(outerAccessor(cls).asTerm, EmptyTree)
-      else {
-        val outerParamAcc = outerParamAccessor(cls)
-        newDefs += ValDef(outerParamAcc, EmptyTree)
-        newDefs += DefDef(outerAccessor(cls).asTerm, ref(outerParamAcc))
+
+      if (clsHasOuter) {
+        if (isTrait)
+          newDefs += DefDef(outerAccessor(cls).asTerm, EmptyTree)
+        else {
+          val outerParamAcc = outerParamAccessor(cls)
+          newDefs += ValDef(outerParamAcc, EmptyTree)
+          newDefs += DefDef(outerAccessor(cls).asTerm, ref(outerParamAcc))
+        }
       }
 
       for (parentTrait <- cls.mixins) {
@@ -181,6 +186,7 @@ object ExplicitOuter {
   private def needsOuterAlways(cls: ClassSymbol)(implicit ctx: Context): Boolean =
     needsOuterIfReferenced(cls) &&
     (!hasLocalInstantiation(cls) || // needs outer because we might not know whether outer is referenced or not
+     cls.mixins.exists(needsOuterIfReferenced) || // needs outer for parent traits
      cls.classInfo.parents.exists(parent => // needs outer to potentially pass along to parent
        needsOuterIfReferenced(parent.classSymbol.asClass)))
 

tests/pos/i1812.scala

@@ -0,0 +1,12 @@
+class FF[R] {
+  def compose(): R = ???
+}
+
+class Test(x: Int) extends AnyVal {
+  def method: Unit = {
+    class Bla
+    class Foo extends FF[Bla] {
+      override def compose() = super[FF].compose()
+    }
+  }
+}

tests/pos/i1812b.scala

@@ -0,0 +1,11 @@
+class FF[R] {
+  def compose(): R = ???
+}
+
+class Test(x: Int) extends AnyVal {
+  def method: Unit = {
+    class Bla{ def bar:a.S = ???}
+    trait TRT{ type S}
+    val a: TRT = ???
+  }
+}

tests/run/i1820.check

@@ -0,0 +1 @@
+a

tests/run/i1820.scala

@@ -0,0 +1,17 @@
+class A {
+  val a = "a"
+  trait Inner {
+    def f = println(a)
+    def h = 3
+  }
+}
+
+class Inner extends Test.a.Inner
+
+object Test {
+  val a = new A
+
+  def main(args: Array[String]): Unit = {
+    (new Inner).f
+  }
+}

tests/run/i1820b.check

@@ -0,0 +1 @@
+a

tests/run/i1820b.scala

@@ -0,0 +1,19 @@
+trait A {
+  val a = "a"
+  trait Inner {
+    def f = println(a)
+    def h = 3
+  }
+}
+
+trait B extends A {
+  trait Inner2 extends Inner
+  def g = new Inner2 {}
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val b = new B {}
+    b.g.f
+  }
+}