add syntactic combinators that represent enumerators

2 files changed, 95 insertions, 0 deletions

diff --git a/src/reflect/scala/reflect/api/BuildUtils.scala b/src/reflect/scala/reflect/api/BuildUtils.scala
index 28551b1dcd..4d2a1dcc30 100644
--- a/src/reflect/scala/reflect/api/BuildUtils.scala
+++ b/src/reflect/scala/reflect/api/BuildUtils.scala
@@ -223,5 +223,26 @@ private[reflect] trait BuildUtils { self: Universe =>
       def apply(lhs: Tree, rhs: Tree): Tree
       def unapply(tree: Tree): Option[(Tree, Tree)]
     }
+
+    val SyntacticValFrom: SyntacticValFromExtractor
+
+    trait SyntacticValFromExtractor {
+      def apply(pat: Tree, rhs: Tree): Tree
+      def unapply(tree: Tree): Option[(Tree, Tree)]
+    }
+
+    val SyntacticValEq: SyntacticValEqExtractor
+
+    trait SyntacticValEqExtractor {
+      def apply(pat: Tree, rhs: Tree): Tree
+      def unapply(tree: Tree): Option[(Tree, Tree)]
+    }
+
+    val SyntacticFilter: SyntacticFilterExtractor
+
+    trait SyntacticFilterExtractor {
+      def apply(test: Tree): Tree
+      def unapply(tree: Tree): Option[(Tree)]
+    }
   }
 }
diff --git a/src/reflect/scala/reflect/internal/BuildUtils.scala b/src/reflect/scala/reflect/internal/BuildUtils.scala
index cae671a5e9..db4e5685fd 100644
--- a/src/reflect/scala/reflect/internal/BuildUtils.scala
+++ b/src/reflect/scala/reflect/internal/BuildUtils.scala
@@ -442,6 +442,68 @@ trait BuildUtils { self: SymbolTable =>
       }
     }
 
+    object SyntacticValFrom extends SyntacticValFromExtractor {
+      def apply(pat: Tree, rhs: Tree): Tree = gen.ValFrom(pat, gen.mkCheckIfRefutable(pat, rhs))
+      def unapply(tree: Tree): Option[(Tree, Tree)] = tree match {
+        case gen.ValFrom(pat, UnCheckIfRefutable(pat1, rhs1)) if pat.equalsStructure(pat1) =>
+          Some((pat, rhs1))
+        case gen.ValFrom(pat, rhs) =>
+          Some((pat, rhs))
+        case _ => None
+      }
+    }
+
+    object SyntacticValEq extends SyntacticValEqExtractor {
+      def apply(pat: Tree, rhs: Tree): Tree         = gen.ValEq(pat, rhs)
+      def unapply(tree: Tree): Option[(Tree, Tree)] = gen.ValEq.unapply(tree)
+    }
+
+    object SyntacticFilter extends SyntacticFilterExtractor {
+      def apply(tree: Tree): Tree           = gen.Filter(tree)
+      def unapply(tree: Tree): Option[Tree] = gen.Filter.unapply(tree)
+    }
+
+    // undo gen.mkSyntheticParam
+    protected object UnSyntheticParam {
+      def unapply(tree: Tree): Option[TermName] = tree match {
+        case ValDef(mods, name, _, EmptyTree)
+          if mods.hasFlag(SYNTHETIC) && mods.hasFlag(PARAM) =>
+          Some(name)
+        case _ => None
+      }
+    }
+
+    // undo gen.mkVisitor
+    protected object UnVisitor {
+      def unapply(tree: Tree): Option[(TermName, List[CaseDef])] = tree match {
+        case Function(UnSyntheticParam(x1) :: Nil, Match(MaybeUnchecked(Ident(x2)), cases))
+          if x1 == x2 =>
+          Some((x1, cases))
+        case _ => None
+      }
+    }
+
+    // match call to either withFilter or filter
+    protected object FilterCall {
+      def unapply(tree: Tree): Option[(Tree,Tree)] = tree match {
+        case Apply(Select(obj, nme.withFilter | nme.filter), arg :: Nil) =>
+          Some(obj, arg)
+        case _ => None
+      }
+    }
+
+    // undo gen.mkCheckIfRefutable
+    protected object UnCheckIfRefutable {
+      def unapply(tree: Tree): Option[(Tree, Tree)] = tree match {
+        case FilterCall(rhs, UnVisitor(name,
+            CaseDef(pat, EmptyTree, Literal(Constant(true))) ::
+            CaseDef(Ident(nme.WILDCARD), EmptyTree, Literal(Constant(false))) :: Nil))
+          if name.toString.contains(nme.CHECK_IF_REFUTABLE_STRING) =>
+          Some((pat, rhs))
+        case _ => None
+      }
+    }
+
     // use typetree's original instead of typetree itself
     protected object MaybeTypeTreeOriginal {
       def unapply(tree: Tree): Some[Tree] = tree match {
@@ -457,6 +519,18 @@ trait BuildUtils { self: SymbolTable =>
         case other                => Some(other)
       }
     }
+
+    // drop potential @scala.unchecked annotation
+    protected object MaybeUnchecked {
+      def unapply(tree: Tree): Some[Tree] = tree match {
+        case Annotated(SyntacticNew(Nil, Apply(ScalaDot(tpnme.unchecked), Nil) :: Nil, noSelfType, Nil), annottee) =>
+          Some(annottee)
+        case Typed(annottee, MaybeTypeTreeOriginal(
+          Annotated(SyntacticNew(Nil, Apply(ScalaDot(tpnme.unchecked), Nil) :: Nil, noSelfType, Nil), _))) =>
+          Some(annottee)
+        case annottee => Some(annottee)
+      }
+    }
   }
 
   val build: BuildImpl = new BuildImpl