Basic implementation of 42.type:

- Implements mandatory `.type` for identifiers
- Implements optional `.type` for literals
- Fixes a few problems with it, updates .check files

Author: folone

bincompat-backward.whitelist.conf

@@ -134,22 +134,17 @@ filter {
         problemName=MissingMethodProblem
     },
     {
-        matchName="scala.reflect.api.Mirror.symbolOf"
+        matchName="scala.reflect.api.Trees#SingletonTypeTreeApi.isLiteral"
         problemName=MissingMethodProblem
     },
     {
-        matchName="scala.reflect.api.Mirror.typeOf"
+        matchName="scala.reflect.api.Trees#SingletonTypeTreeApi.scala$reflect$api$Trees$SingletonTypeTreeApi$$$outer"
         problemName=MissingMethodProblem
     },
     {
-        matchName="scala.reflect.api.Mirror.weakTypeOf"
+        matchName="scala.reflect.api.Mirror.symbolOf"
         problemName=MissingMethodProblem
     },
-    // see SI-8388
-    {
-        matchName="scala.reflect.api.Internals$ReificationSupportApi$SyntacticIdentExtractor"
-        problemName=MissingClassProblem
-    },
     {
         matchName="scala.reflect.api.Internals#ReificationSupportApi.SyntacticIdent"
         problemName=MissingMethodProblem

bincompat-forward.whitelist.conf

@@ -228,7 +228,11 @@ filter {
         problemName=MissingClassProblem
     },
     {
-        matchName="scala.reflect.runtime.JavaMirrors#JavaMirror.scala$reflect$runtime$JavaMirrors$JavaMirror$$followStatic"
+        matchName="scala.reflect.api.Trees#SingletonTypeTreeApi.scala$reflect$api$Trees$SingletonTypeTreeApi$$$outer"
+        problemName=MissingMethodProblem
+    },
+    {
+        matchName="scala.reflect.api.Trees#SingletonTypeTreeApi.isLiteral"
         problemName=MissingMethodProblem
     },
     {
@@ -393,6 +397,10 @@ filter {
     {
         matchName="scala.reflect.runtime.Settings.ZirrefutableGeneratorPatterns"
         problemName=MissingMethodProblem
-    }
+    },
+    {
+        matchName="scala.reflect.runtime.JavaMirrors#JavaMirror.scala$reflect$runtime$JavaMirrors$JavaMirror$$followStatic"
+        problemName=MissingMethodProblem
+     }
   ]
 }

src/compiler/scala/reflect/reify/codegen/GenTypes.scala

@@ -52,7 +52,8 @@ trait GenTypes {
         reifyBuildCall(nme.SuperType, thistpe, supertpe)
       case tpe @ SingleType(pre, sym) =>
         reifyBuildCall(nme.SingleType, pre, sym)
-      case tpe @ ConstantType(value) =>
+      // TODO (folone): ConstantType folding?
+      case tpe @ ConstantType(value) if !tpe.isDeclaredSingleton =>
         mirrorBuildCall(nme.ConstantType, reifyProduct(value))
       case tpe @ TypeRef(pre, sym, args) =>
         reifyBuildCall(nme.TypeRef, pre, sym, args)

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

@@ -674,11 +674,11 @@ self =>
 
     def isExprIntro: Boolean = isExprIntroToken(in.token)
 
-    def isTypeIntroToken(token: Token): Boolean = token match {
+    def isTypeIntroToken(token: Token): Boolean = isLiteralToken(token) || (token match {
       case IDENTIFIER | BACKQUOTED_IDENT | THIS |
-           SUPER | USCORE | LPAREN | AT => true
+           SUPER | USCORE | LPAREN | AT | NULL => true
       case _ => false
-    }
+    })
 
     def isStatSeqEnd = in.token == RBRACE || in.token == EOF
 
@@ -861,7 +861,13 @@ self =>
         in.nextToken()
         if (in.token == RPAREN) {
           in.nextToken()
-          atPos(start, accept(ARROW)) { makeFunctionTypeTree(Nil, typ()) }
+          if (in.token == DOT && lookingAhead { in.token == TYPE }) {
+            accept(DOT)
+            accept(TYPE)
+            atPos(start)(new SingletonTypeTree(Literal(Constant(()))) { override val isLiteral = true })
+          } else {
+            atPos(start, accept(ARROW)) { makeFunctionTypeTree(Nil, typ()) }
+          }
         }
         else {
           val ts = functionTypes()
@@ -1090,6 +1096,14 @@ self =>
         if (in.token == DOT) t = selectors(t, typeOK, in.skipToken())
       } else {
         val tok = in.token
+        if (tok != BACKQUOTED_IDENT && tok != IDENTIFIER) {
+          val lit = literal(false)
+          if (in.token == DOT && lookingAhead { in.token == TYPE }) {
+            accept(DOT)
+            accept(TYPE)
+          }
+          return atPos(start)(new SingletonTypeTree(lit) { override val isLiteral = true })
+        }
         val name = ident()
         t = atPos(start) {
           if (tok == BACKQUOTED_IDENT) Ident(name) updateAttachment BackquotedIdentifierAttachment

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

@@ -640,6 +640,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
         // methods with constant result type get literals as their body
         // all methods except the primary constructor go into template
         stat.symbol.tpe match {
+          // TODO (folone): inlining of defs with literal-based singleton type results?
           case MethodType(List(), tp @ ConstantType(c)) =>
             defBuf += deriveDefDef(stat)(Literal(c) setPos _.pos setType tp)
           case _ =>

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

@@ -535,7 +535,8 @@ abstract class Erasure extends AddInterfaces
         } else bridgingCall
       }
       val rhs = member.tpe match {
-        case MethodType(Nil, ConstantType(c)) => Literal(c)
+        // TODO (folone): inlining of defs with literal-based singleton type results?
+        case MethodType(Nil, tp @ ConstantType(c)) if !tp.isDeclaredSingleton => Literal(c)
         case _                                =>
           val sel: Tree    = Select(This(root), member)
           val bridgingCall = (sel /: bridge.paramss)((fun, vparams) => Apply(fun, vparams map Ident))

src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala

@@ -496,6 +496,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis {
       val alternativesSupported = true
       val canJump = true
 
+      // TODO (folone): ConstantType folding?
       // Constant folding sets the type of a constant tree to `ConstantType(Constant(folded))`
       // The tree itself can be a literal, an ident, a selection, ...
       object SwitchablePattern { def unapply(pat: Tree): Option[Tree] = pat.tpe match {

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

@@ -14,6 +14,7 @@ import java.lang.ArithmeticException
  *  @author Martin Odersky
  *  @version 1.0
  */
+// TODO (folone): ConstantType folding?
 abstract class ConstantFolder {
 
   val global: Global
@@ -30,7 +31,7 @@ abstract class ConstantFolder {
    *  the conversion.
    */
   def apply(tree: Tree, pt: Type): Tree = fold(apply(tree), tree.tpe match {
-    case ConstantType(x) => x convertTo pt
+    case t @ ConstantType(x) if !t.isDeclaredSingleton => x convertTo pt
     case _ => null
   })
 

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

@@ -477,6 +477,7 @@ trait Infer extends Checkable {
           else Some(
             if (targ.typeSymbol == RepeatedParamClass)     targ.baseType(SeqClass)
             else if (targ.typeSymbol == JavaRepeatedParamClass) targ.baseType(ArrayClass)
+            else if (targ.isDeclaredSingleton) targ
             // this infers Foo.type instead of "object Foo" (see also widenIfNecessary)
             else if (targ.typeSymbol.isModuleClass || tvar.constr.avoidWiden) targ
             else targ.widen

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

@@ -25,6 +25,8 @@ trait Namers extends MethodSynthesis {
   var _lockedCount = 0
   def lockedCount = this._lockedCount
 
+  private var inferDependentTypes = false
+
   /** Replaces any Idents for which cond is true with fresh TypeTrees().
    *  Does the same for any trees containing EmptyTrees.
    */
@@ -838,7 +840,7 @@ trait Namers extends MethodSynthesis {
      *  value should not be widened, so it has a use even in situations
      *  whether it is otherwise redundant (such as in a singleton.)
      */
-    private def widenIfNecessary(sym: Symbol, tpe: Type, pt: Type): Type = {
+    private def widenIfNecessary(sym: Symbol, tpe: Type, pt: Type, isLiteral: Boolean): Type = {
       val getter =
         if (sym.isValue && sym.owner.isClass && sym.isPrivate)
           sym.getter(sym.owner)
@@ -863,7 +865,7 @@ trait Namers extends MethodSynthesis {
       )
       dropIllegalStarTypes(
         if (shouldWiden) tpe.widen
-        else if (sym.isFinal) tpe    // "final val" allowed to retain constant type
+        else if (sym.isFinal || (isLiteral && inferDependentTypes)) tpe    // "final val" allowed to retain constant type
         else tpe.deconst
       )
     }
@@ -876,7 +878,7 @@ trait Namers extends MethodSynthesis {
         case _ => defnTyper.computeType(tree.rhs, pt)
       }
 
-      val defnTpe = widenIfNecessary(tree.symbol, rhsTpe, pt)
+      val defnTpe = widenIfNecessary(tree.symbol, rhsTpe, pt, tree.rhs.isInstanceOf[Literal])
       tree.tpt defineType defnTpe setPos tree.pos.focus
       tree.tpt.tpe
     }