/src/intellij*/*.iml

/src/intellij*/*.ipr

/src/intellij*/*.iws

Note that sbt's incremental compilation is often too coarse for the Scala compiler

codebase and re-compiles too many files, resulting in long build times (check

[sbt#1104](https://github.com/sbt/sbt/issues/1104) for progress on that front). In the

meantime you can:

- Use IntelliJ IDEA for incremental compiles (see [IDE Setup](#ide-setup) below) - its

incremental compiler is a bit less conservative, but usually correct.

You may use IntelliJ IDEA (see [src/intellij/README.md](src/intellij/README.md)),

or ENSIME (see [this page on the ENSIME site](http://ensime.org/editors/)).

In order to use IntelliJ's incremental compiler:

- run `dist/mkBin` in sbt to get a build and the runner scripts in `build/quick/bin`

- run "Build" - "Make Project" in IntelliJ

Now you can edit and build in IntelliJ and use the scripts (compiler, REPL) to

directly test your changes. You can also run the `scala`, `scalac` and `partest`

commands in sbt. Enable "Ant mode" (explained above) to prevent sbt's incremental

compiler from re-compiling (too many) files before each `partest` invocation.

lazy val intellij = taskKey[Unit]("Update the library classpaths in the IntelliJ project files.")

def moduleDeps(p: Project, config: Configuration = Compile) = (p / config / externalDependencyClasspath).map(a => (p.id, a.map(_.data)))

def compilerP = compiler

intellij := {

import xml._

import xml.transform._

val s = streams.value

val compilerScalaInstance = (LocalProject("compiler") / scalaInstance).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(java.io.File.pathSeparator).toSeq.map(new File(_)))

// `sbt projects` lists all modules in the build

buildModule :: List(

moduleDeps(bench).value,

moduleDeps(compilerP).value,

// moduleDeps(dist).value, // No sources, therefore no module in IntelliJ

moduleDeps(interactive).value,

moduleDeps(junit).value,

moduleDeps(library).value,

// moduleDeps(libraryAll).value, // No sources

moduleDeps(manual).value,

moduleDeps(partest).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(scalacheck, config = Test).value,

moduleDeps(scaladoc).value,

moduleDeps(scalap).value,

moduleDeps(testP).value,

moduleDeps(compilerOptionsExporter).value

)

}

def moduleDep(name: String, jars: Seq[File]) = {

val entries = jars.map(f => s""" <root url="jar://${f.toURI.getPath}!/" />""").mkString("\n")

s"""| <library name="$name-deps">

|$entries

| </library>""".stripMargin

}

def starrDep(jars: Seq[File]) = {

val entries = jars.map(f => s""" <root url="file://${f.toURI.getPath}" />""").mkString("\n")

s"""| <library name="starr" type="Scala">

|$entries

| </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 intellijDir = (ThisBuild / baseDirectory).value / "src/intellij"

val ipr = intellijDir / "scala.ipr"

backupIdea(intellijDir)

if (!ipr.exists) {

intellijCreateFromSample((ThisBuild / baseDirectory).value)

}

s.log.info("Updating library classpaths in src/intellij/scala.ipr.")

val content = XML.loadFile(ipr)

val newStarr = replaceLibrary(content, "starr", Some("Scala"), starrDep(compilerScalaInstance.allJars))

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))

})

// I can't figure out how to keep the entity escapes for \n in the attribute values after this use of XML transform.

// Patching the original version back in with more brutish parsing.

val R = """(?ims)(.*)(<copyright>.*</copyright>)(.*)""".r

val oldContents = IO.read(ipr)

XML.save(ipr.getAbsolutePath, newModules)

oldContents match {

case R(_, withEscapes, _) =>

val newContents = IO.read(ipr)

val R(pre, toReplace, post) = newContents

IO.write(ipr, pre + withEscapes + post)

case _ =>

// .ipr file hasn't been updated from `intellijFromSample` yet

}

}

lazy val intellijFromSample = taskKey[Unit]("Create fresh IntelliJ project files from src/intellij/*.SAMPLE.")

def backupIdea(ideaDir: File): Unit = {

val temp = IO.createTemporaryDirectory

IO.copyDirectory(ideaDir, temp)

println(s"Backed up existing src/intellij to $temp")

}

intellijFromSample := {

val s = streams.value

val intellijDir = (ThisBuild / baseDirectory).value / "src/intellij"

val ipr = intellijDir / "scala.ipr"

backupIdea(intellijDir)

intellijCreateFromSample((ThisBuild / baseDirectory).value)

}

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, CopyOptions() withOverwrite true)

}

lazy val intellijToSample = taskKey[Unit]("Update src/intellij/*.SAMPLE using the current IntelliJ project files.")

intellijToSample := {

val s = streams.value

val intellijDir = (ThisBuild / baseDirectory).value / "src/intellij"

val ipr = intellijDir / "scala.ipr"

backupIdea(intellijDir)

val existing =intellijDir * "*.SAMPLE"

IO.delete(existing.get)

val current = intellijDir * ("*.iml" || "*.ipr")

val copies = current.get.map(f => (f, new File(f.getAbsolutePath + ".SAMPLE")))

IO.copy(copies)

}

enablePlugins(BuildInfoPlugin)

lazy val buildClasspath = taskKey[String]("Colon-separated (or semicolon-separated in case of Windows) list of entries on the sbt build classpath.")

buildClasspath := (Compile / externalDependencyClasspath).value.map(_.data).mkString(java.io.File.pathSeparator)

buildInfoKeys := Seq[BuildInfoKey](buildClasspath)

buildInfoPackage := "scalabuild"