Fixes handling of op-assignments for polymorphic apply/update.

See t3252 for a test case.

Author: odersky

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

@@ -759,6 +759,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Ident(defn.ScalaRuntimeModule.requiredMethod(name).termRef).appliedToArgs(args)
   }
 
+  /** An extractor that pulls out type arguments */
+  object MaybePoly {
+    def unapply(tree: Tree): Option[(Tree, List[Tree])] = tree match {
+      case TypeApply(tree, targs) => Some(tree, targs)
+      case _ => Some(tree, Nil)
+    }
+  }
+
   /** A traverser that passes the enlcosing class or method as an argumenr
    *  to the traverse method.
    */

src/dotty/tools/dotc/typer/EtaExpansion.scala

@@ -34,8 +34,11 @@ object EtaExpansion {
    *     lhs += expr
    */
   def liftAssigned(defs: mutable.ListBuffer[Tree], tree: Tree)(implicit ctx: Context): Tree = tree match {
-    case Apply(fn @ Select(pre, name), args) =>
-      cpy.Apply(tree)(cpy.Select(fn)(lift(defs, pre), name), liftArgs(defs, fn.tpe, args))
+    case Apply(MaybePoly(fn @ Select(pre, name), targs), args) =>
+      cpy.Apply(tree)(
+        cpy.Select(fn)(
+          lift(defs, pre), name).appliedToTypeTrees(targs), 
+          liftArgs(defs, fn.tpe, args))
     case Select(pre, name) =>
       cpy.Select(tree)(lift(defs, pre), name)
     case _ =>

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

@@ -400,10 +400,13 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     tree.lhs match {
       case lhs @ Apply(fn, args) =>
         typed(cpy.Apply(lhs)(untpd.Select(fn, nme.update), args :+ tree.rhs), pt)
-      case untpd.TypedSplice(Apply(Select(fn, app), args)) if app == nme.apply =>
-        typed(cpy.Apply(fn)(
-            untpd.Select(untpd.TypedSplice(fn), nme.update),
-            (args map untpd.TypedSplice) :+ tree.rhs), pt)
+      case untpd.TypedSplice(Apply(MaybePoly(Select(fn, app), targs), args)) if app == nme.apply =>
+        val rawUpdate: untpd.Tree = untpd.Select(untpd.TypedSplice(fn), nme.update)
+        val wrappedUpdate = 
+          if (targs.isEmpty) rawUpdate 
+          else untpd.TypeApply(rawUpdate, targs map untpd.TypedSplice)
+        val appliedUpdate = cpy.Apply(fn)(wrappedUpdate, (args map untpd.TypedSplice) :+ tree.rhs)
+        typed(appliedUpdate, pt)
       case lhs =>
         val lhsCore = typedUnadapted(lhs)
         def lhs1 = typed(untpd.TypedSplice(lhsCore))