Add scala.compiletime.requireConst

`requireConst` checks at compiletime that the provided values is a constant after inlining and constant folding.

Usage:
```scala
inline def twice(inline n: Int): Int =
  requireConst(n) // static assertion that the parameter `n` is a constant
  n + n

twice(1)
val m: Int = ...
twice(m) // error: expected a constant value but found: m
```

This check may aslo be used to stop inlining in the branches of an if that does not have a constant condition.
Such checks can avoid infinite recursions of inlining when a value is assumed to be a constant.
```scala
inline def power(x: Long, n: Int): Long =
  if requireConst(n == 0) then 1L
  else if requireConst(n % 2 == 1) then x * power(x, n - 1)
  else {
    val y: Long = x * x
    power(y, n / 2)
  }

val n: Int = ...
power(x, n) // error: expected a constant value but found: n == 0
```

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -226,6 +226,7 @@ class Definitions {
   @tu lazy val CompiletimePackageObject: Symbol = requiredModule("scala.compiletime.package")
     @tu lazy val Compiletime_erasedValue  : Symbol = CompiletimePackageObject.requiredMethod("erasedValue")
     @tu lazy val Compiletime_error        : Symbol = CompiletimePackageObject.requiredMethod(nme.error)
+    @tu lazy val Compiletime_requireConst: Symbol = CompiletimePackageObject.requiredMethod("requireConst")
     @tu lazy val Compiletime_constValue   : Symbol = CompiletimePackageObject.requiredMethod("constValue")
     @tu lazy val Compiletime_constValueOpt: Symbol = CompiletimePackageObject.requiredMethod("constValueOpt")
     @tu lazy val Compiletime_code         : Symbol = CompiletimePackageObject.requiredMethod("extension_code")

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -463,7 +463,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case tree @ Inlined(call, bindings, body) =>
         (("/* inlined from " ~ (if (call.isEmpty) "outside" else toText(call)) ~ " */ ") `provided`
           !homogenizedView && ctx.settings.XprintInline.value) ~
-        blockText(bindings :+ body)
+          (if bindings.isEmpty then toText(body) else blockText(bindings :+ body))
       case tpt: untpd.DerivedTypeTree =>
         "<derived typetree watching " ~ tpt.watched.showSummary() ~ ">"
       case TypeTree() =>

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

@@ -620,8 +620,21 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
   /** The Inlined node representing the inlined call */
   def inlined(sourcePos: SrcPos): Tree = {
 
+    // Special handling of `const`
+    callValueArgss match
+      case (arg :: Nil) :: Nil =>
+        if (inlinedMethod == defn.Compiletime_requireConst) {
+          arg match
+            case ConstantValue(v) => return arg
+            case Inlined(_, Nil, Typed(ConstantValue(v), _)) => return arg
+            case _ =>
+              report.error(em"expected a constant value but found: $arg", arg.srcPos)
+        }
+      case _ =>
+
   	// Special handling of `constValue[T]` and `constValueOpt[T]`
     if (callTypeArgs.length == 1)
+
       if (inlinedMethod == defn.Compiletime_constValue) {
         val constVal = tryConstValue
         if (!constVal.isEmpty) return constVal
@@ -890,12 +903,6 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
       }
     }
 
-    object ConstantValue {
-      def unapply(tree: Tree)(using Context): Option[Any] = tree.tpe.widenTermRefExpr.normalized match {
-        case ConstantType(Constant(x)) => Some(x)
-        case _ => None
-      }
-    }
 
     def tryInline(tree: Tree)(using Context): Tree = tree match {
       case InlineableArg(rhs) =>
@@ -1208,14 +1215,17 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
     }
 
     override def typedIf(tree: untpd.If, pt: Type)(using Context): Tree =
+      val err = ctx.reporter.errorCount
       typed(tree.cond, defn.BooleanType) match {
         case cond1 @ ConstantValue(b: Boolean) =>
           val selected0 = if (b) tree.thenp else tree.elsep
           val selected = if (selected0.isEmpty) tpd.Literal(Constant(())) else typed(selected0, pt)
           if (isIdempotentExpr(cond1)) selected
           else Block(cond1 :: Nil, selected)
+        case cond1: tpd.Inlined if cond1.call.symbol == defn.Compiletime_requireConst =>
+          errorTree(tree, em"Expected constant condition but found: ${tree.cond}")
         case cond1 =>
-          if (tree.isInline)
+          if (tree.isInline) // TODO replace with Compiletime_requireConst value check?
             errorTree(tree, em"""cannot reduce inline if
                                 | its condition   ${tree.cond}
                                 | is not a constant value""")
@@ -1452,4 +1462,12 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
             foldOver(syms, tree)
         }
     }.apply(Nil, tree)
+
+  object ConstantValue {
+    def unapply(tree: Tree)(using Context): Option[Any] = tree.tpe.widenTermRefExpr.normalized match {
+      case ConstantType(Constant(x)) => Some(x)
+      case _ => None
+    }
+  }
+
 }

library/src/scala/compiletime/package.scala

@@ -50,6 +50,37 @@ package object compiletime {
       ${ dotty.internal.CompileTimeMacros.codeExpr('self, 'args) }
   end extension
 
+  /** Checks at compiletime that the provided values is a constant after
+   *  inlining and constant folding and returns the value.
+   *
+   *  Usage:
+   *  ```scala
+   *  inline def twice(inline n: Int): Int =
+   *    requireConst(n) // static assertion that the parameter `n` is a constant
+   *    n + n
+   *
+   *  twice(1)
+   *  val m: Int = ...
+   *  twice(m) // error: expected a constant value but found: m
+   *  ```
+   *
+   *  This check may aslo be used to stop inlining in the branches of an if that does not have a constant condition.
+   *  Such checks can avoid infinite recursions of inlining when a value is assumed to be a constant.
+   *  ```scala
+   *  inline def power(x: Long, n: Int): Long =
+   *    if requireConst(n == 0) then 1L
+   *    else if requireConst(n % 2 == 1) then x * power(x, n - 1)
+   *    else {
+   *      val y: Long = x * x
+   *      power(y, n / 2)
+   *    }
+   *
+   *  val n: Int = ...
+   *  power(x, n) // error: expected a constant value but found: n == 0
+   *  ```
+   */
+  inline def requireConst(x: Any): x.type = ???
+
   /** Same as `constValue` but returns a `None` if a constant value
    *  cannot be constructed from the provided type. Otherwise returns
    *  that value wrapped in `Some`.

tests/invalid/run/typelevel1.scala

@@ -33,7 +33,7 @@ object Test extends App {
   // Does not work since it infers `Any` as a type argument for `::`
   // and we cannot undo that without a typing from untyped.
   transparent inline def concat[T1, T2](xs: HList, ys: HList): HList =
-    inline if xs.isEmpty then ys
+    if compiletime.requireConst(xs.isEmpty) then ys
     else new ::(xs.head, concat(xs.tail, ys))
 
   val xs = 1 :: "a" :: "b" :: HNil

tests/neg/cannot-reduce-inline-match.check

@@ -2,8 +2,6 @@
 9 |  foo("f") // error
   |  ^^^^^^^^
   |  cannot reduce inline match with
-  |   scrutinee:  {
-  |    "f"
-  |  } : ("f" : String)
+  |   scrutinee:  "f" : ("f" : String)
   |   patterns :  case _:Int
   | This location contains code that was inlined from cannot-reduce-inline-match.scala:3

tests/neg/compiletime-const.scala

@@ -0,0 +1,48 @@
+import scala.compiletime.requireConst
+
+object Test {
+
+  requireConst(true)
+  requireConst(1)
+  requireConst(1L)
+  requireConst(1d)
+  requireConst(1f)
+  requireConst('a')
+  requireConst("abc")
+
+  requireConst(1 + 3)
+  requireConst("abc" + "cde")
+
+  val a: Int = 2
+  inline val b = 2
+
+  requireConst(a) // error: expected a requireConstant value but found: Test.a
+  requireConst(b)
+  requireConst(b + b)
+  requireConst(b - b)
+  requireConst(b / b)
+  requireConst(b % b)
+
+  inline def f(inline n: Int): Int = 4 + n
+
+  requireConst(f(1))
+  requireConst(f(a)) // error: expected a requireConstant value but found: 4.+(Test.a):Int
+  requireConst(f(b))
+  requireConst(f(b + b))
+
+  def g(n: Int): n.type = n
+
+  requireConst(g(1))
+  requireConst(g(a)) // error: expected a requireConstant value but found: Test.a
+  requireConst(g(b))
+
+
+  inline def twice(inline n: Int): Int =
+    requireConst(n) // static assertion that n is a requireConstant
+    n + n
+
+  twice(1)
+  twice(a) // error: expected a requireConstant value but found: Test.a
+  twice(b)
+
+}

tests/neg/inline-error-pos.check

@@ -2,8 +2,6 @@
 8 |  val b = foo(2) // error
   |          ^^^^^^
   |          cannot reduce inline match with
-  |           scrutinee:  {
-  |            2
-  |          } : (2 : Int)
+  |           scrutinee:  2 : (2 : Int)
   |           patterns :  case 1
   | This location contains code that was inlined from inline-error-pos.scala:3

tests/neg/inlinevals.scala

@@ -1,9 +1,11 @@
+import scala.compiletime.requireConst
+
 object Test {
 
   def power0(x: Double, inline n: Int): Double = ???  // error: inline modifier can only be used for parameters of inline methods
 
   inline def power(x: Double, inline n: Int): Double = // ok
-    inline if n == 0 then ??? else ???
+    if requireConst(n == 0) then ??? else ???
 
   inline val N = 10
   def X = 20

tests/run/typeclass-derivation3.scala

@@ -129,7 +129,7 @@ object typeclasses {
 
     inline def unpickleCase[T, Elems <: Tuple](buf: mutable.ListBuffer[Int], m: Mirror.ProductOf[T]): T = {
       inline val size = constValue[Tuple.Size[Elems]]
-      inline if (size == 0)
+      if requireConst(size == 0) then
         m.fromProduct(EmptyProduct)
       else {
         val elems = new ArrayProduct(size)