Uncurry does Literal RHS for ConstantType def, not Constructors

Uncurry seems more logical to me. Ideally, Erasure would erase
ConstantTypes, since they do not exist in bytecode.

In any case, doing this earlier, when we're rewriting method anyway,
simplifies constructors, which should be focussing on, well,
constructors (& fields).

Author: adriaanm

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

@@ -631,21 +631,11 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
         // recurse on class definition, store in defBuf
         case _: ClassDef => defBuf += new ConstructorTransformer(unit).transform(stat)
 
-        // all methods except the primary constructor go into template
+        // methods (except primary constructor) go into template
+        // (non-primary ctors --> auxConstructorBuf / regular defs --> defBuf)
         case _: DefDef if statSym.isPrimaryConstructor => ()
         case _: DefDef if statSym.isConstructor        => auxConstructorBuf += stat
-
-        // other methods go to defBuf
-        // methods with ConstantType result get the corresponding Literal for their RHS
-        case _: DefDef =>
-          val resTp = statSym.info.resultType
-          def mkLiteral(rhs: Tree) = gen.mkAttributedQualifier(resTp) setPos rhs.pos
-
-          val literalized =
-            if (resTp.isInstanceOf[ConstantType] && statSym.info.params.isEmpty) deriveDefDef(stat)(mkLiteral)
-            else stat
-
-          defBuf += literalized
+        case _: DefDef                                 => defBuf += stat
 
         // val defs with constant right-hand sides are eliminated.
         case _: ValDef if statSym.info.isInstanceOf[ConstantType] => ()

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

@@ -582,6 +582,7 @@ abstract class UnCurry extends InfoTransform
           }
 
         case dd @ DefDef(_, _, _, vparamss0, _, rhs0) =>
+          val ddSym = dd.symbol
           val (newParamss, newRhs): (List[List[ValDef]], Tree) =
             if (dependentParamTypeErasure isDependent dd)
               dependentParamTypeErasure erase dd
@@ -593,11 +594,22 @@ abstract class UnCurry extends InfoTransform
               (vparamss1, rhs0)
             }
 
+          // A no-arg method with ConstantType result type can safely be reduced to the corresponding Literal
+          // (only pure methods are typed as ConstantType). We could also do this for methods with arguments,
+          // after ensuring the arguments are not referenced.
+          val literalRhsIfConst =
+            if (newParamss.head.isEmpty) { // We know newParamss.length == 1 from above
+              ddSym.info.resultType match {
+                case tp@ConstantType(value) => Literal(value) setType tp setPos newRhs.pos // inlining of gen.mkAttributedQualifier(tp)
+                case _ => newRhs
+              }
+            } else newRhs
+
           val flatdd = copyDefDef(dd)(
             vparamss = newParamss,
-            rhs = nonLocalReturnKeys get dd.symbol match {
-              case Some(k) => atPos(newRhs.pos)(nonLocalReturnTry(newRhs, k, dd.symbol))
-              case None    => newRhs
+            rhs = nonLocalReturnKeys get ddSym match {
+              case Some(k) => atPos(newRhs.pos)(nonLocalReturnTry(literalRhsIfConst, k, ddSym))
+              case None    => literalRhsIfConst
             }
           )
           addJavaVarargsForwarders(dd, flatdd)