/* NSC -- new Scala compiler
* Copyright 2005-2013 LAMP/EPFL
* @author Paul Phillips
*/
package scala
package tools
package nsc
package transform
package patmat
/** An extractor returns: F1, F2, ..., Fi, opt[Seq[E] or E*]
* A case matches: P1, P2, ..., Pj, opt[Seq[E]]
* Put together: P1/F1, P2/F2, ... Pi/Fi, Pi+1/E, Pi+2/E, ... Pj/E, opt[Seq[E]]
*
* Here Pm/Fi is the last pattern to match the fixed arity section.
*
* productArity: the value of i, i.e. the number of non-sequence types in the extractor
* nonStarArity: the value of j, i.e. the number of non-star patterns in the case definition
* elementArity: j - i, i.e. the number of non-star patterns which must match sequence elements
* starArity: 1 or 0 based on whether there is a star (sequence-absorbing) pattern
* totalArity: nonStarArity + starArity, i.e. the number of patterns in the case definition
*
* Note that productArity is a function only of the extractor, and
* nonStar/star/totalArity are all functions of the patterns. The key
* value for aligning and typing the patterns is elementArity, as it
* is derived from both sets of information.
*/
trait PatternExpander[Pattern, Type] {
/** You'll note we're not inside the cake. "Pattern" and "Type" are
* arbitrary types here, and NoPattern and NoType arbitrary values.
*/
def NoPattern: Pattern
def NoType: Type
/** It's not optimal that we're carrying both sequence and repeated
* type here, but the implementation requires more unraveling before
* it can be avoided.
*
* sequenceType is Seq[T], elementType is T, repeatedType is T*.
*/
sealed case class Repeated(sequenceType: Type, elementType: Type, repeatedType: Type) {
def exists = elementType != NoType
def elementList = if (exists) elementType :: Nil else Nil
def sequenceList = if (exists) sequenceType :: Nil else Nil
def repeatedList = if (exists) repeatedType :: Nil else Nil
override def toString = s"${elementType}*"
}
object NoRepeated extends Repeated(NoType, NoType, NoType) {
override def toString = "<none>"
}
final case class Patterns(fixed: List[Pattern], star: Pattern) {
def hasStar = star != NoPattern
def starArity = if (hasStar) 1 else 0
def nonStarArity = fixed.length
def totalArity = nonStarArity + starArity
def starPatterns = if (hasStar) star :: Nil else Nil
def all = fixed ::: starPatterns
override def toString = all mkString ", "
}
/** An 'extractor' can be a case class or an unapply or unapplySeq method.
* Decoding what it is that they extract takes place before we arrive here,
* so that this class can concentrate only on the relationship between
* patterns and types.
*
* In a case class, the class is the unextracted type and the fixed and
* repeated types are derived from its constructor parameters.
*
* In an unapply, this is reversed: the parameter to the unapply is the
* unextracted type, and the other types are derived based on the return
* type of the unapply method.
*
* In other words, this case class and unapply are encoded the same:
*
* case class Foo(x: Int, y: Int, zs: Char*)
* def unapplySeq(x: Foo): Option[(Int, Int, Seq[Char])]
*
* Both are Extractor(Foo, Int :: Int :: Nil, Repeated(Seq[Char], Char, Char*))
*
* @param whole The type in its unextracted form
* @param fixed The non-sequence types which are extracted
* @param repeated The sequence type which is extracted
*/
final case class Extractor(whole: Type, fixed: List[Type], repeated: Repeated, typeOfSinglePattern: Type) {
require(whole != NoType, s"expandTypes($whole, $fixed, $repeated)")
/** A pattern with arity-1 that doesn't match the arity of the Product-like result of the `get` method,
* will match that result in its entirety. Example:
*
* {{{
* warning: there was one deprecation warning; re-run with -deprecation for details
* scala> object Extractor { def unapply(a: Any): Option[(Int, String)] = Some((1, "2")) }
* defined object Extractor
*
* scala> "" match { case Extractor(x: Int, y: String) => }
*
* scala> "" match { case Extractor(xy : (Int, String)) => }
* warning: there was one deprecation warning; re-run with -deprecation for details
* }}}
* */
def asSinglePattern: Extractor = copy(fixed = List(typeOfSinglePattern))
def productArity = fixed.length
def hasSeq = repeated.exists
def elementType = repeated.elementType
def sequenceType = repeated.sequenceType
def allTypes = fixed ::: repeated.sequenceList
def varargsTypes = fixed ::: repeated.repeatedList
def isErroneous = allTypes contains NoType
private def typeStrings = fixed.map("" + _) ::: ( if (hasSeq) List("" + repeated) else Nil )
def offeringString = if (isErroneous) "<error>" else typeStrings match {
case Nil => "Boolean"
case tp :: Nil => tp
case tps => tps.mkString("(", ", ", ")")
}
override def toString = "%s => %s".format(whole, offeringString)
}
final case class TypedPat(pat: Pattern, tpe: Type) {
override def toString = s"$pat: $tpe"
}
/** If elementArity is...
* 0: A perfect match between extractor and the fixed patterns.
* If there is a star pattern it will match any sequence.
* > 0: There are more patterns than products. There will have to be a
* sequence which can populate at least <elementArity> patterns.
* < 0: There are more products than patterns: compile time error.
*/
final case class Aligned(patterns: Patterns, extractor: Extractor) {
def elementArity = patterns.nonStarArity - productArity
def productArity = extractor.productArity
def starArity = patterns.starArity
def totalArity = patterns.totalArity
def wholeType = extractor.whole
def sequenceType = extractor.sequenceType
def productTypes = extractor.fixed
def extractedTypes = extractor.allTypes
def typedNonStarPatterns = products ::: elements
def typedPatterns = typedNonStarPatterns ::: stars
def isBool = !isSeq && productArity == 0
def isSingle = !isSeq && totalArity == 1
def isStar = patterns.hasStar
def isSeq = extractor.hasSeq
private def typedAsElement(pat: Pattern) = TypedPat(pat, extractor.elementType)
private def typedAsSequence(pat: Pattern) = TypedPat(pat, extractor.sequenceType)
private def productPats = patterns.fixed take productArity
private def elementPats = patterns.fixed drop productArity
private def products = (productPats, productTypes).zipped map TypedPat
private def elements = elementPats map typedAsElement
private def stars = patterns.starPatterns map typedAsSequence
override def toString = s"""
|Aligned {
| patterns $patterns
| extractor $extractor
| arities $productArity/$elementArity/$starArity // product/element/star
| typed ${typedPatterns mkString ", "}
|}""".stripMargin.trim
}
}
