WIP: Add scala.Dynamic support.

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")
 
+  /* We are currently inside a potential scala.Dynamic rewrite */
+  val IgnoreNextDynamic = newMode(15, "IgnoreSelectDynamic")
+
   val PatternOrType = Pattern | Type
 }

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

@@ -3016,6 +3016,10 @@ object Types {
 
   object ErrorType extends ErrorType
 
+  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

@@ -541,7 +541,14 @@ 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)
+
+      val ctx1 = tree.fun match {
+        case Select(_, name) if isDynamicMethod(name) ||
+            (name == nme.update &&  ctx.mode.is(Mode.IgnoreNextDynamic)) =>
+          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 +560,18 @@ trait Applications extends Compatibility { self: Typer =>
 
       fun1.tpe match {
         case ErrorType => tree.withType(ErrorType)
+        case TryDynamicCallType =>
+          tree match {
+            case Apply(Select(qual, name), args) if !isDynamicMethod(name) =>
+              if (untpd.isWildcardStarArgList(args)) {
+                ctx.error(name.toString + " does not support passing a vararg parameter", tree.pos)
+                tree.withType(ErrorType)
+              } else {
+                typedDynamicApply(qual, name, args, pt)
+              }
+            case _ =>
+              handleUnexpectedFunType(tree, fun1)
+          }
         case _ => methPart(fun1).tpe match {
           case funRef: TermRef =>
             tryEither { implicit ctx =>

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

@@ -194,13 +194,20 @@ trait TypeAssigner {
   /** The type of a selection with `name` of a tree with type `site`.
    */
   def selectionType(site: Type, name: Name, pos: Position)(implicit ctx: Context): Type = {
+    def isNotDynamicMethodName =
+      name != nme.applyDynamic && name != nme.applyDynamicNamed && name != nme.selectDynamic && name != nme.updateDynamic
     val mbr = site.member(name)
     if (reallyExists(mbr)) site.select(name, mbr)
-    else {
+    else if (site <:< defn.DynamicType && isNotDynamicMethodName) {
+      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

@@ -289,10 +289,15 @@ 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 = {
+    if (qual.tpe == TryDynamicCallType) {
+      tree.withType(TryDynamicCallType)
+    } else {
+      val select = assignType(cpy.Select(tree)(qual, tree.name), qual)
+      if (select.tpe == TryDynamicCallType) tree.withType(TryDynamicCallType)
+      else 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,15 @@ 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)
+      if (qual1.tpe == TryDynamicCallType) {
+        tree.withType(TryDynamicCallType)
+      } else {
+        if (tree.name.isTypeName) checkStable(qual1.tpe, qual1.pos)
+        val select = typedSelect(tree, pt, qual1)
+        if (select.tpe == TryDynamicCallType && !isDynamicMethod(tree.name) && !ctx.mode.is(Mode.IgnoreNextDynamic)) {
+          typedDynamicSelect(cpy.Select(tree)(qual1, tree.name), pt)
+        } else select
+      }
    }
 
     def asJavaSelectFromTypeTree(implicit ctx: Context): Tree = {
@@ -467,7 +479,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) =>
-        typed(cpy.Apply(lhs)(untpd.Select(fn, nme.update), args :+ tree.rhs), pt)
+        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 +488,7 @@ 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)
+        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 +516,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 +1679,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 {
@@ -1699,4 +1717,38 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       }
     }
   }
+
+  /** Translate selection that does not typecheck according to the normal rules into a applyDynamic/applyDynamicNamed.
+   *  foo.method("blah")     ~~> foo.applyDynamic("method")("blah")
+   *  foo.method(x = "blah") ~~> foo.applyDynamicNamed("method")(("x", "blah"))
+   */
+  def typedDynamicApply(qual: untpd.Tree, name: Name, args: List[untpd.Tree], pt: Type)(implicit ctx: Context): Tree = {
+    def isNamedArg(arg: untpd.Tree): Boolean = arg match { case NamedArg(_, _) => true ; case _ => false }
+    def namedArgTupple(name: String, arg: untpd.Tree) = untpd.Tuple(List(Literal(Constant(name)), arg))
+    def namedArgs = args.map {
+      case NamedArg(argName, arg) => namedArgTupple(argName.toString, arg)
+      case arg                    => namedArgTupple("", arg)
+    }
+    val dynName = if (args.exists(isNamedArg)) nme.applyDynamicNamed else nme.applyDynamic
+    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.field ~~> foo.selectDynamic("field")
+   */
+  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.varia = 10 ~~> foo.updateDynamic("varia")(10)
+   */
+  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)
+
+  def isDynamicMethod(name: Name): Boolean =
+    name == nme.applyDynamic || name == nme.selectDynamic || name == nme.updateDynamic || name == nme.applyDynamicNamed
+
+  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)))
 }

tests/neg/dynamicApplyDynamicStarTest1.scala

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

tests/neg/dynamicApplyDynamicStarTest2.scala

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

tests/neg/dynamicApplyDynamicStarTest3.scala

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

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")
+}

tests/neg/dynamicApplyNamedDynamicTest5.scala

@@ -0,0 +1,9 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic {
+  def applyDynamicNamed(name: String)(args: String*): String = ???
+}
+
+object DynamicTest {
+  new Foo().bazApply("abc", 4, b = 1, b = "bcd")
+}

tests/neg/dynamicApplyNamedDynamicTest6.scala

@@ -0,0 +1,9 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic {
+  def applyDynamicNamed(name: Int)(args: Any*): String = ???
+}
+
+object DynamicTest {
+  new Foo().bazApply("abc", 4, b = 1, b = "bcd")
+}

tests/neg/dynamicApplyNamedDynamicTest7.scala

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

tests/neg/dynamicApplyNamedDynamicTest8.scala

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

tests/neg/dynamicDynamicImplicitsTest1.scala

@@ -0,0 +1,13 @@
+import scala.language.dynamics
+
+class Foo extends scala.Dynamic {
+  def selectDynamic(name: String): String = ???
+}
+
+object DynamicTest {
+  implicit class Bar(foo: Foo) {
+    def bazSelect: Int = ???
+  }
+
+  def baz: String = new Foo().bazSelect
+}