Merge pull request #1881 from dotty-staging/add-structural-select

Implement structural type member access

5 files changed, 95 insertions, 6 deletions

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index da83d0644..bcda4b92f 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -629,6 +629,28 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       case nil =>
         Nil
     }
+
+  /** Is this a selection of a member of a structural type that is not a member
+   *  of an underlying class or trait?
+   */
+  def isStructuralTermSelect(tree: Tree)(implicit ctx: Context) = tree match {
+    case tree: Select =>
+      def hasRefinement(qualtpe: Type): Boolean = qualtpe.dealias match {
+        case RefinedType(parent, rname, rinfo) =>
+          rname == tree.name || hasRefinement(parent)
+        case tp: TypeProxy =>
+          hasRefinement(tp.underlying)
+        case tp: OrType =>
+          hasRefinement(tp.tp1) || hasRefinement(tp.tp2)
+        case tp: AndType =>
+          hasRefinement(tp.tp1) && hasRefinement(tp.tp2)
+        case _ =>
+          false
+      }
+      !tree.symbol.exists && tree.isTerm && hasRefinement(tree.qualifier.tpe)
+    case _ =>
+      false
+  }
 }
 
 object TreeInfo {
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 0aeb28d36..716c9ef23 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -26,6 +26,9 @@ object Definitions {
    *  else without affecting the set of programs that can be compiled.
    */
   val MaxImplementedFunctionArity = 22
+
+  /** The maximal arity of a function that can be accessed as member of a structural type */
+  val MaxStructuralMethodArity = 7
 }
 
 /** A class defining symbols and types of standard definitions
@@ -515,6 +518,7 @@ class Definitions {
   lazy val LanguageModuleRef = ctx.requiredModule("scala.language")
   def LanguageModuleClass(implicit ctx: Context) = LanguageModuleRef.symbol.moduleClass.asClass
   lazy val NonLocalReturnControlType: TypeRef   = ctx.requiredClassRef("scala.runtime.NonLocalReturnControl")
+  lazy val SelectableType: TypeRef              = ctx.requiredClassRef("scala.Selectable")
 
   lazy val ClassTagType = ctx.requiredClassRef("scala.reflect.ClassTag")
   def ClassTagClass(implicit ctx: Context) = ClassTagType.symbol.asClass
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index 716959648..4a9c50dad 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -481,6 +481,7 @@ object StdNames {
     val sameElements: N         = "sameElements"
     val scala_ : N              = "scala"
     val selectDynamic: N        = "selectDynamic"
+    val selectDynamicMethod: N  = "selectDynamicMethod"
     val selectOverloadedMethod: N = "selectOverloadedMethod"
     val selectTerm: N           = "selectTerm"
     val selectType: N           = "selectType"
diff --git a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
index 4039c8b81..000cfd026 100644
--- a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
@@ -7,10 +7,13 @@ 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.Names.{Name, TermName}
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.core.Decorators._
+import core.Symbols._
+import core.Definitions
+import Inferencing._
 import ErrorReporting._
 
 object Dynamic {
@@ -18,7 +21,10 @@ object Dynamic {
     name == nme.applyDynamic || name == nme.selectDynamic || name == nme.updateDynamic || name == nme.applyDynamicNamed
 }
 
-/** Translates selection that does not typecheck according to the scala.Dynamic rules:
+/** Handles programmable member selections of `Dynamic` instances and values
+ *  with structural types. Two functionalities:
+ *
+ * 1. 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), ...)
@@ -26,6 +32,10 @@ object Dynamic {
  *    foo.bar                               ~~> foo.selectDynamic(bar)
  *
  *  The first matching rule of is applied.
+ *
+ * 2. Translates member selections on structural types to calls of `selectDynamic`
+ *    or `selectDynamicMethod` on a `Selectable` instance. @See handleStructural.
+ *
  */
 trait Dynamic { self: Typer with Applications =>
   import Dynamic._
@@ -100,4 +110,56 @@ trait Dynamic { self: Typer with Applications =>
       else untpd.TypeApply(select, targs)
     untpd.Apply(selectWithTypes, Literal(Constant(name.toString)))
   }
+
+  /** Handle reflection-based dispatch for members of structural types.
+   *  Given `x.a`, where `x` is of (widened) type `T` and `x.a` is of type `U`:
+   *
+   *  If `U` is a value type, map `x.a` to the equivalent of:
+   *
+   *     (x: Selectable).selectDynamic(x, "a").asInstanceOf[U]
+   *
+   *  If `U` is a method type (T1,...,Tn)R, map `x.a` to the equivalent of:
+   *
+   *     (x: Selectable).selectDynamicMethod("a", CT1, ..., CTn).asInstanceOf[(T1,...,Tn) => R]
+   *
+   *  where CT1,...,CTn are the class tags representing the erasure of T1,...,Tn.
+   *
+   *  It's an error if U is neither a value nor a method type, or a dependent method
+   *  type, or of too large arity (limit is Definitions.MaxStructuralMethodArity).
+   */
+  def handleStructural(tree: Tree)(implicit ctx: Context): Tree = {
+    val Select(qual, name) = tree
+
+    def structuralCall(selectorName: TermName, formals: List[Tree]) = {
+      val selectable = adapt(qual, defn.SelectableType)
+      val scall = untpd.Apply(
+        untpd.TypedSplice(selectable.select(selectorName)),
+        (Literal(Constant(name.toString)) :: formals).map(untpd.TypedSplice(_)))
+      typed(scall)
+    }
+
+    def fail(reason: String) =
+      errorTree(tree, em"Structural access not allowed on method $name because it $reason")
+
+    tree.tpe.widen match {
+      case tpe: MethodType =>
+        if (tpe.isDependent)
+          fail(i"has a dependent method type")
+        else if (tpe.paramNames.length > Definitions.MaxStructuralMethodArity)
+          fail(i"""takes too many parameters.
+                  |Structural types only support methods taking up to ${Definitions.MaxStructuralMethodArity} arguments""")
+        else {
+          def issueError(msgFn: String => String): Unit = ctx.error(msgFn(""), tree.pos)
+          val ctags = tpe.paramTypes.map(pt =>
+            inferImplicitArg(defn.ClassTagType.appliedTo(pt :: Nil), issueError, tree.pos.endPos))
+          structuralCall(nme.selectDynamicMethod, ctags).asInstance(tpe.toFunctionType())
+        }
+      case tpe: ValueType =>
+        structuralCall(nme.selectDynamic, Nil).asInstance(tpe)
+      case tpe: PolyType =>
+        fail("is polymorphic")
+      case tpe =>
+        fail(i"has an unsupported type: $tpe")
+    }
+  }
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index d05a0aaa7..59df98a93 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1040,9 +1040,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       typr.println(s"adding refinement $refinement")
       checkRefinementNonCyclic(refinement, refineCls, seen)
       val rsym = refinement.symbol
-      if (rsym.is(Method) && rsym.allOverriddenSymbols.isEmpty)
-        ctx.error(i"refinement $rsym without matching type in parent $tpt1", refinement.pos)
-    }
+      if (rsym.info.isInstanceOf[PolyType] && rsym.allOverriddenSymbols.isEmpty)
+        ctx.error(i"polymorphic refinement $rsym without matching type in parent $tpt1 is no longer allowed", refinement.pos)    }
     assignType(cpy.RefinedTypeTree(tree)(tpt1, refinements1), tpt1, refinements1, refineCls)
   }
 
@@ -2067,7 +2066,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
               adaptInterpolated(tree.appliedToTypeTrees(typeArgs), pt, original))
           }
         case wtp =>
-          pt match {
+          if (isStructuralTermSelect(tree)) adapt(handleStructural(tree), pt)
+          else pt match {
             case pt: FunProto =>
               adaptToArgs(wtp, pt)
             case pt: PolyProto =>