Verify symbol is a param by querying the reftree

In the HoistSuperArgs phase we have established which tree should be
hoisted, and replace all references in the Tree with params that are
accessible in the hoisted tree.

When the Tree contains an anonymous class without parameters,
the paramSyms of that class refer to the created 'fresh' super symbol
(e.g. `B$superArg$1`), while the RefTree symbol belongs to the
superclass `B`.
This meant that the conditional was never satisfied, and the type was
never replaced by the primary constructor argument of the generated
superArg class.

In the current design `treeMap` is called before `typeMap` on a given
tree, thus the code in `treeMap` was never executed.

This is mitigated by rewriting the check, to only take params or
accessors into account in the scope of the hoisted tree.

Author: DieBauer

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

@@ -116,6 +116,13 @@ class HoistSuperArgs extends MiniPhase with IdentityDenotTransformer { thisPhase
         case _                    => false
       }
 
+      /** Only rewire types that are owned by the current Hoister and is an param or accessor */
+      def needsRewire(tp: Type) = tp match {
+        case ntp: NamedType =>
+          (ntp.symbol.owner == cls || ntp.symbol.owner == constr) && ntp.symbol.isParamOrAccessor
+        case _ => false
+      }
+
       // begin hoistSuperArg
       arg match {
         case Apply(fn, arg1 :: Nil) if fn.symbol == defn.cbnArg =>
@@ -128,9 +135,7 @@ class HoistSuperArgs extends MiniPhase with IdentityDenotTransformer { thisPhase
               typeMap = new TypeMap {
                 lazy val origToParam = origParams.zip(paramSyms).toMap
                 def apply(tp: Type) = tp match {
-                  case tp: NamedType
-                  if (tp.symbol.owner == cls || tp.symbol.owner == constr) &&
-                     tp.symbol.isParamOrAccessor =>
+                  case tp: NamedType if needsRewire(tp) =>
                     origToParam.get(tp.symbol) match {
                       case Some(mappedSym) => if (tp.symbol.isType) mappedSym.typeRef else mappedSym.termRef
                       case None => mapOver(tp)
@@ -140,7 +145,7 @@ class HoistSuperArgs extends MiniPhase with IdentityDenotTransformer { thisPhase
                 }
               },
               treeMap = {
-                case tree: RefTree if paramSyms.contains(tree.symbol) =>
+                case tree: RefTree if needsRewire(tree.tpe) =>
                   cpy.Ident(tree)(tree.name).withType(tree.tpe)
                 case tree =>
                   tree

tests/pos/i8748.scala

@@ -0,0 +1,9 @@
+class A(a: String) extends B(new C {
+  override def get(): String = a
+})
+
+class B(c: C)
+
+trait C {
+  def get(): String
+}

tests/pos/i8786.scala

@@ -0,0 +1,7 @@
+class B(y: Int) extends A(new C(y){})
+
+class A(c: C)
+
+abstract class C(y: Int) {
+  def x: Int = y
+}