SIP-23 Implementation of literal types

Co-Authored-By: George Leontiev <[email protected]>
Co-Authored-By: Adriaan Moors <[email protected]>

Author: 3 people

bincompat-forward.whitelist.conf

@@ -114,6 +114,22 @@ filter {
     {
       matchName="scala.reflect.runtime.Settings.YkindPolymorphism"
       problemName=DirectMissingMethodProblem
+    },
+    {
+      matchName="scala.reflect.runtime.Settings.YliteralTypes"
+      problemName=MissingMethodProblem
+    },
+    {
+      matchName="scala.ValueOf"
+      problemName=MissingClassProblem
+    },
+    {
+      matchName="scala.Predef.valueOf"
+      problemName=DirectMissingMethodProblem
+    },
+    {
+      matchName="scala.ValueOf$"
+      problemName=MissingClassProblem
     }
   ]
 }

project/ScalaOptionParser.scala

@@ -86,7 +86,7 @@ object ScalaOptionParser {
     "-Xno-forwarders", "-Xno-patmat-analysis", "-Xno-uescape", "-Xnojline", "-Xprint-pos", "-Xprint-types", "-Xprompt", "-Xresident", "-Xshow-phases", "-Xstrict-inference", "-Xverify", "-Y",
     "-Ybreak-cycles", "-Ydebug", "-Ycompact-trees", "-YdisableFlatCpCaching", "-Ydoc-debug",
     "-Yide-debug", "-Yinfer-argument-types",
-    "-Yissue-debug", "-Ylog-classpath", "-Ymacro-debug-lite", "-Ymacro-debug-verbose", "-Ymacro-no-expand",
+    "-Yissue-debug", "-Yliteral-types", "-Ylog-classpath", "-Ymacro-debug-lite", "-Ymacro-debug-verbose", "-Ymacro-no-expand",
     "-Yno-completion", "-Yno-generic-signatures", "-Yno-imports", "-Yno-predef",
     "-Yoverride-objects", "-Yoverride-vars", "-Ypatmat-debug", "-Yno-adapted-args", "-Ypartial-unification", "-Ypos-debug", "-Ypresentation-debug",
     "-Ypresentation-strict", "-Ypresentation-verbose", "-Yquasiquote-debug", "-Yrangepos", "-Yreify-copypaste", "-Yreify-debug", "-Yrepl-class-based",

spec/01-lexical-syntax.md

@@ -523,9 +523,9 @@ string literal does not start a valid escape sequence.
 symbolLiteral  ::=  ‘'’ plainid
 ```
 
-A symbol literal `'x` is a shorthand for the expression
-`scala.Symbol("x")`. `Symbol` is a [case class](05-classes-and-objects.html#case-classes),
-which is defined as follows.
+A symbol literal `'x` is a shorthand for the expression `scala.Symbol("x")` and
+is of the [literal type](03-types#literal-types) `'x`. `Symbol` is a [case
+class](05-classes-and-objects.html#case-classes), which is defined as follows.
 
 ```scala
 package scala

spec/03-types.md

@@ -23,6 +23,7 @@ chapter: 3
                       |  SimpleType ‘#’ id
                       |  StableId
                       |  Path ‘.’ ‘type’
+                      |  Literal
                       |  ‘(’ Types ‘)’
   TypeArgs          ::=  ‘[’ Types ‘]’
   Types             ::=  Type {‘,’ Type}
@@ -102,16 +103,46 @@ forms.
 ### Singleton Types
 
 ```ebnf
-SimpleType  ::=  Path ‘.’ type
+SimpleType  ::=  Path ‘.’ ‘type’
 ```
 
-A _singleton type_ is of the form $p.$`type`, where $p$ is a
-path pointing to a value expected to [conform](06-expressions.html#expression-typing)
-to `scala.AnyRef`. The type denotes the set of values
-consisting of `null` and the value denoted by $p$.
+A _singleton type_ is of the form $p.$`type`. Where $p$ is a path pointing to a
+value which [conforms](06-expressions.html#expression-typing) to
+`scala.AnyRef`, the type denotes the set of values consisting of `null` and the
+value denoted by $p$ (i.e., the value $v$ for which `v eq p`). Where the path
+does not conform to `scala.AnyRef` the type denotes the set consisting of only
+the value denoted by $p$.
 
-A _stable type_ is either a singleton type or a type which is
-declared to be a subtype of trait `scala.Singleton`.
+<!-- a pattern match/type test against a singleton type `p.type` desugars to `_ eq p` -->
+
+### Literal Types
+
+```ebnf
+SimpleType  ::=  Literal
+```
+
+A literal type `lit` is a special kind of singleton type which denotes the
+single literal value `lit`.  Thus, the type ascription `1: 1` gives the most
+precise type to the literal value `1`:  the literal type `1`.
+
+At run time, an expression `e` is considered to have literal type `lit` if `e ==
+lit`.  Concretely, the result of `e.isInstanceOf[lit]` and `e match { case _ :
+lit => }` is determined by evaluating `e == lit`.
+
+Literal types are available for all types for which there is dedicated syntax
+except `Unit`. This includes the numeric types (other than `Byte` and `Short`
+which don't currently have syntax), `Boolean`, `Char`, `String` and `Symbol`.
+
+<!-- TODO: use eq when we lift it up to Any -->
+
+<!-- TODO: add Byte when Byte literals are added -->
+
+<!-- TODO: there is a relationship with constant folding but the latter
+     isn't currently specified at all -->
+
+### Stable Types
+A _stable type_ is a singleton type, a literal type,
+or a type that is declared to be a subtype of trait `scala.Singleton`.
 
 ### Type Projection
 

spec/06-expressions.md

@@ -76,8 +76,8 @@ $T$ forSome { type $t_1[\mathit{tps}\_1] >: L_1 <: U_1$; $\ldots$; type $t_n[\ma
 SimpleExpr    ::=  Literal
 ```
 
-Typing of literals is as described [here](01-lexical-syntax.html#literals); their
-evaluation is immediate.
+Typing of literals is described along with their [lexical syntax](01-lexical-syntax.html#literals);
+their evaluation is immediate.
 
 ## The _Null_ Value
 

spec/08-pattern-matching.md

@@ -339,9 +339,13 @@ A type pattern $T$ is of one of the following  forms:
   be used as type patterns, because they would match nothing in any case.
 
 * A singleton type `$p$.type`. This type pattern matches only the value
-  denoted by the path $p$ (that is, a pattern match involved a
-  comparison of the matched value with $p$ using method `eq` in class
-  `AnyRef`).
+  denoted by the path $p$ (the `eq` method is used to compare the matched value
+  to $p$).
+
+* A literal type `$lit$`. This type pattern matches only the value
+  denoted by the literal $lit$ (the `==` method is used to compare the matched
+  value to $lit$).
+
 * A compound type pattern `$T_1$ with $\ldots$ with $T_n$` where each $T_i$ is a
   type pattern. This type pattern matches all values that are matched by each of
   the type patterns $T_i$.

spec/12-the-scala-standard-library.md

@@ -642,6 +642,12 @@ object Predef {
   def classOf[T]: Class[T] = null
    // this is a dummy, classOf is handled by compiler.
 
+  // valueOf -----------------------------------------------------------
+
+  /** Retrieve the single value of a type with a unique inhabitant. */
+  @inline def valueOf[T](implicit vt: ValueOf[T]): T {} = vt.value
+   // instances of the ValueOf type class are provided by the compiler.
+
   // Standard type aliases ---------------------------------------------
 
   type String    = java.lang.String

src/compiler/scala/reflect/macros/contexts/Evals.scala

@@ -8,7 +8,7 @@ trait Evals {
   self: Context =>
 
   private lazy val evalMirror = ru.runtimeMirror(universe.analyzer.defaultMacroClassloader)
-  private lazy val evalToolBox = evalMirror.mkToolBox()
+  private lazy val evalToolBox = evalMirror.mkToolBox(options = if(global.settings.YliteralTypes) "-Yliteral-types" else "")
   private lazy val evalImporter = ru.internal.createImporter(universe).asInstanceOf[ru.Importer { val from: universe.type }]
 
   def eval[T](expr: Expr[T]): T = {
@@ -20,4 +20,4 @@ trait Evals {
         evalToolBox.eval(imported).asInstanceOf[T]
     }
   }
-}
+}

src/compiler/scala/reflect/reify/phases/Reify.scala

@@ -51,6 +51,8 @@ trait Reify extends GenSymbols
     case mods: global.Modifiers   => reifyModifiers(mods)
     case xs: List[_]              => reifyList(xs)
     case s: String                => Literal(Constant(s))
+    case s: scala.Symbol if settings.YliteralTypes
+                                  => Literal(Constant(s))
     case v if isAnyVal(v)         => Literal(Constant(v))
     case null                     => Literal(Constant(null))
     case _                        =>

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -706,11 +706,11 @@ self =>
 
     def isExprIntro: Boolean = isExprIntroToken(in.token)
 
-    def isTypeIntroToken(token: Token): Boolean = token match {
+    def isTypeIntroToken(token: Token): Boolean = (settings.YliteralTypes && isLiteralToken(token)) || (token match {
       case IDENTIFIER | BACKQUOTED_IDENT | THIS |
            SUPER | USCORE | LPAREN | AT => true
       case _ => false
-    }
+    })
 
     def isStatSeqEnd = in.token == RBRACE || in.token == EOF
 
@@ -1013,6 +1013,7 @@ self =>
        *                     |  SimpleType `#' Id
        *                     |  StableId
        *                     |  Path `.' type
+       *                     |  Literal
        *                     |  `(' Types `)'
        *                     |  WildcardType
        *  }}}
@@ -1022,6 +1023,7 @@ self =>
         simpleTypeRest(in.token match {
           case LPAREN   => atPos(start)(makeSafeTupleType(inParens(types()), start))
           case USCORE   => wildcardType(in.skipToken())
+          case tok if settings.YliteralTypes && isLiteralToken(tok) => atPos(start){SingletonTypeTree(literal())}
           case _        =>
             path(thisOK = false, typeOK = true) match {
               case r @ SingletonTypeTree(_) => r
@@ -1103,7 +1105,14 @@ self =>
           else
             mkOp(infixType(InfixMode.RightOp))
         }
+        def isNegatedLiteralType = settings.YliteralTypes && (
+          t match { // the token for `t` (Ident("-")) has already been read, thus `isLiteral` below is looking at next token (must be a literal)
+            case Ident(name) if isLiteral => name == nme.MINUS.toTypeName
+            case _ => false
+          }
+        )
         if (isIdent) checkRepeatedParam orElse asInfix
+        else if (isNegatedLiteralType) atPos(t.pos.start){SingletonTypeTree(literal(isNegated = true, start = t.pos.start))}
         else t
       }
 
@@ -1259,9 +1268,12 @@ self =>
      */
     def literal(isNegated: Boolean = false, inPattern: Boolean = false, start: Offset = in.offset): Tree = atPos(start) {
       def finish(value: Any): Tree = try newLiteral(value) finally in.nextToken()
-      if (in.token == SYMBOLLIT)
-        Apply(scalaDot(nme.Symbol), List(finish(in.strVal)))
-      else if (in.token == INTERPOLATIONID)
+      if (in.token == SYMBOLLIT) {
+        if(settings.YliteralTypes)
+          finish(Symbol(in.strVal.intern()))
+        else
+          Apply(scalaDot(nme.Symbol), List(finish(in.strVal)))
+      } else if (in.token == INTERPOLATIONID)
         interpolatedString(inPattern = inPattern)
       else finish(in.token match {
         case CHARLIT                => in.charVal
@@ -2603,6 +2615,11 @@ self =>
           if (!tp.isEmpty && newmods.isMutable &&
               (lhs.toList forall (_.isInstanceOf[Ident])) && in.token == USCORE) {
             in.nextToken()
+            tp match {
+              case SingletonTypeTree(Literal(Constant(_))) =>
+                syntaxError(tp.pos, "default initialization prohibited for literal-typed vars", skipIt = false)
+              case _ =>
+            }
             newmods = newmods | Flags.DEFAULTINIT
             EmptyTree
           } else {

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -30,7 +30,7 @@ trait ScalaSettings extends AbsScalaSettings
   protected def defaultClasspath = sys.env.getOrElse("CLASSPATH", ".")
 
   /** Enabled under -Xexperimental. */
-  protected def experimentalSettings = List[BooleanSetting](YpartialUnification, YinductionHeuristics, YkindPolymorphism)
+  protected def experimentalSettings = List[BooleanSetting](YpartialUnification, YinductionHeuristics, YkindPolymorphism, YliteralTypes)
 
   /** Enabled under -Xfuture. */
   protected def futureSettings = List[BooleanSetting]()
@@ -223,6 +223,7 @@ trait ScalaSettings extends AbsScalaSettings
   val Yvirtpatmat     = BooleanSetting    ("-Yvirtpatmat", "Enable pattern matcher virtualization")
   val YinductionHeuristics = BooleanSetting ("-Yinduction-heuristics", "Enable induction heuristics in implicit resolution")
   val YkindPolymorphism = BooleanSetting ("-Ykind-polymorphism", "Enable kind polymorphism")
+  val YliteralTypes   = BooleanSetting    ("-Yliteral-types", "Enable literal-based singleton types")
 
   val exposeEmptyPackage = BooleanSetting ("-Yexpose-empty-package", "Internal only: expose the empty package.").internalOnly()
   val Ydelambdafy        = ChoiceSetting  ("-Ydelambdafy", "strategy", "Strategy used for translating lambdas into JVM code.", List("inline", "method"), "method")

src/compiler/scala/tools/nsc/transform/Constructors.scala

@@ -598,7 +598,7 @@ abstract class Constructors extends Statics with Transform with TypingTransforme
 
       private def triage() = {
         // Constant typed vals are not memoized.
-        def memoizeValue(sym: Symbol) = !sym.info.resultType.isInstanceOf[ConstantType]
+        def memoizeValue(sym: Symbol) = !sym.info.resultType.isInstanceOf[FoldableConstantType]
 
         // The early initialized field definitions of the class (these are the class members)
         val presupers = treeInfo.preSuperFields(stats)