enso/build.sbt

import java.io.File

import sbt.Keys.scalacOptions

import scala.sys.process._
import org.enso.build.BenchTasks._
import org.enso.build.WithDebugCommand
import sbtassembly.AssemblyPlugin.defaultUniversalScript
import sbtcrossproject.CrossPlugin.autoImport.{crossProject, CrossType}

//////////////////////////////
//// Global Configuration ////
//////////////////////////////

val scalacVersion = "2.12.10"
val graalVersion  = "19.3.0"
val circeVersion  = "0.12.3"
organization in ThisBuild := "org.enso"
scalaVersion in ThisBuild := scalacVersion

Global / onChangedBuildSource := ReloadOnSourceChanges

//////////////////////////
//// Compiler Options ////
//////////////////////////

javacOptions in ThisBuild ++= Seq(
  "-encoding", // Provide explicit encoding (the next line)
  "UTF-8"      // Specify character encoding used by Java source files.
)

scalacOptions in ThisBuild ++= Seq(
  "-deprecation",                       // Emit warning and location for usages of deprecated APIs.
  "-encoding",                          // Provide explicit encoding (the next line)
  "utf-8",                              // Specify character encoding used by Scala source files.
  "-explaintypes",                      // Explain type errors in more detail.
  "-feature",                           // Emit warning and location for usages of features that should be imported explicitly.
  "-language:existentials",             // Existential types (besides wildcard types) can be written and inferred
  "-language:experimental.macros",      // Allow macro definition (besides implementation and application)
  "-language:higherKinds",              // Allow higher-kinded types
  "-language:implicitConversions",      // Allow definition of implicit functions called views
  "-unchecked",                         // Enable additional warnings where generated code depends on assumptions.
  "-Xcheckinit",                        // Wrap field accessors to throw an exception on uninitialized access.
  "-Xlint:adapted-args",                // Warn if an argument list is modified to match the receiver.
  "-Xlint:by-name-right-associative",   // By-name parameter of right associative operator.
  "-Xlint:constant",                    // Evaluation of a constant arithmetic expression results in an error.
  "-Xlint:delayedinit-select",          // Selecting member of DelayedInit.
  "-Xlint:doc-detached",                // A Scaladoc comment appears to be detached from its element.
  "-Xlint:inaccessible",                // Warn about inaccessible types in method signatures.
  "-Xlint:infer-any",                   // Warn when a type argument is inferred to be `Any`.
  "-Xlint:missing-interpolator",        // A string literal appears to be missing an interpolator id.
  "-Xlint:nullary-override",            // Warn when non-nullary `def f()' overrides nullary `def f'.
  "-Xlint:nullary-unit",                // Warn when nullary methods return Unit.
  "-Xlint:option-implicit",             // Option.apply used implicit view.
  "-Xlint:package-object-classes",      // Class or object defined in package object.
  "-Xlint:poly-implicit-overload",      // Parameterized overloaded implicit methods are not visible as view bounds.
  "-Xlint:private-shadow",              // A private field (or class parameter) shadows a superclass field.
  "-Xlint:stars-align",                 // Pattern sequence wildcard must align with sequence component.
  "-Xlint:unsound-match",               // Pattern match may not be typesafe.
  "-Xmacro-settings:-logging@org.enso", // Disable the debug logging globally.
  "-Yno-adapted-args",                  // Do not adapt an argument list (either by inserting () or creating a tuple) to match the receiver.
  "-Ypartial-unification",              // Enable partial unification in type constructor inference
  "-Ywarn-dead-code",                   // Warn when dead code is identified.
  "-Ywarn-extra-implicit",              // Warn when more than one implicit parameter section is defined.
  "-Ywarn-inaccessible",                // Warn about inaccessible types in method signatures.
  "-Ywarn-infer-any",                   // Warn when a type argument is inferred to be `Any`.
  "-Ywarn-nullary-override",            // Warn when non-nullary `def f()' overrides nullary `def f'.
  "-Ywarn-nullary-unit",                // Warn when nullary methods return Unit.
  "-Ywarn-numeric-widen",               // Warn when numerics are widened.
  "-Ywarn-unused:imports",              // Warn if an import selector is not referenced.
  "-Ywarn-unused:locals",               // Warn if a local definition is unused.
  "-Ywarn-unused:patvars",              // Warn if a variable bound in a pattern is unused.
  "-Ywarn-unused:privates",             // Warn if a private member is unused.
  "-Ywarn-value-discard"                // Warn when non-Unit expression results are unused.
)

// ENABLE THIS IN Scala 2.13.1 (where import annotation.unused is available).
//  "-Xlint:type-parameter-shadow",     // A local type parameter shadows a type already in scope.
//  "-Ywarn-unused:implicits",          // Warn if an implicit parameter is unused.
//  "-Ywarn-unused:params",             // Warn if a value parameter is unused.

/////////////////////////////////
//// Benchmark Configuration ////
/////////////////////////////////

lazy val Benchmark = config("bench") extend sbt.Test

// Native Image Generation
lazy val buildNativeImage =
  taskKey[Unit]("Build native image for the Enso executable")

////////////////////////
//// Global Project ////
////////////////////////

lazy val enso = (project in file("."))
  .settings(version := "0.1")
  .aggregate(
    unused.jvm,
    flexer.jvm,
    syntax_definition.jvm,
    syntax.jvm,
    pkg,
    project_manager,
    runtime,
    polyglot_api,
    parser_service,
    file_manager,
    project_manager,
    graph,
    runner,
    gateway,
    language_server
  )
  .settings(Global / concurrentRestrictions += Tags.exclusive(Exclusive))

////////////////////////////
//// Dependency Bundles ////
////////////////////////////

val monocle = {
  val monocleVersion = "1.6.0"
  Seq(
    "com.github.julien-truffaut" %% "monocle-core"  % monocleVersion,
    "com.github.julien-truffaut" %% "monocle-macro" % monocleVersion,
    "com.github.julien-truffaut" %% "monocle-law"   % monocleVersion % "test"
  )
}
val cats = {
  Seq(
    "org.typelevel" %% "cats-core"   % "2.0.0",
    "org.typelevel" %% "cats-effect" % "2.0.0",
    "org.typelevel" %% "cats-free"   % "2.0.0",
    "org.typelevel" %% "cats-macros" % "2.0.0",
    "org.typelevel" %% "kittens"     % "2.0.0"
  )
}

val scala_compiler = Seq(
  "org.scala-lang" % "scala-reflect"  % scalacVersion,
  "org.scala-lang" % "scala-compiler" % scalacVersion
)

val circe = Seq("circe-core", "circe-generic", "circe-parser")
  .map("io.circe" %% _ % circeVersion)

def akkaPkg(name: String)     = akkaURL %% s"akka-$name" % akkaVersion
def akkaHTTPPkg(name: String) = akkaURL %% s"akka-$name" % akkaHTTPVersion

val akkaURL          = "com.typesafe.akka"
val akkaVersion      = "2.5.23"
val akkaHTTPVersion  = "10.1.8"
val akkaActor        = akkaPkg("actor")
val akkaStream       = akkaPkg("stream")
val akkaTyped        = akkaPkg("actor-typed")
val akkaTestkit      = akkaPkg("testkit")
val akkaSLF4J        = akkaPkg("slf4j")
val akkaTestkitTyped = akkaPkg("actor-testkit-typed") % Test
val akkaHttp         = akkaHTTPPkg("http")
val akkaSpray        = akkaHTTPPkg("http-spray-json")
val akka             = Seq(akkaActor, akkaStream, akkaHttp, akkaSpray, akkaTyped)

val jmh = Seq(
  "org.openjdk.jmh" % "jmh-core"                 % "1.21" % Benchmark,
  "org.openjdk.jmh" % "jmh-generator-annprocess" % "1.21" % Benchmark
)

val silencerVersion = "1.4.4"

////////////////////////////
//// Internal Libraries ////
////////////////////////////

val jsSettings = Seq(
  scalaJSLinkerConfig ~= { _.withModuleKind(ModuleKind.ESModule) },
  // FIXME workaround for scalajs bug:
  //  https://github.com/scala-js/scala-js/issues/3673
  testFrameworks := Nil
)

lazy val logger = crossProject(JVMPlatform, JSPlatform)
  .withoutSuffixFor(JVMPlatform)
  .crossType(CrossType.Pure)
  .in(file("common/scala/logger"))
  .dependsOn(unused)
  .settings(
    version := "0.1",
    libraryDependencies ++= scala_compiler
  )
  .jsSettings(jsSettings)

lazy val flexer = crossProject(JVMPlatform, JSPlatform)
  .withoutSuffixFor(JVMPlatform)
  .crossType(CrossType.Pure)
  .in(file("common/scala/flexer"))
  .dependsOn(logger)
  .settings(
    version := "0.1",
    scalacOptions -= "-deprecation", // FIXME
    resolvers += Resolver.sonatypeRepo("releases"),
    libraryDependencies ++= scala_compiler ++ Seq(
      "org.feijoas"   %% "mango"      % "0.14",
      "org.typelevel" %%% "cats-core" % "2.0.0-RC1",
      "org.typelevel" %%% "kittens"   % "2.0.0"
    )
  )
  .jsSettings(jsSettings)

lazy val unused = crossProject(JVMPlatform, JSPlatform)
  .withoutSuffixFor(JVMPlatform)
  .crossType(CrossType.Pure)
  .in(file("common/scala/unused"))
  .settings(version := "0.1", scalacOptions += "-nowarn")
  .jsSettings(testFrameworks := Nil)

lazy val syntax_definition = crossProject(JVMPlatform, JSPlatform)
  .withoutSuffixFor(JVMPlatform)
  .crossType(CrossType.Pure)
  .in(file("common/scala/syntax/definition"))
  .dependsOn(logger, flexer)
  .settings(
    libraryDependencies ++= monocle ++ scala_compiler ++ Seq(
      "org.typelevel" %%% "cats-core"     % "2.0.0-RC1",
      "org.typelevel" %%% "kittens"       % "2.0.0",
      "com.lihaoyi"   %%% "scalatags"     % "0.7.0",
      "io.circe"      %%% "circe-core"    % circeVersion,
      "io.circe"      %%% "circe-generic" % circeVersion,
      "io.circe"      %%% "circe-parser"  % circeVersion
    )
  )
  .jsSettings(jsSettings)

lazy val syntax = crossProject(JVMPlatform, JSPlatform)
  .withoutSuffixFor(JVMPlatform)
  .crossType(CrossType.Full)
  .in(file("common/scala/syntax/specialization"))
  .dependsOn(logger, flexer, syntax_definition)
  .configs(Test)
  .configs(Benchmark)
  .settings(
    testFrameworks := Nil,
    mainClass in (Compile, run) := Some("org.enso.syntax.text.Main"),
    version := "0.1",
    logBuffered := false,
    libraryDependencies ++= Seq(
      "org.scalatest" %%% "scalatest"     % "3.0.5" % Test,
      "com.lihaoyi"   %%% "pprint"        % "0.5.3",
      "io.circe"      %%% "circe-core"    % circeVersion,
      "io.circe"      %%% "circe-generic" % circeVersion,
      "io.circe"      %%% "circe-parser"  % circeVersion
    ),
    compile := (Compile / compile)
      .dependsOn(Def.taskDyn {
        val parserCompile =
          (syntax_definition.jvm / Compile / compileIncremental).value
        if (parserCompile.hasModified) {
          Def.task {
            streams.value.log.info("Parser changed, forcing recompilation.")
            clean.value
          }
        } else Def.task {}
      })
      .value
  )
  .jvmSettings(
    inConfig(Benchmark)(Defaults.testSettings),
    unmanagedSourceDirectories in Benchmark +=
    baseDirectory.value.getParentFile / "src/bench/scala",
    libraryDependencies += "com.storm-enroute" %% "scalameter" % "0.17" % "bench",
    testFrameworks := List(
      new TestFramework("org.scalatest.tools.Framework"),
      new TestFramework("org.scalameter.ScalaMeterFramework")
    ),
    bench := (test in Benchmark).tag(Exclusive).value
  )
  .jsSettings(
    scalaJSUseMainModuleInitializer := false,
    scalaJSLinkerConfig ~= { _.withModuleKind(ModuleKind.ESModule) },
    testFrameworks := List(new TestFramework("org.scalatest.tools.Framework")),
    Compile / fullOptJS / artifactPath := file("target/scala-parser.js")
  )

lazy val parser_service = (project in file("common/scala/parser-service"))
  .dependsOn(syntax.jvm)
  .settings(
    libraryDependencies ++= akka,
    mainClass := Some("org.enso.ParserServiceMain")
  )

lazy val graph = (project in file("common/scala/graph/"))
  .dependsOn(logger.jvm)
  .configs(Test)
  .settings(
    version := "0.1",
    scalacOptions -= "-deprecation", // FIXME
    resolvers ++= Seq(
      Resolver.sonatypeRepo("releases"),
      Resolver.sonatypeRepo("snapshots")
    ),
    libraryDependencies ++= scala_compiler ++ Seq(
      "com.chuusai"                %% "shapeless"    % "2.3.3",
      "io.estatico"                %% "newtype"      % "0.4.3",
      "org.scalatest"              %% "scalatest"    % "3.2.0-SNAP10" % Test,
      "org.scalacheck"             %% "scalacheck"   % "1.14.0" % Test,
      "com.github.julien-truffaut" %% "monocle-core" % "2.0.0"
    ),
    libraryDependencies ++= Seq(
      compilerPlugin(
        "com.github.ghik" % "silencer-plugin" % silencerVersion cross CrossVersion.full
      ),
      "com.github.ghik" % "silencer-lib" % silencerVersion % Provided cross CrossVersion.full
    ),
    addCompilerPlugin(
      "org.scalamacros" % "paradise" % "2.1.1" cross CrossVersion.full
    ),
    addCompilerPlugin("io.tryp" % "splain" % "0.5.0" cross CrossVersion.patch),
    scalacOptions ++= Seq(
      "-P:splain:infix:true",
      "-P:splain:foundreq:true",
      "-P:splain:implicits:true",
      "-P:splain:tree:true"
    )
  )

lazy val pkg = (project in file("common/scala/pkg"))
  .settings(
    mainClass in (Compile, run) := Some("org.enso.pkg.Main"),
    version := "0.1",
    libraryDependencies ++= circe ++ Seq(
      "io.circe"   %% "circe-yaml" % "0.10.0", // separate from other circe deps because its independent project with its own versioning
      "commons-io" % "commons-io"  % "2.6"
    )
  )

lazy val file_manager = (project in file("common/scala/file-manager"))
  .settings(
    (Compile / mainClass) := Some("org.enso.filemanager.FileManager")
  )
  .settings(
    libraryDependencies ++= akka,
    libraryDependencies += akkaSLF4J,
    libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.2.3",
    libraryDependencies += "org.scalatest"  %% "scalatest"      % "3.2.0-SNAP10" % Test,
    libraryDependencies += "org.scalacheck" %% "scalacheck"     % "1.14.0" % Test,
    libraryDependencies += akkaTestkitTyped,
    libraryDependencies += "commons-io" % "commons-io"        % "2.6",
    libraryDependencies += "io.methvin" % "directory-watcher" % "0.9.6"
  )

lazy val project_manager = (project in file("common/scala/project-manager"))
  .settings(
    (Compile / mainClass) := Some("org.enso.projectmanager.Server")
  )
  .settings(
    libraryDependencies ++= akka,
    libraryDependencies ++= circe,
    libraryDependencies += "io.spray" %% "spray-json" % "1.3.5"
  )
  .dependsOn(pkg)

//////////////////////
//// Sub Projects ////
//////////////////////

val truffleRunOptions = Seq(
  "-Dgraal.TruffleIterativePartialEscape=true",
  "-XX:-UseJVMCIClassLoader",
  "-Dgraal.TruffleBackgroundCompilation=false",
  "-Dgraalvm.locatorDisabled=true"
)

val truffleRunOptionsSettings = Seq(
  fork := true,
  javaOptions ++= truffleRunOptions
)

lazy val runtime = (project in file("engine/runtime"))
  .configs(Benchmark)
  .settings(
    version := "0.1",
    commands += WithDebugCommand.withDebug,
    inConfig(Compile)(truffleRunOptionsSettings),
    inConfig(Benchmark)(Defaults.testSettings),
    parallelExecution in Test := false,
    logBuffered in Test := false,
    libraryDependencies ++= jmh ++ Seq(
      "com.chuusai"            %% "shapeless"                % "2.3.3",
      "org.apache.commons"     % "commons-lang3"             % "3.9",
      "org.apache.tika"        % "tika-core"                 % "1.21",
      "org.graalvm.sdk"        % "graal-sdk"                 % graalVersion % "provided",
      "org.graalvm.sdk"        % "polyglot-tck"              % graalVersion % "provided",
      "org.graalvm.truffle"    % "truffle-api"               % graalVersion % "provided",
      "org.graalvm.truffle"    % "truffle-dsl-processor"     % graalVersion % "provided",
      "org.graalvm.truffle"    % "truffle-tck"               % graalVersion % "provided",
      "org.graalvm.truffle"    % "truffle-tck-common"        % graalVersion % "provided",
      "org.scala-lang.modules" %% "scala-parser-combinators" % "1.0.4",
      "org.scalacheck"         %% "scalacheck"               % "1.14.0" % Test,
      "org.scalactic"          %% "scalactic"                % "3.0.8" % Test,
      "org.scalatest"          %% "scalatest"                % "3.2.0-SNAP10" % Test,
      "org.graalvm.truffle"    % "truffle-api"               % graalVersion % Benchmark,
      "org.typelevel"          %% "cats-core"                % "2.0.0-M4"
    )
  )
  .settings(
    (Compile / javacOptions) ++= Seq(
      "-s",
      (Compile / sourceManaged).value.getAbsolutePath
    ),
    addCompilerPlugin(
      "org.scalamacros" % "paradise" % "2.1.1" cross CrossVersion.full
    )
  )
  .settings(
    (Compile / compile) := (Compile / compile)
      .dependsOn(Def.task { (Compile / sourceManaged).value.mkdirs })
      .value
  )
  .settings(
    logBuffered := false,
    bench := (test in Benchmark).tag(Exclusive).value,
    benchOnly := Def.inputTaskDyn {
      import complete.Parsers.spaceDelimited
      val name = spaceDelimited("<name>").parsed match {
        case List(name) => name
        case _          => throw new IllegalArgumentException("Expected one argument.")
      }
      Def.task {
        (testOnly in Benchmark).toTask(" -- -z " + name).value
      }
    }.evaluated,
    parallelExecution in Benchmark := false
  )
  .dependsOn(pkg)
  .dependsOn(syntax.jvm)
  .dependsOn(graph)
  .dependsOn(polyglot_api)

lazy val runner = project
  .in(file("engine/runner"))
  .settings(
    mainClass in (Compile, run) := Some("org.enso.runner.Main"),
    mainClass in assembly := (Compile / run / mainClass).value,
    assemblyJarName in assembly := "enso.jar",
    test in assembly := {},
    assemblyOutputPath in assembly := file("enso.jar"),
    assemblyOption in assembly := (assemblyOption in assembly).value.copy(
      prependShellScript = Some(
        defaultUniversalScript(
          shebang  = false,
          javaOpts = truffleRunOptions
        )
      )
    ),
    inConfig(Compile)(truffleRunOptionsSettings),
    libraryDependencies ++= Seq(
      "org.graalvm.sdk"       % "polyglot-tck"           % graalVersion % "provided",
      "org.graalvm.truffle"   % "truffle-api"            % graalVersion % "provided",
      "commons-cli"           % "commons-cli"            % "1.4",
      "io.github.spencerpark" % "jupyter-jvm-basekernel" % "2.3.0",
      "org.jline"             % "jline"                  % "3.1.3"
    ),
    connectInput in run := true
  )
  .settings(
    buildNativeImage := Def
      .task {
        val javaHome         = System.getProperty("java.home")
        val nativeImagePath  = s"$javaHome/bin/native-image"
        val classPath        = (Runtime / fullClasspath).value.files.mkString(":")
        val resourcesGlobOpt = "-H:IncludeResources=.*Main.enso$"
        val cmd =
          s"$nativeImagePath $resourcesGlobOpt --macro:truffle --no-fallback --initialize-at-build-time -cp $classPath ${(Compile / mainClass).value.get} enso"
        cmd !
      }
      .dependsOn(Compile / compile)
      .value
  )
  .dependsOn(runtime)
  .dependsOn(pkg)
  .dependsOn(language_server)
  .dependsOn(gateway)
  .dependsOn(polyglot_api)

lazy val gateway = (project in file("engine/gateway"))
  .dependsOn(language_server)
  .settings(
    libraryDependencies ++= akka ++ circe ++ Seq(
      akkaTestkit      % Test,
      "io.circe"       %% "circe-generic-extras" % "0.12.2",
      "io.circe"       %% "circe-literal" % circeVersion,
      "org.scalatest"  %% "scalatest" % "3.2.0-SNAP10" % Test,
      "org.scalacheck" %% "scalacheck" % "1.14.0" % Test
    )
  )

lazy val language_server = (project in file("engine/language-server"))
  .settings(
    libraryDependencies ++= akka ++ Seq(
      "org.graalvm.sdk" % "polyglot-tck" % graalVersion % Provided
    )
  )
  .dependsOn(polyglot_api)

lazy val polyglot_api = project
  .in(file("engine/polyglot-api"))
  .settings(
    Test / fork := true,
    Test / javaOptions ++= Seq(
      // Puts the language runtime on the truffle classpath, rather than the
      // standard classpath. This is the recommended way of handling this and
      // we should strive to use such structure everywhere. See
      // https://www.graalvm.org/docs/graalvm-as-a-platform/implement-language#graalvm
      s"-Dtruffle.class.path.append=${(LocalProject("runtime") / Compile / fullClasspath).value
        .map(_.data)
        .mkString(File.pathSeparator)}"
    ),
    libraryDependencies ++= Seq(
      "org.graalvm.sdk" % "polyglot-tck" % graalVersion   % "provided",
      "org.scalatest"   %% "scalatest"   % "3.2.0-SNAP10" % Test,
      "org.scalacheck"  %% "scalacheck"  % "1.14.0"       % Test
    )
  )