Add Constant type

Constant is s subtype of Singleton types that only allow constants
for which the value is known at compile time.

Author: nicolasstucki

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

@@ -410,6 +410,13 @@ class Definitions {
       List(AnyClass.typeRef), EmptyScope)
   lazy val SingletonType: TypeRef = SingletonClass.typeRef
 
+  lazy val ConstantClass: ClassSymbol =
+    // TODO needs to be synthetic as is SingletonClass?
+    enterCompleteClassSymbol(
+      ScalaPackageClass, tpnme.Constant, PureInterfaceCreationFlags | Final,
+      List(SingletonType), EmptyScope)
+  lazy val ConstantType: TypeRef = ConstantClass.typeRef
+
   lazy val SeqType: TypeRef =
     if (isNewCollections) ctx.requiredClassRef("scala.collection.immutable.Seq")
     else ctx.requiredClassRef("scala.collection.Seq")
@@ -1209,6 +1216,7 @@ class Definitions {
     NullClass,
     NothingClass,
     SingletonClass,
+    ConstantClass,
     EqualsPatternClass)
 
   lazy val syntheticCoreClasses = syntheticScalaClasses ++ List(

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

@@ -393,6 +393,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
             if (base.exists && base.ne(tp1))
               return isSubType(base, tp2, if (tp1.isRef(cls2)) approx else approx.addLow)
             if (cls2 == defn.SingletonClass && tp1.isStable) return true
+            if (cls2 == defn.ConstantClass && tp1.isConstant) return true
           }
           else if (cls2.is(JavaDefined)) {
             // If `cls2` is parameterized, we are seeing a raw type, so we need to compare only the symbol

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

@@ -158,6 +158,14 @@ object Types {
       case _ => false
     }
 
+    /** Does this type denote a constant type */
+    final def isConstant(implicit ctx: Context): Boolean = stripTypeVar match {
+      case _: ConstantType => true
+      case tp: ExprType => tp.resultType.isConstant
+      case tp: AnnotatedType => tp.parent.isConstant
+      case _ => false
+    }
+
     /** Is this type a (possibly refined or applied or aliased) type reference
      *  to the given type symbol?
      *  @sym  The symbol to compare to. It must be a class symbol or abstract type.

tests/neg/constant-types.scala

@@ -0,0 +1,20 @@
+object Constants {
+
+  def f[C <: Constant](c: C): Unit = ()
+  val x = 1
+  f(x) // error
+
+  def fBool(c: Boolean & Constant): Unit = ()
+  val b = true
+  fBool(b) // error
+
+
+  def fInt(c: Int & Constant): Unit = ()
+  val i = 3
+  fInt(i) // error
+
+  def fChar(c: Char & Constant): Unit = ()
+  val c = 'c'
+  fChar(c) // error
+
+}

tests/pos/constant-types.scala

@@ -0,0 +1,30 @@
+object Constants {
+
+  def f[C <: Constant](c: C): Unit = ()
+  f(true)
+  f(1)
+  f(2L)
+  f(1.2f)
+  f(1.2d)
+  f('a')
+  f("abc")
+
+  def fBool(c: Boolean & Constant): Unit = ()
+  fBool(true)
+  fBool(false)
+  transparent def bb: Boolean = true
+  fBool(bb)
+
+  def fInt(c: Int & Constant): Unit = ()
+  fInt(1)
+  fInt(2)
+  transparent def ii: Int = 4
+  fInt(ii)
+
+  def fChar(c: Char & Constant): Unit = ()
+  fChar('a')
+  fChar('b')
+  transparent def cc: Char = 'd'
+  fChar(cc)
+
+}