Fix scala#11178: remove unsound tweak for F-bounds

This reverts scala#9789. We have made several improvements to F-bounds,
the unsound tweak is no longer needed.

Author: liufengyun

compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala

@@ -73,7 +73,7 @@ trait PatternTypeConstrainer { self: TypeComparer =>
    *  scrutinee and pattern types. This does not apply if the pattern type is only applied to type variables,
    *  in which case the subtyping relationship "heals" the type.
    */
-  def constrainPatternType(pat: Type, scrut: Type): Boolean = trace(i"constrainPatternType($scrut, $pat)", gadts) {
+  def constrainPatternType(pat: Type, scrut: Type, widenParams: Boolean = true): Boolean = trace(i"constrainPatternType($scrut, $pat)", gadts) {
 
     def classesMayBeCompatible: Boolean = {
       import Flags._
@@ -135,7 +135,7 @@ trait PatternTypeConstrainer { self: TypeComparer =>
             case _ => NoType
           }
           if (upcasted.exists)
-            constrainSimplePatternType(pat, upcasted) || constrainUpcasted(upcasted)
+            constrainSimplePatternType(pat, upcasted, widenParams) || constrainUpcasted(upcasted)
           else true
       }
     }
@@ -155,7 +155,7 @@ trait PatternTypeConstrainer { self: TypeComparer =>
         case pat: RefinedOrRecType =>
           constrainPatternType(stripRefinement(pat), scrut)
         case pat =>
-          constrainSimplePatternType(pat, scrut) || classesMayBeCompatible && constrainUpcasted(scrut)
+          constrainSimplePatternType(pat, scrut, widenParams) || classesMayBeCompatible && constrainUpcasted(scrut)
       }
     }
   }
@@ -194,7 +194,7 @@ trait PatternTypeConstrainer { self: TypeComparer =>
    *  case classes without also appropriately extending the relevant case class
    *  (see `RefChecks#checkCaseClassInheritanceInvariant`).
    */
-  def constrainSimplePatternType(patternTp: Type, scrutineeTp: Type): Boolean = {
+  def constrainSimplePatternType(patternTp: Type, scrutineeTp: Type, widenParams: Boolean): Boolean = {
     def refinementIsInvariant(tp: Type): Boolean = tp match {
       case tp: ClassInfo => tp.cls.is(Final) || tp.cls.is(Case)
       case tp: TypeProxy => refinementIsInvariant(tp.underlying)
@@ -213,7 +213,8 @@ trait PatternTypeConstrainer { self: TypeComparer =>
 
     val widePt =
       if migrateTo3 || refinementIsInvariant(patternTp) then scrutineeTp
-      else widenVariantParams(scrutineeTp)
+      else if widenParams then widenVariantParams(scrutineeTp)
+      else scrutineeTp
     val narrowTp = SkolemType(patternTp)
     trace(i"constraining simple pattern type $narrowTp <:< $widePt", gadts, res => s"$res\ngadt = ${ctx.gadt.debugBoundsDescription}") {
       isSubType(narrowTp, widePt)

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -2687,8 +2687,8 @@ object TypeComparer {
   def dropTransparentTraits(tp: Type, bound: Type)(using Context): Type =
     comparing(_.dropTransparentTraits(tp, bound))
 
-  def constrainPatternType(pat: Type, scrut: Type)(using Context): Boolean =
-    comparing(_.constrainPatternType(pat, scrut))
+  def constrainPatternType(pat: Type, scrut: Type, widenParams: Boolean = true)(using Context): Boolean =
+    comparing(_.constrainPatternType(pat, scrut, widenParams))
 
   def explained[T](op: ExplainingTypeComparer => T, header: String = "Subtype trace:")(using Context): String =
     comparing(_.explained(op, header))

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

@@ -77,19 +77,6 @@ object TypeTestsCasts {
       }
     }.apply(tp)
 
-    /** Approximate type parameters depending on variance */
-    def stripTypeParam(tp: Type)(using Context) = new ApproximatingTypeMap {
-      val boundTypeParams = util.HashMap[TypeRef, TypeVar]()
-      def apply(tp: Type): Type = tp match {
-        case _: MatchType =>
-          tp // break cycles
-        case tp: TypeRef if !tp.symbol.isClass =>
-          boundTypeParams.getOrElseUpdate(tp, newTypeVar(tp.underlying.toBounds))
-        case _ =>
-          mapOver(tp)
-      }
-    }.apply(tp)
-
     /** Returns true if the type arguments of `P` can be determined from `X` */
     def typeArgsTrivial(X: Type, P: AppliedType)(using Context) = inContext(ctx.fresh.setExploreTyperState().setFreshGADTBounds) {
       val AppliedType(tycon, _) = P
@@ -102,6 +89,7 @@ object TypeTestsCasts {
       val tvars = constrained(typeLambda, untpd.EmptyTree, alwaysAddTypeVars = true)._2.map(_.tpe)
       val P1 = tycon.appliedTo(tvars)
 
+      debug.println("before " + ctx.typerState.constraint.show)
       debug.println("P : " + P.show)
       debug.println("P1 : " + P1.show)
       debug.println("X : " + X.show)
@@ -111,18 +99,23 @@ object TypeTestsCasts {
       // conforms to the type skeleton pre.F[_]. Then it goes on to check
       // if P1 <: P, which means the type arguments in P are trivial,
       // thus no runtime checks are needed for them.
-      P1 <:< X
+      withMode(Mode.GadtConstraintInference) {
+        TypeComparer.constrainPatternType(P1, X, widenParams = false)
+        debug.println(TypeComparer.explained(_.constrainPatternType(P1, X, widenParams = false)))
+        true
+      }
 
       // Maximization of the type means we try to cover all possible values
       // which conform to the skeleton pre.F[_] and X. Then we have to make
       // sure all of them are actually of the type P, which implies that the
       // type arguments in P are trivial (no runtime check needed).
       maximizeType(P1, span, fromScala2x = false)
 
+      debug.println("after " + ctx.typerState.constraint.show)
+
       val res = P1 <:< P
 
       debug.println(TypeComparer.explained(_.isSubType(P1, P)))
-
       debug.println("P1 : " + P1.show)
       debug.println("P1 <:< P = " + res)
 
@@ -151,10 +144,8 @@ object TypeTestsCasts {
           case _ =>
             // always false test warnings are emitted elsewhere
             X.classSymbol.exists && P.classSymbol.exists &&
-              !X.classSymbol.asClass.mayHaveCommonChild(P.classSymbol.asClass) ||
-            // first try without striping type parameters for performance
-            typeArgsTrivial(X, tpe) ||
-            typeArgsTrivial(stripTypeParam(X), tpe)
+              !X.classSymbol.asClass.mayHaveCommonChild(P.classSymbol.asClass)
+            || typeArgsTrivial(X, tpe)
         }
       case AndType(tp1, tp2)    => recur(X, tp1) && recur(X, tp2)
       case OrType(tp1, tp2)     => recur(X, tp1) && recur(X, tp2)

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -746,7 +746,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         tpd.Closure(meth, tss => xCheckMacroedOwners(xCheckMacroValidExpr(rhsFn(meth, tss.head.map(withDefaultPos))), meth))
 
       def unapply(tree: Block): Option[(List[ValDef], Term)] = tree match {
-        case Block((ddef @ DefDef(_, TermParamClause(params) :: Nil, _, Some(body))) :: Nil, Closure(meth, _))
+        case Block((ddef @ DefDef(_, tpd.ValDefs(params) :: Nil, _, Some(body))) :: Nil, Closure(meth, _))
         if ddef.symbol == meth.symbol =>
           Some((params, body))
         case _ => None

tests/neg-custom-args/isInstanceOf/i11178.scala

@@ -0,0 +1,39 @@
+trait Box[+T]
+case class Foo[+S](s: S) extends Box[S]
+
+def unwrap2[A](b: Box[A]): A =
+  b match
+  case _: Foo[Int] => 0 // error
+
+object Test1 {
+  // Invariant case, OK
+  sealed trait Bar[A]
+
+  def test[A](bar: Bar[A]) =
+    bar match {
+      case _: Bar[Boolean] => ??? // error
+      case _ => ???
+    }
+}
+
+object Test2 {
+  // Covariant case
+  sealed trait Bar[+A]
+
+  def test[A](bar: Bar[A]) =
+    bar match {
+      case _: Bar[Boolean] => ??? // error
+      case _ => ???
+    }
+}
+
+object Test3 {
+  // Contravariant case
+  sealed trait Bar[-A]
+
+  def test[A](bar: Bar[A]) =
+    bar match {
+      case _: Bar[Boolean] => ??? // error
+      case _ => ???
+    }
+}