Address review

Author: OlivierBlanvillain

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

@@ -955,7 +955,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 
         val dummyArg = dummyTreeOfType(ownType)
         val unapplyApp = typedExpr(untpd.TypedSplice(Apply(unapplyFn, dummyArg :: Nil)))
-        def unapplyImplicits(unapp: Tree = unapplyApp): List[Tree] = unapp match {
+        def unapplyImplicits(unapp: Tree): List[Tree] = unapp match {
           case Apply(Apply(unapply, `dummyArg` :: Nil), args2) => assert(args2.nonEmpty); args2
           case Apply(unapply, `dummyArg` :: Nil) => Nil
           case Inlined(u, _, _) => unapplyImplicits(u)
@@ -982,7 +982,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
             List.fill(argTypes.length - args.length)(WildcardType)
         }
         val unapplyPatterns = (bunchedArgs, argTypes).zipped map (typed(_, _))
-        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits(), unapplyPatterns), ownType)
+        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits(unapplyApp), unapplyPatterns), ownType)
         unapp.println(s"unapply patterns = $unapplyPatterns")
         if ((ownType eq selType) || ownType.isError) result
         else tryWithClassTag(Typed(result, TypeTree(ownType)), selType)

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

@@ -54,13 +54,13 @@ class ReTyper extends Typer {
 
   override def typedTyped(tree: untpd.Typed, pt: Type)(implicit ctx: Context): Tree = {
     assertTyped(tree)
-    val type1 = checkSimpleKinded(typedType(tree.tpt))
-    val tree1 = tree.expr match {
+    val tpt1 = checkSimpleKinded(typedType(tree.tpt))
+    val expr1 = tree.expr match {
       case id: untpd.Ident if (ctx.mode is Mode.Pattern) && untpd.isVarPattern(id) && (id.name == nme.WILDCARD || id.name == nme.WILDCARD_STAR) =>
-        tree.expr.withType(type1.tpe)
+        tree.expr.withType(tpt1.tpe)
       case _ => typed(tree.expr)
     }
-   untpd.cpy.Typed(tree)(tree1, type1).withType(tree.typeOpt)
+   untpd.cpy.Typed(tree)(expr1, tpt1).withType(tree.typeOpt)
   }
 
   override def typedTypeTree(tree: untpd.TypeTree, pt: Type)(implicit ctx: Context): TypeTree =