Make singleton typecase patterns and type checks consistent

compiler/src/dotty/tools/dotc/transform/FirstTransform.scala

@@ -144,7 +144,14 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   }
 
   override def transformIdent(tree: Ident)(implicit ctx: Context): Tree =
-    if (tree.isType) toTypeTree(tree) else constToLiteral(tree)
+    if (tree.isType) {
+      toTypeTree(tree)
+    } else if (tree.name != nme.WILDCARD) {
+      // We want to constant-fold _some_ idents here - for instance, @switch needs to see literals in patterns.
+      // However, constant-foldable wildcards can occur in patterns, for instance as `case _: "a"`;
+      // we avoid constant-folding those as doing so would change the meaning of the pattern.
+      constToLiteral(tree)
+    } else tree
 
   override def transformSelect(tree: Select)(implicit ctx: Context): Tree =
     if (tree.isType) toTypeTree(tree) else constToLiteral(tree)
@@ -156,7 +163,9 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
     constToLiteral(foldCondition(tree))
 
   override def transformTyped(tree: Typed)(implicit ctx: Context): Tree =
-    constToLiteral(tree)
+    // Singleton type cases (such as `case _: "a"`) are constant-foldable
+    // we avoid constant-folding those as doing so would change the meaning of the pattern
+    if (!ctx.mode.is(Mode.Pattern)) constToLiteral(tree) else tree
 
   override def transformBlock(tree: Block)(implicit ctx: Context): Tree =
     constToLiteral(tree)

tests/run/i6996.check

@@ -0,0 +1,3 @@
+an `a`
+false
+not `a`

tests/run/i6996.scala

@@ -0,0 +1,14 @@
+object Test {
+
+  def isAType(arg: String): Unit = arg match {    
+    case _ : "a" => println("an `a`")
+    case _ => println("not `a`")
+  }
+
+  def main(args: Array[String]): Unit = {
+    isAType("a")
+    println(new String("a").isInstanceOf["a"])
+    isAType(new String("a"))
+  }
+
+}