Fix #8404: Use both scrutinee type and given type in pattern ascriptions

In a pattern ascription `x: T` type `x` to have the intersection of
the given type `T` and the scrutinee type. This matches scalac's behavior.
It now makes i5418.scala compile. The type intersection was enough to make
that one compile, it did not need unsound covariant GADT matching (which was
what I claimed before in the issue).

Author: odersky

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

@@ -1573,8 +1573,20 @@ class Typer extends Namer
           // for a singleton pattern like `x @ Nil`, `x` should get the type from the scrutinee
           // see tests/neg/i3200b.scala and SI-1503
           val symTp =
-            if (body1.tpe.isInstanceOf[TermRef]) pt1
-            else body1.tpe.underlyingIfRepeated(isJava = false)
+            if body1.tpe.isInstanceOf[TermRef] then pt1
+            else if isWildcardStarArg(body1)
+                    || pt1 == defn.ImplicitScrutineeTypeRef
+                    || body1.tpe <:< pt  // There is some strange interaction with gadt matching.
+                                         // and implicit scopes.
+                                         // run/t2755.scala fails to compile if this subtype test is omitted
+                                         // and the else clause is changed to `body1.tpe & pt1`. What
+                                         // happens is that we get either an Array[Float] or an Array[T]
+                                         // where T is GADT constrained to := Float. But the case body
+                                         // compiles only if the bound variable is Array[Float]. If
+                                         // it is Array[T] we get an implicit not found. To avoid fragility
+                                         // wrt to operand order for `&`, we include the explicit subtype test here.
+            then body1.tpe
+            else pt1 & body1.tpe
           val sym = ctx.newPatternBoundSymbol(name, symTp, tree.span)
           if (pt == defn.ImplicitScrutineeTypeRef || tree.mods.is(Given)) sym.setFlag(Given)
           if (ctx.mode.is(Mode.InPatternAlternative))

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -44,7 +44,7 @@ class CompilationTests extends ParallelTesting {
       compileFile("tests/pos-special/sourcepath/outer/nested/Test4.scala", defaultOptions.and("-sourcepath", "tests/pos-special/sourcepath")),
       compileFilesInDir("tests/pos-special/fatal-warnings", defaultOptions.and("-Xfatal-warnings", "-feature")),
       compileFilesInDir("tests/pos-special/spec-t5545", defaultOptions),
-      compileFilesInDir("tests/pos-special/strawman-collections", defaultOptions),
+      compileFilesInDir("tests/pos-special/strawman-collections", allowDeepSubtypes),
       compileFilesInDir("tests/pos-special/isInstanceOf", allowDeepSubtypes.and("-Xfatal-warnings")),
       compileFilesInDir("tests/new", defaultOptions),
       compileFilesInDir("tests/pos-scala2", scala2CompatMode),

tests/neg/i5418.scala renamed to tests/pos/i5418.scala

@@ -0,0 +1,10 @@
+trait ActorRefScope
+class ActorRef
+case class DeathWatchNotification(actor: ActorRef)
+object Main {
+  val ref: ActorRef = ???
+  ref match {
+    case r: ActorRefScope => DeathWatchNotification(r)
+    case _ =>
+  }
+}