Address the review:

- Remove mutable state by introducing `DeclaredSingletonType`
- Update the spec

Author: folone

spec/03-types.md

@@ -103,12 +103,13 @@ forms.
 
 ```ebnf
 SimpleType  ::=  Path ‘.’ type
+              |  Literal [‘.’ 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,
+or $42$, with `.type` being optional for literals.
+The type denotes the set of values consisting of `null` and 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`.

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -5114,8 +5114,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           typed(tree.ref, MonoQualifierModes | mode.onlyTypePat, AnyClass.tpe)
         }
         tree setType {
-          if (tree.isLiteral) refTyped.tpe.resultType.asDeclaredSingleton
-          else refTyped.tpe.resultType
+          refTyped.tpe.resultType.asDeclaredSingleton.getOrElse(refTyped.tpe.resultType)
         }
         if (!refTyped.isErrorTyped)
           tree setType refTyped.tpe.resultType

src/reflect/scala/reflect/internal/Types.scala

@@ -258,11 +258,8 @@ trait Types
 
   /** The base class for all types */
   abstract class Type extends TypeApiImpl with Annotatable[Type] {
-    var isDeclaredSingleton: Boolean = false
-    def asDeclaredSingleton: this.type = {
-      isDeclaredSingleton = true
-      this
-    }
+    val isDeclaredSingleton: Boolean = false
+    def asDeclaredSingleton: Option[DeclaredSingletonType] = None
 
     /** Types for which asSeenFrom always is the identity, no matter what
      *  prefix or owner.
@@ -1817,15 +1814,24 @@ trait Types
   class PackageClassInfoType(decls: Scope, clazz: Symbol)
   extends ClassInfoType(List(), decls, clazz)
 
+  final case class DeclaredSingletonType(value: Constant) extends SingletonType with SingletonTypeApi {
+    override val isDeclaredSingleton = true
+    override def asDeclaredSingleton = Some(this)
+    override def underlying: Type = value.tpe
+    override def isTrivial: Boolean = true
+    override def deconst = underlying
+    override def safeToString: String = value.escapedStringValue + ".type"
+    override def kind = "DeclaredSingletonType"
+  }
+
   /** A class representing a constant type.
    */
   abstract case class ConstantType(value: Constant) extends SingletonType with ConstantTypeApi {
+    override def asDeclaredSingleton = Some(DeclaredSingletonType(value))
     override def underlying: Type = value.tpe
     assert(underlying.typeSymbol != UnitClass)
     override def isTrivial: Boolean = true
-    override def deconst: Type =
-      if (isDeclaredSingleton) this
-      else underlying
+    override def deconst: Type = underlying
     override def safeToString: String = value.escapedStringValue + ".type"
     override def kind = "ConstantType"
   }

src/reflect/scala/reflect/runtime/JavaUniverseForce.scala

@@ -143,6 +143,7 @@ trait JavaUniverseForce { self: runtime.JavaUniverse  =>
     this.baseClassesCycleMonitor
     this.RefinedType
     this.ClassInfoType
+    this.DeclaredSingletonType
     this.ConstantType
     this.TypeRef
     this.MethodType

test/files/run/42.type.check

@@ -1,4 +1,3 @@
-2
 (2,0,1)
 got 1
 got PANDA!

test/files/run/42.type.scala

@@ -16,7 +16,7 @@ object Test {
 
   type Null = null.type
 
-  var x: 3.type = 3
+  //var x: 3.type = 3
   /*
     scala> x = 42
     <console>:8: error: type mismatch;
@@ -46,7 +46,7 @@ object Test {
 
   implicit object One extends Succ[1.type] {
     type Out = 2.type
-    def apply(x: 1.type) = 2
+    def apply(x: 1.type): 2 = 2
   }
 
   def f[T](x: T)(implicit succ: Succ[T]) = succ(x)
@@ -57,28 +57,32 @@ object Test {
   }
 
   def main(args: Array[String]): Unit = {
-    println(f(1))
+    //println(f(1))
     // println(f(5))
     println((g(1), g(5), g(7)))
     noisyIdentity(1)
     noisyIdentity("PANDA!")
   }
 
-  // Inlining functions with singleton result type
+  // vars don't play well with singleton types:
+/*
+scala> var test: 3.type = 3
+<console>:7: error: assignment to non variable
+       var test: 3.type = 3
+           ^
+ */
+
+  // No inlining of functions with singleton result type anymore, but then this:
   /*
-scala> def ok(): 7.type = {
+scala> def test(): 7.type = {
      | println("PANDA!")
      | 7
      | }
-ok: ()7.type
-
-scala> ok()
-res0: 7.type = 7
-
-// Expected:
-scala> ok()
-PANDA!
-res0: 7.type = 7
+<console>:7: error: type mismatch;
+ found   : Int
+ required: 7.type
+       def test(): 7.type = {
+                            ^
    */
 
   // Parser problem: