Add missing tasty.reflect.Constant constructors

compiler/src/dotty/tools/dotc/tastyreflect/ConstantOpsImpl.scala

@@ -12,84 +12,97 @@ trait ConstantOpsImpl extends scala.tasty.reflect.ConstantOps with CoreImpl {
   object Constant extends ConstantModule {
 
     object Unit extends UnitModule {
+      def apply(): Constant = Constants.Constant(())
       def unapply(x: Constant): Boolean = x.tag == Constants.UnitTag
     }
 
     object Null extends NullModule {
+      def apply(): Constant = Constants.Constant(null)
       def unapply(x: Constant): Boolean = x.tag == Constants.NullTag
     }
 
     object Boolean extends BooleanModule {
+      def apply(x: Boolean): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[Boolean] = x match {
         case x: Constants.Constant if x.tag == Constants.BooleanTag => Some(x.booleanValue)
         case _ => None
       }
     }
 
     object Byte extends ByteModule {
+      def apply(x: Byte): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[Byte] = x match {
         case x: Constants.Constant if x.tag == Constants.ByteTag => Some(x.byteValue)
         case _ => None
       }
     }
 
     object Short extends ShortModule {
+      def apply(x: Short): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[Short] = x match {
         case x: Constants.Constant if x.tag == Constants.ShortTag => Some(x.shortValue)
         case _ => None
       }
     }
 
     object Char extends CharModule {
+      def apply(x: Char): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[Char] = x match {
         case x: Constants.Constant if x.tag == Constants.CharTag => Some(x.charValue)
         case _ => None
       }
     }
 
     object Int extends IntModule {
+      def apply(x: Int): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[Int] = x match {
         case x: Constants.Constant if x.tag == Constants.IntTag => Some(x.intValue)
         case _ => None
       }
     }
 
     object Long extends LongModule {
+      def apply(x: Long): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[Long] = x match {
         case x: Constants.Constant if x.tag == Constants.LongTag => Some(x.longValue)
         case _ => None
       }
     }
 
     object Float extends FloatModule {
+      def apply(x: Float): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[Float] = x match {
         case x: Constants.Constant if x.tag == Constants.FloatTag => Some(x.floatValue)
         case _ => None
       }
     }
 
     object Double extends DoubleModule {
+      def apply(x: Double): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[Double] = x match {
         case x: Constants.Constant if x.tag == Constants.DoubleTag => Some(x.doubleValue)
         case _ => None
       }
     }
 
     object String extends StringModule {
+      def apply(x: String): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[String] = x match {
         case x: Constants.Constant if x.tag == Constants.StringTag => Some(x.stringValue)
         case _ => None
       }
     }
 
     object ClassTag extends ClassTagModule {
+      def apply[T](implicit x: scala.reflect.ClassTag[T]): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[Type] = x match {
         case x: Constants.Constant if x.tag == Constants.ClazzTag => Some(x.typeValue)
         case _ => None
       }
     }
 
     object Symbol extends SymbolModule {
+      def apply(x: scala.Symbol): Constant = Constants.Constant(x)
       def unapply(x: Constant): Option[scala.Symbol] = x match {
         case x: Constants.Constant if x.tag == Constants.ScalaSymbolTag => Some(x.scalaSymbolValue)
         case _ => None

library/src/scala/tasty/reflect/ConstantOps.scala

@@ -15,83 +15,119 @@ trait ConstantOps extends Core {
     /** Module of Null literals */
     val Unit: UnitModule
     abstract class UnitModule {
+      /** Unit `()` literal */
+      def apply(): Constant
+
       /** Extractor for Unit literals */
       def unapply(constant: Constant): Boolean
     }
 
     /** Module of Null literals */
     val Null: NullModule
     abstract class NullModule {
+      /** `null` literal */
+      def apply(): Constant
+
       /** Extractor for Null literals */
       def unapply(constant: Constant): Boolean
     }
 
     /** Module of Boolean literals */
     val Boolean: BooleanModule
     abstract class BooleanModule {
+      /** Boolean literal */
+      def apply(x: Boolean): Constant
+
       /** Extractor for Boolean literals */
       def unapply(constant: Constant): Option[Boolean]
     }
 
     /** Module of Byte literals */
     val Byte: ByteModule
     abstract class ByteModule {
+      /** Byte literal */
+      def apply(x: Byte): Constant
+
       /** Extractor for Byte literals */
       def unapply(constant: Constant): Option[Byte]
     }
 
     /** Module of Short literals */
     val Short: ShortModule
     abstract class ShortModule {
+      /** Short literal */
+      def apply(x: Short): Constant
+
       /** Extractor for Short literals */
       def unapply(constant: Constant): Option[Short]
     }
 
     /** Module of Char literals */
     val Char: CharModule
     abstract class CharModule {
+      /** Char literal */
+      def apply(x: Char): Constant
+
       /** Extractor for Char literals */
       def unapply(constant: Constant): Option[Char]
     }
 
     /** Module of Int literals */
     val Int: IntModule
     abstract class IntModule {
+      /** Int literal */
+      def apply(x: Int): Constant
+
       /** Extractor for Int literals */
       def unapply(constant: Constant): Option[Int]
     }
 
     /** Module of Long literals */
     val Long: LongModule
     abstract class LongModule {
+      /** Long literal */
+      def apply(x: Long): Constant
+
       /** Extractor for Long literals */
       def unapply(constant: Constant): Option[Long]
     }
 
     /** Module of Float literals */
     val Float: FloatModule
     abstract class FloatModule {
+      /** Float literal */
+      def apply(x: Float): Constant
+
       /** Extractor for Float literals */
       def unapply(constant: Constant): Option[Float]
     }
 
     /** Module of Double literals */
     val Double: DoubleModule
     abstract class DoubleModule {
+      /** Double literal */
+      def apply(x: Double): Constant
+
       /** Extractor for Double literals */
       def unapply(constant: Constant): Option[Double]
     }
 
     /** Module of String literals */
     val String: StringModule
     abstract class StringModule {
+      /** String literal */
+      def apply(x: String): Constant
+
       /** Extractor for String literals */
       def unapply(constant: Constant): Option[String]
     }
 
     /** Module of ClassTag literals */
     val ClassTag: ClassTagModule
     abstract class ClassTagModule {
+      /** scala.reflect.ClassTag literal */
+      def apply[T](implicit x: scala.reflect.ClassTag[T]): Constant
+
       /** Extractor for ClassTag literals */
       def unapply(constant: Constant): Option[Type]
     }
@@ -100,6 +136,10 @@ trait ConstantOps extends Core {
     val Symbol: SymbolModule
     /** Extractor for scala.Symbol literals */
     abstract class SymbolModule {
+      /** scala.Symbol literal */
+      def apply(x: scala.Symbol): Constant
+
+      /** Extractor for scala.Symbol literals */
       def unapply(constant: Constant): Option[scala.Symbol]
     }
   }