Ignore ascriptions from PrepareInlinable.wrapRHS in InlineTyper

Author: mbovel

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

@@ -1056,8 +1056,20 @@ class Inliner(val call: tpd.Tree)(using Context):
       val meth = tree.symbol
       if meth.isAllOf(DeferredInline) then
         errorTree(tree, em"Deferred inline ${meth.showLocated} cannot be invoked")
-      else if Inlines.needsInlining(tree) then Inlines.inlineCall(simplify(tree, pt, locked))
-      else tree
+      else if Inlines.needsInlining(tree) then
+        StripInlineResultAscriptionMap().transform(Inlines.inlineCall(simplify(tree, pt, locked)))
+      else
+        tree
+
+    private class StripInlineResultAscriptionMap extends tpd.TreeMap:
+      override def transform(tree: Tree)(using Context): Tree =
+        tree match
+          case Typed(expr, _) if tree.hasAttachment(PrepareInlineable.InlineResultAscription) =>
+            expr
+          case tree: Inlined =>
+            super.transform(tree)
+          case _ =>
+            tree
 
     override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(using Context): Tree =
       super.typedUnadapted(tree, pt, locked) match

compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala

@@ -30,6 +30,11 @@ object PrepareInlineable {
 
   private val InlineAccessorsKey = new Property.Key[InlineAccessors]
 
+  /** Indicates that an ascription was inserted by [[PrepareInlinable.wrapRHS]].
+   *  It is used to remove it [[Inliner.stripInlineResultAscription]].
+   */
+  val InlineResultAscription = new Property.StickyKey[Unit]
+
   def initContext(ctx: Context): Context =
     ctx.fresh.setProperty(InlineAccessorsKey, new InlineAccessors)
 
@@ -246,7 +251,10 @@ object PrepareInlineable {
 
   /** The type ascription `rhs: tpt`, unless `original` is `transparent`. */
   def wrapRHS(original: untpd.DefDef, tpt: Tree, rhs: Tree)(using Context): Tree =
-    if original.mods.is(Transparent) then rhs else Typed(rhs, tpt)
+    if original.mods.is(Transparent) then
+      rhs
+    else
+      Typed(rhs, tpt).withAttachment(InlineResultAscription, ())
 
   /** Return result of evaluating `op`, but drop `Inline` flag and `Body` annotation
    *  of `sym` in case that leads to errors.

tests/pos/i24412.scala

@@ -0,0 +1,13 @@
+object test {
+  import scala.compiletime.erasedValue
+
+  inline def contains[T <: Tuple, E]: Boolean = inline erasedValue[T] match {
+    case _: EmptyTuple => false
+    case _: (_ *: tail) => contains[tail, E]
+  }
+  inline def check[T <: Tuple]: Unit = {
+    inline if contains[T, Long] && false then ???
+  }
+
+  check[(String, Double)]
+}

tests/run/i24420-inline-local-ref.scala

@@ -0,0 +1,12 @@
+inline def f(): Long =
+  1L
+
+inline def g(): Long =
+  inline val x = f()
+  x
+
+inline def h(): Long =
+  inline if g() > 0L then 1L else 0L
+
+@main def Test: Unit =
+  assert(h() == 1L)

tests/run/i24420-inline-val.scala

@@ -0,0 +1,25 @@
+inline def f1(): Long =
+  1L
+
+inline def f2(): Long =
+  inline val x = f1() + 1L
+  x
+
+inline def f3(): Long =
+  inline val x = f1()
+  x
+
+inline def g1(): Boolean =
+  true
+
+inline def g2(): Long =
+  inline if g1() then 1L else 2L
+
+inline def g3(): Long =
+  inline if f1() > 0L then 1L else 2L
+
+@main def Test: Unit =
+  assert(f2() == 2L)
+  assert(f3() == 1L)
+  assert(g2() == 1L)
+  assert(g3() == 1L)