Refactor 'typedAssign' to ensure the right evaluation order

Author: kyouko-taiga

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -208,7 +208,8 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case UnstableInlineAccessorID // errorNumber: 192
   case VolatileOnValID // errorNumber: 193
   case InvalidMultipleAssignmentSourceID // errorNumber: 194
-  case MultipleAssignmentShapeMismatchID // errorNumber: 195
+  case InvalidMultipleAssignmentTargetID // errorNumber: 195
+  case MultipleAssignmentShapeMismatchID // errorNumber: 196
 
   def errorNumber = ordinal - 1
 

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -3164,6 +3164,14 @@ class InvalidMultipleAssignmentSource(found: Type)(using Context)
   def explain(using Context) = ""
 }
 
+class InvalidMultipleAssignmentTarget()(using Context)
+  extends TypeMsg(InvalidMultipleAssignmentTargetID) {
+  def msg(using Context) =
+    i"""invalid target of multiple assignment.
+        |Multiple assignments admit only one level of nesting."""
+  def explain(using Context) = ""
+}
+
 class MultipleAssignmentShapeMismatch(found: Int, required: Int)(using Context)
   extends TypeMsg(MultipleAssignmentShapeMismatchID) {
   def msg(using Context) =

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

@@ -141,6 +141,33 @@ trait Dynamic {
     }
   }
 
+  /** Returns the partial application of a dynamic assignment translating selection that does not
+    * typecheck according to the normal rules into a `updateDynamic`.
+    *
+    * For example: `foo.bar = baz ~~> foo.updateDynamic(bar)(baz)`
+    *
+    * @param lhs The target of the assignment.
+    */
+  def formPartialDynamicAssignment(
+      lhs: untpd.Tree
+  )(using Context): PartialAssignment[SimpleLValue] =
+    lhs match
+      case s @ Select(q, n) if !isDynamicMethod(n) =>
+        formPartialDynamicAssignment(q, n, s.span, Nil)
+      case TypeApply(s @ Select(q, n), targs) if !isDynamicMethod(n) =>
+        formPartialDynamicAssignment(q, n, s.span, Nil)
+      case _ =>
+        val e = errorTree(lhs, ReassignmentToVal(lhs.symbol.name))
+        PartialAssignment(SimpleLValue(e)) { (l, _) => l.expression }
+
+  def formPartialDynamicAssignment(
+      q: untpd.Tree, n: Name, s: Span, targs: List[untpd.Tree]
+  )(using Context): PartialAssignment[SimpleLValue] =
+    val v = typed(coreDynamic(q, nme.updateDynamic, n, s, targs))
+    PartialAssignment(SimpleLValue(v)) { (l, r) =>
+      untpd.Apply(untpd.TypedSplice(l.expression), List(r))
+    }
+
   private def coreDynamic(qual: untpd.Tree, dynName: Name, name: Name, selSpan: Span, targs: List[untpd.Tree])(using Context): untpd.Apply = {
     val select = untpd.Select(qual, dynName).withSpan(selSpan)
     val selectWithTypes =

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

@@ -0,0 +1,123 @@
+package dotty.tools
+package dotc
+package typer
+
+import dotty.tools.dotc.ast.Trees.ApplyKind
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.untpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Names.Name
+import core.Symbols.defn
+
+/** A function computing the assignment of a lvalue.
+  *
+  * @param lhs The target of the assignment.
+  * @param perform: A closure that accepts `lhs` and an untyped tree `rhs`, and returns a tree
+  *   representing the assignment of `rhs` ro `lhs`.
+  */
+private[typer] final class PartialAssignment[+T <: LValue](val lhs: T)(
+    perform: (T, untpd.Tree) => untpd.Tree
+):
+
+  /** Returns a tree computing the assignment of `rhs` to `lhs`. */
+  def apply(rhs: untpd.Tree): untpd.Tree =
+    perform(lhs, rhs)
+
+end PartialAssignment
+
+/** The left-hand side of an assignment. */
+private[typer] sealed abstract class LValue:
+
+  /** Returns the local `val` definitions composing this lvalue. */
+  def locals: List[tpd.ValDef]
+
+  /** Returns this lvalue converted to a rvalue. */
+  def toRValue(using Context): untpd.Tree
+
+  /** Returns a tree computing the assignment of `rhs` to this lvalue. */
+  def formAssignment(rhs: untpd.Tree)(using Context): untpd.Tree
+
+  /** Returns the value of `t`, which may be an expression or a local `val` definition. */
+  protected final def read(t: tpd.Tree)(using Context): tpd.Tree =
+    t match
+      case d: tpd.ValDef => tpd.Ident(d.namedType)
+      case e => e
+
+end LValue
+
+/** A simple expression, typically valid on left-hand side of an `Assign` tree.
+  *
+  * Use this class to represent an assignment that translates to an `Assign` tree or to wrap an
+  * error whose diagnostic can be delayed until the right-hand side is known.
+  *
+  * @param expression The expression of the lvalue.
+  */
+private[typer] final case class SimpleLValue(expression: tpd.Tree) extends LValue:
+
+  def locals: List[tpd.ValDef] =
+    List()
+
+  def toRValue(using Context): untpd.Tree =
+    untpd.TypedSplice(expression)
+
+  def formAssignment(rhs: untpd.Tree)(using Context): untpd.Tree =
+    val s = untpd.Assign(untpd.TypedSplice(expression), rhs)
+    untpd.TypedSplice(s.withType(defn.UnitType))
+
+end SimpleLValue
+
+/** A lvalue represeted by the partial application a function.
+  *
+  * @param function The partially applied function.
+  * @param arguments The arguments of the partial application.
+  * @param kind The way in which the function is applied.
+  */
+private[typer] final case class ApplyLValue(
+    function: tpd.Tree,
+    arguments: List[tpd.Tree],
+    kind: ApplyKind = ApplyKind.Regular
+) extends LValue:
+
+  val locals: List[tpd.ValDef] =
+    (function +: arguments).collect { case d: tpd.ValDef => d }
+
+  def toRValue(using Context): untpd.Tree =
+    untpd.Apply(function, arguments)
+
+  def formAssignment(rhs: untpd.Tree)(using Context): untpd.Tree =
+    val s = untpd.TypedSplice(read(function))
+    val t = arguments.map((a) => untpd.TypedSplice(read(a))) :+ rhs
+    untpd.Apply(s, t)
+
+end ApplyLValue
+
+/** A lvalue represeted by the application of a partially applied method.
+  *
+  * @param receiver The receiver of the partially applied method.
+  * @param member The name of the partially applied method.
+  * @param arguments The arguments of the partial application.
+  */
+private[typer] final case class SelectLValue(
+    receiver: tpd.Tree,
+    member: Name,
+    arguments: List[tpd.Tree] = List()
+) extends LValue:
+
+  def expandReceiver()(using Context): tpd.Tree =
+    receiver match
+      case d: tpd.ValDef => d.rhs
+      case r => r
+
+  val locals: List[tpd.ValDef] =
+    (receiver +: arguments).collect { case d: tpd.ValDef => d }
+
+  def toRValue(using Context): untpd.Tree =
+    require(arguments.isEmpty)
+    untpd.Select(untpd.TypedSplice(expandReceiver()), member)
+
+  def formAssignment(rhs: untpd.Tree)(using Context): untpd.Tree =
+    val s = untpd.Select(untpd.TypedSplice(read(receiver)), member)
+    val t = arguments.map((a) => untpd.TypedSplice(read(a))) :+ rhs
+    untpd.Apply(s, t)
+
+end SelectLValue