Add constValue function

A function that produces the constant value represented by a type.

Author: odersky

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

@@ -222,6 +222,8 @@ class Definitions {
   lazy val TypelevelPackageObject = TypelevelPackageObjectRef.symbol.moduleClass
     lazy val Typelevel_errorR = TypelevelPackageObjectRef.symbol.requiredMethodRef(nme.error)
     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
 
   /** 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/core/TypeComparer.scala

@@ -887,7 +887,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
           false
       }
 
-    /** Compare `tp` of form `S[arg]` with `other`, via ">:>` if fromBelowis true, "<:<" otherwise.
+    /** Compare `tp` of form `S[arg]` with `other`, via ">:>` if fromBelow is true, "<:<" otherwise.
      *  If `arg` is a Nat constant `n`, proceed with comparing `n + 1` and `other`.
      *  Otherwise, if `other` is a Nat constant `n`, proceed with comparing `arg` and `n - 1`.
      */
@@ -951,11 +951,17 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
   }
 
   /** Optionally, the `n` such that `tp <:< ConstantType(Constant(n: Int))` */
-  def natValue(tp: Type): Option[Int] = {
+  def natValue(tp: Type): Option[Int] = constValue(tp) match {
+    case Some(Constant(n: Int)) if n >= 0 => Some(n)
+    case _ => None
+  }
+
+  /** Optionally, the constant `c` such that `tp <:< ConstantType(c)` */
+  def constValue(tp: Type): Option[Constant] = {
     val ct = new AnyConstantType
     if (isSubTypeWhenFrozen(tp, ct))
       ct.tpe match {
-        case ConstantType(Constant(n: Int)) if n >= 0 => Some(n)
+        case ConstantType(c) => Some(c)
         case _ => None
       }
     else None

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

@@ -350,7 +350,15 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
   }
 
   /** The Inlined node representing the inlined call */
-  def inlined(pt: Type) = {
+  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")
+      }
+    }
+
     // Compute bindings for all parameters, appending them to bindingsBuf
     computeParamBindings(inlinedMethod.info, callTypeArgs, callValueArgss)
 

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

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