From a4594ddc496cb4599188ce047cf783aa92465288 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Fri, 14 Oct 2016 12:25:55 +0200
Subject: [PATCH] Fix #1515: Don't narrow gadt bounds when frozen

Fixes #1515. Review by @smarter.
---
 src/dotty/tools/dotc/core/TypeComparer.scala | 43 ++++++++++----------
 tests/pos/i1515.scala                        | 16 ++++++++
 2 files changed, 38 insertions(+), 21 deletions(-)
 create mode 100644 tests/pos/i1515.scala

diff --git a/src/dotty/tools/dotc/core/TypeComparer.scala b/src/dotty/tools/dotc/core/TypeComparer.scala
index b495f00d00e1..1980fe50df91 100644
--- a/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -965,28 +965,29 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
    *  Test that the resulting bounds are still satisfiable.
    */
   private def narrowGADTBounds(tr: NamedType, bound: Type, isUpper: Boolean): Boolean =
-    ctx.mode.is(Mode.GADTflexible) && {
-    val tparam = tr.symbol
-    typr.println(i"narrow gadt bound of $tparam: ${tparam.info} from ${if (isUpper) "above" else "below"} to $bound ${bound.isRef(tparam)}")
-    if (bound.isRef(tparam)) false
-    else bound match {
-      case bound: TypeRef
-      if bound.symbol.is(BindDefinedType) && ctx.gadt.bounds.contains(bound.symbol) &&
-         !tr.symbol.is(BindDefinedType) =>
-        // Avoid having pattern-bound types in gadt bounds,
-        // as these might be eliminated once the pattern is typechecked.
-        // Pattern-bound type symbols should be narrowed first, only if that fails
-        // should symbols in the environment be constrained.
-        narrowGADTBounds(bound, tr, !isUpper)
-      case _ =>
-        val oldBounds = ctx.gadt.bounds(tparam)
-        val newBounds =
-          if (isUpper) TypeBounds(oldBounds.lo, oldBounds.hi & bound)
-          else TypeBounds(oldBounds.lo | bound, oldBounds.hi)
-        isSubType(newBounds.lo, newBounds.hi) &&
-        { ctx.gadt.setBounds(tparam, newBounds); true }
+    ctx.mode.is(Mode.GADTflexible) && !frozenConstraint && {
+      val tparam = tr.symbol
+      typr.println(i"narrow gadt bound of $tparam: ${tparam.info} from ${if (isUpper) "above" else "below"} to $bound ${bound.isRef(tparam)}")
+      if (bound.isRef(tparam)) false
+      else bound match {
+        case bound: TypeRef
+        if bound.symbol.is(BindDefinedType) &&
+           ctx.gadt.bounds.contains(bound.symbol) &&
+           !tr.symbol.is(BindDefinedType) =>
+          // Avoid having pattern-bound types in gadt bounds,
+          // as these might be eliminated once the pattern is typechecked.
+          // Pattern-bound type symbols should be narrowed first, only if that fails
+          // should symbols in the environment be constrained.
+          narrowGADTBounds(bound, tr, !isUpper)
+        case _ =>
+          val oldBounds = ctx.gadt.bounds(tparam)
+          val newBounds =
+            if (isUpper) TypeBounds(oldBounds.lo, oldBounds.hi & bound)
+            else TypeBounds(oldBounds.lo | bound, oldBounds.hi)
+          isSubType(newBounds.lo, newBounds.hi) &&
+            { ctx.gadt.setBounds(tparam, newBounds); true }
+      }
     }
-  }
 
   // Tests around `matches`
 
diff --git a/tests/pos/i1515.scala b/tests/pos/i1515.scala
new file mode 100644
index 000000000000..fb3ad78ee63d
--- /dev/null
+++ b/tests/pos/i1515.scala
@@ -0,0 +1,16 @@
+sealed trait Trait[T]
+
+final case class Case[T](e: T) extends Trait[T]
+
+object Demo {
+  def main(args: Array[String]): Unit = {
+
+    def f[H](t: Trait[H]): Unit =
+      t match {
+        case Case(e) => println(Some(e))
+      }
+
+    f(Case(1))
+
+  }
+}