Merge pull request #1324 from felixmulder/fix/dotc-version#1321

Multiple fixes for `bin/dotc` and `bin/dotr`

6 files changed, 254 insertions, 98 deletions

diff --git a/.gitignore b/.gitignore
index ce4e4a440..c9f12e986 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,3 +38,6 @@ scala-scala
 # Ignore output files but keep the directory
 out/
 !out/.keep
+
+# Ignore build-file
+.packages
diff --git a/bin/common b/bin/common
new file mode 100755
index 000000000..150e79016
--- /dev/null
+++ b/bin/common
@@ -0,0 +1,138 @@
+#!/bin/bash
+
+# Finds in dotty build file a line containing PATTERN
+# returns last "" escaped string in this line
+function getLastStringOnLineWith {
+    PATTERN="$1"
+    grep "$PATTERN" "$DOTTY_ROOT/project/Build.scala"|sed -n 's/.*\"\(.*\)\".*/\1/'p
+}
+
+# Configuration
+SCALA_VERSION=$(getLastStringOnLineWith "scalaVersion in")
+SCALA_BINARY_VERSION=2.11
+SCALA_COMPILER_VERSION=$(getLastStringOnLineWith "scala-compiler")
+JLINE_VERSION=$(getLastStringOnLineWith "jline")
+SBT_VERSION=$(grep "sbt.version=" "$DOTTY_ROOT/project/build.properties" | sed 's/sbt.version=//')
+bootcp=true
+bootstrapped=false
+default_java_opts="-Xmx768m -Xms768m"
+programName=$(basename "$0")
+# uncomment next line to enable debug output
+#debug=true
+
+declare -a java_args scala_args residual_args
+unset verbose quiet cygwin toolcp colors saved_stty CDPATH
+
+function find_jar {
+    # Usage:
+    #   find_jar path/to/location file.jar
+    local artifact="$1/$2"
+
+    if [ ! -f "$artifact" ]; then
+        artifact=$(find "$HOME/.coursier/cache" -iname "$2")
+    fi
+
+    echo "$artifact"
+}
+
+# Autodetecting the scala-library location, in case it wasn't provided by an environment variable
+if [ "$SCALA_LIBRARY_JAR" == "" ]; then
+    SCALA_LIBRARY_JAR=$(find_jar "$HOME/.ivy2/cache/org.scala-lang/scala-library/jars" "scala-library-$SCALA_VERSION.jar")
+fi
+
+if [ "$SCALA_REFLECT_JAR" == "" ]; then
+    SCALA_REFLECT_JAR=$(find_jar "$HOME/.ivy2/cache/org.scala-lang/scala-reflect/jars" "scala-reflect-$SCALA_VERSION.jar")
+fi
+
+if [ "$SCALA_COMPILER_JAR" == "" ]; then
+    SCALA_COMPILER_JAR=$(find_jar "$HOME/.ivy2/cache/me.d-d/scala-compiler/jars" "scala-compiler-$SCALA_COMPILER_VERSION.jar")
+fi
+
+if [ "$JLINE_JAR" == "" ]; then
+    JLINE_JAR=$(find_jar "$HOME/.ivy2/cache/jline/jline/jars" "jline-$JLINE_VERSION.jar")
+fi
+
+if [ "$SBT_INTERFACE_JAR" == "" ]; then
+    SBT_INTERFACE_JAR=$(find_jar "$HOME/.ivy2/cache/org.scala-sbt/interface/jars" "interface-$SBT_VERSION.jar")
+fi
+
+function build_jar {
+    # Usage:
+    #   build_jar package path/to/jar/dir ['/some/sed/command']
+    #
+    #   Last arg is optional
+    cd $DOTTY_ROOT >& /dev/null
+    local build_output=$(sbt "$1")
+    local jar=$(echo $build_output | sed -n 's/.*Packaging //g; s/ \.\.\..*//g; /^\/.*/p')
+
+    local sedjar="$3"
+    if [ "$sedjar" == "" ]; then
+        sedjar="/.*\.jar/p"
+    fi
+
+    if [ "$jar" == "" ]; then
+        # Didn't build a jar - could've run sbt by oneself, get latest jar in target:
+        jar="$DOTTY_ROOT/$2/$(ls -1t "$2" | sed -n "$sedjar" | awk 'NR==1')"
+    fi
+
+    cd - >& /dev/null
+
+    echo $jar
+}
+
+function update_packages {
+    echo "$INTERFACES_JAR" >  $DOTTY_ROOT/.packages
+    echo "$MAIN_JAR"       >> $DOTTY_ROOT/.packages
+    echo "$TEST_JAR"       >> $DOTTY_ROOT/.packages
+}
+
+function build_all {
+    echo "The script is going to build the required jar files"
+
+    printf "Building dotty-interfaces..."
+    INTERFACES_JAR=$(build_jar dotty-interfaces/package interfaces/target)
+    printf "done\n"
+
+    printf "Building dotty..."
+    MAIN_JAR=$(build_jar package target/scala-2.11)
+    printf "done\n"
+
+    printf "Building tests..."
+    TEST_JAR=$(build_jar test:package target/scala-2.11 '/dotty.*-tests\.jar/p')
+    printf "done\n"
+
+    update_packages
+}
+
+# Check if .packages file does not exist - if so assume old build and rebuild all
+if  [ ! -f "$DOTTY_ROOT/.packages" ]; then
+    build_all
+else
+    IFS=$'\r\n' GLOBIGNORE='*' command eval 'JARS=($(cat $DOTTY_ROOT/.packages))'
+
+    if [ "${#JARS[@]}" == "3" ]; then
+        INTERFACES_JAR="${JARS[0]}"
+        MAIN_JAR="${JARS[1]}"
+        TEST_JAR="${JARS[2]}"
+    else
+        echo "Corrupted .packages file"
+        build_all
+    fi
+fi
+
+################# After this point, jar variables will be set #################
+function check_jar {
+    # Usage:
+    #   check_jar "name" "path/to/package.jar" "sources/dir" 'lambda to exec on failure'
+    local new_files="$(find "$3" \( -iname "*.scala" -o -iname "*.java" \) -newer "$2")"
+    if [ ! -z "$new_files" ]; then
+        printf "New files detected in $1, rebuilding..."
+        eval "$4"
+        printf "done\n"
+        update_packages
+    fi
+}
+
+check_jar "dotty-interfaces" $INTERFACES_JAR "interfaces" 'INTERFACES_JAR=$(build_jar dotty-interfaces/package interfaces/target)'
+check_jar "dotty"            $MAIN_JAR       "src"        'MAIN_JAR=$(build_jar package target/scala-2.11)'
+check_jar "dotty-tests"      $TEST_JAR       "test"       'TEST_JAR=$(build_jar test:package target/scala-2.11 /dotty.*-tests\.jar/p)'
diff --git a/bin/dotc b/bin/dotc
index 128b42c4b..f604483c1 100755
--- a/bin/dotc
+++ b/bin/dotc
@@ -10,102 +10,15 @@ fi
 DOTTY_ROOT="$(dirname "$DOTTY_ROOT")"
 DOTTY_ROOT="$( cd "$DOTTY_ROOT" >& /dev/null && pwd )/.."  # absolute
 
-# Finds in dotty build file a line containing PATTERN
-# returns last "" escaped string in this line
-function getLastStringOnLineWith {
-  PATTERN="$1"
-  grep "$PATTERN" "$DOTTY_ROOT/project/Build.scala"|sed -n 's/.*\"\(.*\)\".*/\1/'p
-}
-
-# Configuration
-SCALA_VERSION=$(getLastStringOnLineWith "scalaVersion in")
-SCALA_BINARY_VERSION=2.11
-SCALA_COMPILER_VERSION=$(getLastStringOnLineWith "scala-compiler")
-DOTTY_VERSION=$(getLastStringOnLineWith "version in")
-JLINE_VERSION=$(getLastStringOnLineWith "jline")
-SBT_VERSION=$(grep "sbt.version=" "$DOTTY_ROOT/project/build.properties" | sed 's/sbt.version=//')
-bootcp=true
-bootstrapped=false
-default_java_opts="-Xmx768m -Xms768m"
-programName=$(basename "$0")
-# uncomment next line to enable debug output
-#debug=true
-
-
-
-declare -a java_args scala_args residual_args
-unset verbose quiet cygwin toolcp colors saved_stty CDPATH
+source $DOTTY_ROOT/bin/common
 
+# dotc.build test places bootstrapped jar here
+DOTTY_JAR=$DOTTY_ROOT/dotty.jar
 
 CompilerMain=dotty.tools.dotc.Main
 FromTasty=dotty.tools.dotc.FromTasty
 ReplMain=dotty.tools.dotc.repl.Main
 
-
-
-# autodetecting the compiler jars. this is the location where sbt 'packages' them
-INTERFACES_JAR=$DOTTY_ROOT/interfaces/target/dotty-interfaces-$DOTTY_VERSION.jar
-MAIN_JAR=$DOTTY_ROOT/target/scala-$SCALA_BINARY_VERSION/dotty_$SCALA_BINARY_VERSION-$DOTTY_VERSION.jar
-TEST_JAR=$DOTTY_ROOT/target/scala-$SCALA_BINARY_VERSION/dotty_$SCALA_BINARY_VERSION-$DOTTY_VERSION-tests.jar
-DOTTY_JAR=$DOTTY_ROOT/dotty.jar
-
-function checkjar {
-  if [ ! -f "$1" ]
-  then
-    echo "The script is going to build the required jar file $1 by running \"sbt $2\""
-    cd $DOTTY_ROOT
-    sbt "$2"
-    cd -
-    if [ ! -f "$1" ]
-    then
-      echo "The required jar file has not been built by sbt. Please run \"sbt $2\""
-      exit 1
-    else
-      echo "The required jar file was built successfully."
-    fi
-  else
-    NEW_FILES="$(find "$DOTTY_ROOT/$3" \( -iname "*.scala" -o -iname "*.java" \) -newer "$1")"
-    if [ ! -z "$NEW_FILES" ]; 
-    then
-      echo "new files detected. rebuilding"
-      cd $DOTTY_ROOT
-      sbt "$2"
-      touch "$1"
-      cd -
-    fi
-  fi
-}
-
-checkjar $INTERFACES_JAR dotty-interfaces/package interfaces
-checkjar $MAIN_JAR package src
-checkjar $TEST_JAR test:package test
-
-# Autodetecting the scala-library location, in case it wasn't provided by an environment variable
-if [ "$SCALA_LIBRARY_JAR" == "" ]
-then
-  SCALA_LIBRARY_JAR=$HOME/.ivy2/cache/org.scala-lang/scala-library/jars/scala-library-$SCALA_VERSION.jar
-  # this is location where sbt stores it in ivy cache
-fi
-# save as for scala-library now for scala-reflect
-if [ "$SCALA_REFLECT_JAR" == "" ]
-then
-  SCALA_REFLECT_JAR=$HOME/.ivy2/cache/org.scala-lang/scala-reflect/jars/scala-reflect-$SCALA_VERSION.jar
-fi
-if [ "$SCALA_COMPILER_JAR" == "" ]
-then
-  SCALA_COMPILER_JAR=$HOME/.ivy2/cache/me.d-d/scala-compiler/jars/scala-compiler-$SCALA_COMPILER_VERSION.jar
-fi
-
-if [ "$JLINE_JAR" == "" ]
-then
-  JLINE_JAR=$HOME/.ivy2/cache/jline/jline/jars/jline-$JLINE_VERSION.jar
-fi
-
-if [ "$SBT_INTERFACE_JAR" == "" ]
-then
-  SBT_INTERFACE_JAR=$HOME/.ivy2/cache/org.scala-sbt/interface/jars/interface-$SBT_VERSION.jar
-fi
-
 if [ ! -f "$SCALA_LIBRARY_JAR" -o ! -f "$SCALA_REFLECT_JAR"  -o ! -f "$SCALA_COMPILER_JAR"  -o ! -f "$JLINE_JAR" -o ! -f "$SBT_INTERFACE_JAR" ]
 then
   echo To use this script please set
@@ -201,8 +114,8 @@ trap onExit INT
 # If using the boot classpath, also pass an empty classpath
 # to java to suppress "." from materializing.
 classpathArgs () {
-  if [[ "true" == $bootstrapped ]]; then 
-    checkjar $DOTTY_JAR "test:runMain dotc.build" src
+  if [[ "true" == $bootstrapped ]]; then
+    check_jar "dotty-bootstrapped" $DOTTY_JAR "target" 'build_jar "test:runMain dotc.build" target' &> /dev/null
     toolchain="$DOTTY_JAR:$SCALA_LIBRARY_JAR:$SCALA_REFLECT_JAR:$SCALA_COMPILER_JAR:$JLINE_JAR:$SBT_INTERFACE_JAR"
   else
     toolchain="$SCALA_LIBRARY_JAR:$SCALA_REFLECT_JAR:$SCALA_COMPILER_JAR:$JLINE_JAR:$SBT_INTERFACE_JAR"
diff --git a/bin/dotr b/bin/dotr
index ee113b706..a3870ac7a 100755
--- a/bin/dotr
+++ b/bin/dotr
@@ -8,11 +8,25 @@ fi
 DOTTY_ROOT="$(dirname "$DOTTY_ROOT")"
 DOTTY_ROOT="$( cd "$DOTTY_ROOT" >& /dev/null && pwd )/.."  # absolute
 
-# CLASS_PATH is derived from the DOTTY_ROOT
-CLASS_PATH="-J-Xbootclasspath/a:.:$DOTTY_ROOT/target/scala-2.11/classes/"
+# Load common functions and variables
+source $DOTTY_ROOT/bin/common
+
+# CLASS_PATH is derived from the DOTTY_ROOT and SCALA_LIBRARY_JAR
+CLASS_PATH="-Xbootclasspath/a:.:$DOTTY_ROOT/target/scala-2.11/classes/:.:$SCALA_LIBRARY_JAR"
 
 function runMain {
-    scala $CLASS_PATH $@
+    local jbin=$(which "java")
+
+    if [ ! -z "$JAVA_BIN" ]; then
+        jbin=$JAVA_BIN
+    fi
+
+    if [ "$jbin" == "" ]; then
+        echo "java bin not detected - please specify with \$JAVA_BIN or install java to a default location"
+        exit 1
+    else
+        eval "$jbin $CLASS_PATH $@"
+    fi
 }
 
 if [ -z "$1" ]; then
diff --git a/project/Build.scala b/project/Build.scala
index fc452f7f6..ecb0668bd 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -93,8 +93,7 @@ object DottyBuild extends Build {
                                   "org.scala-lang.modules" %% "scala-partest" % "1.0.11" % "test",
                                   "com.novocode" % "junit-interface" % "0.11" % "test",
                                   "jline" % "jline" % "2.12",
-                                  "org.scala-sbt" % "interface" % sbtVersion.value),
-
+                                  "com.typesafe.sbt" % "sbt-interface" % sbtVersion.value),
       // enable improved incremental compilation algorithm
       incOptions := incOptions.value.withNameHashing(true),
 
@@ -205,7 +204,7 @@ object DottyBuild extends Build {
       description := "sbt compiler bridge for Dotty",
       resolvers += Resolver.typesafeIvyRepo("releases"),
       libraryDependencies ++= Seq(
-        "org.scala-sbt" % "interface" % sbtVersion.value,
+        "com.typesafe.sbt" % "sbt-interface" % sbtVersion.value,
         "org.scala-sbt" % "api" % sbtVersion.value % "test",
         "org.specs2" %% "specs2" % "2.3.11" % "test"
       ),
diff --git a/test/scripts/TestDotc.scala b/test/scripts/TestDotc.scala
new file mode 100644
index 000000000..f662a2695
--- /dev/null
+++ b/test/scripts/TestDotc.scala
@@ -0,0 +1,89 @@
+package test
+
+import org.junit.Assert._
+import org.junit.{Before, After, Test}
+
+import scala.io.Source
+import scala.sys.process.{Process, ProcessLogger}
+import java.io.{File => JFile, FileNotFoundException}
+
+class TestDotc {
+  private val lineSep = util.Properties.lineSeparator
+  private def doUnlessWindows(op: => Unit) =
+    if (!System.getProperty("os.name").toLowerCase.contains("windows"))
+      op
+    else
+      Console.err.println("[warn] Could not perform test, windows batch-scripts not available")
+
+  private def executeScript(script: String): (Int, String) = {
+    val sb = new StringBuilder
+    val ret = Process(script) ! ProcessLogger(sb append _)
+    (ret, sb.toString)
+  }
+
+  private def deletePackages: Unit = {
+    def delete(path: String) = {
+      val file = new JFile(path)
+      if (file.exists) file.delete()
+    }
+
+    try {
+      for (jar <- Source.fromFile(".packages").getLines())
+        delete(jar)
+
+      delete(".packages")
+      delete("src/dotty/tools/dotc/Dummy.scala")
+    } catch {
+      case _: FileNotFoundException => ()
+    }
+  }
+
+  @Before def buildUp  = deletePackages
+  @After  def tearDown = deletePackages
+
+  /** bin/dotc script should be able to build hello world and successfully
+   *  execute it using dotr
+   */
+  @Test def buildAndRunHelloWorld = doUnlessWindows {
+    val (retDotc, dotcOutput) = executeScript("bin/dotc tests/pos/HelloWorld.scala")
+
+    // Check correct output of building and running dotc
+    assert(
+      retDotc == 0,
+      s"bin/dotc script did not run properly. Output:$lineSep$dotcOutput"
+    )
+
+    val (retDotr, dotrOutput) = executeScript("bin/dotr HelloWorld")
+    assert(
+      retDotr == 0 && dotrOutput == "hello world",
+      s"Running hello world exited with status: $retDotr and output: $dotrOutput"
+    )
+  }
+
+  /** bin/dotc script should be able to detect changes in dotty sources and
+   *  rebuild dotty if needed
+   */
+  @Test def rebuildIfNecessary = doUnlessWindows {
+    val (retFirstBuild, _) = executeScript("bin/dotc tests/pos/HelloWorld.scala")
+    assert(retFirstBuild == 0, "building dotc failed")
+
+    // Create a new file
+    new JFile("src/dotty/tools/dotc/Dummy.scala").createNewFile()
+
+    val (retSecondBuild, output) = executeScript("bin/dotc tests/pos/HelloWorld.scala")
+    assert(
+      retSecondBuild == 0 && output.contains("rebuilding"),
+      s"Rebuilding the tool should result in jar files being rebuilt. Status: $retSecondBuild, output:$lineSep$output")
+  }
+
+  /** if no changes to dotty, dotc script should be fast */
+  @Test def beFastOnNoChanges = doUnlessWindows {
+    val (retFirstBuild, _) = executeScript("bin/dotc tests/pos/HelloWorld.scala")
+    assert(retFirstBuild == 0, "building dotc failed")
+
+    val (ret, output) = executeScript("bin/dotc tests/pos/HelloWorld.scala")
+    assert(
+      ret == 0 && !output.contains("rebuilding"),
+      s"Project recompiled when it didn't need to be. Status $ret, output:$lineSep$output")
+  }
+}