Change position of dynamic selections

When checking whether non-member value refinements could cause unsoundness problems,
I noted that the end position of a dynamic select got lost; the dynamic selection would
have the same position as its qualifier. I.e. if `z.x` is a dynamic selection, the indicated
position would be just `z`. Fixed now. The correct position can be seen when inspecting
the error message of i4098.scala. Ideally, this would be a scripting test. I let someone else
add one.

Author: odersky

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

@@ -11,6 +11,7 @@ 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 util.Positions._
 import core.Symbols._
 import core.Definitions
 import Inferencing._
@@ -49,7 +50,7 @@ trait Dynamic { self: Typer with Applications =>
    *    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 typedDynamicApply(qual: untpd.Tree, name: Name, selPos: Position, 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
@@ -62,19 +63,19 @@ trait Dynamic { self: Typer with Applications =>
           case arg => namedArgTuple("", arg)
         }
         val args1 = if (dynName == nme.applyDynamic) args else namedArgs
-        typedApply(untpd.Apply(coreDynamic(qual, dynName, name, targs), args1), pt)
+        typedApply(untpd.Apply(coreDynamic(qual, dynName, name, selPos, 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 sel @ Select(qual, name) if !isDynamicMethod(name) =>
+        typedDynamicApply(qual, name, sel.pos, Nil)
+      case TypeApply(sel @ Select(qual, name), targs) if !isDynamicMethod(name) =>
+        typedDynamicApply(qual, name, sel.pos, targs)
       case TypeApply(fun, targs) =>
-        typedDynamicApply(fun, nme.apply, targs)
+        typedDynamicApply(fun, nme.apply, fun.pos, targs)
       case fun =>
-        typedDynamicApply(fun, nme.apply, Nil)
+        typedDynamicApply(fun, nme.apply, fun.pos, Nil)
     }
   }
 
@@ -86,26 +87,26 @@ trait Dynamic { self: Typer with Applications =>
    *  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)
+    typedApply(coreDynamic(tree.qualifier, nme.selectDynamic, tree.name, tree.pos, 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)
+    def typedDynamicAssign(qual: untpd.Tree, name: Name, selPos: Position, targs: List[untpd.Tree]): Tree =
+      typedApply(untpd.Apply(coreDynamic(qual, nme.updateDynamic, name, selPos, 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 sel @ Select(qual, name) if !isDynamicMethod(name) =>
+        typedDynamicAssign(qual, name, sel.pos, Nil)
+      case TypeApply(sel @ Select(qual, name), targs) if !isDynamicMethod(name) =>
+        typedDynamicAssign(qual, name, sel.pos, targs)
       case _ =>
         errorTree(tree, ReassignmentToVal(tree.lhs.symbol.name))
     }
   }
 
-  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)
+  private def coreDynamic(qual: untpd.Tree, dynName: Name, name: Name, selPos: Position, targs: List[untpd.Tree])(implicit ctx: Context): untpd.Apply = {
+    val select = untpd.Select(qual, dynName).withPos(selPos)
     val selectWithTypes =
       if (targs.isEmpty) select
       else untpd.TypeApply(select, targs)
@@ -134,7 +135,7 @@ trait Dynamic { self: Typer with Applications =>
     def structuralCall(selectorName: TermName, formals: List[Tree]) = {
       val selectable = adapt(qual, defn.SelectableType)
       val scall = untpd.Apply(
-        untpd.TypedSplice(selectable.select(selectorName)),
+        untpd.TypedSplice(selectable.select(selectorName)).withPos(tree.pos),
         (Literal(Constant(name.toString)) :: formals).map(untpd.TypedSplice(_)))
       typed(scall)
     }

tests/neg/i4098a.scala

@@ -0,0 +1,16 @@
+object App {
+  import scala.reflect.Selectable.reflectiveSelectable
+
+  def coerce[U, V](u: U): V = {
+    type X = { val x: { type R >: U } }
+    type Y = { val x: { type R = V } }
+    lazy val z: X & Y = z
+    val u1: z.x.R = u  // error: Object { type R >: U | V <: V } is not stable (with arrows under z.x)
+    u1
+  }
+
+  def main(args: Array[String]): Unit = {
+    val x: Int = coerce[String, Int]("a")
+    println(x + 1)
+  }
+}