Removed redundant case and inlined RHSs

Author: milessabin

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

@@ -936,7 +936,6 @@ trait Implicits { self: Typer =>
       }
 
       formal.member(tpnme.MirroredType).info match {
-        case TypeAlias(mirroredType) => mirrorFor(mirroredType)
         case TypeBounds(mirroredType, _) => mirrorFor(mirroredType)
         case other => EmptyTree
       }
@@ -947,76 +946,72 @@ trait Implicits { self: Typer =>
    */
   lazy val synthesizedSumMirror: SpecialHandler =
     (formal: Type, span: Span) => implicit (ctx: Context) => {
-      def mirrorFor(mirroredType0: Type): Tree = {
-        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
+      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
-          }
-
-          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)
-          }
+              case child => child.termRef
+            }
 
-          val mirrorType =
-             mirrorCore(defn.Mirror_SumType, monoType, mirroredType, cls.name)
-              .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
-      }
+            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)
+            }
 
-      formal.member(tpnme.MirroredType).info match {
-        case TypeAlias(mirroredType) => mirrorFor(mirroredType)
-        case TypeBounds(mirroredType, _) => mirrorFor(mirroredType)
+            val mirrorType =
+               mirrorCore(defn.Mirror_SumType, monoType, mirroredType, cls.name)
+                .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
       }
     }
@@ -1026,15 +1021,12 @@ trait Implicits { self: Typer =>
    */
   lazy val synthesizedMirror: SpecialHandler =
     (formal: Type, span: Span) => implicit (ctx: Context) => {
-      def mirrorFor(mirroredType: Type): Tree =
-        if (mirroredType.termSymbol.is(CaseVal) || mirroredType.classSymbol.isGenericProduct)
-          synthesizedProductMirror(formal, span)(ctx)
-        else
-          synthesizedSumMirror(formal, span)(ctx)
-
       formal.member(tpnme.MirroredType).info match {
-        case TypeAlias(mirroredType) => mirrorFor(mirroredType)
-        case TypeBounds(mirroredType, _) => mirrorFor(mirroredType)
+        case TypeBounds(mirroredType, _) =>
+          if (mirroredType.termSymbol.is(CaseVal) || mirroredType.classSymbol.isGenericProduct)
+            synthesizedProductMirror(formal, span)(ctx)
+          else
+            synthesizedSumMirror(formal, span)(ctx)
         case _ => EmptyTree
       }
     }