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
|
package dotty.tools
package dotc
package reporting
import core.Contexts.Context
import diagnostic.messages._
import org.junit.Assert._
import org.junit.Test
class ErrorMessagesTests extends ErrorMessagesTest {
// In the case where there are no errors, we can do "expectNoErrors" in the
// `Report`
@Test def noErrors =
checkMessagesAfter("frontend")("""class Foo""")
.expectNoErrors
@Test def typeMismatch =
checkMessagesAfter("frontend") {
"""
|object Foo {
| def bar: String = 1
|}
""".stripMargin
}
.expect { (ictx, messages) =>
implicit val ctx: Context = ictx
val defn = ictx.definitions
// Assert that we only got one error message
assertMessageCount(1, messages)
// Pattern match out the expected error
val TypeMismatch(found, expected, _, _) :: Nil = messages
// The type of the right hand side will actually be the constant 1,
// therefore we check if it "derivesFrom" `IntClass`
assert(found.derivesFrom(defn.IntClass), s"found was: $found")
// The expected type is `scala.String` which we dealias to
// `java.lang.String` and compare with `=:=` to `defn.StringType` which
// is a type reference to `java.lang.String`
assert(expected.dealias =:= defn.StringType, s"expected was: $expected")
}
@Test def overridesNothing =
checkMessagesAfter("refchecks") {
"""
|object Foo {
| override def bar: Unit = {}
|}
""".stripMargin
}
.expect { (ictx, messages) =>
implicit val ctx: Context = ictx
val defn = ictx.definitions
assertMessageCount(1, messages)
val OverridesNothing(member) :: Nil = messages
assertEquals("bar", member.name.show)
}
@Test def overridesNothingDifferentSignature =
checkMessagesAfter("refchecks") {
"""
|class Bar {
| def bar(s: String): Unit = {}
| def bar(s: Int): Unit = {}
| final def bar(s: Long): Unit = {}
|}
|object Foo extends Bar {
| override def bar: Unit = {}
|}
""".stripMargin
}
.expect { (ictx, messages) =>
implicit val ctx: Context = ictx
val defn = ictx.definitions
assertMessageCount(1, messages)
val OverridesNothingButNameExists(member, sameName) :: Nil = messages
// check expected context data
assertEquals("bar", member.name.show)
assertEquals(3, sameName.size)
assert(sameName.forall(_.symbol.name.show == "bar"),
"at least one method had an unexpected name")
}
}
|
