blob: ca1ac308211ff74db7e5377e2b2412d0e5b4ae03 (
plain) (
blame)
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
|
class A {
val bippy = 123
def f = "Put the $bippy in the $bippy!" // warn 1
}
class B {
val dingus = 123
def f = "Put the $bippy in the $bippy!" // no warn
}
class C {
def f = """Put the ${println("bippy")} in the bippy!""" // warn 2
}
package object test {
def aleppo = 9
def greppo(n: Int) = ???
def zappos(n: Int)(implicit ord: math.Ordering[Int]) = ???
def hippo(implicit n: Int) = ???
}
package test {
// not sure if overloading is kosher in pkg obj yet
class Doo {
def beppo(i: Int) = 8 * i
def beppo = 8
class Dah extends Doo {
def f = "$beppo was a marx bros who saw dollars." // warn 3
}
}
class E {
def f = "$aleppo is a pepper and a city." // warn 4
def k = s"Just an interpolation of $aleppo" // no warn
}
class Bar {
private def bar = 8
if (bar > 8) ??? // use it to avoid extra warning
}
class Baz extends Bar {
def f = "$bar is private, shall we warn just in case?" // no longer a warning, private members aren't inherited!
}
class G {
def g = "$greppo takes an arg" // no warn
def z = "$zappos takes an arg too" // no warn
def h = "$hippo takes an implicit" // warn 6
}
class J {
def j = 8
class J2 {
def j(i: Int) = 2 * i
def jj = "shadowed $j" // no warn
}
}
import annotation._
@implicitNotFound("No Z in ${T}") // no warn
class Z[T]
}
package inf1 {
import scala.annotation.implicitNotFound
@implicitNotFound(msg = "Cannot construct a collection of type ${To} with elements of type ${Elem} based on a collection of type ${From}.") // no warn
trait CannotBuildFrom[-From, -Elem, +To]
}
package inf2 {
@scala.annotation.implicitNotFound(msg = "Cannot construct a collection of type ${To} with elements of type ${Elem} based on a collection of type ${From}.") // no warn
trait CannotBuildFrom[-From, -Elem, +To]
}
package inf3 {
@scala.annotation.implicitNotFound("Cannot construct a collection of type ${To} with elements of type ${Elem} based on a collection of type ${From}.") // no warn
trait CannotBuildFrom[-From, -Elem, +To]
}
package curry {
class A {
def bunko()(x: Int): Int = 5
def groucho(): Int = 5
def dingo()()()()()(): Int = 5 // kind of nuts this can be evaluated with just 'dingo', but okay
def calico[T1, T2]()()(): Int = 5 // even nutsier
def palomino[T1, T2]()(y: Int = 5)(): Int = 5 // even nutsier
def f1 = "I was picked up by the $bunko squad" // no warn
def f2 = "I salute $groucho" // warn 7
def f3 = "I even salute $dingo" // warn 8
def f4 = "I also salute $calico" // warn 9
def f5 = "I draw the line at $palomino" // no warn
}
}
|
