1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
trait Treez requires Shmeez {
abstract class Tree
case class Beez(i:Int) extends Tree
case object HagbardCeline extends Tree
}
trait Shmeez extends AnyRef with Treez {
val tree: Tree
def foo = tree match {
case Beez(2) => 1
case HagbardCeline => 0
}
}
object Test {
/*
import scala.testing.SUnit._
def main(args:Array[String]): Unit = {
val tr = new TestResult
new TestSuite(
new Test717,
new TestGuards
).run(tr)
for(val f <- tr.failures())
Console println f
}
class Foo(j:Int) {
case class Bar(i:Int)
}
class Test717 extends TestCase("#717 test path of case classes") {
val foo1 = new Foo(1)
val foo2 = new Foo(2)
override def runTest() = {
val res = (foo1.Bar(2):Any) match {
case foo2.Bar(2) => false
case foo1.Bar(2) => true
}
assertTrue("ok", res);
}
}
class TestGuards extends TestCase("multiple guards for same pattern") with Shmeez {
val tree:Tree = Beez(2)
override def runTest = {
val res = tree match {
case Beez(x) if x == 3 => false
case Beez(x) if x == 2 => true
}
assertTrue("ok", res);
val ret = (Beez(3):Tree) match {
case Beez(x) if x == 3 => true
case Beez(x) if x == 2 => false
}
assertTrue("ok", ret);
}
}
class Test806_818 { // #806, #811 compile only -- type of bind
// bug811
trait Core {
trait NodeImpl;
trait OtherImpl extends NodeImpl;
trait DoubleQuoteImpl extends NodeImpl;
def asDQ(node : OtherImpl) = node match {
case dq : DoubleQuoteImpl => dq;
}
}
trait IfElseMatcher {
type Node <: NodeImpl;
trait NodeImpl;
trait IfImpl;
private def coerceIf(node : Node) = node match {
case node : IfImpl => node; // var node is of type Node with IfImpl!
case _ => null;
}
}
}
// these are exhaustive matches
// should not generate any warnings
def f[A](z:{Option[A],Option[A]}) = z match {
case {None,Some(x)} => 1
case {Some(x),None } => 2
case {Some(x),Some(y)} => 3
case _ => 4
}
def g1[A](z:Option[List[A]]) = z match {
case Some(Nil) => true
case Some(x::Nil) => true
case _ => true
}
def g2[A](z:Option[List[A]]) = z match {
case Some(x::Nil) => true
case Some(_) => false
case _ => true
}
def h[A](x:{Option[A],Option[A]}) = x match {
case {None,_:Some[_]} => 1
case {_:Some[_],None } => 2
case {_:Some[_],_:Some[_]} => 3
case _ => 4
}
*/
def i = List(1,2) match {
case List(1) =>
case List(1,2,xs @ _*) =>
case Nil =>
}
}
|
