Fixup for 80f977d

Author: nicolasstucki

src/dotty/tools/dotc/core/Mode.scala

@@ -84,8 +84,5 @@ object Mode {
   /** Use Scala2 scheme for overloading and implicit resolution */
   val OldOverloadingResolution = newMode(14, "OldOverloadingResolution")
 
-  /* Currently inside a potential scala.Dynamic rewrite. */
-  val IgnoreNextDynamic = newMode(15, "IgnoreNextDynamic")
-
   val PatternOrType = Pattern | Type
 }

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

@@ -542,22 +542,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 
     def realApply(implicit ctx: Context): Tree = track("realApply") {
       var proto = new FunProto(tree.args, IgnoredProto(pt), this)(argCtx(tree))
-
-      /* In the default case we type using Mode.IgnoreNextDynamic because fun1 might be a Select(foo, bar) where foo is of
-       * type scala.Dynamic and bar is not one of its members. In which case the following transformation will be tried:
-       *   foo.bar(baz0, baz1, ...) ~~> foo.applyDynamic(bar)(baz0, baz1, ...)
-       * Mode.IgnoreNextDynamic will ensure that Apply(Select(foo, bar), baz) is not transformed
-       * into foo.selectDynamic(bar).apply(args).
-       * We remove Mode.IgnoreNextDynamic if the name of the called method if is one of the scala.Dynamic methods or
-       * if this node was generated by an assign (see typedAssign).
-       * See: Dynamic.scala
-       */
-      def generatedByTypedAssign(name: Name) = name == nme.update &&  ctx.mode.is(Mode.IgnoreNextDynamic)
-      val ctx1 = tree.fun match {
-        case Select(_, name) if isDynamicMethod(name) || generatedByTypedAssign(name) => ctx.retractMode(Mode.IgnoreNextDynamic)
-        case _                                                                        => ctx.addMode(Mode.IgnoreNextDynamic)
-      }
-      val fun1 = typedExpr(tree.fun, proto)(ctx1)
+      val fun1 = typedExpr(tree.fun, proto)
 
       // Warning: The following line is dirty and fragile. We record that auto-tupling was demanded as
       // a side effect in adapt. If it was, we assume the tupled proto-type in the rest of the application.

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

@@ -430,6 +430,31 @@ object ProtoTypes {
       (if (theMap != null) theMap else new WildApproxMap).mapOver(tp)
   }
 
+  trait AssigningProto extends ProtoType
+
+  /** A prototype for expressions that appear in the lhs position of an assign
+   *
+   *  lhs = (rhs: resType)
+   */
+  case class AssignProto(lhs: untpd.Tree, rhsType: Type, typer: Typer)(implicit ctx: Context)
+      extends UncachedGroundType with AssigningProto {
+    override def resultType(implicit ctx: Context) = rhsType
+
+    def isMatchedBy(tp: Type)(implicit ctx: Context) = ???
+
+    def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context): T = ta(x, rhsType)
+
+    def map(tm: TypeMap)(implicit ctx: Context): ProtoType = derivedAssignProto(lhs, tm(rhsType), typer)
+
+    def derivedAssignProto(lhs: untpd.Tree, rhsType: Type, typer: Typer) =
+      if ((lhs eq this.lhs) && (rhsType eq this.resultType) && (typer eq this.typer)) this
+      else new AssignProto(lhs, rhsType, typer)
+
+    override def toString = s"AssignProto($lhs = (rhs: $resultType))"
+
+    override def deepenProto(implicit ctx: Context) = derivedAssignProto(lhs, resultType.deepenProto, typer)
+  }
+
   private[ProtoTypes] class WildApproxMap(implicit ctx: Context) extends TypeMap {
     def apply(tp: Type) = wildApprox(tp, this)
   }

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

@@ -315,12 +315,17 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = track("typedSelect") {
     def asSelect(implicit ctx: Context): Tree = {
-      val qual1 = typedExpr(tree.qualifier, selectionProto(tree.name, pt, this))(ctx.retractMode(Mode.IgnoreNextDynamic))
+      val qual1 = typedExpr(tree.qualifier, selectionProto(tree.name, pt, this))
       if (tree.name.isTypeName) checkStable(qual1.tpe, qual1.pos)
       val select = typedSelect(tree, pt, qual1)
-      if (select.tpe == TryDynamicCallType && !ctx.mode.is(Mode.IgnoreNextDynamic)) {
-        typedDynamicSelect(tree, pt)
-      } else select
+      if (select.tpe != TryDynamicCallType) {
+        select
+      } else {
+        pt match {
+          case _: FunProto | _: AssignProto => select
+          case _                            => typedDynamicSelect(tree, pt)
+        }
+      }
    }
 
     def asJavaSelectFromTypeTree(implicit ctx: Context): Tree = {
@@ -475,14 +480,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   def typedAssign(tree: untpd.Assign, pt: Type)(implicit ctx: Context) = track("typedAssign") {
     tree.lhs match {
       case lhs @ Apply(fn, args) =>
-        /* We type using Mode.IgnoreNextDynamic because fn might be a Select(foo, bar) where foo is of type
-         * scala.Dynamic and bar is not one of its members. In which case the following transformation will be tried:
-         *   foo.bar(baz) = quux ~~> foo.selectDynamic("bar").update(baz, quux)
-         * Mode.IgnoreNextDynamic will ensure that Apply(Select(fn, update), args) is not transformed
-         * into fn.applyDynamic(update)(args) and will only transform the contents of fn if needed.
-         * See: Dynamic.scala
-         */
-        typed(cpy.Apply(lhs)(untpd.Select(fn, nme.update), args :+ tree.rhs), pt)(ctx.addMode(Mode.IgnoreNextDynamic))
+        typed(cpy.Apply(lhs)(untpd.Select(fn, nme.update), args :+ 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 =
@@ -491,13 +489,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         val appliedUpdate = cpy.Apply(fn)(wrappedUpdate, (args map untpd.TypedSplice) :+ tree.rhs)
         typed(appliedUpdate, pt)
       case lhs =>
-        /* We type using Mode.IgnoreNextDynamic because this tree might be transformed with:
-         *   foo.bar = baz ~~> foo.updateDynamic("bar")(baz)
-         * Mode.IgnoreNextDynamic will ensure that Assign(Select(foo, bar), baz) will not be transformed
-         * into foo.selectDynamic(bar) = baz during the typing of the lhs.
-         * See: Dynamic.scala
-         */
-        val lhsCore = typedUnadapted(lhs)(ctx.addMode(Mode.IgnoreNextDynamic))
+        val proto = new AssignProto(tree.lhs, pt, this)(argCtx(tree))
+        val lhsCore = typedUnadapted(lhs, proto)
         def lhs1 = typed(untpd.TypedSplice(lhsCore))
         def canAssign(sym: Symbol) = // allow assignments from the primary constructor to class fields
           sym.is(Mutable, butNot = Accessor) ||