Extracting TypedCases to be reused for typedTry

1 files changed, 39 insertions, 35 deletions

diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 1afa5f9f3..42b973eed 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -590,47 +590,51 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         val selType = widenForMatchSelector(
             fullyDefinedType(sel1.tpe, "pattern selector", tree.pos))
 
-        /** gadtSyms = "all type parameters of enclosing methods that appear
-         *              non-variantly in the selector type" todo: should typevars
-         *              which appear with variances +1 and -1 (in different
-         *              places) be considered as well?
-         */
-        val gadtSyms: Set[Symbol] = ctx.traceIndented(i"GADT syms of $selType", gadts) {
-          val accu = new TypeAccumulator[Set[Symbol]] {
-            def apply(tsyms: Set[Symbol], t: Type): Set[Symbol] = {
-              val tsyms1 = t match {
-                case tr: TypeRef if (tr.symbol is TypeParam) && tr.symbol.owner.isTerm && variance == 0 =>
-                  tsyms + tr.symbol
-                case _ =>
-                  tsyms
-              }
-              foldOver(tsyms1, t)
-            }
-          }
-          accu(Set.empty, selType)
-        }
-
-        val cases1 = tree.cases mapconserve (typedCase(_, pt, selType, gadtSyms))
+        val cases1 = typedCases(tree.cases, selType, pt)
         assignType(cpy.Match(tree)(sel1, cases1), cases1)
     }
   }
 
-  def typedCase(tree: untpd.CaseDef, pt: Type, selType: Type, gadtSyms: Set[Symbol])(implicit ctx: Context): CaseDef = track("typedCase") {
-    def caseRest(pat: Tree)(implicit ctx: Context) = {
-      gadtSyms foreach (_.resetGADTFlexType)
-      pat foreachSubTree {
-        case b: Bind =>
-          if (ctx.scope.lookup(b.name) == NoSymbol) ctx.enter(b.symbol)
-          else ctx.error(d"duplicate pattern variable: ${b.name}", b.pos)
-        case _ =>
+  def typedCases(cases: List[untpd.CaseDef], selType: Type, pt: Type)(implicit ctx: Context) = {
+
+    /** gadtSyms = "all type parameters of enclosing methods that appear
+      *              non-variantly in the selector type" todo: should typevars
+      *              which appear with variances +1 and -1 (in different
+      *              places) be considered as well?
+      */
+    val gadtSyms: Set[Symbol] = ctx.traceIndented(i"GADT syms of $selType", gadts) {
+      val accu = new TypeAccumulator[Set[Symbol]] {
+        def apply(tsyms: Set[Symbol], t: Type): Set[Symbol] = {
+          val tsyms1 = t match {
+            case tr: TypeRef if (tr.symbol is TypeParam) && tr.symbol.owner.isTerm && variance == 0 =>
+              tsyms + tr.symbol
+            case _ =>
+              tsyms
+          }
+          foldOver(tsyms1, t)
+        }
+      }
+      accu(Set.empty, selType)
+    }
+
+    def typedCase(tree: untpd.CaseDef): CaseDef = track("typedCase") {
+      def caseRest(pat: Tree)(implicit ctx: Context) = {
+        gadtSyms foreach (_.resetGADTFlexType)
+        pat foreachSubTree {
+          case b: Bind =>
+            if (ctx.scope.lookup(b.name) == NoSymbol) ctx.enter(b.symbol)
+            else ctx.error(d"duplicate pattern variable: ${b.name}", b.pos)
+          case _ =>
+        }
+        val guard1 = typedExpr(tree.guard, defn.BooleanType)
+        val body1 = typedExpr(tree.body, pt)
+        assignType(cpy.CaseDef(tree)(pat, guard1, body1), body1)
       }
-      val guard1 = typedExpr(tree.guard, defn.BooleanType)
-      val body1 = typedExpr(tree.body, pt)
-      assignType(cpy.CaseDef(tree)(pat, guard1, body1), body1)
+      val doCase: () => CaseDef =
+        () => caseRest(typedPattern(tree.pat, selType))(ctx.fresh.setNewScope)
+      (doCase /: gadtSyms)((op, tsym) => tsym.withGADTFlexType(op))()
     }
-    val doCase: () => CaseDef =
-      () => caseRest(typedPattern(tree.pat, selType))(ctx.fresh.setNewScope)
-    (doCase /: gadtSyms)((op, tsym) => tsym.withGADTFlexType(op))()
+    cases mapconserve typedCase
   }
 
   def typedReturn(tree: untpd.Return)(implicit ctx: Context): Return = track("typedReturn") {