Allow generic literals in patterns

Wrap generic literals in patterns in blocks, which force
expression evaluation. This allows to match (say) a scrutinee
of BigInt type against large numeric literals. But it does
not work if the scrutinee is of type `Any` because then
the expeected type for the pattern is missing.

This would be addressed by a feature that's still missing: patterns
of the form `<literal> : <type>`. We have to change the syntax of patterns
in general for this one.

Author: odersky

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -347,9 +347,11 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       Typ(pat.tpe.stripAnnots, false)
     case EmptyTree =>         // default rethrow clause of try/catch, check tests/patmat/try2.scala
       Typ(WildcardType, false)
+    case Block(Nil, expr) =>
+      project(expr)
     case _ =>
-      ctx.error(s"unknown pattern: $pat", pat.sourcePos)
-      Empty
+      // Pattern is an arbitrary expression; assume a skolem (i.e. an unknown value) of the pattern type
+      Typ(pat.tpe.narrow, false)
   }
 
   private def unapplySeqInfo(resTp: Type, pos: SourcePosition)(implicit ctx: Context): (Int, Type, Type) = {

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -550,7 +550,9 @@ class Typer extends Namer
               case Whole(r) if r != 10 => Literal(Constant(r)) :: Nil
               case _ => Nil
             }
-            return typed(untpd.Apply(fromDigits, firstArg :: otherArgs), pt)
+            var app: untpd.Tree = untpd.Apply(fromDigits, firstArg :: otherArgs)
+            if (ctx.mode.is(Mode.Pattern)) app = untpd.Block(Nil, app)
+            return typed(app, pt)
           case _ =>
         }
       }
@@ -765,7 +767,8 @@ class Typer extends Namer
     (index(stats), typedStats(stats, ctx.owner))
 
   def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context): Tree = track("typedBlock") {
-    val (exprCtx, stats1) = typedBlockStats(tree.stats)
+    val localCtx = ctx.retractMode(Mode.Pattern)
+    val (exprCtx, stats1) = typedBlockStats(tree.stats) given localCtx
     val expr1 = typedExpr(tree.expr, pt.dropIfProto)(exprCtx)
     ensureNoLocalRefs(
       cpy.Block(tree)(stats1, expr1).withType(expr1.tpe), pt, localSyms(stats1))

tests/run/genericNumLits.scala

@@ -26,4 +26,24 @@ object Test extends App {
   catch {
     case ex: FromDigits.MalformedNumber => println("malformed")
   }
+
+  val N = 10
+
+  x match {
+    case 13232202002020202020202 => ()
+  }
+  y match {
+    case 13232202002020202020202 => assert(false)
+    case -0xaabb12345ACF12345AC => ()
+  }
+  z match {
+    case 132322020020.223 => ()
+  }
+  z match {
+    case 132322020020.223 => ()
+  }
+
+  e match {
+    case 1234 =>
+  }
 }