Add constValueOpt method

useful to allow libraries to fail gracefully if something is not a constant
(not necessarily a parameter, it could be a quantity computed by the rewrite
method).

Author: odersky

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

@@ -224,6 +224,8 @@ class Definitions {
     def Typelevel_error(implicit ctx: Context) = Typelevel_errorR.symbol
     lazy val Typelevel_constValueR = TypelevelPackageObjectRef.symbol.requiredMethodRef("constValue")
     def Typelevel_constValue(implicit ctx: Context) = Typelevel_constValueR.symbol
+    lazy val Typelevel_constValueOptR = TypelevelPackageObjectRef.symbol.requiredMethodRef("constValueOpt")
+    def Typelevel_constValueOpt(implicit ctx: Context) = Typelevel_constValueOptR.symbol
 
   /** The `scalaShadowing` package is used to safely modify classes and
    *  objects in scala so that they can be used from dotty. They will

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

@@ -349,15 +349,28 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     else result
   }
 
+  def tryConstValue: Tree =
+    ctx.typeComparer.constValue(callTypeArgs.head.tpe) match {
+      case Some(c) => Literal(c).withPos(call.pos)
+      case _ => EmptyTree
+    }
+
   /** The Inlined node representing the inlined call */
   def inlined(pt: Type): Tree = {
 
-    if (inlinedMethod == defn.Typelevel_constValue && callTypeArgs.length == 1) {
-      ctx.typeComparer.constValue(callTypeArgs.head.tpe) match {
-        case Some(c) => return tpd.Literal(c).withPos(call.pos)
-        case _ => ctx.error(i"not a constant type: ${callTypeArgs.head}; cannot take constValue")
+    if (callTypeArgs.length == 1)
+      if (inlinedMethod == defn.Typelevel_constValue) {
+        val constVal = tryConstValue
+        if (!constVal.isEmpty) return constVal
+        ctx.error(i"not a constant type: ${callTypeArgs.head}; cannot take constValue")
+      }
+      else if (inlinedMethod == defn.Typelevel_constValueOpt) {
+        val constVal = tryConstValue
+        return (
+          if (constVal.isEmpty) ref(defn.NoneModuleRef)
+          else New(defn.SomeClass.typeRef.appliedTo(constVal.tpe), constVal :: Nil)
+        )
       }
-    }
 
     // Compute bindings for all parameters, appending them to bindingsBuf
     computeParamBindings(inlinedMethod.info, callTypeArgs, callValueArgss)

library/src-scala3/scala/typelevel/package.scala

@@ -8,6 +8,8 @@ package object typelevel {
 
   rewrite def error(transparent msg: String): Nothing = ???
 
+  rewrite def constValueOpt[T]: Option[T] = ???
+
   rewrite def constValue[T]: T = ???
 
   type S[X <: Int] <: Int