Follow TermRefs when constant folding

A TermRef representing a constant value needs to be
considered a constant when folding.

src/dotty/tools/dotc/core/Types.scala

@@ -715,6 +715,14 @@ object Types {
       case _ => this
     }
 
+    /** Widen from TermRef to its underlying non-termref
+     *  base type, while also skipping Expr types.
+     */
+    final def widenTermRefExpr(implicit ctx: Context): Type = stripTypeVar match {
+      case tp: TermRef if !tp.isOverloaded => tp.underlying.widenExpr.widenTermRefExpr
+      case _ => this
+    }
+
     /** Widen from ExprType type to its result type.
      *  (Note: no stripTypeVar needed because TypeVar's can't refer to ExprTypes.)
      */

src/dotty/tools/dotc/typer/ConstFold.scala

@@ -20,16 +20,16 @@ object ConstFold {
   def apply(tree: Tree)(implicit ctx: Context): Tree = finish(tree) {
     tree match {
       case Apply(Select(xt, op), yt :: Nil) =>
-        xt.tpe match {
+        xt.tpe.widenTermRefExpr match {
           case ConstantType(x) =>
-            yt.tpe match {
+            yt.tpe.widenTermRefExpr match {
               case ConstantType(y) => foldBinop(op, x, y)
               case _ => null
             }
           case _ => null
         }
       case Select(xt, op) =>
-        xt.tpe match {
+        xt.tpe.widenTermRefExpr match {
           case ConstantType(x) => foldUnop(op, x)
           case _ => null
         }
@@ -42,7 +42,7 @@ object ConstFold {
    */
   def apply(tree: Tree, pt: Type)(implicit ctx: Context): Tree =
     finish(apply(tree)) {
-      tree.tpe match {
+      tree.tpe.widenTermRefExpr match {
         case ConstantType(x) => x convertTo pt
         case _ => null
       }