Merge pull request scala#5054 from lrytz/intellij-2.11

Update IntelliJ build for use with sbt

Author: lrytz

.gitignore

@@ -30,6 +30,7 @@
 /jenkins.properties
 
 # target directories for ant build
+/build
 /build/
 /dists/
 
@@ -55,5 +56,6 @@
 # Sbt's target directories
 /target/
 /project/target/
-/project/project/target
+/project/project/target/
+/project/project/project/target/
 /build-sbt/

build.sbt

@@ -463,7 +463,6 @@ lazy val replJlineEmbedded = Project("repl-jline-embedded", file(".") / "target"
           x.name.endsWith(".class") || x.name.endsWith(".properties") || x.name.startsWith("META-INF/native") || x.name.startsWith("META-INF/maven")
         )
       }
-      //println(inputs.map(_.name).mkString("\n"))
       import JarJar.JarJarConfig._
       val config: Seq[JarJar.JarJarConfig] = Seq(
         Rule("org.fusesource.**", "scala.tools.fusesource_embedded.@1"),
@@ -851,3 +850,158 @@ commands ++= {
 }
 
 addCommandAlias("scalap",   "scalap/compile:runMain              scala.tools.scalap.Main -usejavacp")
+
+lazy val intellij = taskKey[Unit]("Update the library classpaths in the IntelliJ project files.")
+
+def moduleDeps(p: Project) = (externalDependencyClasspath in Compile in p).map(a => (p.id, a.map(_.data)))
+
+// aliases to projects to prevent name clashes
+def compilerP = compiler
+def testP = test
+
+intellij := {
+  import xml._
+  import xml.transform._
+
+  val s = streams.value
+
+  val modules: List[(String, Seq[File])] = {
+    // for the sbt build module, the dependencies are fetched from the project's build using sbt-buildinfo
+    val buildModule = ("scala-build", scalabuild.BuildInfo.buildClasspath.split(":").toSeq.map(new File(_)))
+    // `sbt projects` lists all modules in the build
+    buildModule :: List(
+      moduleDeps(actors).value,
+      moduleDeps(compilerP).value,
+      // moduleDeps(dist).value,                // No sources, therefore no module in IntelliJ
+      moduleDeps(forkjoin).value,
+      moduleDeps(interactive).value,
+      moduleDeps(junit).value,
+      moduleDeps(library).value,
+      // moduleDeps(libraryAll).value,          // No sources
+      moduleDeps(manual).value,
+      moduleDeps(partestExtras).value,
+      moduleDeps(partestJavaAgent).value,
+      moduleDeps(reflect).value,
+      moduleDeps(repl).value,
+      moduleDeps(replJline).value,
+      // moduleDeps(replJlineEmbedded).value,   // No sources
+      // moduleDeps(root).value,                // No sources
+      // moduleDeps(scalaDist).value,           // No sources
+      moduleDeps(scaladoc).value,
+      moduleDeps(scalap).value,
+      moduleDeps(testP).value)
+  }
+
+  def moduleDep(name: String, jars: Seq[File]) = {
+    val entries = jars.map(f => s"""        <root url="jar://${f.toURI.getRawPath}!/" />""").mkString("\n")
+    s"""|    <library name="${name}-deps">
+        |      <CLASSES>
+        |$entries
+        |      </CLASSES>
+        |      <JAVADOC />
+        |      <SOURCES />
+        |    </library>""".stripMargin
+  }
+
+  def starrDep(jars: Seq[File]) = {
+    val entries = jars.map(f => s"""          <root url="file://${f.toURI.getRawPath}" />""").mkString("\n")
+    s"""|    <library name="starr" type="Scala">
+        |      <properties>
+        |        <option name="languageLevel" value="Scala_2_12" />
+        |        <compiler-classpath>
+        |$entries
+        |        </compiler-classpath>
+        |      </properties>
+        |      <CLASSES />
+        |      <JAVADOC />
+        |      <SOURCES />
+        |    </library>""".stripMargin
+  }
+
+  def replaceLibrary(data: Node, libName: String, libType: Option[String], newContent: String) = {
+    object rule extends RewriteRule {
+      var transformed = false
+      def checkAttrs(attrs: MetaData) = {
+        def check(key: String, expected: String) = {
+          val a = attrs(key)
+          a != null && a.text == expected
+        }
+        check("name", libName) && libType.forall(tp => check("type", tp))
+      }
+
+      override def transform(n: Node): Seq[Node] = n match {
+        case e @ Elem(_, "library", attrs, _, _, _*) if checkAttrs(attrs) =>
+          transformed = true
+          XML.loadString(newContent)
+        case other =>
+          other
+      }
+    }
+    object trans extends RuleTransformer(rule)
+    val r = trans(data)
+    if (!rule.transformed) sys.error(s"Replacing library classpath for $libName failed, no existing library found.")
+    r
+  }
+
+  val ipr = (baseDirectory in ThisBuild).value / "src/intellij/scala.ipr"
+
+  var continue = false
+  if (!ipr.exists) {
+    scala.Console.print(s"Could not find src/intellij/scala.ipr. Create new project files from src/intellij/*.SAMPLE (y/N)? ")
+    if (scala.Console.readLine() == "y") {
+      intellijCreateFromSample((baseDirectory in ThisBuild).value)
+      continue = true
+    }
+  } else {
+    scala.Console.print("Update library classpaths in the current src/intellij/scala.ipr (y/N)? ")
+    continue = scala.Console.readLine() == "y"
+  }
+  if (continue) {
+    s.log.info("Updating library classpaths in src/intellij/scala.ipr.")
+    val content = XML.loadFile(ipr)
+
+    val newStarr = replaceLibrary(content, "starr", Some("Scala"), starrDep((scalaInstance in LocalProject("compiler")).value.jars))
+    val newModules = modules.foldLeft(newStarr)({
+      case (res, (modName, jars)) =>
+        if (jars.isEmpty) res // modules without dependencies
+        else replaceLibrary(res, s"$modName-deps", None, moduleDep(modName, jars))
+    })
+
+    XML.save(ipr.getAbsolutePath, newModules)
+  } else {
+    s.log.info("Aborting.")
+  }
+}
+
+lazy val intellijFromSample = taskKey[Unit]("Create fresh IntelliJ project files from src/intellij/*.SAMPLE.")
+
+intellijFromSample := {
+  val s = streams.value
+  scala.Console.print(s"Create new project files from src/intellij/*.SAMPLE (y/N)? ")
+  if (scala.Console.readLine() == "y")
+    intellijCreateFromSample((baseDirectory in ThisBuild).value)
+  else
+    s.log.info("Aborting.")
+}
+
+def intellijCreateFromSample(basedir: File): Unit = {
+  val files = basedir / "src/intellij" * "*.SAMPLE"
+  val copies = files.get.map(f => (f, new File(f.getAbsolutePath.stripSuffix(".SAMPLE"))))
+  IO.copy(copies, overwrite = true)
+}
+
+lazy val intellijToSample = taskKey[Unit]("Update src/intellij/*.SAMPLE using the current IntelliJ project files.")
+
+intellijToSample := {
+  val s = streams.value
+  scala.Console.print(s"Update src/intellij/*.SAMPLE using the current IntelliJ project files (y/N)? ")
+  if (scala.Console.readLine() == "y") {
+    val basedir = (baseDirectory in ThisBuild).value
+    val existing = basedir / "src/intellij" * "*.SAMPLE"
+    IO.delete(existing.get)
+    val current = basedir / "src/intellij" * ("*.iml" || "*.ipr")
+    val copies = current.get.map(f => (f, new File(f.getAbsolutePath + ".SAMPLE")))
+    IO.copy(copies)
+  } else
+    s.log.info("Aborting.")
+}

project/plugins.sbt

@@ -3,3 +3,15 @@ libraryDependencies += "org.apache.commons" % "commons-lang3" % "3.3.2"
 libraryDependencies += "org.pantsbuild" % "jarjar" % "1.6.0"
 
 libraryDependencies += "biz.aQute" % "bndlib" % "1.50.0"
+
+enablePlugins(BuildInfoPlugin)
+
+// configure sbt-buildinfo to send the externalDependencyClasspath to the main build, which allows using it for the IntelliJ project config
+
+lazy val buildClasspath = taskKey[String]("Colon-separated list of entries on the sbt build classpath.")
+
+buildClasspath := (externalDependencyClasspath in Compile).value.map(_.data).mkString(":")
+
+buildInfoKeys := Seq[BuildInfoKey](buildClasspath)
+
+buildInfoPackage := "scalabuild"

project/project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.6.1")

src/intellij/README.md

@@ -1,13 +1,41 @@
-Use the latest IntelliJ IDEA release and install the Scala plugin from within the IDE.
+# Building Scala in IntelliJ IDEA
 
-Compilation withing IDEA is performed in "-Dlocker.skip=1" mode: the sources are built
-directly using the STARR compiler.
+## Requirements
 
-The following steps are required to use IntelliJ IDEA on Scala trunk
- - Run `ant init`. This will download some JARs to `./build/deps`, which are included in IntelliJ's classpath.
- - Run `./src/intellij/setup.sh`.
- - Open `./src/intellij/scala.ipr` in IntelliJ.
- - `File` → `Project Structure` → `Project` → `Project SDK`. Create an SDK entry named "1.6" containing the Java 1.6 SDK. (Or other SDK version; see "Requirements" in the repo's main README.)
+Use the latest IntelliJ release and install the Scala plugin from within the IDE.
 
-Compilation within IDEA is performed in `-Dlocker.skip=1` mode: the sources are built
-directly using the STARR compiler (which is downloaded from [the Central Repository](http://central.sonatype.org/), according to `starr.version` in `versions.properties`).
+## Initial setup
+
+To create the IntelliJ project files:
+
+  - Run `sbt intellij`
+  - Open `src/intellij/scala.ipr` in IntelliJ
+  - In `File` → `Project Structure` → `Project` → `Project SDK`, create an SDK entry named "1.6" containing the Java 1.6 SDK
+
+The project files are created by as copies of the `.SAMPLE` files, which are under version control.
+The actual IntelliJ project files are in `.gitignore` so that local changes are ignored.
+
+## Dependencies
+
+For every module in the IntelliJ project there is a corresponding `-deps` library, for exmaple `compiler-deps` provides `ant.jar` for the compiler codebase.
+The `.jar` files in these `-deps` libraries can be easily kept up-to-date by running `sbt intellij` again.
+This is necessary whenever the dependencies in the sbt build change, for example when the STARR version is updated.
+
+Note that this command only patches the dependency lists, all other settings in the IntelliJ project definition are unchanged.
+To overwrite the project definition files by copying the `.SAMPLE` files again run `sbt intellijFromSample`.
+
+## Usage
+
+Compiling, running, JUnit tests and debugging should all work.
+You can work on the compiler, the standard library, and other components as well.
+
+Note that compilation within IntelliJ is performed in a single pass.
+The code is compiled using the "STARR" (stable reference) compiler, as specified by `starr.version` in `versions.properties`.
+This is consistent with the sbt build.
+
+Note that the output directory when compiling in IntelliJ is the same as for the sbt build.
+This allows building incrementally in IntelliJ and directly use the changes using the command-line scripts in `build/quick/bin/`.
+
+## Updating the `.SAMPLE` files
+
+The command `intellijToSample` overwrites the `.SAMPLE` files using the current project definition files.

src/intellij/actors.iml.SAMPLE

@@ -1,6 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
+  <component name="NewModuleRootManager" inherit-compiler-output="false">
+    <output url="file://$MODULE_DIR$/../../build/quick/classes/actors" />
+    <output-test url="file://$MODULE_DIR$/../../out/test/actors" />
     <exclude-output />
     <content url="file://$MODULE_DIR$/../actors">
       <sourceFolder url="file://$MODULE_DIR$/../actors" isTestSource="false" />

src/intellij/asm.iml.SAMPLE

@@ -1,17 +1,17 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
+  <component name="NewModuleRootManager" inherit-compiler-output="false">
+    <output url="file://$MODULE_DIR$/../../build/quick/classes/compiler" />
+    <output-test url="file://$MODULE_DIR$/../../out/test/compiler" />
     <exclude-output />
     <content url="file://$MODULE_DIR$/../compiler">
-      <sourceFolder url="file://$MODULE_DIR$/../compiler/src" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/../compiler" isTestSource="false" />
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="module" module-name="library" />
     <orderEntry type="module" module-name="reflect" />
+    <orderEntry type="library" name="compiler-deps" level="project" />
     <orderEntry type="library" name="starr" level="project" />
-    <orderEntry type="library" name="ant" level="project" />
-    <orderEntry type="library" name="asm" level="project" />
   </component>
 </module>

src/intellij/compiler.iml.SAMPLE

@@ -1,6 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
+  <component name="NewModuleRootManager" inherit-compiler-output="false">
+    <output url="file://$MODULE_DIR$/../../build/quick/classes/forkjoin" />
+    <output-test url="file://$MODULE_DIR$/../../out/test/forkjoin" />
     <exclude-output />
     <content url="file://$MODULE_DIR$/../forkjoin">
       <sourceFolder url="file://$MODULE_DIR$/../forkjoin" isTestSource="false" />