1 files changed, 104 insertions, 0 deletions
diff --git a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
new file mode 100644
index 000000000..b5ace87d3
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
@@ -0,0 +1,104 @@
+package dotty.tools
+package dotc
+package typer
+
+import dotty.tools.dotc.ast.Trees._
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.untpd
+import dotty.tools.dotc.core.Constants.Constant
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Names.Name
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.core.Decorators._
+
+object Dynamic {
+  def isDynamicMethod(name: Name): Boolean =
+    name == nme.applyDynamic || name == nme.selectDynamic || name == nme.updateDynamic || name == nme.applyDynamicNamed
+}
+
+/** Translates selection that does not typecheck according to the scala.Dynamic rules:
+ *    foo.bar(baz) = quux                   ~~> foo.selectDynamic(bar).update(baz, quux)
+ *    foo.bar = baz                         ~~> foo.updateDynamic("bar")(baz)
+ *    foo.bar(x = bazX, y = bazY, baz, ...) ~~> foo.applyDynamicNamed("bar")(("x", bazX), ("y", bazY), ("", baz), ...)
+ *    foo.bar(baz0, baz1, ...)              ~~> foo.applyDynamic(bar)(baz0, baz1, ...)
+ *    foo.bar                               ~~> foo.selectDynamic(bar)
+ *
+ *  The first matching rule of is applied.
+ */
+trait Dynamic { self: Typer with Applications =>
+  import Dynamic._
+  import tpd._
+
+  /** Translate selection that does not typecheck according to the normal rules into a applyDynamic/applyDynamicNamed.
+   *    foo.bar(baz0, baz1, ...)                       ~~> foo.applyDynamic(bar)(baz0, baz1, ...)
+   *    foo.bar[T0, ...](baz0, baz1, ...)              ~~> foo.applyDynamic[T0, ...](bar)(baz0, baz1, ...)
+   *    foo.bar(x = bazX, y = bazY, baz, ...)          ~~> foo.applyDynamicNamed("bar")(("x", bazX), ("y", bazY), ("", baz), ...)
+   *    foo.bar[T0, ...](x = bazX, y = bazY, baz, ...) ~~> foo.applyDynamicNamed[T0, ...]("bar")(("x", bazX), ("y", bazY), ("", baz), ...)
+   */
+  def typedDynamicApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = {
+    def typedDynamicApply(qual: untpd.Tree, name: Name, targs: List[untpd.Tree]): Tree = {
+      def isNamedArg(arg: untpd.Tree): Boolean = arg match { case NamedArg(_, _) => true; case _ => false }
+      val args = tree.args
+      val dynName = if (args.exists(isNamedArg)) nme.applyDynamicNamed else nme.applyDynamic
+      if (dynName == nme.applyDynamicNamed && untpd.isWildcardStarArgList(args)) {
+        ctx.error("applyDynamicNamed does not support passing a vararg parameter", tree.pos)
+        tree.withType(ErrorType)
+      } else {
+        def namedArgTuple(name: String, arg: untpd.Tree) = untpd.Tuple(List(Literal(Constant(name)), arg))
+        def namedArgs = args.map {
+          case NamedArg(argName, arg) => namedArgTuple(argName.toString, arg)
+          case arg => namedArgTuple("", arg)
+        }
+        val args1 = if (dynName == nme.applyDynamic) args else namedArgs
+        typedApply(untpd.Apply(coreDynamic(qual, dynName, name, targs), args1), pt)
+      }
+    }
+
+     tree.fun match {
+      case Select(qual, name) if !isDynamicMethod(name) =>
+        typedDynamicApply(qual, name, Nil)
+      case TypeApply(Select(qual, name), targs) if !isDynamicMethod(name) =>
+        typedDynamicApply(qual, name, targs)
+      case TypeApply(fun, targs) =>
+        typedDynamicApply(fun, nme.apply, targs)
+      case fun =>
+        typedDynamicApply(fun, nme.apply, Nil)
+    }
+  }
+
+  /** Translate selection that does not typecheck according to the normal rules into a selectDynamic.
+   *    foo.bar          ~~> foo.selectDynamic(bar)
+   *    foo.bar[T0, ...] ~~> foo.selectDynamic[T0, ...](bar)
+   *
+   *  Note: inner part of translation foo.bar(baz) = quux ~~> foo.selectDynamic(bar).update(baz, quux) is achieved
+   *  through an existing transformation of in typedAssign [foo.bar(baz) = quux ~~> foo.bar.update(baz, quux)].
+   */
+  def typedDynamicSelect(tree: untpd.Select, targs: List[Tree], pt: Type)(implicit ctx: Context): Tree =
+    typedApply(coreDynamic(tree.qualifier, nme.selectDynamic, tree.name, targs), pt)
+
+  /** Translate selection that does not typecheck according to the normal rules into a updateDynamic.
+   *    foo.bar = baz ~~> foo.updateDynamic(bar)(baz)
+   */
+  def typedDynamicAssign(tree: untpd.Assign, pt: Type)(implicit ctx: Context): Tree = {
+    def typedDynamicAssign(qual: untpd.Tree, name: Name, targs: List[untpd.Tree]): Tree =
+      typedApply(untpd.Apply(coreDynamic(qual, nme.updateDynamic, name, targs), tree.rhs), pt)
+    tree.lhs match {
+      case Select(qual, name) if !isDynamicMethod(name) =>
+        typedDynamicAssign(qual, name, Nil)
+      case TypeApply(Select(qual, name), targs) if !isDynamicMethod(name) =>
+        typedDynamicAssign(qual, name, targs)
+      case _ =>
+        ctx.error("reassignment to val", tree.pos)
+        tree.withType(ErrorType)
+    }
+  }
+
+  private def coreDynamic(qual: untpd.Tree, dynName: Name, name: Name, targs: List[untpd.Tree])(implicit ctx: Context): untpd.Apply = {
+    val select = untpd.Select(qual, dynName)
+    val selectWithTypes =
+      if (targs.isEmpty) select
+      else untpd.TypeApply(select, targs)
+    untpd.Apply(selectWithTypes, Literal(Constant(name.toString)))
+  }
+}