Pattern matcher: extractors become name-based.

An extractor is no longer required to return Option[T], and
can instead return anything which directly contains methods
with these signatures:

  def isEmpty: Boolean
  def get: T

If the type of get contains methods with the names of
product selectors (_1, _2, etc.) then the type and arity
of the extraction is inferred from the type of get. If
it does not contain _1, then it is a single value
extractor analogous like Option[T].

This has significant benefits and opens new territory:

  - an AnyVal based Option-like class can be used which
    leverages null as None, and no allocations are necessary
  - for primitive types the benefit is squared (see below)
  - the performance difference between case classes and
    extractors should now be largely eliminated
  - this in turn allows us to recapture great swaths of
    memory which are currently squandered (e.g. every
    TypeRef has fields for pre and args, even though these
    are more than half the time NoPrefix and Nil)

Here is a primitive example:

  final class OptInt(val x: Int) extends AnyVal {
    def get: Int = x
    def isEmpty = x == Int.MinValue // or whatever is appropriate
  }
  // This boxes TWICE: Int => Integer => Some(Integer)
  def unapply(x: Int): Option[Int]
  // This boxes NONCE
  def unapply(x: Int): OptInt

As a multi-value example, after I contribute some methods to TypeRef:

  def isEmpty = false
  def get     = this
  def _1      = pre
  def _2      = sym
  def _3      = args

Then it's extractor becomes

  def unapply(x: TypeRef) = x

Which, it need hardly be said, involves no allocations.

1 files changed, 198 insertions, 220 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala b/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala
index 990de0ca1f..13926ca18b 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala
@@ -38,6 +38,13 @@ trait PatternTypers {
   import global._
   import definitions._
 
+  private object FixedAndRepeatedTypes {
+    def unapply(types: List[Type]) = types match {
+      case init :+ last if isRepeatedParamType(last) => Some((init, dropRepeated(last)))
+      case _                                         => Some((types, NoType))
+    }
+  }
+
   // when true:
   //  - we may virtualize matches (if -Xexperimental and there's a suitable __match in scope)
   //  - we synthesize PartialFunction implementations for `x => x match {...}` and `match {...}` when the expected type is PartialFunction
@@ -52,75 +59,118 @@ trait PatternTypers {
 
     private def unit = context.unit
 
-    /** Type trees in `args0` against corresponding expected type in `adapted0`.
-     *
-     * The mode in which each argument is typed is derived from `mode` and
-     * whether the arg was originally by-name or var-arg (need `formals0` for that)
-     * the default is by-val, of course.
-     *
-     * (docs reverse-engineered -- AM)
-     */
-    def typedArgs(args0: List[Tree], mode: Mode, formals0: List[Type], adapted0: List[Type]): List[Tree] = {
-      def loop(args: List[Tree], formals: List[Type], adapted: List[Type]): List[Tree] = {
-        if (args.isEmpty || adapted.isEmpty) Nil
-        else {
-          // No formals left or * indicates varargs.
-          val isVarArgs = formals.isEmpty || formals.tail.isEmpty && isRepeatedParamType(formals.head)
-          val isByName  = formals.nonEmpty && isByNameParamType(formals.head)
-          def typedMode = if (isByName) mode.onlySticky else mode.onlySticky | BYVALmode
-          def body = typedArg(args.head, mode, typedMode, adapted.head)
-          def arg1 = if (isVarArgs) context.withinStarPatterns(body) else body
-
-          // formals may be empty, so don't call tail
-          arg1 :: loop(args.tail, formals drop 1, adapted.tail)
-        }
+    // If the tree's symbol's type does not define an extractor, maybe the tree's type does.
+    // this is the case when we encounter an arbitrary tree as the target of an unapply call
+    // (rather than something that looks like a constructor call.) (for now, this only happens
+    // due to wrapClassTagUnapply, but when we support parameterized extractors, it will become
+    // more common place)
+    private def hasUnapplyMember(tpe: Type): Boolean   = reallyExists(unapplyMember(tpe))
+    private def hasUnapplyMember(sym: Symbol): Boolean = hasUnapplyMember(sym.tpe_*)
+    private def hasUnapplyMember(fun: Tree): Boolean   = hasUnapplyMember(fun.symbol) || hasUnapplyMember(fun.tpe)
+
+    // ad-hoc overloading resolution to deal with unapplies and case class constructors
+    // If some but not all alternatives survive filtering the tree's symbol with `p`,
+    // then update the tree's symbol and type to exclude the filtered out alternatives.
+    private def inPlaceAdHocOverloadingResolution(fun: Tree)(p: Symbol => Boolean): Tree = fun.symbol filter p match {
+      case sym if sym.exists && (sym ne fun.symbol) => fun setSymbol sym modifyType (tp => filterOverloadedAlts(tp)(p))
+      case _                                        => fun
+    }
+    private def filterOverloadedAlts(tpe: Type)(p: Symbol => Boolean): Type = tpe match {
+      case OverloadedType(pre, alts) => overloadedType(pre, alts filter p)
+      case tp                        => tp
+    }
+
+    def typedConstructorPattern(fun0: Tree, pt: Type) = {
+      // Do some ad-hoc overloading resolution and update the tree's symbol and type
+      // do not update the symbol if the tree's symbol's type does not define an unapply member
+      // (e.g. since it's some method that returns an object with an unapply member)
+      val fun       = inPlaceAdHocOverloadingResolution(fun0)(hasUnapplyMember)
+      def caseClass = fun.tpe.typeSymbol.linkedClassOfClass
+
+      // Dueling test cases: pos/overloaded-unapply.scala, run/case-class-23.scala, pos/t5022.scala
+      // A case class with 23+ params has no unapply method.
+      // A case class constructor be overloaded with unapply methods in the companion.
+      if (caseClass.isCase && !unapplyMember(fun.tpe).isOverloaded)
+        convertToCaseConstructor(fun, caseClass, pt)
+      else if (hasUnapplyMember(fun))
+        fun
+      else
+        CaseClassConstructorError(fun)
+    }
+
+    def expectedPatternTypes(fun: Tree, args: List[Tree]): List[Type] =
+      newExtractorShape(fun, args).expectedPatternTypes
+
+    def typedPatternArgs(fun: Tree, args: List[Tree], mode: Mode): List[Tree] =
+      typedArgsForFormals(args, newExtractorShape(fun, args).formals, mode)
+
+    def typedArgsForFormals(args: List[Tree], formals: List[Type], mode: Mode): List[Tree] = {
+      def typedArgWithFormal(arg: Tree, pt: Type) = {
+        val newMode = if (isByNameParamType(pt)) mode.onlySticky else mode.onlySticky | BYVALmode
+        typedArg(arg, mode, newMode, dropByName(pt))
+      }
+      val FixedAndRepeatedTypes(fixed, elem) = formals
+      val front = (args, fixed).zipped map typedArgWithFormal
+      def rest  = context withinStarPatterns (args drop front.length map (typedArgWithFormal(_, elem)))
+
+      elem match {
+        case NoType => front
+        case _      => front ::: rest
       }
-      loop(args0, formals0, adapted0)
+    }
+
+    private def boundedArrayType(bound: Type): Type = {
+      val tparam = context.owner freshExistential "" setInfo (TypeBounds upper bound)
+      newExistentialType(tparam :: Nil, arrayType(tparam.tpe_*))
     }
 
     protected def typedStarInPattern(tree: Tree, mode: Mode, pt: Type) = {
       val Typed(expr, tpt) = tree
-      val exprTyped = typed(expr, mode.onlySticky)
-      def subArrayType(pt: Type) =
-        if (isPrimitiveValueClass(pt.typeSymbol) || !isFullyDefined(pt)) arrayType(pt)
-        else {
-          val tparam = context.owner freshExistential "" setInfo TypeBounds.upper(pt)
-          newExistentialType(List(tparam), arrayType(tparam.tpe))
-        }
-
-      val (exprAdapted, baseClass) = exprTyped.tpe.typeSymbol match {
-        case ArrayClass => (adapt(exprTyped, mode.onlySticky, subArrayType(pt)), ArrayClass)
-        case _          => (adapt(exprTyped, mode.onlySticky, seqType(pt)), SeqClass)
+      val exprTyped = typed(expr, mode)
+      val baseClass = exprTyped.tpe.typeSymbol match {
+        case ArrayClass => ArrayClass
+        case _          => SeqClass
+      }
+      val starType = baseClass match {
+        case ArrayClass if isPrimitiveValueType(pt) || !isFullyDefined(pt) => arrayType(pt)
+        case ArrayClass                                                    => boundedArrayType(pt)
+        case _                                                             => seqType(pt)
       }
-      exprAdapted.tpe.baseType(baseClass) match {
-        case TypeRef(_, _, List(elemtp)) =>
-          treeCopy.Typed(tree, exprAdapted, tpt setType elemtp) setType elemtp
-        case _ =>
-          setError(tree)
+      val exprAdapted = adapt(exprTyped, mode, starType)
+      exprAdapted.tpe baseType baseClass match {
+        case TypeRef(_, _, elemtp :: Nil) => treeCopy.Typed(tree, exprAdapted, tpt setType elemtp) setType elemtp
+        case _                            => setError(tree)
       }
     }
 
     protected def typedInPattern(tree: Typed, mode: Mode, pt: Type) = {
       val Typed(expr, tpt) = tree
-      val tptTyped = typedType(tpt, mode)
-      val exprTyped = typed(expr, mode.onlySticky, tptTyped.tpe.deconst)
-      val treeTyped = treeCopy.Typed(tree, exprTyped, tptTyped)
-
-      if (mode.inPatternMode) {
-        val uncheckedTypeExtractor = extractorForUncheckedType(tpt.pos, tptTyped.tpe)
-        // make fully defined to avoid bounded wildcard types that may be in pt from calling dropExistential (SI-2038)
-        val ptDefined = ensureFullyDefined(pt) // FIXME this is probably redundant now that we don't dropExistenial in pattern mode.
-        val ownType = inferTypedPattern(tptTyped, tptTyped.tpe, ptDefined, canRemedy = uncheckedTypeExtractor.nonEmpty)
-        treeTyped setType ownType
-
-        uncheckedTypeExtractor match {
-          case None => treeTyped
-          case Some(extractor) => wrapClassTagUnapply(treeTyped, extractor, tptTyped.tpe)
-        }
-      } else
-        treeTyped setType tptTyped.tpe
+      val tptTyped  = typedType(tpt, mode)
+      val tpe       = tptTyped.tpe
+      val exprTyped = typed(expr, mode, tpe.deconst)
+      val extractor = extractorForUncheckedType(tpt.pos, tpe)
+
+      val canRemedy = tpe match {
+        case RefinedType(_, decls) if !decls.isEmpty                 => false
+        case RefinedType(parents, _) if parents exists isUncheckable => false
+        case _                                                       => extractor.nonEmpty
+      }
+
+      val ownType   = inferTypedPattern(tptTyped, tpe, pt, canRemedy)
+      val treeTyped = treeCopy.Typed(tree, exprTyped, tptTyped) setType ownType
+
+      extractor match {
+        case EmptyTree => treeTyped
+        case _         => wrapClassTagUnapply(treeTyped, extractor, tpe)
+      }
     }
 
+    def newExtractorShape(tree: Tree): ExtractorShape = tree match {
+      case Apply(fun, args)   => ExtractorShape(fun, args)
+      case UnApply(fun, args) => ExtractorShape(fun, args)
+    }
+    def newExtractorShape(fun: Tree, args: List[Tree]): ExtractorShape = ExtractorShape(fun, args)
+
     case class CaseClassInfo(clazz: Symbol, classType: Type) {
       def constructor     = clazz.primaryConstructor
       def constructorType = classType.prefix memberType clazz memberType constructor
@@ -243,7 +293,6 @@ trait PatternTypers {
         case tp1 => tp1
       }
     }
-
     /*
      * To deal with the type slack between actual (run-time) types and statically known types, for each abstract type T,
      * reflect its variance as a skolem that is upper-bounded by T (covariant position), or lower-bounded by T (contravariant).
@@ -271,91 +320,39 @@ trait PatternTypers {
      *
      * see test/files/../t5189*.scala
      */
-    def adaptConstrPattern(tree: Tree, pt: Type): Tree = { // (5)
-      def hasUnapplyMember(tp: Type) = reallyExists(unapplyMember(tp))
-      val overloadedExtractorOfObject = tree.symbol filter (sym => hasUnapplyMember(sym.tpe))
-      // if the tree's symbol's type does not define an extractor, maybe the tree's type does.
-      // this is the case when we encounter an arbitrary tree as the target of an unapply call
-      // (rather than something that looks like a constructor call.) (for now, this only happens
-      // due to wrapClassTagUnapply, but when we support parameterized extractors, it will become
-      // more common place)
-      val extractor = overloadedExtractorOfObject orElse unapplyMember(tree.tpe)
-      def convertToCaseConstructor(clazz: Symbol): TypeTree = {
-        // convert synthetic unapply of case class to case class constructor
-        val prefix = tree.tpe.prefix
-        val tree1 = TypeTree(clazz.primaryConstructor.tpe.asSeenFrom(prefix, clazz.owner))
-          .setOriginal(tree)
-
-        val skolems = new mutable.ListBuffer[TypeSymbol]
-        object variantToSkolem extends TypeMap(trackVariance = true) {
-          def apply(tp: Type) = mapOver(tp) match {
-            // !!! FIXME - skipping this when variance.isInvariant allows unsoundness, see SI-5189
-            case TypeRef(NoPrefix, tpSym, Nil) if !variance.isInvariant && tpSym.isTypeParameterOrSkolem && tpSym.owner.isTerm =>
-              // must initialize or tpSym.tpe might see random type params!!
-              // without this, we'll get very weird types inferred in test/scaladoc/run/SI-5933.scala
-              // TODO: why is that??
-              tpSym.initialize
-              val bounds = if (variance.isPositive) TypeBounds.upper(tpSym.tpe) else TypeBounds.lower(tpSym.tpe)
-              // origin must be the type param so we can deskolemize
-              val skolem = context.owner.newGADTSkolem(unit.freshTypeName("?"+tpSym.name), tpSym, bounds)
-              // println("mapping "+ tpSym +" to "+ skolem + " : "+ bounds +" -- pt= "+ pt +" in "+ context.owner +" at "+ context.tree )
-              skolems += skolem
-              skolem.tpe
-            case tp1 => tp1
-          }
-        }
-
-        // have to open up the existential and put the skolems in scope
-        // can't simply package up pt in an ExistentialType, because that takes us back to square one (List[_ <: T] == List[T] due to covariance)
-        val ptSafe   = variantToSkolem(pt) // TODO: pt.skolemizeExistential(context.owner, tree) ?
-        val freeVars = skolems.toList
-
-        // use "tree" for the context, not context.tree: don't make another CaseDef context,
-        // as instantiateTypeVar's bounds would end up there
-        val ctorContext = context.makeNewScope(tree, context.owner)
-        freeVars foreach ctorContext.scope.enter
-        newTyper(ctorContext).infer.inferConstructorInstance(tree1, clazz.typeParams, ptSafe)
-
-        // simplify types without losing safety,
-        // so that we get rid of unnecessary type slack, and so that error messages don't unnecessarily refer to skolems
-        val extrapolate = new ExistentialExtrapolation(freeVars) extrapolate (_: Type)
-        val extrapolated = tree1.tpe match {
-          case MethodType(ctorArgs, res) => // ctorArgs are actually in a covariant position, since this is the type of the subpatterns of the pattern represented by this Apply node
-            ctorArgs foreach (p => p.info = extrapolate(p.info)) // no need to clone, this is OUR method type
-            copyMethodType(tree1.tpe, ctorArgs, extrapolate(res))
-          case tp => tp
-        }
-
-        // once the containing CaseDef has been type checked (see typedCase),
-        // tree1's remaining type-slack skolems will be deskolemized (to the method type parameter skolems)
-        tree1 setType extrapolated
-      }
-
-      if (extractor != NoSymbol) {
-        // if we did some ad-hoc overloading resolution, update the tree's symbol
-        // do not update the symbol if the tree's symbol's type does not define an unapply member
-        // (e.g. since it's some method that returns an object with an unapply member)
-        if (overloadedExtractorOfObject != NoSymbol)
-          tree setSymbol overloadedExtractorOfObject
-
-        tree.tpe match {
-          case OverloadedType(pre, alts) => tree setType overloadedType(pre, alts filter (alt => hasUnapplyMember(alt.tpe)))
-          case _ =>
-        }
-        val unapply = unapplyMember(extractor.tpe)
-        val clazz = unapplyParameterType(unapply)
-
-        if (unapply.isCase && clazz.isCase) {
-          convertToCaseConstructor(clazz)
-        } else {
-          tree
-        }
-      } else {
-        val clazz = tree.tpe.typeSymbol.linkedClassOfClass
-        if (clazz.isCase)
-          convertToCaseConstructor(clazz)
-        else
-          CaseClassConstructorError(tree)
+    private def convertToCaseConstructor(tree: Tree, caseClass: Symbol, pt: Type): Tree = {
+      val variantToSkolem     = new VariantToSkolemMap
+      val caseConstructorType = tree.tpe.prefix memberType caseClass memberType caseClass.primaryConstructor
+      val tree1               = TypeTree(caseConstructorType) setOriginal tree
+
+      // have to open up the existential and put the skolems in scope
+      // can't simply package up pt in an ExistentialType, because that takes us back to square one (List[_ <: T] == List[T] due to covariance)
+      val ptSafe   = variantToSkolem(pt) // TODO: pt.skolemizeExistential(context.owner, tree) ?
+      val freeVars = variantToSkolem.skolems
+
+      // use "tree" for the context, not context.tree: don't make another CaseDef context,
+      // as instantiateTypeVar's bounds would end up there
+      log(sm"""|convert to case constructor {
+               |         tree: $tree: ${tree.tpe}
+               |       ptSafe: $ptSafe
+               | context.tree: ${context.tree}: ${context.tree.tpe}
+               |}""".trim)
+
+      val ctorContext = context.makeNewScope(tree, context.owner)
+      freeVars foreach ctorContext.scope.enter
+      newTyper(ctorContext).infer.inferConstructorInstance(tree1, caseClass.typeParams, ptSafe)
+
+      // simplify types without losing safety,
+      // so that we get rid of unnecessary type slack, and so that error messages don't unnecessarily refer to skolems
+      val extrapolator = new ExistentialExtrapolation(freeVars)
+      def extrapolate(tp: Type) = extrapolator extrapolate tp
+
+      // once the containing CaseDef has been type checked (see typedCase),
+      // tree1's remaining type-slack skolems will be deskolemized (to the method type parameter skolems)
+      tree1 modifyType {
+        case MethodType(ctorArgs, restpe) => // ctorArgs are actually in a covariant position, since this is the type of the subpatterns of the pattern represented by this Apply node
+          copyMethodType(tree1.tpe, ctorArgs map (_ modifyInfo extrapolate), extrapolate(restpe)) // no need to clone ctorArgs, this is OUR method type
+        case tp => tp
       }
     }
 
@@ -363,75 +360,61 @@ trait PatternTypers {
       def duplErrTree = setError(treeCopy.Apply(tree, fun0, args))
       def duplErrorTree(err: AbsTypeError) = { issue(err); duplErrTree }
 
-      val otpe = fun.tpe
-
       if (args.length > MaxTupleArity)
         return duplErrorTree(TooManyArgsPatternError(fun))
 
-      //
-      def freshArgType(tp: Type): (List[Symbol], Type) = tp match {
-        case MethodType(param :: _, _) =>
-          (Nil, param.tpe)
-        case PolyType(tparams, restpe) =>
-          createFromClonedSymbols(tparams, freshArgType(restpe)._2)((ps, t) => ((ps, t)))
-        // No longer used, see test case neg/t960.scala (#960 has nothing to do with it)
-        case OverloadedType(_, _) =>
-          OverloadedUnapplyError(fun)
-          (Nil, ErrorType)
-        case _ =>
-          UnapplyWithSingleArgError(fun)
-          (Nil, ErrorType)
+      def freshArgType(tp: Type): Type = tp match {
+        case MethodType(param :: _, _) => param.tpe
+        case PolyType(tparams, restpe) => createFromClonedSymbols(tparams, freshArgType(restpe))(polyType)
+        case OverloadedType(_, _)      => OverloadedUnapplyError(fun) ; ErrorType
+        case _                         => UnapplyWithSingleArgError(fun) ; ErrorType
+      }
+      val shape = newExtractorShape(fun, args)
+      import shape.{ unapplyParamType, unapplyType, unapplyMethod }
+
+      def extractor     = extractorForUncheckedType(shape.pos, unapplyParamType)
+      def canRemedy     = unapplyParamType match {
+        case RefinedType(_, decls) if !decls.isEmpty                 => false
+        case RefinedType(parents, _) if parents exists isUncheckable => false
+        case _                                                       => extractor.nonEmpty
       }
 
-      val unapp     = unapplyMember(otpe)
-      val unappType = otpe.memberType(unapp)
-      val argDummy  = context.owner.newValue(nme.SELECTOR_DUMMY, fun.pos, Flags.SYNTHETIC) setInfo pt
-      val arg       = Ident(argDummy) setType pt
-
-      val uncheckedTypeExtractor =
-        if (unappType.paramTypes.nonEmpty)
-          extractorForUncheckedType(tree.pos, unappType.paramTypes.head)
-        else None
-
-      if (!isApplicableSafe(Nil, unappType, List(pt), WildcardType)) {
-        //Console.println(s"UNAPP: need to typetest, arg: ${arg.tpe} unappType: $unappType")
-        val (freeVars, unappFormal) = freshArgType(unappType.skolemizeExistential(context.owner, tree))
+      def freshUnapplyArgType(): Type = {
+        val GenPolyType(freeVars, unappFormal) = freshArgType(unapplyType.skolemizeExistential(context.owner, tree))
         val unapplyContext = context.makeNewScope(context.tree, context.owner)
         freeVars foreach unapplyContext.scope.enter
-
-        val typer1 = newTyper(unapplyContext)
-        val pattp = typer1.infer.inferTypedPattern(tree, unappFormal, arg.tpe, canRemedy = uncheckedTypeExtractor.nonEmpty)
-
+        val pattp = newTyper(unapplyContext).infer.inferTypedPattern(tree, unappFormal, pt, canRemedy)
         // turn any unresolved type variables in freevars into existential skolems
         val skolems = freeVars map (fv => unapplyContext.owner.newExistentialSkolem(fv, fv))
-        arg setType pattp.substSym(freeVars, skolems)
-        argDummy setInfo arg.tpe
+        pattp.substSym(freeVars, skolems)
       }
 
+      val unapplyArg = (
+        context.owner.newValue(nme.SELECTOR_DUMMY, fun.pos, Flags.SYNTHETIC) setInfo (
+          if (isApplicableSafe(Nil, unapplyType, pt :: Nil, WildcardType)) pt
+          else freshUnapplyArgType()
+        )
+      )
       // clearing the type is necessary so that ref will be stabilized; see bug 881
-      val fun1 = typedPos(fun.pos)(Apply(Select(fun.clearType(), unapp), List(arg)))
-
-      if (fun1.tpe.isErroneous) duplErrTree
-      else {
-        val resTp     = fun1.tpe.finalResultType.dealiasWiden
-        val nbSubPats = args.length
-        val (formals, formalsExpanded) =
-          extractorFormalTypes(fun0.pos, resTp, nbSubPats, fun1.symbol, treeInfo.effectivePatternArity(args))
-        if (formals == null) duplErrorTree(WrongNumberOfArgsError(tree, fun))
-        else {
-          val args1 = typedArgs(args, mode, formals, formalsExpanded)
-          val pt1   = ensureFullyDefined(pt) // SI-1048
-          val itype = glb(List(pt1, arg.tpe))
-          arg setType pt1    // restore type (arg is a dummy tree, just needs to pass typechecking)
-          val unapply = UnApply(fun1, args1) setPos tree.pos setType itype
-
-          // if the type that the unapply method expects for its argument is uncheckable, wrap in classtag extractor
-          // skip if the unapply's type is not a method type with (at least, but really it should be exactly) one argument
-          // also skip if we already wrapped a classtag extractor (so we don't keep doing that forever)
-          if (uncheckedTypeExtractor.isEmpty || fun1.symbol.owner.isNonBottomSubClass(ClassTagClass)) unapply
-          else wrapClassTagUnapply(unapply, uncheckedTypeExtractor.get, unappType.paramTypes.head)
-        }
+      val fun1 = typedPos(fun.pos)(Apply(Select(fun.clearType(), unapplyMethod), Ident(unapplyArg) :: Nil))
+
+      def makeTypedUnApply() = {
+        // the union of the expected type and the inferred type of the argument to unapply
+        val glbType        = glb(ensureFullyDefined(pt) :: unapplyArg.tpe_* :: Nil)
+        val wrapInTypeTest = canRemedy && !(fun1.symbol.owner isNonBottomSubClass ClassTagClass)
+        val args1          = typedPatternArgs(fun1, args, mode)
+        val result         = UnApply(fun1, args1) setPos tree.pos setType glbType
+
+        if (wrapInTypeTest)
+          wrapClassTagUnapply(result, extractor, glbType)
+        else
+          result
       }
+
+      if (fun1.tpe.isErroneous)
+        duplErrTree
+      else
+        makeTypedUnApply()
     }
 
     def wrapClassTagUnapply(uncheckedPattern: Tree, classTagExtractor: Tree, pt: Type): Tree = {
@@ -459,28 +442,23 @@ trait PatternTypers {
 
     // if there's a ClassTag that allows us to turn the unchecked type test for `pt` into a checked type test
     // return the corresponding extractor (an instance of ClassTag[`pt`])
-    def extractorForUncheckedType(pos: Position, pt: Type): Option[Tree] = if (isPastTyper) None else {
-      // only look at top-level type, can't (reliably) do anything about unchecked type args (in general)
-      // but at least make a proper type before passing it elsewhere
-      val pt1 = pt.dealiasWiden match {
-        case tr @ TypeRef(pre, sym, args) if args.nonEmpty => copyTypeRef(tr, pre, sym, sym.typeParams map (_.tpeHK)) // replace actual type args with dummies
-        case pt1                                           => pt1
-      }
-      pt1 match {
-        // if at least one of the types in an intersection is checkable, use the checkable ones
-        // this avoids problems as in run/matchonseq.scala, where the expected type is `Coll with scala.collection.SeqLike`
-        // Coll is an abstract type, but SeqLike of course is not
-        case RefinedType(ps, _) if ps.length > 1 && (ps exists infer.isCheckable) =>
-          None
-
-        case ptCheckable if infer isUncheckable ptCheckable =>
-          val classTagExtractor = resolveClassTag(pos, ptCheckable)
-
-          if (classTagExtractor != EmptyTree && unapplyMember(classTagExtractor.tpe) != NoSymbol)
-            Some(classTagExtractor)
-          else None
-
-        case _ => None
+    def extractorForUncheckedType(pos: Position, pt: Type): Tree = {
+      if (isPastTyper || (pt eq NoType)) EmptyTree else {
+        pt match {
+          case RefinedType(parents, decls) if !decls.isEmpty || (parents exists isUncheckable) => return EmptyTree
+          case _                                                                               =>
+        }
+        // only look at top-level type, can't (reliably) do anything about unchecked type args (in general)
+        // but at least make a proper type before passing it elsewhere
+        val pt1 = pt.dealiasWiden match {
+          case tr @ TypeRef(pre, sym, args) if args.nonEmpty => copyTypeRef(tr, pre, sym, sym.typeParams map (_.tpeHK)) // replace actual type args with dummies
+          case pt1                                           => pt1
+        }
+        if (isCheckable(pt1)) EmptyTree
+        else resolveClassTag(pos, pt1) match {
+          case tree if unapplyMember(tree.tpe).exists => tree
+          case _                                      => devWarning(s"Cannot create runtime type test for $pt1") ; EmptyTree
+        }
       }
     }
   }