Fix #9965: Properly handle class type parameters when copying symbols

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -3,7 +3,7 @@ package dotc
 package ast
 
 import core._
-import Types._, Contexts._
+import Types._, Contexts._, Flags._
 import Symbols._, Annotations._, Trees._, Symbols._, Constants.Constant
 import Decorators._
 import dotty.tools.dotc.transform.SymUtils._
@@ -187,11 +187,18 @@ class TreeTypeMap(
    */
   def withMappedSyms(syms: List[Symbol], mapped: List[Symbol]): TreeTypeMap = {
     val symsChanged = syms ne mapped
-    val substMap = withSubstitution(syms, mapped)
+    val origTypeParams = syms.filter(_.isClass).flatMap(_.typeParams)
+    val mappedTypeParams = mapped.filter(_.isClass).flatMap(_.typeParams)
+    assert(origTypeParams.hasSameLengthAs(mappedTypeParams))
+    val substMap = withSubstitution(syms ++ origTypeParams, mapped ++ mappedTypeParams)
     val fullMap = mapped.filter(_.isClass).foldLeft(substMap) { (tmap, cls) =>
-      val origDcls = cls.info.decls.toList
+      val origDcls = cls.info.decls.toList.filterNot(_.is(TypeParam))
       val mappedDcls = mapSymbols(origDcls, tmap)
-      val tmap1 = tmap.withMappedSyms(origDcls, mappedDcls)
+       // type parameters were already copied in the `mapSymbols` call which produced `mapped`.
+      val tmap1 = tmap
+//        .withSubstitution(origTypeParams, cls.typeParams)
+          // type parameters were already mapped in the `mapSymbols` call which produced `mapped`.
+        .withMappedSyms(origDcls, mappedDcls)
       if (symsChanged)
         origDcls.lazyZip(mappedDcls).foreach(cls.asClass.replace)
       tmap1

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

@@ -811,22 +811,38 @@ object Symbols {
       val ttmap1 = ttmap.withSubstitution(originals, copies)
       originals.lazyZip(copies) 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)(using Context): Unit =
+
+            val oinfo = original.info match
+              case ClassInfo(pre, _, parents, decls, selfInfo) =>
+                assert(original.isClass)
+                val otypeParams = original.typeParams
+                if otypeParams.isEmpty then
+                  ClassInfo(pre, copy.asClass, parents, decls.cloneScope, selfInfo)
+                else
+                  // copy type params, enter other definitions unchanged
+                  // type parameters need to be copied early, since other type
+                  // computations depend on them.
+                  val decls1 = newScope
+                  val newTypeParams = mapSymbols(original.typeParams, ttmap1, mapAlways = true)
+                  newTypeParams.foreach(decls1.enter)
+                  for sym <- decls do if !sym.is(TypeParam) then decls1.enter(sym)
+                  val parents1 = parents.map(_.substSym(otypeParams, newTypeParams))
+                  val selfInfo1 = selfInfo match
+                    case selfInfo: Type => selfInfo.substSym(otypeParams, newTypeParams)
+                    case _ => selfInfo
+                  ClassInfo(pre, copy.asClass, parents1, decls1, selfInfo1)
+              case oinfo => oinfo
 
-        val completer = new LazyType {
-          def complete(denot: SymDenotation)(using 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)
-          }
-        }
+
+        end completer
 
         copy.denot = odenot.copySymDenotation(
           symbol = copy,

tests/pos/i9965.scala

@@ -0,0 +1,19 @@
+class D[T]
+
+class C {
+  def f() = {
+    locally {
+      class dd[U] extends D[U] {
+        val xx = 1
+      }
+      class ee[V] extends dd[(V, V)]
+      def d[V]: dd[V] = new dd[V]
+      g[D[Int]](d[Int])
+      g[D[(Int, Int)]](new ee[Int])
+    }
+  }
+
+  inline def locally[T](inline body: T): T = body
+
+  def g[T](x: T): T = x
+}