Fold selection of unary ops

Author: som-snytt

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

@@ -55,13 +55,13 @@ abstract class ConstantFolder {
     }
 
   /** If tree is a constant operation, replace with result. */
-  def apply(tree: Tree, site: Symbol): Tree = {
+  def apply(tree: Tree, site: Symbol): Tree = if (isPastTyper) tree else
     try {
       tree match {
-        case Apply(Select(FoldableTerm(x), op), List(FoldableTerm(y))) => fold(tree, foldBinop(op, x, y), true)
-        case Apply(Select(ConstantTerm(x), op), List(ConstantTerm(y))) => fold(tree, foldBinop(op, x, y), false)
-        case Select(FoldableTerm(x), op) => fold(tree, foldUnop(op, x), true)
-        case Select(ConstantTerm(x), op) => fold(tree, foldUnop(op, x), false)
+        case Apply(Select(FoldableTerm(x), op), List(FoldableTerm(y))) => fold(tree, foldBinop(op, x, y), foldable = true)
+        case Apply(Select(ConstantTerm(x), op), List(ConstantTerm(y))) => fold(tree, foldBinop(op, x, y), foldable = false)
+        case Select(FoldableTerm(x), op) => fold(tree, foldUnop(op, x), foldable = true)
+        case Select(ConstantTerm(x), op) => fold(tree, foldUnop(op, x), foldable = false)
         case _ => tree
       }
     } catch {
@@ -70,39 +70,39 @@ abstract class ConstantFolder {
           runReporting.warning(tree.pos, s"Evaluation of a constant expression results in an arithmetic error: ${e.getMessage}", WarningCategory.LintConstant, site)
         tree
     }
-  }
 
-  /** If tree is a constant value that can be converted to type `pt`, perform
-   *  the conversion.
+  /** If tree is a constant value that can be converted to type `pt`, perform the conversion.
    */
   def apply(tree: Tree, pt: Type, site: Symbol): Tree = {
     val orig = apply(tree, site)
     orig.tpe match {
-      case tp@ConstantType(x) => fold(orig, x convertTo pt, isConstantType(tp))
+      case tp@ConstantType(x) => fold(orig, x.convertTo(pt), foldable = isConstantType(tp))
       case _ => orig
     }
   }
 
+  /** Set the computed constant type.
+   */
   private def fold(orig: Tree, folded: Constant, foldable: Boolean): Tree =
     if ((folded eq null) || folded.tag == UnitTag) orig
-    else if(foldable) orig setType FoldableConstantType(folded)
+    else if (foldable) orig setType FoldableConstantType(folded)
     else orig setType LiteralType(folded)
 
   private def foldUnop(op: Name, x: Constant): Constant = (op, x.tag) match {
     case (nme.UNARY_!, BooleanTag) => Constant(!x.booleanValue)
 
-    case (nme.UNARY_~ , IntTag    ) => Constant(~x.intValue)
-    case (nme.UNARY_~ , LongTag   ) => Constant(~x.longValue)
+    case (nme.UNARY_~, IntTag    ) => Constant(~x.intValue)
+    case (nme.UNARY_~, LongTag   ) => Constant(~x.longValue)
 
-    case (nme.UNARY_+ , IntTag    ) => Constant(+x.intValue)
-    case (nme.UNARY_+ , LongTag   ) => Constant(+x.longValue)
-    case (nme.UNARY_+ , FloatTag  ) => Constant(+x.floatValue)
-    case (nme.UNARY_+ , DoubleTag ) => Constant(+x.doubleValue)
+    case (nme.UNARY_+, IntTag    ) => Constant(+x.intValue)
+    case (nme.UNARY_+, LongTag   ) => Constant(+x.longValue)
+    case (nme.UNARY_+, FloatTag  ) => Constant(+x.floatValue)
+    case (nme.UNARY_+, DoubleTag ) => Constant(+x.doubleValue)
 
-    case (nme.UNARY_- , IntTag    ) => Constant(-x.intValue)
-    case (nme.UNARY_- , LongTag   ) => Constant(-x.longValue)
-    case (nme.UNARY_- , FloatTag  ) => Constant(-x.floatValue)
-    case (nme.UNARY_- , DoubleTag ) => Constant(-x.doubleValue)
+    case (nme.UNARY_-, IntTag    ) => Constant(-x.intValue)
+    case (nme.UNARY_-, LongTag   ) => Constant(-x.longValue)
+    case (nme.UNARY_-, FloatTag  ) => Constant(-x.floatValue)
+    case (nme.UNARY_-, DoubleTag ) => Constant(-x.doubleValue)
 
     case _ => null
   }

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

@@ -5453,7 +5453,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
                 )
               case _ =>
                 if (settings.lintUniversalMethods && qualTp.widen.eq(UnitTpe)) checkDubiousUnitSelection(result)
-                result
+                if (isConstantType(qualTp) && nme.isEncodedUnary(name)) constfold(result, context.owner)
+                else result
             }
           }
         }

test/files/pos/t12792.scala

@@ -0,0 +1,28 @@
+
+// scalac: -Werror -Xlint
+
+import annotation._
+
+object Foo {
+  final val w = 1 << (java.lang.Integer.SIZE - 1)
+  final val x = 1 << (java.lang.Integer.SIZE - 2)
+  final val y = 1 << (java.lang.Integer.SIZE - 3)
+  final val z = 1 << (java.lang.Integer.SIZE - 4)
+  final val c = 0xffffffff & ~w & ~x & ~y & ~z
+
+  final val i = +42   // 42.unary_+
+  final val j = -27   // literal -42
+}
+
+class Ann(value: Int) extends ConstantAnnotation
+class Byt(value: Byte) extends ConstantAnnotation
+
+class Test {
+  import Foo._
+  @Ann(w) def fw = 42
+  @Ann(x) def fx = 42
+  @Ann(c) def fc = 42
+  @Ann(i) def fi = 42
+  @Ann(j) def fj = 42
+  @Byt(42) def byteMe = 42
+}