Check rhs of inline val after Inlining phase

To avoid running the phase

Author: nicolasstucki

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -62,6 +62,7 @@ class Compiler {
          new CookComments,           // Cook the comments: expand variables, doc, etc.
          new CheckStatic,            // Check restrictions that apply to @static members
          new BetaReduce,             // Reduce closure applications
+         new InlineVals,             // Check right hand-sides of an `inline val`s
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
          new init.Checker) ::        // Check initialization of objects
     List(new ElimRepeated,           // Rewrite vararg parameters and arguments

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

@@ -0,0 +1,43 @@
+package dotty.tools
+package dotc
+package transform
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import dotty.tools.dotc.typer.Inliner
+
+/** Check that `tree.rhs` can be right hand-side of an `inline` value definition. */
+class InlineVals extends MiniPhase:
+  import ast.tpd._
+
+  def phaseName: String = "inlineVals"
+
+  override def checkPostCondition(tree: Tree)(using Context): Unit =
+    if !ctx.erasedTypes then
+      tree match
+        case tree: ValDef => checkInlineConformant(tree)
+        case _ =>
+
+  override def transformValDef(tree: ValDef)(using Context): Tree =
+    checkInlineConformant(tree)
+    tree
+
+  /** Check that `tree.rhs` can be right hand-side of an `inline` value definition. */
+  private def checkInlineConformant(tree: ValDef)(using Context): Unit = {
+    if tree.symbol.is(Inline, butNot = DeferredOrTermParamOrAccessor)
+      && !Inliner.inInlineMethod
+    then
+      val rhs = tree.rhs
+      val tpt = tree.tpt
+      tpt.tpe.widenTermRefExpr.dealias.normalized match
+        case tp: ConstantType =>
+          if !isPureExpr(rhs) then
+            val details = if enclosingInlineds.isEmpty then "" else em"but was: $rhs"
+            report.error(s"inline value must be pure$details", rhs.srcPos)
+        case _ =>
+          val pos = if tpt.span.isZeroExtent then rhs.srcPos else tpt.srcPos
+          report.error(em"inline value must have a literal constant type", pos)
+  }

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

@@ -61,8 +61,6 @@ class Inlining extends MacroTransform {
                 traverseChildren(tree)(using StagingContext.spliceContext)
               case tree: RefTree if !Inliner.inInlineMethod && StagingContext.level == 0 =>
                 assert(!tree.symbol.isInlineMethod, tree.show)
-              case tree: ValDef =>
-                checkInlineConformant(tree)
               case _ =>
                 traverseChildren(tree)
         }.traverse(tree)
@@ -77,11 +75,6 @@ class Inlining extends MacroTransform {
   private class InliningTreeMap extends TreeMapWithImplicits {
     override def transform(tree: Tree)(using Context): Tree = {
       tree match
-        case tree: ValDef =>
-          super.transform(tree) match
-            case tree: ValDef =>
-              checkInlineConformant(tree)
-              tree
         case tree: DefTree =>
           if tree.symbol.is(Inline) then tree
           else super.transform(tree)
@@ -103,21 +96,5 @@ class Inlining extends MacroTransform {
   }
 }
 
-object Inlining {
+object Inlining:
   val name: String = "inlining"
-
-  /** Check that `vdef.rhs` can be right hand-side of an `inline` value definition. */
-  def checkInlineConformant(vdef: tpd.ValDef)(using Context): Unit = {
-    val ValDef(_, tpt, rhs) = vdef
-    if vdef.symbol.is(Inline, butNot = DeferredOrTermParamOrAccessor) && !ctx.erasedTypes && !Inliner.inInlineMethod then
-      val rhs = vdef.rhs
-      vdef.tpt.tpe.widenTermRefExpr.dealias.normalized match
-        case tp: ConstantType =>
-          if !tpd.isPureExpr(rhs) then
-            val details = if tpd.enclosingInlineds.isEmpty then "" else em"but was: $rhs"
-            report.error(s"inline value must be pure$details", rhs.srcPos)
-        case _ =>
-          val pos = if vdef.tpt.span.isZeroExtent then rhs.srcPos else vdef.tpt.srcPos
-          report.error(em"inline value must have a literal constant type", pos)
-  }
-}

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

@@ -336,8 +336,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             )
           }
         case tree: ValDef =>
-          if tree.symbol.is(Inline, butNot = Param) then
-            ctx.compilationUnit.needsInlining = true
           val tree1 = cpy.ValDef(tree)(rhs = normalizeErasedRhs(tree.rhs, tree.symbol))
           processValOrDefDef(super.transform(tree1))
         case tree: DefDef =>

tests/neg/inlinevals-2.scala

@@ -6,11 +6,7 @@ object Test {
   inline val N = 10
   def X = 20
 
-  inline val M = X  // error: rhs must be constant expression
-
   power(2.0, N) // ok, since it's a by-name parameter
   power(2.0, X) // error: cannot reduce inline if
 
-  inline val xs = List(1, 2, 3) // error: must be a constant expression
-
 }

tests/neg/inlinevals-4.scala

@@ -0,0 +1,13 @@
+object Test {
+
+  inline def power(x: Double, inline n: Int): Double = // ok
+    inline if n == 0 then ??? else ???
+
+  inline val N = 10
+  def X = 20
+
+  inline val M = X  // error: rhs must be constant expression
+
+  inline val xs = List(1, 2, 3) // error: must be a constant expression
+
+}