Bring back recompilation of types after typer.

Previous cpy was almost unconditionally re-creating trees for Apply,
TypeApply and Select, which forced huge portions of other trees to be
recomputed. In particular, if forced to recompute types of selections
with a complex prefix. Those selections would change _signature_ when
recomputed.

Unfortunately, some types that typer are initialised by "lastSymbol"
set by hand. Those type don't correctly recompute their signatures.
They survive with wrong signature and are pickled with wrong signature.

I think this is a bug, but I'm re-creating the way this bug was hidden
before by making FirstTransform copy the entire tree using previous
logic.

Author: DarkDimius

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

@@ -481,8 +481,19 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       val tree1 = untpd.cpy.Select(tree)(qualifier, name)
       lazy val oldMember = tree.asInstanceOf[Select].qualifier.tpe.member(name)
       tree match {
-        case tree: Select if (qualifier.tpe eq tree.qualifier.tpe) && (oldMember.isOverloaded || oldMember.signature == qualifier.tpe.member(name).signature) =>
-          tree1.withTypeUnchecked(tree.tpe)
+        case tree: Select if (qualifier.tpe eq tree.qualifier.tpe) =>
+          tree.tpe match {
+            case tpe: NamedType =>
+              val tp = tpe.derivedSelect(qualifier.tpe.widenIfUnstable)
+              if (tp == tree.tpe)
+              // Unfortunately if qualifiers are the same, the widened type may be different from the one that
+              // was used to construct the tree. And even time travel won't help here.
+              // By the time we call typedSelect not all type-variables may be instantiated
+              // and the selection may succeed with a weaker signature than the one we'll get here.
+                tree.withTypeUnchecked(tree.tpe)
+              else tree1.withType(tpe.derivedSelect(qualifier.tpe.widenIfUnstable))
+            case _ => tree1.withTypeUnchecked(tree.tpe)
+          }
         case _ => tree.tpe match {
           case tpe: NamedType => tree1.withType(tpe.derivedSelect(qualifier.tpe.widenIfUnstable))
           case _ => tree1.withTypeUnchecked(tree.tpe)
@@ -492,15 +503,15 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
       val untyped = untpd.cpy.Apply(tree)(fun, args)
-      if (untyped eq tree)
+      if (false && (untyped eq tree))
         tree.asInstanceOf[Apply]
       else
         ta.assignType(untyped, fun, args)
     }
 
     override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
       val untyped = untpd.cpy.TypeApply(tree)(fun, args)
-      if (untyped eq tree)
+      if (false && (untyped eq tree))
         tree.asInstanceOf[TypeApply]
       else
         ta.assignType(untyped, fun, args)
@@ -613,6 +624,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     // does not work here: The computed type depends on the widened function type, not
     // the function type itself. A treetransform may keep the function type the
     // same but its widened type might change.
+    // It's not only tree transform unfortunatelly. Typer may also create types of Apply nodes that are less precise
+    // than the one that we'would expect because he didn't yet instantiate all type-variables
+    // see https://github.com/lampepfl/dotty/pull/2446 for a testcase
     override def Apply(tree: tpd.Tree)(fun: tpd.Tree, args: List[tpd.Tree])(implicit ctx: Context): tpd.Apply = {
       ta.assignType(untpd.cpy.Apply(tree)(fun, args), fun, args)
     }

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

@@ -9,6 +9,7 @@ import Contexts._
 import Symbols._
 import Flags.PackageVal
 import Decorators._
+import dotty.tools.dotc.ast.tpd
 
 /** A base class for transforms.
  *  A transform contains a compiler phase which applies a tree transformer.
@@ -30,7 +31,7 @@ abstract class MacroTransform extends Phase {
    */
   protected def transformPhase(implicit ctx: Context): Phase = this
 
-  class Transformer extends TreeMap {
+  class Transformer(cpy: TreeCopier = tpd.cpy) extends TreeMap(cpy) {
 
     protected def localCtx(tree: Tree)(implicit ctx: Context) = {
       val sym = tree.symbol

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

@@ -87,7 +87,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
     case _ => tree
   }
 
-  class PostTyperTransformer extends Transformer {
+  class PostTyperTransformer extends Transformer(tpd.cpy_slow) {
 
     private var inJavaAnnot: Boolean = false
 
@@ -119,7 +119,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
       val qual = tree.qualifier
       qual.symbol.moduleClass.denot match {
         case pkg: PackageClassDenotation if !tree.symbol.maybeOwner.is(Package) =>
-          transformSelect(cpy.Select(tree)(qual select pkg.packageObj.symbol, tree.name), targs)
+          transformSelect(cpy_slow.Select(tree)(qual select pkg.packageObj.symbol, tree.name), targs)
         case _ =>
           val tree1 = super.transform(tree)
           constToLiteral(tree1) match {
@@ -189,7 +189,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
             case sel: Select =>
               val args1 = transform(args)
               val sel1 = transformSelect(sel, args1)
-              if (superAcc.isProtectedAccessor(sel1)) sel1 else cpy.TypeApply(tree1)(sel1, args1)
+              if (superAcc.isProtectedAccessor(sel1)) sel1 else cpy_slow.TypeApply(tree1)(sel1, args1)
             case _ =>
               super.transform(tree1)
           }
@@ -207,7 +207,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
           //  2. To enable correct pickling (calls can share symbols with the inlined code, which
           //     would trigger an assertion when pickling).
           val callTrace = Ident(call.symbol.topLevelClass.typeRef).withPos(call.pos)
-          cpy.Inlined(tree)(callTrace, transformSub(bindings), transform(expansion))
+          cpy_slow.Inlined(tree)(callTrace, transformSub(bindings), transform(expansion))
         case tree: Template =>
           val saved = parentNews
           parentNews ++= tree.parents.flatMap(newPart)
@@ -248,7 +248,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
           Checking.checkInstantiable(tree.tpe, tree.pos)
           super.transform(tree)
         case tree @ Annotated(annotated, annot) =>
-          cpy.Annotated(tree)(transform(annotated), transformAnnot(annot))
+          cpy_slow.Annotated(tree)(transform(annotated), transformAnnot(annot))
         case tree: AppliedTypeTree =>
           Checking.checkAppliedType(tree)
           super.transform(tree)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -357,7 +357,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   private def typedSelect(tree: untpd.Select, pt: Type, qual: Tree)(implicit ctx: Context): Select =
     healNonvariant(
-      checkValue(assignType(cpy.Select(tree)(qual, tree.name), qual), pt),
+      checkValue(assignType(cpy.Select(tree)(qual, tree.name), qual), pt), // see note in TypedTreeCopier.select
       pt)
 
   /** Let `tree = p.n` where `p: T`. If tree's type is an unsafe instantiation