aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/neg/inlineAccess/C_1.scala8
-rw-r--r--tests/neg/inlineAccess/Test_2.scala7
-rw-r--r--tests/neg/inlinevals.scala24
-rw-r--r--tests/neg/power.scala15
-rw-r--r--tests/pos/rbtree.scala10
-rw-r--r--tests/run/inline.check9
-rw-r--r--tests/run/inline/Test_2.scala21
-rw-r--r--tests/run/inline/inlines_1.scala41
-rw-r--r--tests/run/inlineAccess/C_1.scala7
-rw-r--r--tests/run/inlineAccess/Test_2.scala7
-rw-r--r--tests/run/inlineArrowAssoc.scala24
-rw-r--r--tests/run/inlineForeach.check137
-rw-r--r--tests/run/inlineForeach.scala48
-rw-r--r--tests/run/inlinePower.check2
-rw-r--r--tests/run/inlinePower/Test_2.scala9
-rw-r--r--tests/run/inlinePower/power_1.scala12
-rw-r--r--tests/run/inlinePrivates.scala36
-rw-r--r--tests/run/inlinedAssign.scala24
-rw-r--r--tests/run/outerPatternMatch/Outer_1.scala6
-rw-r--r--tests/run/outerPatternMatch/Test_2.scala14
20 files changed, 456 insertions, 5 deletions
diff --git a/tests/neg/inlineAccess/C_1.scala b/tests/neg/inlineAccess/C_1.scala
new file mode 100644
index 000000000..9d34fa3f0
--- /dev/null
+++ b/tests/neg/inlineAccess/C_1.scala
@@ -0,0 +1,8 @@
+package p
+private class D
+class C {
+ inline def inl(): Unit = {
+ val d = new D() // error (when inlined): not accessible
+ }
+}
+
diff --git a/tests/neg/inlineAccess/Test_2.scala b/tests/neg/inlineAccess/Test_2.scala
new file mode 100644
index 000000000..98ea7693a
--- /dev/null
+++ b/tests/neg/inlineAccess/Test_2.scala
@@ -0,0 +1,7 @@
+
+object Test {
+ def main(args: Array[String]) = {
+ val c = new p.C()
+ c.inl()
+ }
+}
diff --git a/tests/neg/inlinevals.scala b/tests/neg/inlinevals.scala
new file mode 100644
index 000000000..184aa2168
--- /dev/null
+++ b/tests/neg/inlinevals.scala
@@ -0,0 +1,24 @@
+object Test {
+
+ def power(x: Double, inline n: Int): Double = ???
+
+ inline val N = 10
+ def X = 20
+
+ inline inline val twice = 30 // error: repeated modifier
+
+ class C(inline x: Int, private inline val y: Int) {
+ inline val foo: Int // error: abstract member may not be inline
+ inline def bar: Int // error: abstract member may not be inline
+ }
+
+ power(2.0, N) // ok, since it's a by-name parameter
+ power(2.0, X) // error: argument to inline parameter must be a constant expression
+
+ inline val M = X // error: rhs must be constant expression
+
+ def byname(inline f: => String): Int = ??? // ok
+
+ byname("hello" ++ " world")
+
+}
diff --git a/tests/neg/power.scala b/tests/neg/power.scala
new file mode 100644
index 000000000..6230b4e51
--- /dev/null
+++ b/tests/neg/power.scala
@@ -0,0 +1,15 @@
+object Test {
+
+ @inline
+ def power(x: Double, n: Int): Double =
+ if (n == 0) 1.0
+ else if (n == 1) x
+ else {
+ val y = power(x, n / 2) // error: maximal number of inlines exceeded
+ if (n % 2 == 0) y * y else y * y * x
+ }
+
+ def main(args: Array[String]): Unit = {
+ println(power(2.0, args.length))
+ }
+}
diff --git a/tests/pos/rbtree.scala b/tests/pos/rbtree.scala
index 1401a1231..04c084596 100644
--- a/tests/pos/rbtree.scala
+++ b/tests/pos/rbtree.scala
@@ -430,12 +430,12 @@ object RedBlackTree {
* An alternative is to implement the these classes using plain old Java code...
*/
sealed abstract class Tree[A, +B](
- @(inline @getter) final val key: A,
- @(inline @getter) final val value: B,
- @(inline @getter) final val left: Tree[A, B],
- @(inline @getter) final val right: Tree[A, B])
+ @(`inline` @getter) final val key: A,
+ @(`inline` @getter) final val value: B,
+ @(`inline` @getter) final val left: Tree[A, B],
+ @(`inline` @getter) final val right: Tree[A, B])
extends Serializable {
- @(inline @getter) final val count: Int = 1 + RedBlackTree.count(left) + RedBlackTree.count(right)
+ @(`inline` @getter) final val count: Int = 1 + RedBlackTree.count(left) + RedBlackTree.count(right)
def black: Tree[A, B]
def red: Tree[A, B]
}
diff --git a/tests/run/inline.check b/tests/run/inline.check
new file mode 100644
index 000000000..5f711274b
--- /dev/null
+++ b/tests/run/inline.check
@@ -0,0 +1,9 @@
+100
+10000
+
+ Inner
+Outer.f
+Outer.f Inner
+ Inner
+Outer.f
+Outer.f Inner
diff --git a/tests/run/inline/Test_2.scala b/tests/run/inline/Test_2.scala
new file mode 100644
index 000000000..605868c80
--- /dev/null
+++ b/tests/run/inline/Test_2.scala
@@ -0,0 +1,21 @@
+object Test {
+
+ import p.inlines._
+
+ def main(args: Array[String]): Unit = {
+ println(f(10))
+ println(f(f(10)))
+
+ track("hello") { println("") }
+
+ val o = new Outer
+ val i = new o.Inner
+ println(i.m)
+ println(i.g)
+ println(i.h)
+ println(o.inner.m)
+ println(o.inner.g)
+ println(o.inner.h)
+ }
+
+}
diff --git a/tests/run/inline/inlines_1.scala b/tests/run/inline/inlines_1.scala
new file mode 100644
index 000000000..24f1c78fe
--- /dev/null
+++ b/tests/run/inline/inlines_1.scala
@@ -0,0 +1,41 @@
+package p
+import collection.mutable
+
+object inlines {
+
+ final val monitored = false
+
+ inline def f(x: Int): Int = x * x
+
+ val hits = new mutable.HashMap[String, Int] {
+ override def default(key: String): Int = 0
+ }
+
+ def record(fn: String, n: Int = 1) = {
+ if (monitored) {
+ val name = if (fn.startsWith("member-")) "member" else fn
+ hits(name) += n
+ }
+ }
+
+ @volatile private var stack: List[String] = Nil
+
+ inline def track[T](fn: String)(op: => T) =
+ if (monitored) {
+ stack = fn :: stack
+ record(fn)
+ try op
+ finally stack = stack.tail
+ } else op
+
+ class Outer {
+ def f = "Outer.f"
+ class Inner {
+ val msg = " Inner"
+ inline def m = msg
+ inline def g = f
+ inline def h = f ++ m
+ }
+ val inner = new Inner
+ }
+}
diff --git a/tests/run/inlineAccess/C_1.scala b/tests/run/inlineAccess/C_1.scala
new file mode 100644
index 000000000..349f5b150
--- /dev/null
+++ b/tests/run/inlineAccess/C_1.scala
@@ -0,0 +1,7 @@
+package p {
+class C {
+ protected def f(): Unit = ()
+
+ inline def inl() = f() // error (when inlined): not accessible
+}
+}
diff --git a/tests/run/inlineAccess/Test_2.scala b/tests/run/inlineAccess/Test_2.scala
new file mode 100644
index 000000000..98ea7693a
--- /dev/null
+++ b/tests/run/inlineAccess/Test_2.scala
@@ -0,0 +1,7 @@
+
+object Test {
+ def main(args: Array[String]) = {
+ val c = new p.C()
+ c.inl()
+ }
+}
diff --git a/tests/run/inlineArrowAssoc.scala b/tests/run/inlineArrowAssoc.scala
new file mode 100644
index 000000000..c3625609a
--- /dev/null
+++ b/tests/run/inlineArrowAssoc.scala
@@ -0,0 +1,24 @@
+import scala.collection.immutable._
+
+import scala.collection.mutable.{ Builder, ListBuffer }
+
+object Test {
+
+ private val defaultOrdering = Map[Numeric[_], Ordering[_]](
+ Numeric.BigIntIsIntegral -> Ordering.BigInt,
+ Numeric.IntIsIntegral -> Ordering.Int
+ )
+
+ final implicit class ArrowAssoc[A](private val self: A) extends AnyVal {
+ @inline def -> [B](y: B): Tuple2[A, B] = Tuple2(self, y)
+ def →[B](y: B): Tuple2[A, B] = ->(y)
+ }
+
+ def main(args: Array[String]): Unit = {
+ assert((1 -> 2) == (1, 2))
+ assert((1 → 2) == (1, 2))
+ }
+
+
+}
+
diff --git a/tests/run/inlineForeach.check b/tests/run/inlineForeach.check
new file mode 100644
index 000000000..3fced2fad
--- /dev/null
+++ b/tests/run/inlineForeach.check
@@ -0,0 +1,137 @@
+1
+2
+3
+4
+5
+6
+7
+8
+9
+1
+2
+3
+4
+5
+6
+7
+8
+9
+1
+2
+3
+4
+5
+6
+7
+8
+9
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+2
+2
+2
+2
+2
+2
+2
+2
+2
+2
+3
+3
+3
+3
+3
+3
+3
+3
+3
+3
+4
+4
+4
+4
+4
+4
+4
+4
+4
+4
+5
+5
+5
+5
+5
+5
+5
+5
+5
+5
+6
+6
+6
+6
+6
+6
+6
+6
+6
+6
+7
+7
+7
+7
+7
+7
+7
+7
+7
+7
+8
+8
+8
+8
+8
+8
+8
+8
+8
+8
+9
+9
+9
+9
+9
+9
+9
+9
+9
+9
+10
+10
+10
+10
+10
+10
+10
+10
+10
+10
diff --git a/tests/run/inlineForeach.scala b/tests/run/inlineForeach.scala
new file mode 100644
index 000000000..1389ad6c4
--- /dev/null
+++ b/tests/run/inlineForeach.scala
@@ -0,0 +1,48 @@
+object Test {
+
+ class Range(from: Int, end: Int) {
+
+ inline
+ def foreach(inline op: Int => Unit): Unit = {
+ var i = from
+ while (i < end) {
+ op(i)
+ i += 1
+ }
+ }
+
+ def filter(p: Int => Boolean): List[Int] = ???
+ }
+
+ implicit class intWrapper(private val start: Int) extends AnyVal {
+ def until(end: Int) = new Range(start, end)
+ def to(limit: Int) = new Range(start, limit + 1)
+ }
+
+ def matmul(xs: Array[Array[Double]], ys: Array[Array[Double]]): Array[Array[Double]] = {
+ def nrows = xs.length
+ def ncols = ys(0).length
+ def n = ys.length
+ assert(xs(0).length == n)
+ val zs = Array.ofDim[Double](nrows, ncols)
+ for (i <- intWrapper(0) until nrows)
+ for (j <- 0 until ncols) {
+ var x = 0.0
+ for (k <- 0 until n)
+ x += xs(i)(k) * ys(k)(j)
+ zs(i)(j) = x
+ }
+ zs
+ }
+
+ def main(args: Array[String]) = {
+ 1.until(10).foreach(i => println(i))
+ 1.until(10).foreach(println(_))
+ 1.until(10).foreach(println)
+ for (i <- 1 to 10) println(i)
+
+ for (k1 <- 1 to 10)
+ for (k2 <- 1 to 10)
+ println(s"$k1")
+ }
+}
diff --git a/tests/run/inlinePower.check b/tests/run/inlinePower.check
new file mode 100644
index 000000000..25e115634
--- /dev/null
+++ b/tests/run/inlinePower.check
@@ -0,0 +1,2 @@
+1024.0
+2048.0
diff --git a/tests/run/inlinePower/Test_2.scala b/tests/run/inlinePower/Test_2.scala
new file mode 100644
index 000000000..8e16587b5
--- /dev/null
+++ b/tests/run/inlinePower/Test_2.scala
@@ -0,0 +1,9 @@
+import p.pow.power
+object Test {
+
+ def main(args: Array[String]): Unit = {
+ println(power(2.0, 10))
+ def x = 2.0
+ println(power(x, 11))
+ }
+}
diff --git a/tests/run/inlinePower/power_1.scala b/tests/run/inlinePower/power_1.scala
new file mode 100644
index 000000000..4e96d7caa
--- /dev/null
+++ b/tests/run/inlinePower/power_1.scala
@@ -0,0 +1,12 @@
+package p
+
+object pow {
+
+ inline def power(x: Double, n: Int): Double =
+ if (n == 0) 1.0
+ else if (n == 1) x
+ else {
+ val y = power(x, n / 2)
+ if (n % 2 == 0) y * y else y * y * x
+ }
+}
diff --git a/tests/run/inlinePrivates.scala b/tests/run/inlinePrivates.scala
new file mode 100644
index 000000000..ce438ae8d
--- /dev/null
+++ b/tests/run/inlinePrivates.scala
@@ -0,0 +1,36 @@
+object Test {
+
+ class C[T](private val x: T) {
+
+ private def foo[Z](z: Z): T = x
+
+ private var y: T = _
+
+ inline def get1 = x
+ inline def get2[U](c: C[U]) = c.x
+
+ inline def foo1(x: Int) = foo(x)
+ inline def foo2[U](c: C[U]) = c.foo(x)
+
+ inline def set1(z: T) = { y = z; y }
+ inline def set2[U](c: C[U]) = { c.y = c.x; c.y }
+ }
+
+ object CC {
+ private val x = 3
+ inline def get1 = x
+ }
+
+ def main(args: Array[String]) = {
+ val cc = new C(2)
+ assert(cc.get1 == 2)
+ assert(cc.get2(cc) == 2)
+ assert(cc.foo1(1) == 2)
+ assert(cc.foo2(cc) == 2)
+ assert(cc.set1(3) == 3)
+ assert(cc.set2(cc) == 2)
+
+ assert(CC.get1 == 3)
+ }
+
+}
diff --git a/tests/run/inlinedAssign.scala b/tests/run/inlinedAssign.scala
new file mode 100644
index 000000000..1b524f92b
--- /dev/null
+++ b/tests/run/inlinedAssign.scala
@@ -0,0 +1,24 @@
+object Test {
+
+ inline def swap[T](x: T, inline x_= : T => Unit, y: T, inline y_= : T => Unit) = {
+ x_=(y)
+ y_=(x)
+ }
+
+ inline def f(x: Int => Unit) = x
+
+ def main(args: Array[String]) = {
+ var x = 1
+ var y = 2
+ inline def setX(z: Int) = x = z
+ inline def setY(z: Int) = y = z
+ swap(x, setX, y, setY)
+ assert(x == 2 && y == 1)
+
+ swap(x, x = _, y, y = _)
+ assert(x == 1 && y == 2)
+
+
+ val z = f(setX) // tests case where inline arg is not applied
+ }
+}
diff --git a/tests/run/outerPatternMatch/Outer_1.scala b/tests/run/outerPatternMatch/Outer_1.scala
new file mode 100644
index 000000000..c3b102323
--- /dev/null
+++ b/tests/run/outerPatternMatch/Outer_1.scala
@@ -0,0 +1,6 @@
+class Outer {
+
+ class Inner
+
+}
+
diff --git a/tests/run/outerPatternMatch/Test_2.scala b/tests/run/outerPatternMatch/Test_2.scala
new file mode 100644
index 000000000..e46f52f20
--- /dev/null
+++ b/tests/run/outerPatternMatch/Test_2.scala
@@ -0,0 +1,14 @@
+object Test {
+
+ def main(args: Array[String]): Unit = {
+ val x = new Outer
+ val y = new Outer
+ val i = new x.Inner
+ val j = new y.Inner
+ i match {
+ case _: y.Inner => assert(false)
+ case _: x.Inner => // OK
+ }
+ }
+
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-02 20:48:01 +0000