Fix parameter untupling

Make untupled parameters ValDefs instead of DefDefs so that their references are
stable paths. Add an additional check that untupled parameters don't come from
call-by-name parameters (in that case, ValDefs would be unsound).

I was trying hard to allow paramater untupling for cbn parameters, but this seems to be
very hard since parameter untupling happens as a desugaring step when the expected
parameter type is not yet known. And it seems really hard to change from stable to
unstable (or vice versa) later in the compilation pipleline without doing a lot of
re-checking.

Since untupled cbn parameters are a pretty extreme corner case anyway I think it's
OK to just disallow them.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -39,6 +39,10 @@ object desugar {
    */
   val MultiLineInfix: Property.Key[Unit] = Property.StickyKey()
 
+  /** An attachment key to indicate that a ValDef originated from parameter untupling.
+   */
+  val UntupledParam: Property.Key[Unit] = Property.StickyKey()
+
   /** What static check should be applied to a Match? */
   enum MatchCheck {
     case None, Exhaustive, IrrefutablePatDef, IrrefutableGenFrom
@@ -1426,7 +1430,9 @@ object desugar {
     val vdefs =
       params.zipWithIndex.map {
         case (param, idx) =>
-          DefDef(param.name, Nil, param.tpt, selector(idx)).withSpan(param.span)
+          ValDef(param.name, param.tpt, selector(idx))
+            .withSpan(param.span)
+            .withAttachment(UntupledParam, ())
       }
     Function(param :: Nil, Block(vdefs, body))
   }

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -1,7 +1,7 @@
 package dotty.tools.dotc
 package transform
 
-import dotty.tools.dotc.ast.{Trees, tpd, untpd}
+import dotty.tools.dotc.ast.{Trees, tpd, untpd, desugar}
 import scala.collection.mutable
 import core._
 import dotty.tools.dotc.typer.Checking
@@ -255,6 +255,14 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
       if tree.symbol.is(ConstructorProxy) then
         report.error(em"constructor proxy ${tree.symbol} cannot be used as a value", tree.srcPos)
 
+    def checkStableSelection(tree: Tree)(using Context): Unit =
+      def check(qual: Tree) =
+        if !qual.tpe.isStable then
+          report.error(em"Parameter untupling cannot be used for call-by-name parameters", tree.srcPos)
+      tree match
+        case Select(qual, _) => check(qual)    // simple select _n
+        case Apply(TypeApply(Select(qual, _), _), _) => check(qual) // generic select .apply[T](n)
+
     override def transform(tree: Tree)(using Context): Tree =
       try tree match {
         // TODO move CaseDef case lower: keep most probable trees first for performance
@@ -356,6 +364,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case tree: ValDef =>
           checkErasedDef(tree)
           val tree1 = cpy.ValDef(tree)(rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
+          if tree1.removeAttachment(desugar.UntupledParam).isDefined then
+            checkStableSelection(tree.rhs)
           processValOrDefDef(super.transform(tree1))
         case tree: DefDef =>
           checkErasedDef(tree)

tests/neg/function-arity-2.scala

@@ -0,0 +1,7 @@
+object Test {
+
+  class T[A] { def foo(f: (=> A) => Int) = f(???) }
+
+  def main(args: Array[String]): Unit =
+    new T[(Int, Int)].foo((x, y) => 0) // error // error Parameter untupling cannot be used for call-by-name parameters (twice)
+}

tests/neg/i14783.scala

@@ -0,0 +1,3 @@
+object Test:
+  def foo(f: (=> (Int, Int)) => Int) = ???
+  foo((a, b) => a + b) // error // error

tests/pos/i14783.scala

@@ -0,0 +1,51 @@
+object Wart:
+  def bar(using c: Ctx)(ws: List[Wrap[c.type]]): Unit =
+    ws.zipWithIndex.foreach { (w, _) => w.x.foo }
+
+trait Wrap[C <: Ctx & Singleton]:
+  val ctx: C
+  def x: ctx.inner.X
+
+trait Ctx:
+  object inner:
+    type X
+    extension (self: X) def foo: Int = ???
+
+
+object WartInspector:
+  def myWartTraverser: WartTraverser = ???
+  def inspect(using q: Quotes)(tastys: List[Tasty[q.type]]): Unit = {
+    val universe: WartUniverse.Aux[q.type] = WartUniverse(q)
+    val traverser = myWartTraverser.get(universe)
+    tastys.zipWithIndex.foreach { (tasty, index) =>
+      val tree = tasty.ast
+      traverser.traverseTree(tree)(tree.symbol)
+    }
+  }
+
+object WartUniverse:
+  type Aux[X <: Quotes] = WartUniverse { type Q = X }
+  def apply[Q <: Quotes](quotes: Q): Aux[Q] = ???
+
+
+abstract class WartUniverse:
+  type Q <: Quotes
+  val quotes: Q
+  abstract class Traverser extends quotes.reflect.TreeTraverser
+
+
+abstract class WartTraverser:
+  def get(u: WartUniverse): u.Traverser
+
+trait Tasty[Q <: Quotes & Singleton]:
+  val quotes: Q
+  def path: String
+  def ast: quotes.reflect.Tree
+
+trait Quotes:
+  object reflect:
+    type Tree
+    extension (self: Tree) def symbol: Symbol = ???
+    type Symbol
+    trait TreeTraverser:
+      def traverseTree(tree: Tree)(symbol: Symbol): Unit

tests/run/function-arity.scala

@@ -3,6 +3,6 @@ object Test {
 
   def main(args: Array[String]): Unit = {
     new T[(Int, Int)].foo((ii) => 0)
-    new T[(Int, Int)].foo((x, y) => 0) // check that this does not run into ???
+    //new T[(Int, Int)].foo((x, y) => 0) // not allowed anymore
   }
 }