Don't recurse into type arguments in inliner map

Inlined type arguments should be left alone in the inliner TreeTypeMap, analogous to inlined
term arguments.

Author: odersky

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

@@ -22,6 +22,8 @@ import core.tasty.TreePickler.Hole
  *  @param newOwners New owners, replacing previous owners.
  *  @param substFrom The symbols that need to be substituted.
  *  @param substTo   The substitution targets.
+ *  @param stopAtInlinedArgument  Whether one should stop at an inlined argument,
+ *                    i.e. a node of form Inlined(EmptyTree, _, _).
  *
  *  The reason the substitution is broken out from the rest of the type map is
  *  that all symbols have to be substituted at the same time. If we do not do this,
@@ -31,14 +33,19 @@ import core.tasty.TreePickler.Hole
  *  do S2 we get outer#2.inner#4. But that means that the named type outer#2.inner
  *  gets two different denotations in the same period. Hence, if -Yno-double-bindings is
  *  set, we would get a data race assertion error.
+ *
+ *  Note: TreeTypeMap is final, since derived maps are created dynamically for
+ *  nested scopes. Any subclass of TreeTypeMap would revert to the standard
+ *  TreeTypeMap in these recursive invocations.
  */
-class TreeTypeMap(
+final class TreeTypeMap(
   val typeMap: Type => Type = IdentityTypeMap,
   val treeMap: tpd.Tree => tpd.Tree = identity _,
   val oldOwners: List[Symbol] = Nil,
   val newOwners: List[Symbol] = Nil,
   val substFrom: List[Symbol] = Nil,
-  val substTo: List[Symbol] = Nil)(using Context) extends tpd.TreeMap {
+  val substTo: List[Symbol] = Nil,
+  stopAtInlinedArgument: Boolean = false)(using Context) extends tpd.TreeMap {
   import tpd._
 
   /** If `sym` is one of `oldOwners`, replace by corresponding symbol in `newOwners` */
@@ -76,8 +83,11 @@ class TreeTypeMap(
       updateDecls(prevStats.tail, newStats.tail)
     }
 
-  /** If true, stop return Inlined(Empty, _, _) nodes unchanged */
-  def stopAtInlinedArgument: Boolean = false
+  def transformInlined(tree: tpd.Inlined)(using Context): tpd.Tree =
+    val Inlined(call, bindings, expanded) = tree
+    val (tmap1, bindings1) = transformDefs(bindings)
+    val expanded1 = tmap1.transform(expanded)
+    cpy.Inlined(tree)(call, bindings1, expanded1)
 
   override def transform(tree: tpd.Tree)(using Context): tpd.Tree = treeMap(tree) match {
     case impl @ Template(constr, parents, self, _) =>
@@ -111,7 +121,9 @@ class TreeTypeMap(
           cpy.Block(blk)(stats1, expr1)
         case inlined @ Inlined(call, bindings, expanded) =>
           if stopAtInlinedArgument && call.isEmpty then
-            inlined
+            expanded match
+              case expanded: TypeTree => assert(bindings.isEmpty); expanded
+              case _ => inlined
           else
             val (tmap1, bindings1) = transformDefs(bindings)
             val expanded1 = tmap1.transform(expanded)
@@ -177,7 +189,8 @@ class TreeTypeMap(
         from ++ oldOwners,
         to ++ newOwners,
         from ++ substFrom,
-        to ++ substTo)
+        to ++ substTo,
+        stopAtInlinedArgument)
     }
 
   /** Apply `typeMap` and `ownerMap` to given symbols `syms`

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

@@ -746,16 +746,15 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
               val inlinedSingleton = singleton(t).withSpan(argSpan)
               inlinedFromOutside(inlinedSingleton)(tree.span)
             case Some(t) if tree.isType =>
-              TypeTree(t).withSpan(argSpan)
+              inlinedFromOutside(TypeTree(t).withSpan(argSpan))(tree.span)
             case _ => tree
           }
         case tree => tree
       },
       oldOwners = inlinedMethod :: Nil,
-      newOwners = ctx.owner :: Nil
-    )(using inlineCtx) {
-      override def stopAtInlinedArgument: Boolean = true
-    }
+      newOwners = ctx.owner :: Nil,
+      stopAtInlinedArgument = true
+    )(using inlineCtx)
 
     // Apply inliner to `rhsToInline`, split off any implicit bindings from result, and
     // make them part of `bindingsBuf`. The expansion is then the tree that remains.

tests/pos/i11350.scala

@@ -0,0 +1,5 @@
+//case class A[T](action: A[T] ?=> String) // now disallowed
+
+class A1[T](action: A1[T] ?=> String = (_: A1[T]) ?=> "") // works
+//case class A2[T](action: A2[?] ?=> String) // now disallowed
+//case class A3[T](action: A3[T] => String) // now disallowed

tests/pos/i11894.scala

@@ -0,0 +1,7 @@
+class CallbackTo[A](val x: A):
+  inline def runNow(): A = x
+  inline def toScalaFn: () => A = () => runNow()
+  def toOption(): Option[A] =
+    val y: CallbackTo[Option[A]] = ???
+    val f: () => Option[A] = y.toScalaFn // error
+    f()

tests/pos/i11894b.scala

@@ -0,0 +1,24 @@
+object CallbackTo {
+  extension [A](self: CallbackTo[Option[A]]) {
+    inline def asOption: Option[A] =
+      self.toScalaFn()
+  }
+}
+
+final class CallbackTo[A] (val x: List[A]) {
+
+  inline def runNow(): A =
+    x.head
+
+  inline def toScalaFn: () => A =
+    () => runNow()
+
+  def map[B](f: A => B): CallbackTo[B] =
+    ???
+
+  def toOption: Option[A] = {
+    val x = map[Option[A]](Some(_))
+    val y = x: CallbackTo[Option[A]] // ok: type is what we expect
+    y.asOption // error
+  }
+}