Fix interaction between vars and DeclaredSingletonTypes.

Author: folone

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

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

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

@@ -640,7 +640,6 @@ 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,8 +535,7 @@ abstract class Erasure extends AddInterfaces
         } else bridgingCall
       }
       val rhs = member.tpe match {
-        // TODO (folone): inlining of defs with literal-based singleton type results?
-        case MethodType(Nil, tp @ ConstantType(c)) if !tp.isDeclaredSingleton => Literal(c)
+        case MethodType(Nil, tp @ ConstantType(c)) if !tp.asDeclaredSingleton.isDefined => 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,7 +496,6 @@ 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/Infer.scala

@@ -477,7 +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
+            else if (targ.asDeclaredSingleton.isDefined) 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/TypeDiagnostics.scala

@@ -504,7 +504,6 @@ trait TypeDiagnostics {
           && !targets(m)
           && !(m.name == nme.WILDCARD)              // e.g. val _ = foo
           && !ignoreNames(m.name.toTermName)        // serialization methods
-          // TODO (folone): inlining of defs with literal-based singleton type results?
           && !isConstantType(m.info.resultType)     // subject to constant inlining
           && !treeTypes.exists(_ contains m)        // e.g. val a = new Foo ; new a.Bar
         )

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

@@ -996,7 +996,6 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
         if (mode.inPatternMode && isPopulatedPattern)
           return tree
 
-        // TODO (folone): ConstantType folding?
         val tree1 = constfold(tree, pt) // (10) (11)
         if (tree1.tpe <:< pt)
           return adapt(tree1, mode, pt, original)
@@ -1097,7 +1096,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       } else tree.tpe match {
         case atp @ AnnotatedType(_, _) if canAdaptAnnotations(tree, this, mode, pt) => // (-1)
           adaptAnnotations(tree, this, mode, pt)
-        case ct @ ConstantType(value) if mode.inNone(TYPEmode | FUNmode) && (ct <:< pt) && canAdaptConstantTypeToLiteral && !ct.isDeclaredSingleton => // (0)
+        case ct @ ConstantType(value) if mode.inNone(TYPEmode | FUNmode) && (ct <:< pt) && canAdaptConstantTypeToLiteral && !ct.asDeclaredSingleton.isDefined => // (0)
           adaptConstant(value)
         case OverloadedType(pre, alts) if !mode.inFunMode => // (1)
           inferExprAlternative(tree, pt)
@@ -3479,7 +3478,6 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
         ErroneousAnnotation
       }
 
-      // TODO (folone): ConstantType folding?
       /* Calling constfold right here is necessary because some trees (negated
        * floats and literals in particular) are not yet folded.
        */
@@ -3543,7 +3541,6 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
         case Typed(t, _) =>
           tree2ConstArg(t, pt)
 
-        // TODO (folone): ConstantType folding?
         case tree =>
           tryConst(tree, pt)
       }

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;
@@ -57,7 +57,7 @@ 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)