synth PartialFunction in uncurry

due to interaction with the CPS plugin, can't synth PartialFun during typer
(the types don't work out: in PartialFun[T, U @cps[V]], U @cps[V] does not conform to Any, and we can't move the annot from the type arg directly to applyOrElse's result,
since then it won't override anything)

thus, we face the pain of mangling labeldefs again

resetLocalAttrsKeepLabels can't use leaveAlone

don't cast matcherror throw, uncurry gets confused

uncurry: cast selector valdef's rhs to avoid skolem mismatch

NOTE: I'm not happy about this code, but I don't know
how to make the clean way (typedMatchAnonFun) compatible with the CPS plugin
one avenue to explor would be to introduce PartialFunCPS,
which is transformed into a regular PartialFun
when T @cps[U] is turned into ControlContext[T, U]

5 files changed, 188 insertions, 99 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
index e566384713..d3e64811d3 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -72,14 +72,6 @@ abstract class TreeGen extends reflect.internal.TreeGen with TreeDSL {
     Annotated(Ident(nme.synthSwitch), expr)
   }
 
-  // must be kept in synch with the codegen in PatMatVirtualiser
-  object VirtualCaseDef {
-    def unapply(b: Block): Option[(Assign, Tree, Tree)] = b match {
-      case Block(List(assign@Assign(keepGoingLhs, falseLit), matchRes), zero) => Some((assign, matchRes, zero)) // TODO: check tree annotation
-      case _ => None
-    }
-  }
-
   def hasSynthCaseSymbol(t: Tree) = (t.symbol ne null) && (t.symbol hasFlag (CASE | SYNTHETIC))
 
   // TODO: would be so much nicer if we would know during match-translation (i.e., type checking)
@@ -87,9 +79,11 @@ abstract class TreeGen extends reflect.internal.TreeGen with TreeDSL {
   class MatchMatcher {
     def caseMatch(orig: Tree, selector: Tree, cases: List[CaseDef], wrap: Tree => Tree): Tree = unknownTree(orig)
     def caseVirtualizedMatch(orig: Tree, _match: Tree, targs: List[Tree], scrut: Tree, matcher: Tree): Tree = unknownTree(orig)
-    def caseVirtualizedMatchOpt(orig: Tree, zero: ValDef, x: ValDef, matchRes: ValDef, keepGoing: ValDef, stats: List[Tree], epilogue: Tree, wrap: Tree => Tree): Tree = unknownTree(orig)
+    def caseVirtualizedMatchOpt(orig: Tree, prologue: List[Tree], cases: List[Tree], matchEndDef: Tree, wrap: Tree => Tree): Tree = unknownTree(orig)
 
-    def apply(matchExpr: Tree): Tree = (matchExpr: @unchecked) match {
+    def genVirtualizedMatch(prologue: List[Tree], cases: List[Tree], matchEndDef: Tree): Tree = Block(prologue ++ cases, matchEndDef)
+
+    def apply(matchExpr: Tree): Tree = matchExpr match {
       // old-style match or virtpatmat switch
       case Match(selector, cases) => // println("simple match: "+ (selector, cases) + "for:\n"+ matchExpr )
         caseMatch(matchExpr, selector, cases, identity)
@@ -100,11 +94,15 @@ abstract class TreeGen extends reflect.internal.TreeGen with TreeDSL {
       case Apply(Apply(TypeApply(Select(tgt, nme.runOrElse), targs), List(scrut)), List(matcher)) if opt.virtPatmat => // println("virt match: "+ (tgt, targs, scrut, matcher) + "for:\n"+ matchExpr )
         caseVirtualizedMatch(matchExpr, tgt, targs, scrut, matcher)
       // optimized version of virtpatmat
-      case Block((zero: ValDef) :: (x: ValDef) :: (matchRes: ValDef) :: (keepGoing: ValDef) :: stats, epilogue) if opt.virtPatmat => // TODO: check tree annotation // println("virtopt match: "+ (zero, x, matchRes, keepGoing, stats) + "for:\n"+ matchExpr )
-        caseVirtualizedMatchOpt(matchExpr, zero, x, matchRes, keepGoing, stats, epilogue, identity)
+      case Block(stats, matchEndDef) if opt.virtPatmat && (stats forall hasSynthCaseSymbol) =>
+        // the assumption is once we encounter a case, the remainder of the block will consist of cases
+        // the prologue may be empty, usually it is the valdef that stores the scrut
+        val (prologue, cases) = stats span (s => !s.isInstanceOf[LabelDef])
+        caseVirtualizedMatchOpt(matchExpr, prologue, cases, matchEndDef, identity)
       // optimized version of virtpatmat
-      case Block(outerStats, orig@Block((zero: ValDef) :: (x: ValDef) :: (matchRes: ValDef) :: (keepGoing: ValDef) :: stats, epilogue)) if opt.virtPatmat => // TODO: check tree annotation // println("virt opt block match: "+ (zero, x, matchRes, keepGoing, stats, outerStats) + "for:\n"+ matchExpr )
-        caseVirtualizedMatchOpt(matchExpr, zero, x, matchRes, keepGoing, stats, epilogue, m => copyBlock(matchExpr, outerStats, m))
+      case Block(outerStats, orig@Block(stats, matchEndDef)) if opt.virtPatmat && (stats forall hasSynthCaseSymbol) =>
+        val (prologue, cases) = stats span (s => !s.isInstanceOf[LabelDef])
+        caseVirtualizedMatchOpt(matchExpr, prologue, cases, matchEndDef, m => copyBlock(matchExpr, outerStats, m))
       case other =>
         unknownTree(other)
     }
@@ -120,35 +118,6 @@ abstract class TreeGen extends reflect.internal.TreeGen with TreeDSL {
            }
   }
 
-  def withDefaultCase(matchExpr: Tree, defaultAction: Tree/*scrutinee*/ => Tree): Tree = {
-    object withDefaultTransformer extends MatchMatcher {
-      override def caseMatch(orig: Tree, selector: Tree, cases: List[CaseDef], wrap: Tree => Tree): Tree = {
-        val casesNoSynthCatchAll = dropSyntheticCatchAll(cases)
-        if (casesNoSynthCatchAll exists treeInfo.isDefaultCase) orig
-        else {
-          val defaultCase = CaseDef(Ident(nme.WILDCARD), EmptyTree, defaultAction(selector.duplicate))
-          wrap(Match(selector, casesNoSynthCatchAll :+ defaultCase))
-        }
-      }
-      override def caseVirtualizedMatch(orig: Tree, _match: Tree, targs: List[Tree], scrut: Tree, matcher: Tree): Tree = { import CODE._
-        ((matcher APPLY (scrut)) DOT nme.getOrElse) APPLY (defaultAction(scrut.duplicate)) // TODO: pass targs
-      }
-      override def caseVirtualizedMatchOpt(orig: Tree, zero: ValDef, x: ValDef, matchRes: ValDef, keepGoing: ValDef, stats: List[Tree], epilogue: Tree, wrap: Tree => Tree): Tree = { import CODE._
-        wrap(Block(
-          zero ::
-          x ::
-          matchRes ::
-          keepGoing ::
-          stats,
-          // replace `if (keepGoing) throw new MatchError(...) else matchRes` by `if (keepGoing) ${defaultAction(`x`)} else matchRes`
-          (IF (REF(keepGoing.symbol)) THEN defaultAction(x.rhs.duplicate) ELSE REF(matchRes.symbol))
-        ))
-      }
-    }
-    withDefaultTransformer(matchExpr)
-  }
-
-
   def mkCached(cvar: Symbol, expr: Tree): Tree = {
     val cvarRef = mkUnattributedRef(cvar)
     Block(
diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala
index 59e36e86f6..04452c68e5 100644
--- a/src/compiler/scala/tools/nsc/ast/Trees.scala
+++ b/src/compiler/scala/tools/nsc/ast/Trees.scala
@@ -255,6 +255,7 @@ trait Trees extends reflect.internal.Trees { self: Global =>
 
   def resetAllAttrs[A <: Tree](x: A, leaveAlone: Tree => Boolean = null): A = new ResetAttrs(false, leaveAlone).transform(x)
   def resetLocalAttrs[A <: Tree](x: A, leaveAlone: Tree => Boolean = null): A = new ResetAttrs(true, leaveAlone).transform(x)
+  def resetLocalAttrsKeepLabels[A<:Tree](x: A, leaveAlone: Tree => Boolean = null): A = new ResetAttrs(true, leaveAlone, true).transform(x)
 
   /** A transformer which resets symbol and tpe fields of all nodes in a given tree,
    *  with special treatment of:
@@ -265,7 +266,7 @@ trait Trees extends reflect.internal.Trees { self: Global =>
    *
    *  (bq:) This transformer has mutable state and should be discarded after use
    */
-  private class ResetAttrs(localOnly: Boolean, leaveAlone: Tree => Boolean = null) {
+  private class ResetAttrs(localOnly: Boolean, leaveAlone: Tree => Boolean = null, keepLabels: Boolean = false) {
     val debug = settings.debug.value
     val trace = scala.tools.nsc.util.trace when debug
 
@@ -328,18 +329,18 @@ trait Trees extends reflect.internal.Trees { self: Global =>
               case EmptyTree =>
                 tree
               case _ =>
-                if (tree.hasSymbol && (!localOnly || (locals contains tree.symbol)))
+                if (tree.hasSymbol && (!localOnly || (locals contains tree.symbol)) && !(keepLabels && tree.symbol.isLabel))
                   tree.symbol = NoSymbol
                 tree.tpe = null
                 tree
             }
           }
-        }
+      }
     }
 
     def transform[T <: Tree](x: T): T = {
       if (localOnly)
-        new MarkLocals().traverse(x)
+      new MarkLocals().traverse(x)
 
       if (localOnly && debug) {
         assert(locals.size == orderedLocals.size)
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 1d2206bc3d..57cd51ad35 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -241,7 +241,6 @@ abstract class UnCurry extends InfoTransform
           def owner     = fun.symbol.owner
           def targs     = fun.tpe.typeArgs
           def isPartial = fun.tpe.typeSymbol == PartialFunctionClass
-          assert(!(opt.virtPatmat && isPartial)) // empty-selector matches have already been translated into instantiations of anonymous (partial) functions
 
           def parents =
             if (isFunctionType(fun.tpe)) List(abstractFunctionForFunctionType(fun.tpe), SerializableClass.tpe)
@@ -282,7 +281,44 @@ abstract class UnCurry extends InfoTransform
 
             val substParam = new TreeSymSubstituter(fun.vparams map (_.symbol), List(x))
             val body = localTyper.typedPos(fun.pos) { import CODE._
-              gen.mkUncheckedMatch(gen.withDefaultCase(substParam(fun.body), scrut => REF(default) APPLY (REF(x))))
+              def defaultAction(scrut: Tree) = REF(default) APPLY (REF(x))
+
+              object withDefaultTransformer extends gen.MatchMatcher {
+                override def caseMatch(orig: Tree, selector: Tree, cases: List[CaseDef], wrap: Tree => Tree): Tree = {
+                  val casesNoSynthCatchAll = dropSyntheticCatchAll(cases)
+                  if (casesNoSynthCatchAll exists treeInfo.isDefaultCase) orig
+                  else {
+                    val defaultCase = CaseDef(Ident(nme.WILDCARD), EmptyTree, defaultAction(selector.duplicate))
+                    wrap(Match(/*gen.mkUnchecked*/(selector), casesNoSynthCatchAll :+ defaultCase))
+                  }
+                }
+                override def caseVirtualizedMatch(orig: Tree, _match: Tree, targs: List[Tree], scrut: Tree, matcher: Tree): Tree = { import CODE._
+                  ((matcher APPLY (scrut)) DOT nme.getOrElse) APPLY (defaultAction(scrut.duplicate)) // TODO: pass targs
+                }
+                override def caseVirtualizedMatchOpt(orig: Tree, prologue: List[Tree], cases: List[Tree], matchEndDef: Tree, wrap: Tree => Tree): Tree = { import CODE._
+                  val scrutRef = REF(prologue.head.symbol) // scrut valdef is always emitted (except for nested matchers that handle alternatives)
+
+                  val casesNewSynthCatchAll = cases.init :+ (deriveLabelDef(cases.last){
+                    case Apply(matchEnd, List(Throw(Apply(Select(New(exTpt), nme.CONSTRUCTOR), _)))) if exTpt.tpe.typeSymbol eq MatchErrorClass =>
+                      assert(matchEnd.symbol == matchEndDef.symbol, "matchEnd discrepancy "+(matchEnd, matchEndDef))
+                      matchEnd APPLY (defaultAction(scrutRef))
+                    case x => x
+                  } setSymbol cases.last.symbol setType null)
+
+                  val LabelDef(_, List(matchRes), rhs) = matchEndDef
+                  val matchEnd = matchEndDef.symbol
+                  matchRes setType B1.tpe
+                  rhs setType B1.tpe
+                  matchEndDef setType B1.tpe
+                  matchRes.symbol setInfo B1.tpe
+                  matchEnd setInfo MethodType(List(matchRes.symbol), B1.tpe)
+                  cases foreach (c => c.symbol setInfo MethodType(List(), B1.tpe))
+
+                  wrap(Block(prologue ++ casesNewSynthCatchAll, matchEndDef))
+                }
+              }
+
+              withDefaultTransformer(substParam(fun.body))
             }
             body.changeOwner(fun.symbol -> methSym)
 
@@ -294,30 +330,115 @@ abstract class UnCurry extends InfoTransform
             methDef
           }
 
-          // duplicate before applyOrElseMethodDef is run so we start with the same symbols as applyOrElseMethodDef
+          // duplicate before applyOrElseMethodDef is run so that it does not mess up our trees and label symbols (we have a fresh set)
           // otherwise `TreeSymSubstituter(fun.vparams map (_.symbol), params)` won't work as the subst has been run already
-          val bodyForIDA = fun.body.duplicate
+          val bodyForIDA = {
+            val duped   = fun.body.duplicate
+            val oldParams = new mutable.ListBuffer[Symbol]()
+            val newParams = new mutable.ListBuffer[Symbol]()
+
+            val oldSyms0 =
+              duped filter {
+                case l@LabelDef(_, params, _) =>
+                  params foreach {p =>
+                    val oldSym = p.symbol
+                    p.symbol = oldSym.cloneSymbol
+                    oldParams += oldSym
+                    newParams += p.symbol
+                  }
+                  true
+                case _ => false
+              } map (_.symbol)
+            val oldSyms = oldParams.toList ++ oldSyms0
+            val newSyms = newParams.toList ++ (oldSyms0 map (_.cloneSymbol))
+            // println("duping "+ oldSyms +" --> "+ (newSyms map (_.ownerChain)))
+
+            val substLabels = new TreeSymSubstituter(oldSyms, newSyms)
+
+            substLabels(duped)
+          }
+
           def isDefinedAtMethodDef = {
             val methSym = anonClass.newMethod(nme.isDefinedAt, fun.pos, FINAL)
             val params  = methSym newSyntheticValueParams formals
             methSym setInfoAndEnter MethodType(params, BooleanClass.tpe)
 
             val substParam = new TreeSymSubstituter(fun.vparams map (_.symbol), params)
-            def doSubst(x: Tree) = substParam(resetLocalAttrs(x)) // see pos/t1761 for why `resetLocalAttrs`
+            def doSubst(x: Tree) = substParam(resetLocalAttrsKeepLabels(x)) // see pos/t1761 for why `resetLocalAttrs`, but must keep label symbols around
+
             object isDefinedAtTransformer extends gen.MatchMatcher {
               // TODO: optimize duplication, but make sure ValDef's introduced by wrap are treated correctly
               override def caseMatch(orig: Tree, selector: Tree, cases: List[CaseDef], wrap: Tree => Tree): Tree = { import CODE._
-                gen.mkUncheckedMatch(
-                  if (cases exists treeInfo.isDefaultCase) TRUE_typed
+                val casesNoSynthCatchAll = dropSyntheticCatchAll(cases)
+                  if (casesNoSynthCatchAll exists treeInfo.isDefaultCase) TRUE_typed
                   else
                     doSubst(wrap(
-                        Match(selector,
-                            (cases map (c => deriveCaseDef(c)(x => TRUE_typed))) :+ (
+                        Match(/*gen.mkUnchecked*/(selector),
+                            (casesNoSynthCatchAll map (c => deriveCaseDef(c)(x => TRUE_typed))) :+ (
                             DEFAULT ==> FALSE_typed)
                         )))
-                )
+              }
+              override def caseVirtualizedMatch(orig: Tree, _match: Tree, targs: List[Tree], scrut: Tree, matcher: Tree): Tree = {
+                object noOne extends Transformer {
+                  override val treeCopy = newStrictTreeCopier // must duplicate everything
+                  val one = _match.tpe member newTermName("one")
+                  override def transform(tree: Tree): Tree = tree match {
+                    case Apply(fun, List(a)) if fun.symbol == one =>
+                      // blow one's argument away since all we want to know is whether the match succeeds or not
+                      // (the alternative, making `one` CBN, would entail moving away from Option)
+                      Apply(fun.duplicate, List(gen.mkZeroContravariantAfterTyper(a.tpe)))
+                    case _ =>
+                      super.transform(tree)
+                  }
+                }
+                doSubst(Apply(Apply(TypeApply(Select(_match.duplicate, _match.tpe.member(newTermName("isSuccess"))), targs map (_.duplicate)), List(scrut.duplicate)), List(noOne.transform(matcher))))
+              }
+
+              override def caseVirtualizedMatchOpt(orig: Tree, prologue: List[Tree], cases: List[Tree], matchEndDef: Tree, wrap: Tree => Tree) = {
+                val matchEnd                       = matchEndDef.symbol
+                val LabelDef(_, List(matchRes), rhs) = matchEndDef
+                matchRes setType BooleanClass.tpe
+                rhs setType BooleanClass.tpe
+                matchEndDef setType BooleanClass.tpe
+                matchRes.symbol setInfo BooleanClass.tpe
+                matchEnd setInfo MethodType(List(matchRes.symbol), BooleanClass.tpe)
+                cases foreach (c => c.symbol setInfo MethodType(List(), BooleanClass.tpe))
+                // println("matchEnd: "+ matchEnd)
+
+                // when the type of the selector contains a skolem owned by the applyOrElseMethod, should reskolemize everything,
+                // for now, just cast the RHS (since we're just trying to keep the typer happy, the cast is meaningless)
+                // ARGH -- this is why I would prefer the typedMatchAnonFun approach (but alas, CPS blocks that)
+                val newPrologue = prologue match {
+                  case List(vd@ValDef(mods, name, tpt, rhs)) => List(treeCopy.ValDef(vd, mods, name, tpt, gen.mkAsInstanceOf(rhs, tpt.tpe, true, false)))
+                  case _ => prologue
+                }
+                object casesReturnTrue extends Transformer {
+                  // override val treeCopy = newStrictTreeCopier // will duplicate below
+                  override def transform(tree: Tree): Tree = tree match {
+                    // don't compute the result of the match, return true instead
+                    case Apply(fun, List(res)) if fun.symbol eq matchEnd =>
+                      // println("matchend call "+ fun.symbol)
+                      Apply(fun, List(TRUE_typed)) setType BooleanClass.tpe
+                    case _ => super.transform(tree)
+                  }
+                }
+                val newCatchAll = cases.last match {
+                  case LabelDef(n, ps, Apply(matchEnd1, List(Throw(Apply(Select(New(exTpt), nme.CONSTRUCTOR), _))))) if exTpt.tpe.typeSymbol eq MatchErrorClass =>
+                    assert(matchEnd1.symbol == matchEnd, "matchEnd discrepancy "+(matchEnd, matchEndDef))
+                    List(treeCopy.LabelDef(cases.last, n, ps, matchEnd APPLY (FALSE_typed)) setSymbol cases.last.symbol)
+                  case x => Nil
+                }
+                val casesWithoutCatchAll = if(newCatchAll.isEmpty) cases else cases.init
+                doSubst(wrap(Block(newPrologue ++ casesReturnTrue.transformTrees(casesWithoutCatchAll) ++ newCatchAll, matchEndDef)))
+
+                // val duped = idaBlock //.duplicate // TODO: duplication of labeldefs is BROKEN
+                // duped foreach {
+                //   case l@LabelDef(name, params, rhs) if gen.hasSynthCaseSymbol(l) => println("newInfo"+ l.symbol.info)
+                //   case _ =>
+                // }
               }
             }
+
             val body = isDefinedAtTransformer(bodyForIDA)
             body.changeOwner(fun.symbol -> methSym)
 
@@ -328,11 +449,14 @@ abstract class UnCurry extends InfoTransform
             if (isPartial) List(applyOrElseMethodDef, isDefinedAtMethodDef)
             else List(applyMethodDef)
 
-          localTyper.typedPos(fun.pos) {
+          // println("MEMBERS "+ members)
+          val res = localTyper.typedPos(fun.pos) {
             Block(
               List(ClassDef(anonClass, NoMods, List(List()), List(List()), members, fun.pos)),
               Typed(New(anonClass.tpe), TypeTree(fun.tpe)))
           }
+          // println("MEMBERS TYPED "+ members)
+          res
         }
 
     def transformArgs(pos: Position, fun: Symbol, args: List[Tree], formals: List[Type]) = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala b/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala
index e8e65071af..313818a9d4 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatMatVirtualiser.scala
@@ -1650,7 +1650,11 @@ class Foo(x: Other) { x._1 } // no error in this order
 
         def catchAll = matchFailGen map { matchFailGen =>
           val scrutRef = if(scrutSym ne NoSymbol) REF(scrutSym) else EmptyTree // for alternatives
-          LabelDef(nextCase, Nil, matchEnd APPLY (_asInstanceOf(matchFailGen(scrutRef), restpe))) // need to jump to matchEnd with result generated by matchFailGen (could be `FALSE` for isDefinedAt)
+          // must jump to matchEnd, use result generated by matchFailGen (could be `FALSE` for isDefinedAt)
+          LabelDef(nextCase, Nil, matchEnd APPLY (matchFailGen(scrutRef)))
+          // don't cast the arg to matchEnd when using PartialFun synth in uncurry, since it won't detect the throw (see gen.withDefaultCase)
+          // the cast is necessary when using typedMatchAnonFun-style PartialFun synth:
+          // (_asInstanceOf(matchFailGen(scrutRef), restpe))
         } toList
         // catchAll.isEmpty iff no synthetic default case needed (the (last) user-defined case is a default)
         // if the last user-defined case is a default, it will never jump to the next case; it will go immediately to matchEnd
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index a6893ff4b2..c4eb43c427 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -2193,7 +2193,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
 
     def adaptCase(cdef: CaseDef, mode: Int, tpe: Type): CaseDef = deriveCaseDef(cdef)(adapt(_, mode, tpe))
 
-    def prepareTranslateMatch(selector0: Tree, cases: List[CaseDef], mode: Int, resTp: Type) = {
+    def typedMatch(selector0: Tree, cases: List[CaseDef], mode: Int, resTp: Type) = {
       val (selector, doTranslation) = selector0 match {
         case Annotated(Ident(nme.synthSwitch), selector) => (selector, false)
         case s => (s, true)
@@ -2210,7 +2210,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
       (selector1, selectorTp, casesAdapted, ownType, doTranslation)
     }
 
-    def translateMatch(selector1: Tree, selectorTp: Type, casesAdapted: List[CaseDef], ownType: Type, doTranslation: Boolean, matchFailGen: Option[Tree => Tree] = None) = {
+    def translatedMatch(selector1: Tree, selectorTp: Type, casesAdapted: List[CaseDef], ownType: Type, doTranslation: Boolean, matchFailGen: Option[Tree => Tree] = None) = {
       def repeatedToSeq(tp: Type): Type = (tp baseType RepeatedParamClass) match {
         case TypeRef(_, RepeatedParamClass, arg :: Nil) => seqType(arg)
         case _                                          => tp
@@ -2220,7 +2220,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         Match(selector1, casesAdapted) setType ownType // setType of the Match to avoid recursing endlessly
       } else {
         val scrutType = repeatedToSeq(elimAnonymousClass(selectorTp))
-        // we've packed the type for each case in prepareTranslateMatch so that if all cases have the same existential case, we get a clean lub
+        // we've packed the type for each case in typedMatch so that if all cases have the same existential case, we get a clean lub
         // here, we should open up the existential again
         // relevant test cases: pos/existentials-harmful.scala, pos/gadt-gilles.scala, pos/t2683.scala, pos/virtpatmat_exist4.scala
         MatchTranslator(this).translateMatch(selector1, casesAdapted, repeatedToSeq(ownType.skolemizeExistential(context.owner, context.tree)), scrutType, matchFailGen)
@@ -2283,7 +2283,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           val methodBodyTyper = newTyper(context.makeNewScope(context.tree, methodSym)) // should use the DefDef for the context's tree, but it doesn't exist yet (we need the typer we're creating to create it)
           paramSyms foreach (methodBodyTyper.context.scope enter _)
 
-          val (selector1, selectorTp, casesAdapted, resTp, doTranslation) = methodBodyTyper.prepareTranslateMatch(selector, cases, mode, ptRes)
+          val (selector1, selectorTp, casesAdapted, resTp, doTranslation) = methodBodyTyper.typedMatch(selector, cases, mode, ptRes)
 
           val methFormals = paramSyms map (_.tpe)
           val parents = List(abstractFunctionType(methFormals, resTp), SerializableClass.tpe)
@@ -2291,7 +2291,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           anonClass setInfo ClassInfoType(parents, newScope, anonClass)
           methodSym setInfoAndEnter MethodType(paramSyms, resTp)
 
-          DefDef(methodSym, methodBodyTyper.translateMatch(selector1, selectorTp, casesAdapted, resTp, doTranslation))
+          DefDef(methodSym, methodBodyTyper.translatedMatch(selector1, selectorTp, casesAdapted, resTp, doTranslation))
         }
       }
 
@@ -2321,7 +2321,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           val methodBodyTyper = newTyper(context.makeNewScope(context.tree, methodSym)) // should use the DefDef for the context's tree, but it doesn't exist yet (we need the typer we're creating to create it)
           paramSyms foreach (methodBodyTyper.context.scope enter _)
 
-          val (selector1, selectorTp, casesAdapted, resTp, doTranslation) = methodBodyTyper.prepareTranslateMatch(selector, cases, mode, ptRes)
+          val (selector1, selectorTp, casesAdapted, resTp, doTranslation) = methodBodyTyper.typedMatch(selector, cases, mode, ptRes)
 
           anonClass setInfo ClassInfoType(parents(List(argTp, resTp)), newScope, anonClass)
           B1 setInfo TypeBounds.lower(resTp)
@@ -2330,7 +2330,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           // use applyOrElse's first parameter since the scrut's type has been widened
           def doDefault(scrut_ignored: Tree) = REF(default) APPLY (REF(x))
 
-          val body = methodBodyTyper.translateMatch(selector1, selectorTp, casesAdapted, B1.tpe, doTranslation, Some(doDefault))
+          val body = methodBodyTyper.translatedMatch(selector1, selectorTp, casesAdapted, B1.tpe, doTranslation, Some(doDefault))
 
           DefDef(methodSym, body)
         }
@@ -2345,8 +2345,8 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           paramSyms foreach (methodBodyTyper.context.scope enter _)
           methodSym setInfoAndEnter MethodType(paramSyms, BooleanClass.tpe)
 
-          val (selector1, selectorTp, casesAdapted, resTp, doTranslation) = methodBodyTyper.prepareTranslateMatch(selector, casesTrue, mode, BooleanClass.tpe)
-          val body = methodBodyTyper.translateMatch(selector1, selectorTp, casesAdapted, resTp, doTranslation, Some(scrutinee => FALSE_typed))
+          val (selector1, selectorTp, casesAdapted, resTp, doTranslation) = methodBodyTyper.typedMatch(selector, casesTrue, mode, BooleanClass.tpe)
+          val body = methodBodyTyper.translatedMatch(selector1, selectorTp, casesAdapted, resTp, doTranslation, Some(scrutinee => FALSE_typed))
 
           DefDef(methodSym, body)
         }
@@ -2407,29 +2407,21 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           }
         }
 
-        fun.body match {
-          case Match(sel, cases) if opt.virtPatmat =>
-            // go to outer context -- must discard the context that was created for the Function since we're discarding the function
-            // thus, its symbol, which serves as the current context.owner, is not the right owner
-            // you won't know you're using the wrong owner until lambda lift crashes (unless you know better than to use the wrong owner)
-            newTyper(context.outer).typedMatchAnonFun(fun, cases, mode, pt, Some((fun.vparams, sel)))
-          case _ =>
-            val vparamSyms = fun.vparams map { vparam =>
-              enterSym(context, vparam)
-              if (context.retyping) context.scope enter vparam.symbol
-              vparam.symbol
-            }
-            val vparams = fun.vparams mapConserve (typedValDef)
-    //        for (vparam <- vparams) {
-    //          checkNoEscaping.locals(context.scope, WildcardType, vparam.tpt); ()
-    //        }
-            val formals = vparamSyms map (_.tpe)
-            val body1 = typed(fun.body, respt)
-            val restpe = packedType(body1, fun.symbol).deconst.resultType
-            val funtpe = typeRef(clazz.tpe.prefix, clazz, formals :+ restpe)
-    //        body = checkNoEscaping.locals(context.scope, restpe, body)
-            treeCopy.Function(fun, vparams, body1).setType(funtpe)
+        val vparamSyms = fun.vparams map { vparam =>
+          enterSym(context, vparam)
+          if (context.retyping) context.scope enter vparam.symbol
+          vparam.symbol
         }
+        val vparams = fun.vparams mapConserve (typedValDef)
+//        for (vparam <- vparams) {
+//          checkNoEscaping.locals(context.scope, WildcardType, vparam.tpt); ()
+//        }
+        val formals = vparamSyms map (_.tpe)
+        val body1 = typed(fun.body, respt)
+        val restpe = packedType(body1, fun.symbol).deconst.resultType
+        val funtpe = typeRef(clazz.tpe.prefix, clazz, formals :+ restpe)
+//        body = checkNoEscaping.locals(context.scope, restpe, body)
+        treeCopy.Function(fun, vparams, body1).setType(funtpe)
       }
     }
 
@@ -3797,13 +3789,9 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         }
       }
 
-      def typedMatch(tree: Tree, selector: Tree, cases: List[CaseDef]): Tree = {
-        if (opt.virtPatmat && !isPastTyper) {
-          if (selector ne EmptyTree) {
-            val (selector1, selectorTp, casesAdapted, ownType, doTranslation) = prepareTranslateMatch(selector, cases, mode, pt)
-            typed(translateMatch(selector1, selectorTp, casesAdapted, ownType, doTranslation), mode, pt)
-          } else typedMatchAnonFun(tree, cases, mode, pt)
-        } else if (selector == EmptyTree) {
+      // translation only happens when (selector != EmptyTree) && !isPastTyper && opt.virtPatmat
+      def typedTranslatedMatch(tree: Tree, selector: Tree, cases: List[CaseDef]): Tree = {
+        if (selector == EmptyTree) {
           val arity = if (isFunctionType(pt)) pt.normalize.typeArgs.length - 1 else 1
           val params = for (i <- List.range(0, arity)) yield
             atPos(tree.pos.focusStart) {
@@ -3814,7 +3802,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           val selector1 = atPos(tree.pos.focusStart) { if (arity == 1) ids.head else gen.mkTuple(ids) }
           val body = treeCopy.Match(tree, selector1, cases)
           typed1(atPos(tree.pos) { Function(params, body) }, mode, pt)
-        } else {
+        } else if (!opt.virtPatmat || isPastTyper) {
           val selector1 = checkDead(typed(selector, EXPRmode | BYVALmode, WildcardType))
           var cases1 = typedCases(cases, packCaptured(selector1.tpe.widen), pt)
           val (owntype, needAdapt) = ptOrLub(cases1 map (_.tpe))
@@ -3822,6 +3810,9 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
             cases1 = cases1 map (adaptCase(_, mode, owntype))
           }
           treeCopy.Match(tree, selector1, cases1) setType owntype
+        } else {
+          val (selector1, selectorTp, casesAdapted, ownType, doTranslation) = typedMatch(selector, cases, mode, pt)
+          typed(translatedMatch(selector1, selectorTp, casesAdapted, ownType, doTranslation), mode, pt)
         }
       }
 
@@ -4681,7 +4672,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
           typedIf(cond, thenp, elsep)
 
         case tree @ Match(selector, cases) =>
-          typedMatch(tree, selector, cases)
+          typedTranslatedMatch(tree, selector, cases)
 
         case Return(expr) =>
           typedReturn(expr)