From 7f826e9797cbd35f18c7ff0bb034144d90ed689f Mon Sep 17 00:00:00 2001
From: Miles Sabin <miles@milessabin.com>
Date: Wed, 17 Jul 2019 19:38:43 +0100
Subject: [PATCH 1/6] Mirrors can now be materialized with additional type
 member refinements. Any additional type members will contribute to the
 implicit scope of any searches involving the type of the summoned Mirror. 
 Typically such types will be the singleton types of objects containing
 implicit extension methods for the Mirror, or other related implicit
 definitions.

Pass through all extra refinements
---
 .../dotty/tools/dotc/typer/Implicits.scala    | 40 +++++++++++++++----
 tests/pos/mirror-implicit-scope.scala         | 27 +++++++++++++
 2 files changed, 59 insertions(+), 8 deletions(-)
 create mode 100644 tests/pos/mirror-implicit-scope.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 13908b9b18a3..690e4962266b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -884,14 +884,38 @@ trait Implicits { self: Typer =>
    *
    *     <parent> {
    *       MirroredMonoType = <monoType>
-   *       MirroredTypeConstrictor = <tycon>
-   *       MirroredLabel = <label> }
+   *       MirroredType = <mirroredType>
+   *       MirroredLabel = <label>
+   *       Scope = <scope> // if scope ne NoType
+   *     }
    */
-  private def mirrorCore(parentClass: ClassSymbol, monoType: Type, mirroredType: Type, label: Name)(implicit ctx: Context) = {
-    parentClass.typeRef
+  private def mirrorCore(parentClass: ClassSymbol, monoType: Type, mirroredType: Type, label: Name, extras: List[(Name, Type)])(implicit ctx: Context) = {
+    val m = parentClass.typeRef
       .refinedWith(tpnme.MirroredMonoType, TypeAlias(monoType))
       .refinedWith(tpnme.MirroredType, TypeAlias(mirroredType))
       .refinedWith(tpnme.MirroredLabel, TypeAlias(ConstantType(Constant(label.toString))))
+
+    extras.foldLeft(m) { case (m, (tpnme, tpe)) => m.refinedWith(tpnme, tpe) }
+  }
+
+  private def extraRefinements(formal: Type)(implicit ctx: Context): List[(Name, Type)] = {
+    def isMirrorMember(nme: Name): Boolean =
+      nme == tpnme.MirroredType ||
+      nme == tpnme.MirroredMonoType ||
+      nme == tpnme.MirroredLabel ||
+      nme == tpnme.MirroredElemTypes ||
+      nme == tpnme.MirroredElemLabels
+
+    @tailrec
+    def loop(tp: Type, acc: List[(Name, Type)]): List[(Name, Type)] = tp match {
+      case RefinedType(parent, nme, rhs) if !isMirrorMember(nme) =>
+        loop(parent, (nme, rhs) :: acc)
+      case RefinedType(parent, nme, rhs) =>
+        loop(parent, acc)
+      case other =>
+        acc
+    }
+    loop(formal, Nil)
   }
 
   /** A path referencing the companion of class type `clsType` */
@@ -916,12 +940,12 @@ trait Implicits { self: Typer =>
               val module = mirroredType.termSymbol
               val modulePath = pathFor(mirroredType).withSpan(span)
               if (module.info.classSymbol.is(Scala2x)) {
-                val mirrorType = mirrorCore(defn.Mirror_SingletonProxyClass, mirroredType, mirroredType, module.name)
+                val mirrorType = mirrorCore(defn.Mirror_SingletonProxyClass, mirroredType, mirroredType, module.name, extraRefinements(formal))
                 val mirrorRef = New(defn.Mirror_SingletonProxyClass.typeRef, modulePath :: Nil)
                 mirrorRef.cast(mirrorType)
               }
               else {
-                val mirrorType = mirrorCore(defn.Mirror_SingletonClass, mirroredType, mirroredType, module.name)
+                val mirrorType = mirrorCore(defn.Mirror_SingletonClass, mirroredType, mirroredType, module.name, extraRefinements(formal))
                 modulePath.cast(mirrorType)
               }
             }
@@ -943,7 +967,7 @@ trait Implicits { self: Typer =>
                   (mirroredType, elems)
               }
               val mirrorType =
-                mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, cls.name)
+                mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, cls.name, extraRefinements(formal))
                   .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
                   .refinedWith(tpnme.MirroredElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
               val mirrorRef =
@@ -1024,7 +1048,7 @@ trait Implicits { self: Typer =>
             }
 
             val mirrorType =
-               mirrorCore(defn.Mirror_SumClass, monoType, mirroredType, cls.name)
+               mirrorCore(defn.Mirror_SumClass, monoType, mirroredType, cls.name, extraRefinements(formal))
                 .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
                 .refinedWith(tpnme.MirroredElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
             val mirrorRef =
diff --git a/tests/pos/mirror-implicit-scope.scala b/tests/pos/mirror-implicit-scope.scala
new file mode 100644
index 000000000000..55f365a57b3e
--- /dev/null
+++ b/tests/pos/mirror-implicit-scope.scala
@@ -0,0 +1,27 @@
+import scala.deriving._
+
+object Test {
+  object K0 {
+    type Generic[T] = Mirror { type Scope = K0.type ; type MirroredType = T ; type MirroredElemTypes }
+    given Ops {
+      inline def (gen: Generic[T]) toRepr[T <: Product](t: T): gen.MirroredElemTypes = Tuple.fromProduct(t).asInstanceOf
+    }
+  }
+
+  object K1 {
+    type Generic[F[_]] = Mirror { type Scope = K1.type ; type MirroredType = F ; type MirroredElemTypes[_] }
+    given Ops {
+      inline def (gen: Generic[F]) toRepr[F[_] <: Product, T](t: F[T]): gen.MirroredElemTypes[T] = Tuple.fromProduct(t).asInstanceOf
+    }
+  }
+
+  case class ISB(i: Int, s: String, b: Boolean)
+  val v0 = the[K0.Generic[ISB]]
+  val v1 = v0.toRepr(ISB(23, "foo", true))
+  val v2: (Int, String, Boolean) = v1
+
+  case class Box[T](t: T)
+  val v3 = the[K1.Generic[Box]]
+  val v4 = v3.toRepr(Box(23))
+  val v5: Tuple1[Int] = v4
+}

From f6d4ddba31d80a949655ae0e00393e50360140a1 Mon Sep 17 00:00:00 2001
From: Miles Sabin <miles@milessabin.com>
Date: Thu, 18 Jul 2019 15:15:29 +0100
Subject: [PATCH 2/6] Intersect with formal rather than copying members

---
 .../dotty/tools/dotc/typer/Implicits.scala    | 35 ++++---------------
 1 file changed, 6 insertions(+), 29 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 690e4962266b..6250e2d4aec0 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -889,35 +889,12 @@ trait Implicits { self: Typer =>
    *       Scope = <scope> // if scope ne NoType
    *     }
    */
-  private def mirrorCore(parentClass: ClassSymbol, monoType: Type, mirroredType: Type, label: Name, extras: List[(Name, Type)])(implicit ctx: Context) = {
-    val m = parentClass.typeRef
+  private def mirrorCore(parentClass: ClassSymbol, monoType: Type, mirroredType: Type, label: Name, formal: Type)(implicit ctx: Context) =
+    formal & parentClass.typeRef
       .refinedWith(tpnme.MirroredMonoType, TypeAlias(monoType))
       .refinedWith(tpnme.MirroredType, TypeAlias(mirroredType))
       .refinedWith(tpnme.MirroredLabel, TypeAlias(ConstantType(Constant(label.toString))))
 
-    extras.foldLeft(m) { case (m, (tpnme, tpe)) => m.refinedWith(tpnme, tpe) }
-  }
-
-  private def extraRefinements(formal: Type)(implicit ctx: Context): List[(Name, Type)] = {
-    def isMirrorMember(nme: Name): Boolean =
-      nme == tpnme.MirroredType ||
-      nme == tpnme.MirroredMonoType ||
-      nme == tpnme.MirroredLabel ||
-      nme == tpnme.MirroredElemTypes ||
-      nme == tpnme.MirroredElemLabels
-
-    @tailrec
-    def loop(tp: Type, acc: List[(Name, Type)]): List[(Name, Type)] = tp match {
-      case RefinedType(parent, nme, rhs) if !isMirrorMember(nme) =>
-        loop(parent, (nme, rhs) :: acc)
-      case RefinedType(parent, nme, rhs) =>
-        loop(parent, acc)
-      case other =>
-        acc
-    }
-    loop(formal, Nil)
-  }
-
   /** A path referencing the companion of class type `clsType` */
   private def companionPath(clsType: Type, span: Span)(implicit ctx: Context) = {
     val ref = pathFor(clsType.companionRef)
@@ -940,12 +917,12 @@ trait Implicits { self: Typer =>
               val module = mirroredType.termSymbol
               val modulePath = pathFor(mirroredType).withSpan(span)
               if (module.info.classSymbol.is(Scala2x)) {
-                val mirrorType = mirrorCore(defn.Mirror_SingletonProxyClass, mirroredType, mirroredType, module.name, extraRefinements(formal))
+                val mirrorType = mirrorCore(defn.Mirror_SingletonProxyClass, mirroredType, mirroredType, module.name, formal)
                 val mirrorRef = New(defn.Mirror_SingletonProxyClass.typeRef, modulePath :: Nil)
                 mirrorRef.cast(mirrorType)
               }
               else {
-                val mirrorType = mirrorCore(defn.Mirror_SingletonClass, mirroredType, mirroredType, module.name, extraRefinements(formal))
+                val mirrorType = mirrorCore(defn.Mirror_SingletonClass, mirroredType, mirroredType, module.name, formal)
                 modulePath.cast(mirrorType)
               }
             }
@@ -967,7 +944,7 @@ trait Implicits { self: Typer =>
                   (mirroredType, elems)
               }
               val mirrorType =
-                mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, cls.name, extraRefinements(formal))
+                mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, cls.name, formal)
                   .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
                   .refinedWith(tpnme.MirroredElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
               val mirrorRef =
@@ -1048,7 +1025,7 @@ trait Implicits { self: Typer =>
             }
 
             val mirrorType =
-               mirrorCore(defn.Mirror_SumClass, monoType, mirroredType, cls.name, extraRefinements(formal))
+               mirrorCore(defn.Mirror_SumClass, monoType, mirroredType, cls.name, formal)
                 .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
                 .refinedWith(tpnme.MirroredElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
             val mirrorRef =

From b7841ae8ea2ae26bbec49833765d17f8b2574f08 Mon Sep 17 00:00:00 2001
From: Miles Sabin <miles@milessabin.com>
Date: Fri, 19 Jul 2019 10:23:56 +0100
Subject: [PATCH 3/6] Fixed comment

---
 compiler/src/dotty/tools/dotc/typer/Implicits.scala | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 6250e2d4aec0..84aa28a8b741 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -885,8 +885,7 @@ trait Implicits { self: Typer =>
    *     <parent> {
    *       MirroredMonoType = <monoType>
    *       MirroredType = <mirroredType>
-   *       MirroredLabel = <label>
-   *       Scope = <scope> // if scope ne NoType
+   *       MirroredLabel = <label> }
    *     }
    */
   private def mirrorCore(parentClass: ClassSymbol, monoType: Type, mirroredType: Type, label: Name, formal: Type)(implicit ctx: Context) =

From d96dc21cc7059bb567381b3a61d4bb42e6e1fea1 Mon Sep 17 00:00:00 2001
From: Miles Sabin <miles@milessabin.com>
Date: Fri, 19 Jul 2019 13:33:47 +0100
Subject: [PATCH 4/6] Reject nonsensical refinements and added neg tests

---
 .../dotty/tools/dotc/typer/Implicits.scala    | 150 ++++++++++--------
 tests/neg/mirror-implicit-scope.scala         |  14 ++
 2 files changed, 96 insertions(+), 68 deletions(-)
 create mode 100644 tests/neg/mirror-implicit-scope.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 84aa28a8b741..25d4a51321dc 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -901,6 +901,16 @@ trait Implicits { self: Typer =>
     ref.withSpan(span)
   }
 
+  private def checkFormal(formal: Type)(implicit ctx: Context): Boolean = {
+    @tailrec
+    def loop(tp: Type): Boolean = tp match {
+      case RefinedType(_, _, _: MethodicType) => false
+      case RefinedType(parent, _, _) => loop(parent)
+      case _ => true
+    }
+    loop(formal)
+  }
+
   /** An implied instance for a type of the form `Mirror.Product { type MirroredType = T }`
    *  where `T` is a generic product type or a case object or an enum case.
    */
@@ -955,10 +965,12 @@ trait Implicits { self: Typer =>
         }
       }
 
-      formal.member(tpnme.MirroredType).info match {
-        case TypeBounds(mirroredType, _) => mirrorFor(mirroredType)
-        case other => EmptyTree
-      }
+      if (!checkFormal(formal)) EmptyTree
+      else
+        formal.member(tpnme.MirroredType).info match {
+          case TypeBounds(mirroredType, _) if checkFormal(formal) => mirrorFor(mirroredType)
+          case other => EmptyTree
+        }
     }
 
   /** An implied instance for a type of the form `Mirror.Sum { type MirroredType = T }`
@@ -966,74 +978,76 @@ trait Implicits { self: Typer =>
    */
   lazy val synthesizedSumMirror: SpecialHandler =
     (formal, span) => implicit ctx => {
-      formal.member(tpnme.MirroredType).info match {
-        case TypeBounds(mirroredType0, _) =>
-          val mirroredType = mirroredType0.stripTypeVar
-          if (mirroredType.classSymbol.isGenericSum) {
-            val cls = mirroredType.classSymbol
-            val elemLabels = cls.children.map(c => ConstantType(Constant(c.name.toString)))
-
-            def solve(sym: Symbol): Type = sym match {
-              case caseClass: ClassSymbol =>
-                assert(caseClass.is(Case))
-                if (caseClass.is(Module))
-                  caseClass.sourceModule.termRef
-                else {
-                  caseClass.primaryConstructor.info match {
-                    case info: PolyType =>
-                      // Compute the the full child type by solving the subtype constraint
-                      // `C[X1, ..., Xn] <: P`, where
-                      //
-                      //   - P is the current `mirroredType`
-                      //   - C is the child class, with type parameters X1, ..., Xn
-                      //
-                      // Contravariant type parameters are minimized, all other type parameters are maximized.
-                      def instantiate(implicit ctx: Context) = {
-                        val poly = constrained(info, untpd.EmptyTree)._1
-                        val resType = poly.finalResultType
-                        val target = mirroredType match {
-                          case tp: HKTypeLambda => tp.resultType
-                          case tp => tp
+      if (!checkFormal(formal)) EmptyTree
+      else
+        formal.member(tpnme.MirroredType).info match {
+          case TypeBounds(mirroredType0, _) =>
+            val mirroredType = mirroredType0.stripTypeVar
+            if (mirroredType.classSymbol.isGenericSum) {
+              val cls = mirroredType.classSymbol
+              val elemLabels = cls.children.map(c => ConstantType(Constant(c.name.toString)))
+
+              def solve(sym: Symbol): Type = sym match {
+                case caseClass: ClassSymbol =>
+                  assert(caseClass.is(Case))
+                  if (caseClass.is(Module))
+                    caseClass.sourceModule.termRef
+                  else {
+                    caseClass.primaryConstructor.info match {
+                      case info: PolyType =>
+                        // Compute the the full child type by solving the subtype constraint
+                        // `C[X1, ..., Xn] <: P`, where
+                        //
+                        //   - P is the current `mirroredType`
+                        //   - C is the child class, with type parameters X1, ..., Xn
+                        //
+                        // Contravariant type parameters are minimized, all other type parameters are maximized.
+                        def instantiate(implicit ctx: Context) = {
+                          val poly = constrained(info, untpd.EmptyTree)._1
+                          val resType = poly.finalResultType
+                          val target = mirroredType match {
+                            case tp: HKTypeLambda => tp.resultType
+                            case tp => tp
+                          }
+                          resType <:< target
+                          val tparams = poly.paramRefs
+                          val variances = caseClass.typeParams.map(_.paramVariance)
+                          val instanceTypes = (tparams, variances).zipped.map((tparam, variance) =>
+                            ctx.typeComparer.instanceType(tparam, fromBelow = variance < 0))
+                          resType.substParams(poly, instanceTypes)
                         }
-                        resType <:< target
-                        val tparams = poly.paramRefs
-                        val variances = caseClass.typeParams.map(_.paramVariance)
-                        val instanceTypes = (tparams, variances).zipped.map((tparam, variance) =>
-                          ctx.typeComparer.instanceType(tparam, fromBelow = variance < 0))
-                        resType.substParams(poly, instanceTypes)
-                      }
-                      instantiate(ctx.fresh.setExploreTyperState().setOwner(caseClass))
-                    case _ =>
-                      caseClass.typeRef
+                        instantiate(ctx.fresh.setExploreTyperState().setOwner(caseClass))
+                      case _ =>
+                        caseClass.typeRef
+                    }
                   }
-                }
-              case child => child.termRef
-            }
+                case child => child.termRef
+              }
 
-            val (monoType, elemsType) = mirroredType match {
-              case mirroredType: HKTypeLambda =>
-                val elems = mirroredType.derivedLambdaType(
-                  resType = TypeOps.nestedPairs(cls.children.map(solve))
-                )
-                val AppliedType(tycon, _) = mirroredType.resultType
-                val monoType = AppliedType(tycon, mirroredType.paramInfos)
-                (monoType, elems)
-              case _ =>
-                val elems = TypeOps.nestedPairs(cls.children.map(solve))
-                (mirroredType, elems)
-            }
+              val (monoType, elemsType) = mirroredType match {
+                case mirroredType: HKTypeLambda =>
+                  val elems = mirroredType.derivedLambdaType(
+                    resType = TypeOps.nestedPairs(cls.children.map(solve))
+                  )
+                  val AppliedType(tycon, _) = mirroredType.resultType
+                  val monoType = AppliedType(tycon, mirroredType.paramInfos)
+                  (monoType, elems)
+                case _ =>
+                  val elems = TypeOps.nestedPairs(cls.children.map(solve))
+                  (mirroredType, elems)
+              }
 
-            val mirrorType =
-               mirrorCore(defn.Mirror_SumClass, monoType, mirroredType, cls.name, formal)
-                .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
-                .refinedWith(tpnme.MirroredElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
-            val mirrorRef =
-              if (cls.linkedClass.exists && !cls.is(Scala2x)) companionPath(mirroredType, span)
-              else anonymousMirror(monoType, ExtendsSumMirror, span)
-            mirrorRef.cast(mirrorType)
-          } else EmptyTree
-        case _ => EmptyTree
-      }
+              val mirrorType =
+                 mirrorCore(defn.Mirror_SumClass, monoType, mirroredType, cls.name, formal)
+                  .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
+                  .refinedWith(tpnme.MirroredElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
+              val mirrorRef =
+                if (cls.linkedClass.exists && !cls.is(Scala2x)) companionPath(mirroredType, span)
+                else anonymousMirror(monoType, ExtendsSumMirror, span)
+              mirrorRef.cast(mirrorType)
+            } else EmptyTree
+          case _ => EmptyTree
+        }
     }
 
   /** An implied instance for a type of the form `Mirror { type MirroredType = T }`
diff --git a/tests/neg/mirror-implicit-scope.scala b/tests/neg/mirror-implicit-scope.scala
new file mode 100644
index 000000000000..7bc8abdc19b3
--- /dev/null
+++ b/tests/neg/mirror-implicit-scope.scala
@@ -0,0 +1,14 @@
+import scala.deriving._
+
+object Test {
+  class SomeClass
+  case class ISB(i: Int, s: String, b: Boolean)
+  case class BI(b: Boolean, i: Int)
+
+  val v0 = the[Mirror.ProductOf[ISB]] // OK
+  val v1 = the[SomeClass & Mirror.ProductOf[ISB]] // error
+  val v2 = the[Mirror.ProductOf[ISB] & Mirror.ProductOf[BI]] // error
+  val v3 = the[Mirror.Product { type MirroredType = ISB ; def foo: Int }] // error
+  val v4 = the[Mirror.Product { type MirroredType = ISB ; def foo(i: Int): Int }] // error
+  val v5 = the[Mirror.Product { type MirroredType = ISB ; def foo[T](t: T): T }] // error // error
+}

From 30ec21e0415e6e96afc49a3e2262712c22cbed11 Mon Sep 17 00:00:00 2001
From: Miles Sabin <miles@milessabin.com>
Date: Fri, 19 Jul 2019 16:18:15 +0100
Subject: [PATCH 5/6] Reject all non-type refinements

---
 compiler/src/dotty/tools/dotc/typer/Implicits.scala | 4 ++--
 tests/neg/mirror-implicit-scope.scala               | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 25d4a51321dc..6494b63c20f4 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -904,8 +904,8 @@ trait Implicits { self: Typer =>
   private def checkFormal(formal: Type)(implicit ctx: Context): Boolean = {
     @tailrec
     def loop(tp: Type): Boolean = tp match {
-      case RefinedType(_, _, _: MethodicType) => false
-      case RefinedType(parent, _, _) => loop(parent)
+      case RefinedType(parent, _, _: TypeBounds) => loop(parent)
+      case RefinedType(_, _, _) => false
       case _ => true
     }
     loop(formal)
diff --git a/tests/neg/mirror-implicit-scope.scala b/tests/neg/mirror-implicit-scope.scala
index 7bc8abdc19b3..8ffb500d1077 100644
--- a/tests/neg/mirror-implicit-scope.scala
+++ b/tests/neg/mirror-implicit-scope.scala
@@ -11,4 +11,5 @@ object Test {
   val v3 = the[Mirror.Product { type MirroredType = ISB ; def foo: Int }] // error
   val v4 = the[Mirror.Product { type MirroredType = ISB ; def foo(i: Int): Int }] // error
   val v5 = the[Mirror.Product { type MirroredType = ISB ; def foo[T](t: T): T }] // error // error
+  val v6 = the[Mirror.Product { type MirroredType = ISB ; val foo: Int }] // error
 }

From b2e3e0f33515a2875a08929d7583a2652f75d497 Mon Sep 17 00:00:00 2001
From: Miles Sabin <miles@milessabin.com>
Date: Mon, 22 Jul 2019 10:07:38 +0100
Subject: [PATCH 6/6] Remove redundant guard

---
 compiler/src/dotty/tools/dotc/typer/Implicits.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 6494b63c20f4..6bd6276cd803 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -968,7 +968,7 @@ trait Implicits { self: Typer =>
       if (!checkFormal(formal)) EmptyTree
       else
         formal.member(tpnme.MirroredType).info match {
-          case TypeBounds(mirroredType, _) if checkFormal(formal) => mirrorFor(mirroredType)
+          case TypeBounds(mirroredType, _) => mirrorFor(mirroredType)
           case other => EmptyTree
         }
     }