SI-8177 refine embeddedSymbols

We look for any prefix that has a refinement class for a type symbol.
This includes ThisTypes, which were not considered before.

pos/t8177g.scala, neg/t0764*scala now compile, as they should

Additional test cases contributed by Jason & Paul.

Author: adriaanm

src/compiler/scala/tools/nsc/typechecker/RefChecks.scala

@@ -470,6 +470,8 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
           // Important: first check the pair has the same kind, since the substitution
           // carries high's type parameter's bounds over to low, so that
           // type equality doesn't consider potentially different bounds on low/high's type params.
+          // In b781e25afe this went from using memberInfo to memberType (now lowType/highType), tested by neg/override.scala.
+          // TODO: was that the right fix? it seems type alias's RHS should be checked by looking at the symbol's info
           if (pair.sameKind && lowType.substSym(low.typeParams, high.typeParams) =:= highType) ()
           else overrideTypeError() // (1.6)
         }

src/reflect/scala/reflect/internal/Types.scala

@@ -2051,10 +2051,16 @@ trait Types
   // Return the symbol named `name` that's "embedded" in tp
   // This is the case if `tp` is a `T{...; type/val $name ; ...}`,
   // or a singleton type with such an underlying type.
-  private def embeddedSymbol(tp: Type, name: Name): Symbol = tp.widen match {
-    case RefinedType(_, decls) => decls lookup name
-    case _ => NoSymbol
-  }
+  private def embeddedSymbol(tp: Type, name: Name): Symbol =
+    // normalize to flatten nested RefinedTypes
+    // don't check whether tp is a RefinedType -- it may be a ThisType of one, for example
+    // TODO: check the resulting symbol is owned by the refinement class? likely an invariant...
+    if (tp.typeSymbol.isRefinementClass) tp.normalize.decls lookup name
+    else {
+      debuglog(s"no embedded symbol $name found in ${showRaw(tp)} --> ${tp.normalize.decls lookup name}")
+      NoSymbol
+    }
+
 
   trait AbstractTypeRef extends NonClassTypeRef {
     require(sym.isAbstractType, sym)

test/files/neg/t0764.check

@@ -0,0 +1,27 @@
+class Top[A] {
+        type AType = A
+}
+
+trait Node { outer =>
+        type T <: Node
+        def prepend = new Node { type T = outer.type }
+}
+
+class Main[NextType <: Node](value: Node { type T = NextType })
+        extends Top[Node { type T = NextType }] {
+
+        new Main[AType]( (value: AType).prepend )
+}
+
+/* this used to be a neg test, even though it should've compiled
+SI-8177 fixed this.
+
+Behold the equivalent program which type checks without the fix for SI-8177.
+(Expand type alias, convert type member to type param;
+note the covariance to encode subtyping on type members.)
+
+class Node[+T <: Node[_]] { def prepend = new Node[this.type] }
+class Main[NextType <: Node[_]](value: Node[NextType]) {
+  new Main(value.prepend)
+}
+*/

test/files/neg/t0764.scala

@@ -1,8 +1,3 @@
-/** Note that this should compile! It's a neg test to track the
-behavior. If you have broken this test by making it compile, that
-means you have fixed it and it should be moved to pos.
-**/
-
 // In all cases when calling "prepend" the receiver 'v'
 // has static type NodeAlias[A] or (equivalently) Node { type T = A }.
 // Since prepend explicitly returns the singleton type of the receiver,
@@ -15,6 +10,8 @@ means you have fixed it and it should be moved to pos.
 //   new Main[Node { type T = A }](v.prepend)
 //   new Main(v.prepend)
 
+// the `fail` comments below denote what didn't compile before SI-8177 fixed all of them
+
 package p1 {
   object t0764 {
     type NodeAlias[A] = Node { type T = A }

test/files/neg/t0764b.check

@@ -1,3 +1,4 @@
+// exercise coevolveSym: SingleType with an underlying RefinedType
 trait Thing { type A }
 object IntThing extends Thing { type A = Int }
 

test/files/pos/t0764.scala

@@ -0,0 +1,9 @@
+// exercise coevolveSym
+trait Thing { type A; var p: A = _ }
+class AA[T](final val x: Thing { type A = T }) {
+  def foo: x.A = ???
+}
+
+class B extends AA[Int](null) {
+  override def foo: B.this.x.A = super.foo
+}

test/files/neg/t0764b.scala renamed to test/files/pos/t0764b.scala

@@ -0,0 +1,13 @@
+// exercise coevolveSym: SingleType with an underlying RefinedType, via a type alias
+trait Thing { type A }
+object IntThing extends Thing { type A = Int }
+object ThingHolder { type Alias[AIn] = Thing { type A = AIn } }
+
+// The following erroneously failed with  error: method f overrides nothing.
+// because asSeenFrom produced a typeref of the shape T'#A where A referred to a symbol defined in a T of times past
+// More precisely, the TypeRef case of TypeMap's mapOver correctly modified prefix
+// from having an underlying type of { type A = Ain } to { type A = Int }, with a new symbol for A (now with info Int),
+// but the symbol in the outer type ref wasn't co-evolved (so it still referred to the { type A = AIn } underlying the old prefix)
+// coEvolveSym used to only look at prefixes that were directly RefinedTypes, but they could also be SingleTypes with an underlying RefinedType
+class View[AIn](val in: ThingHolder.Alias[AIn]) {          def f(p: in.A): in.A = p }
+class SubView extends View[Int](IntThing)       { override def f(p: in.A): in.A = p }