Handle generic tuples when inlining

Fixes #14182

Author: nicolasstucki

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

@@ -486,10 +486,18 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
     }
     val argtpe = arg.tpe.dealiasKeepAnnots.translateFromRepeated(toArray = false)
     val argIsBottom = argtpe.isBottomTypeAfterErasure
-    val bindingType =
+    val argwtpe =
       if argIsBottom then formal
-      else if isByName then ExprType(argtpe.widen)
+      else if defn.isTupleNType(formal.widenExpr) && !defn.isTupleNType(argtpe.widen) then
+        // A generic tuple with know size N is considered as a subtype of TupleN but it does not
+        // contain the members of TupleN. All these tuples will be erased to TupleN and will have
+        // those members at runtime. Therefore when inlining it is important to keep the fact that
+        // this is TupleN and that the members can be accessed when the tree is re-typechecked.
+        // Also see `newArg` bellow
+        // See i14182
+        argtpe.widen & formal.widenExpr
       else argtpe.widen
+    val bindingType = if isByName then ExprType(argwtpe) else argwtpe
     var bindingFlags: FlagSet = InlineProxy
     if formal.widenExpr.hasAnnotation(defn.InlineParamAnnot) then
       bindingFlags |= Inline
@@ -500,8 +508,12 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
     val boundSym = newSym(InlineBinderName.fresh(name.asTermName), bindingFlags, bindingType).asTerm
     val binding = {
       var newArg = arg.changeOwner(ctx.owner, boundSym)
-      if bindingFlags.is(Inline) && argIsBottom then
+      if argIsBottom && bindingFlags.is(Inline) then
         newArg = Typed(newArg, TypeTree(formal)) // type ascribe RHS to avoid type errors in expansion. See i8612.scala
+      else if defn.isTupleNType(formal.widenExpr) && !defn.isTupleNType(argtpe.widen) then
+        // Also see `argtpe1` above
+        newArg = Typed(newArg, TypeTree(formal.widenExpr))
+
       if isByName then DefDef(boundSym, newArg)
       else ValDef(boundSym, newArg)
     }.withSpan(boundSym.span)

tests/pos-macros/i14182/Macro_1.scala

@@ -0,0 +1,3 @@
+import scala.quoted._
+def fooImpl(xs: Expr[(Int, Int)])(using Quotes): Expr[Unit] =
+  '{ val a: Int = $xs._1; }

tests/pos-macros/i14182/Test_2.scala

@@ -0,0 +1,3 @@
+inline def foo(inline xs: (Int, Int)): Unit = ${ fooImpl('xs) }
+def fail = foo(1 *: 2 *: EmptyTuple)
+def ok = foo((1, 2))

tests/pos/i14182.scala

@@ -0,0 +1,3 @@
+inline def foo(inline xs: (Int, Int)): Unit = { val a: Int = xs._1; }
+def fail = foo(1 *: 2 *: EmptyTuple)
+def ok = foo((1, 2))

tests/pos/i14182a.scala

@@ -0,0 +1,3 @@
+inline def foo(xs: (Int, Int)): Unit = { val a: Int = xs._1; }
+def fail = foo(1 *: 2 *: EmptyTuple)
+def ok = foo((1, 2))

tests/pos/i14182b.scala

@@ -0,0 +1,4 @@
+inline def foo(inline xs: (Int, Int)): Unit = { val a: Int = xs._1; }
+def bar =
+  val tup: 1 *: 2 *: EmptyTuple = ???
+  foo(tup)

tests/pos/i14182c.scala

@@ -0,0 +1,3 @@
+inline def foo(xs: => (Int, Int)): Unit = { val a: Int = xs._1; }
+def bar =
+  foo(1 *: 2 *: EmptyTuple)