Merge pull request #5669 from dotty-staging/tasty-add-missing-constructors

liufengyun · web-flow · commit bcccb2f3ce83 · 2019-01-03T22:18:59.000+01:00
Add missing tasty.reflect.Constant constructors
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/ConstantOpsImpl.scala b/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
diff --git a/library/src/scala/tasty/reflect/ConstantOps.scala b/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]
     }
   }

Original file line number	Diff line number	Diff line change
`@@ -12,84 +12,97 @@ trait ConstantOpsImpl extends scala.tasty.reflect.ConstantOps with CoreImpl {`
`12`	`12`	`object Constant extends ConstantModule {`
`13`	`13`
`14`	`14`	`object Unit extends UnitModule {`
	`15`	`+ def apply(): Constant = Constants.Constant(())`
`15`	`16`	`def unapply(x: Constant): Boolean = x.tag == Constants.UnitTag`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`object Null extends NullModule {`
	`20`	`+ def apply(): Constant = Constants.Constant(null)`
`19`	`21`	`def unapply(x: Constant): Boolean = x.tag == Constants.NullTag`
`20`	`22`	`}`
`21`	`23`
`22`	`24`	`object Boolean extends BooleanModule {`
	`25`	`+ def apply(x: Boolean): Constant = Constants.Constant(x)`
`23`	`26`	`def unapply(x: Constant): Option[Boolean] = x match {`
`24`	`27`	`case x: Constants.Constant if x.tag == Constants.BooleanTag => Some(x.booleanValue)`
`25`	`28`	`case _ => None`
`26`	`29`	`}`
`27`	`30`	`}`
`28`	`31`
`29`	`32`	`object Byte extends ByteModule {`
	`33`	`+ def apply(x: Byte): Constant = Constants.Constant(x)`
`30`	`34`	`def unapply(x: Constant): Option[Byte] = x match {`
`31`	`35`	`case x: Constants.Constant if x.tag == Constants.ByteTag => Some(x.byteValue)`
`32`	`36`	`case _ => None`
`33`	`37`	`}`
`34`	`38`	`}`
`35`	`39`
`36`	`40`	`object Short extends ShortModule {`
	`41`	`+ def apply(x: Short): Constant = Constants.Constant(x)`
`37`	`42`	`def unapply(x: Constant): Option[Short] = x match {`
`38`	`43`	`case x: Constants.Constant if x.tag == Constants.ShortTag => Some(x.shortValue)`
`39`	`44`	`case _ => None`
`40`	`45`	`}`
`41`	`46`	`}`
`42`	`47`
`43`	`48`	`object Char extends CharModule {`
	`49`	`+ def apply(x: Char): Constant = Constants.Constant(x)`
`44`	`50`	`def unapply(x: Constant): Option[Char] = x match {`
`45`	`51`	`case x: Constants.Constant if x.tag == Constants.CharTag => Some(x.charValue)`
`46`	`52`	`case _ => None`
`47`	`53`	`}`
`48`	`54`	`}`
`49`	`55`
`50`	`56`	`object Int extends IntModule {`
	`57`	`+ def apply(x: Int): Constant = Constants.Constant(x)`
`51`	`58`	`def unapply(x: Constant): Option[Int] = x match {`
`52`	`59`	`case x: Constants.Constant if x.tag == Constants.IntTag => Some(x.intValue)`
`53`	`60`	`case _ => None`
`54`	`61`	`}`
`55`	`62`	`}`
`56`	`63`
`57`	`64`	`object Long extends LongModule {`
	`65`	`+ def apply(x: Long): Constant = Constants.Constant(x)`
`58`	`66`	`def unapply(x: Constant): Option[Long] = x match {`
`59`	`67`	`case x: Constants.Constant if x.tag == Constants.LongTag => Some(x.longValue)`
`60`	`68`	`case _ => None`
`61`	`69`	`}`
`62`	`70`	`}`
`63`	`71`
`64`	`72`	`object Float extends FloatModule {`
	`73`	`+ def apply(x: Float): Constant = Constants.Constant(x)`
`65`	`74`	`def unapply(x: Constant): Option[Float] = x match {`
`66`	`75`	`case x: Constants.Constant if x.tag == Constants.FloatTag => Some(x.floatValue)`
`67`	`76`	`case _ => None`
`68`	`77`	`}`
`69`	`78`	`}`
`70`	`79`
`71`	`80`	`object Double extends DoubleModule {`
	`81`	`+ def apply(x: Double): Constant = Constants.Constant(x)`
`72`	`82`	`def unapply(x: Constant): Option[Double] = x match {`
`73`	`83`	`case x: Constants.Constant if x.tag == Constants.DoubleTag => Some(x.doubleValue)`
`74`	`84`	`case _ => None`
`75`	`85`	`}`
`76`	`86`	`}`
`77`	`87`
`78`	`88`	`object String extends StringModule {`
	`89`	`+ def apply(x: String): Constant = Constants.Constant(x)`
`79`	`90`	`def unapply(x: Constant): Option[String] = x match {`
`80`	`91`	`case x: Constants.Constant if x.tag == Constants.StringTag => Some(x.stringValue)`
`81`	`92`	`case _ => None`
`82`	`93`	`}`
`83`	`94`	`}`
`84`	`95`
`85`	`96`	`object ClassTag extends ClassTagModule {`
	`97`	`+ def apply[T](implicit x: scala.reflect.ClassTag[T]): Constant = Constants.Constant(x)`
`86`	`98`	`def unapply(x: Constant): Option[Type] = x match {`
`87`	`99`	`case x: Constants.Constant if x.tag == Constants.ClazzTag => Some(x.typeValue)`
`88`	`100`	`case _ => None`
`89`	`101`	`}`
`90`	`102`	`}`
`91`	`103`
`92`	`104`	`object Symbol extends SymbolModule {`
	`105`	`+ def apply(x: scala.Symbol): Constant = Constants.Constant(x)`
`93`	`106`	`def unapply(x: Constant): Option[scala.Symbol] = x match {`
`94`	`107`	`case x: Constants.Constant if x.tag == Constants.ScalaSymbolTag => Some(x.scalaSymbolValue)`
`95`	`108`	`case _ => None`