Squash ExtractorCall and ExtractorCallRegular together

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -563,10 +563,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
       // sub patterns bound to wildcard (_) are never stored as they can't be referenced
       // dirty debuggers will have to get dirty to see the wildcards
       lazy val storedBinders: Set[Symbol] =
-        (if (debugInfoEmitVars) subPatBinders.toSet else Set.empty) ++ extraStoredBinders -- ignoredSubPatBinders
-
-      // e.g., mutable fields of a case class in ProductExtractorTreeMaker
-      def extraStoredBinders: Set[Symbol]
+        (if (debugInfoEmitVars) subPatBinders.toSet else Set.empty[Symbol]) -- ignoredSubPatBinders
 
       def emitVars = storedBinders.nonEmpty
 
@@ -643,8 +640,6 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
       val ignoredSubPatBinders: Set[Symbol]
     ) extends FunTreeMaker with PreserveSubPatBinders {
 
-      def extraStoredBinders: Set[Symbol] = Set()
-
       ctx.debuglog(s"""
         |ExtractorTreeMaker($extractor, $extraCond, $nextBinder) {
         |  $subPatBinders
@@ -1348,70 +1343,46 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
           case UnApply(unfun, implicits, args) =>
             val castedBinder = ref(binder).ensureConforms(tree.tpe)
             val synth = if (implicits.isEmpty) unfun.appliedTo(castedBinder) else unfun.appliedTo(castedBinder).appliedToArgs(implicits)
-            new ExtractorCallRegular(alignPatterns(tree, synth.tpe), synth, args, synth.tpe)
+            new ExtractorCall(alignPatterns(tree, synth.tpe), synth, args, synth.tpe)
         }
       }
     }
 
-    abstract class ExtractorCall(val aligner: PatternAligned) {
-
+    class ExtractorCall(val aligner: PatternAligned, extractorCallIncludingDummy: Tree, val args: List[Tree], val resultType: Type) {
       import aligner._
 
-      def args: List[Tree]
-
-      // don't go looking for selectors if we only expect one pattern
-      def rawSubPatTypes = aligner.extractedTypes
-
-      def typeArgOfBaseTypeOr(tp: Type, baseClass: Symbol)(or: => Type): Type = (tp.baseTypeWithArgs(baseClass)).argInfos match {
-        case x :: Nil => x
-        case _        => or
-      }
-
       def resultInMonad  =
         if (aligner.isBool) defn.UnitType
         else if (isProductMatch(resultType, aligner.prodArity)) resultType
         else if (isGetMatch(resultType)) extractorMemberType(resultType, nme.get)
         else resultType
 
-      def resultType: Type
-
-      /** Create the TreeMaker that embodies this extractor call
-        *
-        * `binder` has been casted to `paramType` if necessary
-        * `binderKnownNonNull` indicates whether the cast implies `binder` cannot be null
-        * when `binderKnownNonNull` is `true`, `ProductExtractorTreeMaker` does not do a (redundant) null check on binder
-        */
-      def treeMaker(binder: Symbol, binderKnownNonNull: Boolean, pos: Position, binderTypeTested: Type): TreeMaker
-
       // `subPatBinders` are the variables bound by this pattern in the following patterns
       // subPatBinders are replaced by references to the relevant part of the extractor's result (tuple component, seq element, the result as-is)
       // must set infos to `subPatTypes`, which are provided by extractor's result,
       // as b.info may be based on a Typed type ascription, which has not been taken into account yet by the translation
       // (it will later result in a type test when `tp` is not a subtype of `b.info`)
       // TODO: can we simplify this, together with the Bound case?
       def subPatBinders = subBoundTrees map (_.binder)
-      lazy val subBoundTrees = (args, subPatTypes).zipped map newBoundTree
+      lazy val subBoundTrees = (args, typedPatterns.map(_.tpe)).zipped map newBoundTree
 
       // never store these in local variables (for PreserveSubPatBinders)
       lazy val ignoredSubPatBinders: Set[Symbol] = subPatBinders zip args collect { case (b, PatternBoundToUnderscore()) => b } toSet
 
-      // do repeated-parameter expansion to match up with the expected number of arguments (in casu, subpatterns)
-      private def nonStarSubPatTypes = aligner.typedNonStarPatterns map (_.tpe)
-
-      def subPatTypes: List[Type] = typedPatterns map (_.tpe)
-
       // there are `prodArity` non-seq elements in the tuple.
-      protected def firstIndexingBinder = prodArity
-      protected def expectedLength      = elementArity
-      protected def lastIndexingBinder  = totalArity - starArity - 1
+      private def firstIndexingBinder = prodArity
+      private def expectedLength      = elementArity
+      private def lastIndexingBinder  = totalArity - starArity - 1
 
       private def productElemsToN(binder: Symbol, n: Int): List[Tree] = 1 to n map tupleSel(binder) toList
       private def genTake(binder: Symbol, n: Int): List[Tree]         = (0 until n).toList map (codegen index seqTree(binder))
       private def genDrop(binder: Symbol, n: Int): List[Tree]         = codegen.drop(seqTree(binder))(expectedLength) :: Nil
 
-      // codegen.drop(seqTree(binder))(nbIndexingIndices)))).toList
-      protected def seqTree(binder: Symbol)                = tupleSel(binder)(firstIndexingBinder + 1)
-      protected def tupleSel(binder: Symbol)(i: Int): Tree = {
+      private def seqTree(binder: Symbol): Tree =
+        if (firstIndexingBinder == 0) ref(binder)
+        else tupleSel(binder)(firstIndexingBinder + 1)
+
+      private def tupleSel(binder: Symbol)(i: Int): Tree = {
         val accessors =
           if (defn.isProductSubType(binder.info))
             productSelectors(binder.info)
@@ -1425,7 +1396,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
 
       // the trees that select the subpatterns on the extractor's result,
       // referenced by `binder`
-      protected def subPatRefsSeq(binder: Symbol): List[Tree] = {
+      private def subPatRefsSeq(binder: Symbol): List[Tree] = {
         def lastTrees: List[Tree] = (
           if (!aligner.isStar) Nil
           else if (expectedLength == 0) seqTree(binder) :: Nil
@@ -1446,7 +1417,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
 
       // the trees that select the subpatterns on the extractor's result, referenced by `binder`
       // require (nbSubPats > 0 && (!lastIsStar || isSeq))
-      protected def subPatRefs(binder: Symbol): List[Tree] = {
+      private def subPatRefs(binder: Symbol): List[Tree] = {
         val refs = if (totalArity > 0 && isSeq) subPatRefsSeq(binder)
         else if (binder.info.member(nme._1).exists && !isSeq) productElemsToN(binder, totalArity)
         else ref(binder) :: Nil
@@ -1459,17 +1430,16 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
 
       private def compareInts(t1: Tree, t2: Tree) =
         mathSignum.appliedTo(t1.select(defn.Int_-).appliedTo(t2))
-        //gen.mkMethodCall(termMember(ScalaPackage, "math"), TermName("signum"), Nil, (t1 INT_- t2) :: Nil)
 
-      protected def lengthGuard(binder: Symbol): Option[Tree] =
-      // no need to check unless it's an unapplySeq and the minimal length is non-trivially satisfied
+      private def lengthGuard(binder: Symbol): Option[Tree] =
+        // no need to check unless it's an unapplySeq and the minimal length is non-trivially satisfied
         checkedLength map { expectedLength =>
           // `binder.lengthCompare(expectedLength)`
           // ...if binder has a lengthCompare method, otherwise
           // `scala.math.signum(binder.length - expectedLength)`
           def checkExpectedLength: Tree = sequenceType.member(nme.lengthCompare) match {
-            case NoDenotation => compareInts(Select(seqTree(binder), nme.length), Literal(Constant(expectedLength)))
-            case x:SingleDenotation   => (seqTree(binder).select(x.symbol)).appliedTo(Literal(Constant(expectedLength)))
+            case NoDenotation        => compareInts(Select(seqTree(binder), nme.length), Literal(Constant(expectedLength)))
+            case x: SingleDenotation => (seqTree(binder).select(x.symbol)).appliedTo(Literal(Constant(expectedLength)))
             case _ =>
               ctx.error("TODO: multiple lengthCompare")
               EmptyTree
@@ -1487,12 +1457,9 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
         }
 
       def checkedLength: Option[Int] =
-      // no need to check unless it's an unapplySeq and the minimal length is non-trivially satisfied
+        // no need to check unless it's an unapplySeq and the minimal length is non-trivially satisfied
         if (!isSeq || expectedLength < starArity) None
         else Some(expectedLength)
-    }
-
-    class ExtractorCallRegular(aligner: PatternAligned, extractorCallIncludingDummy: Tree, val args: List[Tree], val resultType: Type) extends ExtractorCall(aligner) {
 
       /** Create the TreeMaker that embodies this extractor call
         *
@@ -1523,21 +1490,16 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
         )
       }
 
-      override protected def seqTree(binder: Symbol): Tree =
-        if (firstIndexingBinder == 0) ref(binder)
-        else super.seqTree(binder)
-
       // the trees that select the subpatterns on the extractor's result, referenced by `binder`
       // require (totalArity > 0 && (!lastIsStar || isSeq))
-      protected def subPatRefs(binder: Symbol, subpatBinders: List[Symbol], binderTypeTested: Type): List[Tree] = {
+      private def subPatRefs(binder: Symbol, subpatBinders: List[Symbol], binderTypeTested: Type): List[Tree] = {
         if (aligner.isSingle && aligner.extractor.prodArity == 1 && defn.isTupleType(binder.info)) {
           // special case for extractor
           // comparing with scalac additional assertions added
           val subpw = subpatBinders.head.info.widen
           val binderw = binder.info.widen
           val go = subpatBinders.head.info <:< binder.info
           val go1 = binder.info <:< subpatBinders.head.info
-          //val spr = subPatRefs(binder)
           assert(go && go1)
           ref(binder) :: Nil
         }
@@ -1547,27 +1509,6 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {
         else
           subPatRefs(binder)
       }
-
-      /*protected def spliceApply(binder: Symbol): Tree = {
-        object splice extends TreeMap {
-          def binderRef(pos: Position): Tree =
-            ref(binder) //setPos pos
-
-          override def transform(t: tpd.Tree)(implicit ctx: Context): tpd.Tree = t match {
-            // duplicated with the extractor Unapplied
-            case Apply(x, List(i @ Ident(nme.SELECTOR_DUMMY))) =>
-              cpy.Apply(t, x, binderRef(i.pos) :: Nil)
-            // SI-7868 Account for numeric widening, e.g. <unappplySelector>.toInt
-            case Apply(x, List(i @ (sel @ Select(Ident(nme.SELECTOR_DUMMY), name)))) =>
-              cpy.Apply(t, x, cpy.Select(sel, binderRef(i.pos), name) :: Nil)
-            case _ =>
-              super.transform(t)
-          }
-        }
-        splice transform extractorCallIncludingDummy
-      }*/
-
-      override def rawSubPatTypes = aligner.extractor.varargsTypes
     }
   }