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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// test that none of these warn due to -Xno-patmat-analysis
// tests taken from test/files/neg/patmatexhaust.scala, test/files/neg/pat_unreachable.scala
class TestSealedExhaustive { // compile only
sealed abstract class Foo
case class Bar(x:Int) extends Foo
case object Baz extends Foo
def ma1(x:Foo) = x match {
case Bar(_) => // not exhaustive
}
def ma2(x:Foo) = x match {
case Baz => // not exhaustive
}
sealed abstract class Mult
case class Kult(s:Mult) extends Mult
case class Qult() extends Mult
def ma33(x:Kult) = x match { // exhaustive
case Kult(_) => // exhaustive
}
def ma3(x:Mult) = (x,x) match { // not exhaustive
case (Kult(_), Qult()) => // Kult missing
//case (Kult(_), Kult(_)) =>
case (Qult(), Kult(_)) => // Qult missing
//case (Qult(), Qult()) =>
}
def ma3u(x:Mult) = ((x,x) : @unchecked) match { // not exhaustive, but not checked!
case (Kult(_), Qult()) =>
case (Qult(), Kult(_)) =>
}
sealed abstract class Deep
case object Ga extends Deep
sealed class Gp extends Deep
case object Gu extends Gp
def zma3(x:Deep) = x match { // exhaustive!
case _ =>
}
def zma4(x:Deep) = x match { // exhaustive!
case Ga =>
case _ =>
}
def ma4(x:Deep) = x match { // missing cases: Gu, Gp which is not abstract so must be included
case Ga =>
}
def ma5(x:Deep) = x match {
case Gu =>
case _ if 1 == 0 =>
case Ga =>
}
def ma6() = List(1,2) match { // give up
case List(1,2) =>
case x :: xs =>
}
def ma7() = List(1,2) match { //exhaustive
case 1::2::Nil =>
case _ =>
}
sealed class B
case class B1() extends B
case object B2 extends B
def ma8(x: B) = x match {
case _: B => true
}
def ma9(x: B) = x match {
case B1() => true // missing B, which is not abstract so must be included
case B2 => true
}
object ob1 {
sealed abstract class C
sealed abstract class C1 extends C
object C2 extends C
case class C3() extends C
case object C4 extends C
def ma10(x: C) = x match { // exhaustive: abstract sealed C1 is dead end.
case C3() => true
case C2 | C4 => true
}
}
object ob2 {
sealed abstract class C
abstract class C1 extends C
object C2 extends C
case class C3() extends C
case object C4 extends C
def ma10(x: C) = x match { // not exhaustive: C1 is not sealed.
case C3() => true
case C2 | C4 => true
}
}
object ob3 {
sealed abstract class C
sealed abstract class C1 extends C
object D1 extends C1
case class D2() extends C1
object C2 extends C
case class C3() extends C
case object C4 extends C
def ma10(x: C) = x match { // not exhaustive: C1 has subclasses.
case C3() => true
case C2 | C4 => true
}
}
object ob4 {
sealed abstract class C
sealed class C1 extends C
object C2 extends C
case class C3() extends C
case object C4 extends C
def ma10(x: C) = x match { // not exhaustive: C1 is not abstract.
case C3() => true
case C2 | C4 => true
}
}
}
object TestUnreachable extends App {
def unreachable1(xs:Seq[Char]) = xs match {
case Seq(x, y, _*) => x::y::Nil
case Seq(x, y, z, w) => List(z,w) // redundant!
}
def unreachable2(xs:Seq[Char]) = xs match {
case Seq(x, y, _*) => x::y::Nil
case Seq(x, y) => List(x, y)
}
def not_unreachable(xs:Seq[Char]) = xs match {
case Seq(x, y, _*) => x::y::Nil
case Seq(x) => List(x)
}
def not_unreachable2(xs:Seq[Char]) = xs match {
case Seq(x, y) => x::y::Nil
case Seq(x, y, z, _*) => List(x,y)
}
def contrivedExample[A, B, C](a: A, b: B, c: C): Unit = a match {
case b => println("matched b")
case c => println("matched c")
case _ => println("matched neither")
}
}
|
