SBT build, migrated tests to use toolbox compiler

Author: adriaanm

.gitignore

@@ -0,0 +1,45 @@
+#
+# Are you tempted to edit this file?
+#
+# First consider if the changes make sense for all,
+# or if they are specific to your workflow/system.
+# If it is the latter, you can augment this list with
+# entries in .git/info/excludes
+#
+# see also test/files/.gitignore
+#
+
+*.jar
+*~
+
+build.properties
+
+# target directories for ant build
+/build/
+/dists/
+
+# other
+/out/
+/bin/
+/sandbox/
+
+# eclipse, intellij
+/.classpath
+/.project
+/src/intellij/*.iml
+/src/intellij/*.ipr
+/src/intellij/*.iws
+/.cache
+/.idea
+/.settings
+
+# bak files produced by ./cleanup-commit
+*.bak
+
+# Standard symbolic link to build/quick/bin
+qbin
+
+# Mac specific, but that is common enough a dev platform to warrant inclusion.
+.DS_Store
+
+target/

.travis.yml

@@ -0,0 +1,14 @@
+language: scala
+script:
+  - sbt ++$TRAVIS_SCALA_VERSION clean update compile test
+scala:
+  - 2.11.0-SNAPSHOT
+jdk:
+  - openjdk6
+  - openjdk7
+notifications:
+  email:
+    - [email protected]
+
+# if we get weird timeouts, see https://github.com/spray/spray/pull/233
+# 'set concurrentRestrictions in Global += Tags.limit(Tags.Test, 1)'

LICENSE.md

@@ -0,0 +1,28 @@
+Copyright (c) 2010-2013 EPFL
+Copyright (c) 2011-2013 Typesafe, Inc.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the EPFL nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,8 @@
+scala-continuations [<img src="https://api.travis-ci.org/scala/scala-continuations.png"/>](https://travis-ci.org/scala/scala-continuations)
+=========
+
+The Scala Delimited Continuations Plugin and Library, which will continue to ship with Scala 2.11.0.
+
+However, we're looking for a new maintainer for the scala-continuations project, as Typesafe does not have the resources to support and maintain it.
+
+We believe most common use cases for CPS are met by https://github.com/scala/async.

build.sbt

@@ -0,0 +1,42 @@
+import Settings._
+import Keys.{`package` => packageTask }
+
+// plugin logic of build based on https://github.com/retronym/boxer
+
+lazy val commonSettings = scalaModuleSettings ++ Seq(
+  repoName                   := "scala-continuations",
+  organization               := "org.scala-lang.plugins",
+  version                    := "1.0.0-SNAPSHOT",
+  scalaVersion               := "2.11.0-M7",
+  snapshotScalaBinaryVersion := "2.11.0-M7"
+)
+
+lazy val root = project.in( file(".") ).settings( publishArtifact := false ).aggregate(plugin, library).settings(commonSettings : _*)
+
+lazy val plugin = project settings (
+  name                := "scala-continuations-plugin",
+  libraryDependencies += "org.scala-lang" % "scala-compiler" % scalaVersion.value
+) settings (commonSettings : _*)
+
+val pluginJar = packageTask in (plugin, Compile)
+
+// TODO: the library project's test are really plugin tests, but we first need that jar
+lazy val library = project settings (
+  name                 := "scala-continuations-library",
+  scalacOptions       ++= Seq(
+    // add the plugin to the compiler
+    s"-Xplugin:${pluginJar.value.getAbsolutePath}",
+    // enable the plugin
+    "-P:continuations:enable",
+    // add plugin timestamp to compiler options to trigger recompile of
+    // the library after editing the plugin. (Otherwise a 'clean' is needed.)
+    s"-Jdummy=${pluginJar.value.lastModified}"),
+  libraryDependencies ++= Seq(
+    "org.scala-lang" % "scala-compiler" % scalaVersion.value % "test",
+    "junit" % "junit" % "4.11" % "test",
+    "com.novocode" % "junit-interface" % "0.10" % "test"),
+  testOptions          += Tests.Argument(
+    TestFrameworks.JUnit,
+    s"-Dscala-continuations-plugin.jar=${pluginJar.value.getAbsolutePath}"
+  )
+) settings (commonSettings : _*)

src/continuations/library/scala/util/continuations/ControlContext.scala renamed to library/src/main/scala/scala/util/continuations/ControlContext.scala

@@ -0,0 +1,242 @@
+package scala.tools.selectivecps
+
+import org.junit.Test
+
+class CompilerErrors extends CompilerTesting {
+  // @Test -- disabled
+  def infer0 =
+    expectCPSError("cannot cps-transform expression 8: type arguments [Int(8),String,Int] do not conform to method shiftUnit's type parameter bounds [A,B,C >: B]",
+      """|def test(x: => Int @cpsParam[String,Int]) = 7
+         |
+         |def main(args: Array[String]) = {
+         |  test(8)
+         |}""")
+
+  @Test def function0 =
+    expectCPSError("""|type mismatch;
+                       | found   : () => Int @scala.util.continuations.cpsParam[Int,Int]
+                       | required: () => Int""".stripMargin,
+      """|def main(args: Array[String]): Any = {
+         |  val f = () => shift { k: (Int=>Int) => k(7) }
+         |  val g: () => Int = f
+         |
+         |  println(reset(g()))
+         |}""")
+
+  @Test def function2 =
+    expectCPSError(
+      """|type mismatch;
+         | found   : () => Int
+         | required: () => Int @scala.util.continuations.cpsParam[Int,Int]""".stripMargin,
+      """|def main(args: Array[String]): Any = {
+         |  val f = () => 7
+         |  val g: () => Int @cps[Int] = f
+         |
+         |  println(reset(g()))
+         |}""")
+
+  @Test def function3 =
+    expectCPSError(
+      """|type mismatch;
+     | found   : Int @scala.util.continuations.cpsParam[Int,Int]
+     | required: Int""".stripMargin,
+      """|def main(args: Array[String]): Any = {
+       |  val g: () => Int = () => shift { k: (Int=>Int) => k(7) }
+       |
+       |  println(reset(g()))
+       |}""")
+
+  @Test def infer2 =
+    expectCPSError("illegal answer type modification: scala.util.continuations.cpsParam[String,Int] andThen scala.util.continuations.cpsParam[String,Int]",
+      """|def test(x: => Int @cpsParam[String,Int]) = 7
+         |
+         |def sym() = shift { k: (Int => String) => 9 }
+         |
+         |
+         |def main(args: Array[String]): Any = {
+         |  test { sym(); sym() }
+         |}""")
+
+  @Test def `lazy` =
+    expectCPSError("implementation restriction: cps annotations not allowed on lazy value definitions",
+      """|def foo() = {
+         |  lazy val x = shift((k:Unit=>Unit)=>k())
+         |  println(x)
+         |}
+         |
+         |def main(args: Array[String]) = {
+         |  reset {
+         |    foo()
+         |  }
+         |}""")
+
+  @Test def t1929 =
+    expectCPSError(
+      """|type mismatch;
+         | found   : Int @scala.util.continuations.cpsParam[String,String] @scala.util.continuations.cpsSynth
+         | required: Int @scala.util.continuations.cpsParam[Int,String]""".stripMargin,
+      """|def main(args : Array[String]) {
+         |  reset {
+         |    println("up")
+         |    val x = shift((k:Int=>String) => k(8) + k(2))
+         |    println("down " + x)
+         |    val y = shift((k:Int=>String) => k(3))
+         |    println("down2 " + y)
+         |    y + x
+         |  }
+         |}""")
+
+  @Test def t2285 =
+    expectCPSError(
+      """|type mismatch;
+         | found   : Int @scala.util.continuations.cpsParam[String,String] @scala.util.continuations.cpsSynth
+         | required: Int @scala.util.continuations.cpsParam[Int,String]""".stripMargin,
+      """|def bar() = shift { k: (String => String) => k("1") }
+         |
+         |def foo() = reset { bar(); 7 }""")
+
+  @Test def t2949 =
+    expectCPSError(
+      """|type mismatch;
+         | found   : Int
+         | required: ? @scala.util.continuations.cpsParam[List[?],Any]""".stripMargin,
+      """|def reflect[A,B](xs : List[A]) = shift{ xs.flatMap[B, List[B]] }
+         |def reify[A, B](x : A @cpsParam[List[A], B]) = reset{ List(x) }
+         |
+         |def main(args: Array[String]): Unit = println(reify {
+         |  val x = reflect[Int, Int](List(1,2,3))
+         |  val y = reflect[Int, Int](List(2,4,8))
+         |  x * y
+         |})""")
+
+  @Test def t3718 =
+    expectCPSError(
+      "cannot cps-transform malformed (possibly in shift/reset placement) expression",
+      "scala.util.continuations.reset((_: Any).##)")
+
+  @Test def t5314_missing_result_type =
+    expectCPSError(
+      "method bar has return statement; needs result type",
+      """|def foo(x:Int): Int @cps[Int] = x
+         |
+         |def bar(x:Int) = return foo(x)
+         |
+         |reset {
+         |  val res = bar(8)
+         |  println(res)
+         |  res
+         |}""")
+
+  @Test def t5314_npe =
+    expectCPSError(
+      "method bar has return statement; needs result type",
+      "def bar(x:Int) = { return x; x }  // NPE")
+
+  @Test def t5314_return_reset =
+    expectCPSError(
+      "return expression not allowed, since method calls CPS method",
+      """|val rnd = new scala.util.Random
+       |
+       |def foo(x: Int): Int @cps[Int] = shift { k => k(x) }
+       |
+       |def bar(x: Int): Int @cps[Int] = return foo(x)
+       |
+       |def caller(): Int = {
+       |  val v: Int = reset {
+       |    val res: Int = bar(8)
+       |    if (rnd.nextInt(100) > 50) return 5 // not allowed, since method is calling `reset`
+       |    42
+       |  }
+       |  v
+       |}
+       |
+       |caller()""")
+
+  @Test def t5314_type_error =
+    expectCPSError(
+      """|type mismatch;
+         | found   : Int @scala.util.continuations.cpsParam[Int,Int]
+         | required: Int @scala.util.continuations.cpsParam[String,String]""".stripMargin,
+      """|def foo(x:Int): Int @cps[Int] = shift { k => k(x) }
+         |
+         |// should be a type error
+         |def bar(x:Int): Int @cps[String] = return foo(x)
+         |
+         |def caller(): Unit = {
+         |  val v: String = reset {
+         |    val res: Int = bar(8)
+         |    "hello"
+         |  }
+         |}
+         |
+         |caller()""")
+
+  @Test def t5445 =
+    expectCPSError(
+      "cps annotations not allowed on by-value parameters or value definitions",
+      "def foo(block: Unit @suspendable ): Unit @suspendable = {}")
+
+  @Test def trycatch2 =
+    expectCPSErrors(2, "only simple cps types allowed in try/catch blocks (found: Int @scala.util.continuations.cpsParam[String,Int])",
+      """|def fatal[T]: T = throw new Exception
+       |def cpsIntStringInt = shift { k:(Int=>String) => k(3); 7 }
+       |def cpsIntIntString = shift { k:(Int=>Int) => k(3); "7" }
+       |
+       |def foo1 = try {
+       |  fatal[Int]
+       |  cpsIntStringInt
+       |} catch {
+       |  case ex: Throwable =>
+       |    cpsIntStringInt
+       |}
+       |
+       |def foo2 = try {
+       |  fatal[Int]
+       |  cpsIntStringInt
+       |} catch {
+       |  case ex: Throwable =>
+       |    cpsIntStringInt
+       |}
+       |
+       |
+       |def main(args: Array[String]): Unit = {
+       |  println(reset { foo1; "3" })
+       |  println(reset { foo2; "3" })
+       |}""")
+}
+
+class CompilerTesting {
+  def loadPlugin = s"-Xplugin:${sys.props("scala-continuations-plugin.jar")} -P:continuations:enable"
+
+  // note: `code` should have a | margin
+  def cpsErrorMessages(msg: String, code: String) =
+    errorMessages(msg, loadPlugin)(s"import scala.util.continuations._\nobject Test {\n${code.stripMargin}\n}")
+
+  def expectCPSError(msg: String, code: String) = {
+    val errors = cpsErrorMessages(msg, code)
+    assert(errors exists (_ contains msg), errors mkString "\n")
+  }
+
+  def expectCPSErrors(msgCount: Int, msg: String, code: String) = {
+    val errors = cpsErrorMessages(msg, code)
+    val errorCount = errors.filter(_ contains msg).length
+    assert(errorCount == msgCount, s"$errorCount occurrences of \'$msg\' found -- expected $msgCount in:\n${errors mkString "\n"}")
+  }
+
+  // TODO: move to scala.tools.reflect.ToolboxFactory
+  def errorMessages(errorSnippet: String, compileOptions: String)(code: String): List[String] = {
+    import scala.tools.reflect._
+    val m = scala.reflect.runtime.currentMirror
+    val tb = m.mkToolBox(options = compileOptions) //: ToolBox[m.universe.type]
+    val fe = tb.frontEnd
+
+    try {
+      tb.eval(tb.parse(code))
+      Nil
+    } catch {
+      case _: ToolBoxError =>
+        import fe._
+        infos.toList collect { case Info(_, msg, ERROR) => msg }
+    }
+  }
+}

src/continuations/library/scala/util/continuations/package.scala renamed to library/src/main/scala/scala/util/continuations/package.scala

@@ -1,7 +1,8 @@
 import scala.collection.mutable.HashMap
 import scala.util.continuations._
 
-object Test extends Application {
+// https://issues.scala-lang.org/browse/SI-3620
+object t3620 extends App {
 
   class Store[K,V] {