[vpm] typer synths Function{} for empty-sel match

typedMatchAnonFun is called from typedFunction when the function's body is a match

this is work-in-progres: the compiler currently won't bootstrap under -Yvirtpatmat
see also the pending test

make sure to use the right context in typeFunction when the body is a Match
when typer is set up for type checking a Function, the current owner is the symbol for the function,
but we'll type check a Block(List(ClassDef(cd)), New(cd)) when the function is a match,
and the function symbol is nowhere to be found, so go to outer context

in patmatvirt:
- simplified default case gen (no need for a Casegen instance)
- using CASE | SYNTHETIC to detect generated matches (for switches) and avoid typing them endlessly
  more uniform, and necessary for new-style anon Function class instance gen for matches

1 files changed, 171 insertions, 86 deletions

diff --git a/test/files/run/virtpatmat_partial.scala b/test/files/run/virtpatmat_partial.scala
index 6597f2f5ae..a235314610 100644
--- a/test/files/run/virtpatmat_partial.scala
+++ b/test/files/run/virtpatmat_partial.scala
@@ -2,95 +2,180 @@ object Test extends App {
   val a = Map("a" -> Some(1), "b" -> None)
   println(a)
 
+// inferred type should be Map[String, Int]
   val res = a collect {case (p, Some(a)) => (p, a)}
 
-  final val GT = 79
-  final val GTGT = 93
-  final val GTGTGT = 94
-  final val GTEQ = 81
-  final val GTGTEQ = 113
-  final val GTGTGTEQ = 114
-  final val ASSIGN = 75
-
-  def acceptClosingAngle(in: Int) {
-    val closers: PartialFunction[Int, Int] = {
-      case GTGTGTEQ => GTGTEQ
-      case GTGTGT   => GTGT
-      case GTGTEQ   => GTEQ
-      case GTGT     => GT
-      case GTEQ     => ASSIGN
+// variations: const target -> switch, non-const -> normal match, char target --> scrut needs toInt,
+// eta-expanded --> work is done by typedFunction, non-eta-expanded --> typedMatch
+
+  object nonConstCharEta {
+    final val GT      : Char = 'a'
+    final val GTGT    : Char = 'b'
+    final val GTGTGT  : Char = 'c'
+    final val GTEQ    : Char = 'd'
+    final val GTGTEQ  : Char = 'e'
+    final val GTGTGTEQ: Char = 'f'
+    final val ASSIGN  : Char = 'g'
+
+    def acceptClosingAngle(in: Char) {
+      val closers: PartialFunction[Char, Char] = {
+        case GTGTGTEQ => GTGTEQ
+        case GTGTGT   => GTGT
+        case GTGTEQ   => GTEQ
+        case GTGT     => GT
+        case GTEQ     => ASSIGN
+      }
+      if (closers isDefinedAt in) println(closers(in))
+      else println("undefined")
+    }
+
+    def test() = {
+      acceptClosingAngle(GTGT)
+      acceptClosingAngle(ASSIGN)
+    }
+  }
+
+  object nonConstChar {
+    final val GT      : Char = 'a'
+    final val GTGT    : Char = 'b'
+    final val GTGTGT  : Char = 'c'
+    final val GTEQ    : Char = 'd'
+    final val GTGTEQ  : Char = 'e'
+    final val GTGTGTEQ: Char = 'f'
+    final val ASSIGN  : Char = 'g'
+
+    def acceptClosingAngle(in: Char) {
+      val closers: PartialFunction[Char, Char] = x => x match {
+        case GTGTGTEQ => GTGTEQ
+        case GTGTGT   => GTGT
+        case GTGTEQ   => GTEQ
+        case GTGT     => GT
+        case GTEQ     => ASSIGN
+      }
+      if (closers isDefinedAt in) println(closers(in))
+      else println("undefined")
+    }
+
+    def test() = {
+      acceptClosingAngle(GTGT)
+      acceptClosingAngle(ASSIGN)
     }
-    if (closers isDefinedAt in) println(closers(in))
-    else println("undefined")
   }
 
-  acceptClosingAngle(GTGT)
-  acceptClosingAngle(ASSIGN)
-
-  // should uncurry to:
-  // val res: Map[String,Int] = a.collect[(String, Int), Map[String,Int]](
-  //   new PartialFunction[(String, Option[Int]),(String, Int)]  {
-  //     def apply(x0_1: (String, Option[Int])): (String, Int) = MatchingStrategy.OptionMatchingStrategy.runOrElse[(String, Option[Int]), (String, Int)](x0_1)(
-  //       (x1: (String, Option[Int])) => {
-  //           val o9: Option[(String, Int)] = ({
-  //             val o8: Option[(String, Option[Int])] = Tuple2.unapply[String, Option[Int]](x1);
-  //             if (o8.isEmpty)
-  //               MatchingStrategy.OptionMatchingStrategy.zero
-  //             else
-  //               {
-  //                 val o7: Option[Some[Int]] = if (o8.get._2.isInstanceOf[Some[Int]])
-  //                   MatchingStrategy.OptionMatchingStrategy.one[Some[Int]](o8.get._2.asInstanceOf[Some[Int]])
-  //                 else
-  //                   MatchingStrategy.OptionMatchingStrategy.zero;
-  //                 if (o7.isEmpty)
-  //                   MatchingStrategy.OptionMatchingStrategy.zero
-  //                 else
-  //                   {
-  //                     val o6: Option[Int] = Some.unapply[Int](o7.get);
-  //                     if (o6.isEmpty)
-  //                       MatchingStrategy.OptionMatchingStrategy.zero
-  //                     else
-  //                       MatchingStrategy.OptionMatchingStrategy.one[(String, Int)]((o8.get._1, o6.get).asInstanceOf[(String, Int)])
-  //                   }
-  //               }
-  //           }: Option[(String, Int)]);
-  //           if (o9.isEmpty)
-  //             (MatchingStrategy.OptionMatchingStrategy.zero: Option[(String, Int)])
-  //           else
-  //             o9
-  //         })
-  //     
-  //       def isDefinedAt(x_1: (String, Option[Int])): Boolean = MatchingStrategy.OptionMatchingStrategy.isSuccess[(String, Option[Int]), (String, Int)](x_1)(
-  //         (x1: (String, Option[Int])) => {
-  //           val o9: Option[(String, Int)] = ({
-  //             val o8: Option[(String, Option[Int])] = scala.Tuple2.unapply[String, Option[Int]](x1);
-  //             if (o8.isEmpty)
-  //               MatchingStrategy.OptionMatchingStrategy.zero
-  //             else
-  //               {
-  //                 val o7: Option[Some[Int]] = if (o8.get._2.isInstanceOf[Some[Int]])
-  //                   MatchingStrategy.OptionMatchingStrategy.one[Some[Int]](o8.get._2.asInstanceOf[Some[Int]]) // XXX
-  //                 else
-  //                   MatchingStrategy.OptionMatchingStrategy.zero;
-  //                 if (o7.isEmpty)
-  //                   MatchingStrategy.OptionMatchingStrategy.zero
-  //                 else
-  //                   {
-  //                     val o6: Option[Int] = scala.Some.unapply[Int](o7.get);
-  //                     if (o6.isEmpty)
-  //                       MatchingStrategy.OptionMatchingStrategy.zero
-  //                     else
-  //                       MatchingStrategy.OptionMatchingStrategy.one[(String, Int)](null.asInstanceOf[(String, Int)])
-  //                   }
-  //               }
-  //           }: Option[(String, Int)]);
-  //           if (o9.isEmpty)
-  //             (MatchingStrategy.OptionMatchingStrategy.zero: Option[(String, Int)])
-  //           else
-  //             o9
-  //     })
-  //   }
-  // )
-
-  println(res)
+  object constCharEta {
+    final val GT      = 'a'
+    final val GTGT    = 'b'
+    final val GTGTGT  = 'c'
+    final val GTEQ    = 'd'
+    final val GTGTEQ  = 'e'
+    final val GTGTGTEQ= 'f'
+    final val ASSIGN  = 'g'
+
+    def acceptClosingAngle(in: Char) {
+      val closers: PartialFunction[Char, Char] = x => x match {
+        case GTGTGTEQ => GTGTEQ
+        case GTGTGT   => GTGT
+        case GTGTEQ   => GTEQ
+        case GTGT     => GT
+        case GTEQ     => ASSIGN
+      }
+      if (closers isDefinedAt in) println(closers(in))
+      else println("undefined")
+    }
+
+    def test() = {
+      acceptClosingAngle(GTGT)
+      acceptClosingAngle(ASSIGN)
+    }
+  }
+
+  object constChar {
+    final val GT      = 'a'
+    final val GTGT    = 'b'
+    final val GTGTGT  = 'c'
+    final val GTEQ    = 'd'
+    final val GTGTEQ  = 'e'
+    final val GTGTGTEQ= 'f'
+    final val ASSIGN  = 'g'
+
+    def acceptClosingAngle(in: Char) {
+      val closers: PartialFunction[Char, Char] = {
+        case GTGTGTEQ => GTGTEQ
+        case GTGTGT   => GTGT
+        case GTGTEQ   => GTEQ
+        case GTGT     => GT
+        case GTEQ     => ASSIGN
+      }
+      if (closers isDefinedAt in) println(closers(in))
+      else println("undefined")
+    }
+
+    def test() = {
+      acceptClosingAngle(GTGT)
+      acceptClosingAngle(ASSIGN)
+    }
+  }
+
+  object constIntEta {
+    final val GT       = 1
+    final val GTGT     = 2
+    final val GTGTGT   = 3
+    final val GTEQ     = 4
+    final val GTGTEQ   = 5
+    final val GTGTGTEQ = 6
+    final val ASSIGN   = 7
+
+    def acceptClosingAngle(in: Int) {
+      val closers: PartialFunction[Int, Int] = x => {println("hai!"); (x + 1)} match {
+        case GTGTGTEQ => GTGTEQ
+        case GTGTGT   => GTGT
+        case GTGTEQ   => GTEQ
+        case GTGT     => GT
+        case GTEQ     => ASSIGN
+      }
+      if (closers isDefinedAt in) println(closers(in))
+      else println("undefined")
+    }
+
+    def test() = {
+      acceptClosingAngle(GTGT)
+      acceptClosingAngle(ASSIGN)
+    }
+  }
+
+  object constInt {
+    final val GT       = 1
+    final val GTGT     = 2
+    final val GTGTGT   = 3
+    final val GTEQ     = 4
+    final val GTGTEQ   = 5
+    final val GTGTGTEQ = 6
+    final val ASSIGN   = 7
+
+    def acceptClosingAngle(in: Int) {
+      val closers: PartialFunction[Int, Int] = {
+        case GTGTGTEQ => GTGTEQ
+        case GTGTGT   => GTGT
+        case GTGTEQ   => GTEQ
+        case GTGT     => GT
+        case GTEQ     => ASSIGN
+      }
+      if (closers isDefinedAt in) println(closers(in))
+      else println("undefined")
+    }
+
+    def test() = {
+      acceptClosingAngle(GTGT)
+      acceptClosingAngle(ASSIGN)
+    }
+  }
+
+  println(res) // prints "Map(a -> 1)"
+
+  nonConstCharEta.test()
+  nonConstChar.test()
+  constCharEta.test()
+  constChar.test()
+  constIntEta.test()
+  constInt.test()
 }