[WIP] FIx #657: Add scala.Dynamic support.

* Supports the whole spec from scalac scala.Dynamic.
* Lifted restriction on _* arguments for applyDynamic.

Author: nicolasstucki

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

@@ -84,5 +84,8 @@ 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/core/Types.scala

@@ -3016,6 +3016,11 @@ object Types {
 
   object ErrorType extends ErrorType
 
+  /* Type used to track Select nodes that could not resolve a member and their qualifier is a scala.Dynamic. */
+  abstract class TryDynamicCallType extends UncachedGroundType with ValueType
+
+  object TryDynamicCallType extends TryDynamicCallType
+
   /** Wildcard type, possibly with bounds */
   abstract case class WildcardType(optBounds: Type) extends CachedGroundType with TermType {
     def derivedWildcardType(optBounds: Type)(implicit ctx: Context) =

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

@@ -86,11 +86,12 @@ object Applications {
 
 import Applications._
 
-trait Applications extends Compatibility { self: Typer =>
+trait Applications extends Compatibility { self: Typer with Dynamic =>
 
   import Applications._
   import tpd.{ cpy => _, _ }
   import untpd.cpy
+  import Dynamic.isDynamicMethod
 
   /** @tparam Arg       the type of arguments, could be tpd.Tree, untpd.Tree, or Type
    *  @param methRef    the reference to the method of the application
@@ -541,7 +542,25 @@ trait Applications extends Compatibility { self: Typer =>
 
     def realApply(implicit ctx: Context): Tree = track("realApply") {
       var proto = new FunProto(tree.args, IgnoredProto(pt), this)(argCtx(tree))
-      val fun1 = typedExpr(tree.fun, proto)
+
+      /* 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)
 
       // 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.
@@ -553,6 +572,13 @@ trait Applications extends Compatibility { self: Typer =>
 
       fun1.tpe match {
         case ErrorType => tree.withType(ErrorType)
+        case TryDynamicCallType =>
+          tree match {
+            case tree @ Apply(Select(qual, name), args) if !isDynamicMethod(name) =>
+              typedDynamicApply(qual, name, args, pt)(tree)
+            case _ =>
+              handleUnexpectedFunType(tree, fun1)
+          }
         case _ => methPart(fun1).tpe match {
           case funRef: TermRef =>
             tryEither { implicit ctx =>

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

@@ -0,0 +1,79 @@
+package dotty.tools
+package dotc
+package typer
+
+import dotty.tools.dotc.ast.Trees.NamedArg
+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.Mode
+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(baz0, baz1, ...)              ~~> foo.applyDynamic(bar)(baz0, baz1, ...)
+ *    foo.bar(x = bazX, y = bazY, baz, ...) ~~> foo.applyDynamicNamed("bar")(("x", bazX), ("y", bazY), ("", baz), ...)
+ *    foo.bar = baz                         ~~> foo.updateDynamic("bar")(baz)
+ *    foo.bar                               ~~> foo.selectDynamic(bar)
+ *    foo.bar(baz) = quux                   ~~> foo.selectDynamic(bar).update(baz, quux)
+ */
+trait Dynamic { self: Applications =>
+  import Dynamic._
+
+  def checkedDynamic(qual: Tree, originalTree: untpd.Select)(implicit ctx: Context): Option[Select] =
+    if (qual.tpe != TryDynamicCallType) None
+    else Some(originalTree.withType(TryDynamicCallType))
+
+  /* Returns the `select` unless it should be transformed into a `selectDynamic` */
+  def typedSelectOrElseDynamicSelect(select: => Tree)(tree: untpd.Select, pt: Type, qual: Tree)(
+      implicit ctx: Context): Tree = {
+    if (select.tpe == TryDynamicCallType && !isDynamicMethod(tree.name) && !ctx.mode.is(Mode.IgnoreNextDynamic)) {
+      typedDynamicSelect(untpd.cpy.Select(tree)(qual, tree.name), pt)
+    } else select
+  }
+
+  /** 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(x = bazX, y = bazY, baz, ...) ~~> foo.applyDynamicNamed("bar")(("x", bazX), ("y", bazY), ("", baz), ...)
+   */
+  def typedDynamicApply(qual: untpd.Tree, name: Name, args: List[untpd.Tree], pt: Type)(original: untpd.Apply)(
+      implicit ctx: Context): Tree = {
+    def isNamedArg(arg: untpd.Tree): Boolean = arg match { case NamedArg(_, _) => true; case _ => false }
+    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", original.pos)
+      original.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), args1), pt)
+    }
+  }
+
+  /** Translate selection that does not typecheck according to the normal rules into a selectDynamic.
+   *  foo.bar ~~> foo.selectDynamic(bar)
+   */
+  def typedDynamicSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree =
+    typedApply(coreDynamic(tree.qualifier, nme.selectDynamic, tree.name), pt)
+
+  /** Translate selection that does not typecheck according to the normal rules into a updateDynamic.
+   *  foo.bar = baz ~~> foo.updateDynamic(bar)(baz)
+   */
+  def typedDynamicAssign(qual: untpd.Tree, name: Name, rhs: untpd.Tree, pt: Type)(implicit ctx: Context): Tree =
+    typedApply(untpd.Apply(coreDynamic(qual, nme.updateDynamic, name), rhs), pt)
+
+  private def coreDynamic(qual: untpd.Tree, dynName: Name, name: Name)(implicit ctx: Context): untpd.Apply =
+    untpd.Apply(untpd.Select(qual, dynName), Literal(Constant(name.toString)))
+}

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

@@ -196,11 +196,16 @@ trait TypeAssigner {
   def selectionType(site: Type, name: Name, pos: Position)(implicit ctx: Context): Type = {
     val mbr = site.member(name)
     if (reallyExists(mbr)) site.select(name, mbr)
-    else {
+    else if (site <:< defn.DynamicType && !Dynamic.isDynamicMethod(name)) {
+      TryDynamicCallType
+    } else {
       if (!site.isErroneous) {
         ctx.error(
           if (name == nme.CONSTRUCTOR) d"$site does not have a constructor"
-          else d"$name is not a member of $site", pos)
+          else if (site <:< defn.DynamicType) {
+            d"$name is not a member of $site\n" +
+            "possible cause: maybe a wrong Dynamic method signature?"
+          } else d"$name is not a member of $site", pos)
       }
       ErrorType
     }

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

@@ -58,11 +58,12 @@ object Typer {
       assert(tree.pos.exists, s"position not set for $tree # ${tree.uniqueId}")
 }
 
-class Typer extends Namer with TypeAssigner with Applications with Implicits with Checking {
+class Typer extends Namer with TypeAssigner with Applications with Implicits with Dynamic with Checking {
 
   import Typer._
   import tpd.{cpy => _, _}
   import untpd.cpy
+  import Dynamic.isDynamicMethod
 
   /** A temporary data item valid for a single typed ident:
    *  The set of all root import symbols that have been
@@ -289,10 +290,14 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     checkValue(tree1, pt)
   }
 
-  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),
-      pt)
+  private def typedSelect(tree: untpd.Select, pt: Type, qual: Tree)(implicit ctx: Context): Select = {
+    checkedDynamic(qual, tree).getOrElse {
+      val select = assignType(cpy.Select(tree)(qual, tree.name), qual)
+      checkedDynamic(select, tree).getOrElse {
+        healNonvariant(checkValue(select, pt), pt)
+      }
+    }
+  }
 
   /** Let `tree = p.n` where `p: T`. If tree's type is an unsafe instantiation
    *  (see TypeOps#asSeenFrom for how this can happen), rewrite the prefix `p`
@@ -315,8 +320,10 @@ 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))
-      if (tree.name.isTypeName) checkStable(qual1.tpe, qual1.pos)
-      typedSelect(tree, pt, qual1)
+      checkedDynamic(qual1, tree).getOrElse {
+        if (tree.name.isTypeName) checkStable(qual1.tpe, qual1.pos)
+        typedSelectOrElseDynamicSelect(typedSelect(tree, pt, qual1))(tree, pt, qual1)
+      }
    }
 
     def asJavaSelectFromTypeTree(implicit ctx: Context): Tree = {
@@ -467,7 +474,14 @@ 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) =>
-        typed(cpy.Apply(lhs)(untpd.Select(fn, nme.update), args :+ tree.rhs), pt)
+        /* 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))
       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 =
@@ -476,7 +490,13 @@ 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 =>
-        val lhsCore = typedUnadapted(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))
         def lhs1 = typed(untpd.TypedSplice(lhsCore))
         def canAssign(sym: Symbol) = // allow assignments from the primary constructor to class fields
           sym.is(Mutable, butNot = Accessor) ||
@@ -504,6 +524,12 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
                   case _ =>
                     reassignmentToVal
                 }
+              case TryDynamicCallType =>
+                tree match {
+                  case Assign(Select(qual, name), rhs) if !isDynamicMethod(name) =>
+                    typedDynamicAssign(qual, name, rhs, pt)
+                  case _ => reassignmentToVal
+                }
               case tpe =>
                 reassignmentToVal
             }
@@ -1661,7 +1687,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     tree match {
       case _: MemberDef | _: PackageDef | _: Import | _: WithoutTypeOrPos[_] => tree
       case _ => tree.tpe.widen match {
-        case ErrorType =>
+        case ErrorType | TryDynamicCallType =>
           tree
         case ref: TermRef =>
           pt match {

tests/neg/dynamicApplyDynamicTest1.scala

@@ -0,0 +1,7 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic
+
+object DynamicTest {
+  new Foo().bazApply()
+}

tests/neg/dynamicApplyDynamicTest2.scala

@@ -0,0 +1,7 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic
+
+object DynamicTest {
+  new Foo().bazApply("abc", 1)
+}

tests/neg/dynamicApplyDynamicTest3.scala

@@ -0,0 +1,7 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic
+
+object DynamicTest {
+  new Foo().bazApply _
+}

tests/neg/dynamicApplyDynamicTest4.scala

@@ -0,0 +1,10 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic {
+  def selectDynamic(name: String): String = ???
+  def applyDynamicNamed(name: String)(args: Any*): String = ???
+}
+
+object DynamicTest {
+  new Foo().bazApply()
+}

tests/neg/dynamicApplyDynamicTest5.scala

@@ -0,0 +1,9 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic {
+  def applyDynamic(name: String)(args: String*): String = ???
+}
+
+object DynamicTest {
+  new Foo().bazApply(1, 2, 3)
+}

tests/neg/dynamicApplyDynamicTest6.scala

@@ -0,0 +1,9 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic {
+  def applyDynamic(name: String)(args: String*): String = ???
+}
+
+object DynamicTest {
+  def test: Int = new Foo().bazApply()
+}

tests/neg/dynamicApplyDynamicTest7.scala

@@ -0,0 +1,9 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic {
+  def applyDynamic(name: Int)(args: String*): String = ???
+}
+
+object DynamicTest {
+  def test: String = new Foo().bazApply()
+}

tests/neg/dynamicApplyDynamicTest8.scala

@@ -0,0 +1,10 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic {
+  def applyDynamic(name: String)(args: Any*): String = ???
+  def applyDynamicNamed(name: String)(args: (Sting, Int)*): String = ???
+}
+
+object DynamicTest {
+  def test: String = new Foo().bazApply("1" -> 2)
+}

tests/neg/dynamicApplyDynamicTest9.scala

@@ -0,0 +1,9 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic {
+  def applyDynamicNamed(name: String)(args: (Sting, Int)*): String = ???
+}
+
+object DynamicTest {
+  new Foo().applyDynamic("bar")("1" -> 2)
+}

tests/neg/dynamicApplyNamedDynamicTest1.scala

@@ -0,0 +1,7 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic
+
+object DynamicTest {
+  new Foo().bazApply(a = "abc", b = 1)
+}

tests/neg/dynamicApplyNamedDynamicTest2.scala

@@ -0,0 +1,10 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic {
+  def selectDynamic(name: String): Array[String] = ???
+  def applyDynamic(name: String)(args: Any*): String = ???
+}
+
+object DynamicTest {
+  new Foo().bazApply(a = "abc", b = 1)
+}

tests/neg/dynamicApplyNamedDynamicTest3.scala

@@ -0,0 +1,7 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic
+
+object DynamicTest {
+  new Foo().bazApply("abc", b = 1)
+}

tests/neg/dynamicApplyNamedDynamicTest4.scala

@@ -0,0 +1,7 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic
+
+object DynamicTest {
+  new Foo().bazApply("abc", 4, b = 1, b = "bcd")
+}