From dfda38550a2d48662fde917d26dfb8e2d6c64eee Mon Sep 17 00:00:00 2001
From: Lex Spoon <lex@lexspoon.org>
Date: Wed, 28 Nov 2007 05:17:14 +0000
Subject: Merge from the annots-normtrees branch.

now use compiler trees instead of reflect trees.
In many cases, annotations on types can be rewritten
instead of discarded as the types undergo various
operations.  Also, -Yself-in-annots has been added.
---
 test/files/run/constrained-types.scala | 103 +++++++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)
 create mode 100644 test/files/run/constrained-types.scala

(limited to 'test/files/run/constrained-types.scala')

diff --git a/test/files/run/constrained-types.scala b/test/files/run/constrained-types.scala
new file mode 100644
index 0000000000..9a6d31cf6d
--- /dev/null
+++ b/test/files/run/constrained-types.scala
@@ -0,0 +1,103 @@
+/* Check on the processing of annotated types.  Initially this tested
+ * asSeenFrom, but now it also tests packedType and the treatment
+ * of DeBruijn's .  It runs the test using the interpreter so that
+ * the resulting annotated types can be printed out.
+ */
+import scala.tools.nsc._
+import java.io._
+import scala.Console
+
+object Test {
+
+  val testCode = List(
+    "class Annot(obj: Any) extends Annotation with TypeConstraint",
+
+    """class A {
+      |  val x = "hello"
+      |  val y: Int @Annot(x) = 10
+      |  override def toString = "an A"
+      |} """,
+
+
+
+    "val a = new A",
+
+    """val y = a.y   // should rewrite "this.x" to "a.x" """,
+
+
+    "var a2 = new A",
+    "val y2 = a2.y   // should drop the annotation",
+
+
+    """object Stuff {
+      |  val x = "hello"
+      |  val y : Int @Annot(x) = 10
+      |}""",
+
+    "val y = Stuff.y // should rewrite the annotation",
+
+    """class B {
+      |  val y: Int @Annot(Stuff.x) = 10
+      |  override def toString = "a B"
+      |}""",
+
+    "val b = new B",
+    "val y = b.y  // should keep the annotation",
+
+
+    "def m(x: String): String @Annot(x) = x     // m should be annotated with a debruijn",
+    "val three = \"three\"",
+    "val three2 = m(three:three.type)  // should change x to three",
+    "var four = \"four\"",
+    "val four2 = m(four) // should have an existential bound",
+    "val four3 = four2   // should have the same type as four2",
+
+    """val stuff = m("stuff") // should not crash""",
+
+    """class peer extends Annotation // should not crash""", // reported by Manfred Stock
+    """class NPE[T <: NPE[T] @peer] // should not crash""",  // reported by Manfred Stock
+
+    """def m = {
+      |  val x = "three"
+      |  val y : String @Annot(x) = x
+      |  y
+      |} // x should be existentially bound""",
+
+    """def n(y: String) = {
+      |  def m(x: String) : String @Annot(x) = {
+      |    (if (x == "")
+      |      m("default")
+      |    else
+      |      x)
+      |  }
+      |  m("stuff".stripMargin)
+      |} // x should be existentially bound""",
+
+    "class rep extends Annotation",
+    """object A { val x = "hello" : String @ rep }""",
+    "val y = a.x // should drop the annotation",
+
+    "val x = 3 : Int @Annot(e+f+g+h) //should have a graceful error message",
+
+    "class Where(condition: Boolean) extends Annotation",
+    "val x : Int @Where(self > 0 && self < 100) = 3"
+    ).map(_.stripMargin)
+
+
+
+  def main(args: Array[String]) {
+    val settings = new Settings
+    settings.Xplugtypes.value = true
+    settings.Xexperimental.value = true
+    settings.selfInAnnots.value = true
+
+    val interp = new Interpreter(settings)
+
+    for (cmd <- testCode) {
+      println(cmd)
+      interp.interpret(cmd)
+      println()
+      println("-----")
+    }
+  }
+}
-- 
cgit v1.2.3