import org.enso.build.BenchTasks._

import org.enso.build.WithDebugCommand

import sbt.Keys.{libraryDependencies, scalacOptions}

import sbt.addCompilerPlugin

import sbtcrossproject.CrossPlugin.autoImport.{crossProject, CrossType}

import src.main.scala.licenses.{

DistributionDescription,

SBTDistributionComponent

}

import java.io.File

// ============================================================================

// === Global Configuration ===================================================

// ============================================================================

val scalacVersion = "2.13.6"

val rustVersion = "1.54.0-nightly"

val graalVersion = "21.1.0"

val javaVersion = "11"

val ensoVersion = "0.2.32-SNAPSHOT" // Note [Engine And Launcher Version]

val currentEdition = "2021.20-SNAPSHOT" // Note [Default Editions]

val stdLibVersion = ensoVersion

/* Note [Engine And Launcher Version]

* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* Currently both Engine and Launcher versions are tied to each other - each new

* releases contains the Engine and the Launcher and thus the version number is

* shared. If the version numbers ever diverge, make sure to update the build

* scripts at .github/workflows accordingly.

*/

/* Note [Default Editions]

* ~~~~~~~~~~~~~~~~~~~~~~~

* Currently, the default edition to use is inferred based on the engine

* version. Each Enso version has an associated default edition name and the

* `currentEdition` field specifies the default edition name for the upcoming

* release.

*

* Thus the `library-manager` needs to depend on the `version-output` to get

* this defaults from the build metadata.

*

* In the future we may automate generating this edition number when cutting a

* release.

*/

ThisBuild / organization := "org.enso"

ThisBuild / scalaVersion := scalacVersion

lazy val gatherLicenses =

taskKey[Unit]("Gathers licensing information for relevant dependencies")

gatherLicenses := {

val _ = GatherLicenses.run.value

}

lazy val verifyLicensePackages =

taskKey[Unit](

"Verifies if the license package has been generated, " +

"has no warnings and is up-to-date with dependencies."

)

verifyLicensePackages := GatherLicenses.verifyReports.value

lazy val verifyGeneratedPackage =

inputKey[Unit](

"Verifies if the license package in a generated distribution is " +

"up-to-date with the one from the report."

)

verifyGeneratedPackage := GatherLicenses.verifyGeneratedPackage.evaluated

def makeStdLibDistribution(

GatherLicenses.distributions := Seq(

Distribution(

"launcher",

file("distribution/launcher/THIRD-PARTY"),

Distribution.sbtProjects(launcher)

),

Distribution(

"engine",

file("distribution/engine/THIRD-PARTY"),

Distribution.sbtProjects(

runtime,

`engine-runner`,

`language-server`

)

),

Distribution(

"project-manager",

file("distribution/project-manager/THIRD-PARTY"),

Distribution.sbtProjects(`project-manager`)

),

makeStdLibDistribution("Base", Distribution.sbtProjects(`std-base`)),

makeStdLibDistribution(

"Google_Api",

Distribution.sbtProjects(`std-google-api`)

),

makeStdLibDistribution("Table", Distribution.sbtProjects(`std-table`)),

makeStdLibDistribution("Database", Distribution.sbtProjects(`std-database`)),

makeStdLibDistribution("Image", Distribution.sbtProjects(`std-image`))

)

GatherLicenses.licenseConfigurations := Set("compile")

GatherLicenses.configurationRoot := file("tools/legal-review")

lazy val openLegalReviewReport =

taskKey[Unit](

"Gathers licensing information for relevant dependencies and opens the " +

"report in review mode in the browser."

)

openLegalReviewReport := {

val _ = gatherLicenses.value

GatherLicenses.runReportServer()

}

lazy val analyzeDependency = inputKey[Unit]("...")

analyzeDependency := GatherLicenses.analyzeDependency.evaluated

val packageBuilder = new DistributionPackage.Builder(

ensoVersion = ensoVersion,

graalVersion = graalVersion,

graalJavaVersion = javaVersion,

artifactRoot = file("built-distribution")

)

Global / onChangedBuildSource := ReloadOnSourceChanges

// ============================================================================

// === Compiler Options =======================================================

// ============================================================================

ThisBuild / javacOptions ++= Seq(

"-encoding", // Provide explicit encoding (the next line)

"UTF-8", // Specify character encoding used by Java source files.

"-deprecation" // Shows a description of each use or override of a deprecated member or class.

)

ThisBuild / scalacOptions ++= 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.

"-Vimplicits", // Prints implicit resolution chains when no implicit can be found.

"-Vtype-diffs", // Prints type errors as coloured diffs between types.

"-Xcheckinit", // Wrap field accessors to throw an exception on uninitialized access.

"-Xfatal-warnings", // Make warnings fatal so they don't make it onto main (use @nowarn for local suppression)

"-Xlint:adapted-args", // Warn if an argument list is modified to match the receiver.

"-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-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:type-parameter-shadow", // A local type parameter shadows a type already in scope.

"-Xmacro-settings:-logging@org.enso", // Disable the debug logging globally.

"-Ywarn-dead-code", // Warn when dead code is identified.

"-Ywarn-extra-implicit", // Warn when more than one implicit parameter section is defined.

"-Ywarn-numeric-widen", // Warn when numerics are widened.

"-Ywarn-unused:implicits", // Warn if an implicit parameter is unused.

"-Ywarn-unused:imports", // Warn if an import selector is not referenced.

"-Ywarn-unused:locals", // Warn if a local definition is unused.

"-Ywarn-unused:params", // Warn if a value parameter 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.

)

val jsSettings = Seq(

scalaJSLinkerConfig ~= { _.withModuleKind(ModuleKind.ESModule) }

)

Compile / console / scalacOptions ~= (_ filterNot (_ == "-Xfatal-warnings"))

// ============================================================================

// === Benchmark Configuration ================================================

// ============================================================================

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

// Native Image Generation

lazy val rebuildNativeImage = taskKey[Unit]("Force to rebuild native image")

lazy val buildNativeImage =

taskKey[Unit]("Ensure that the Native Image is built.")

// Bootstrap task

lazy val bootstrap =

taskKey[Unit]("Prepares Truffle JARs that are required by the sbt JVM")

bootstrap := {}

// ============================================================================

// === Global Project =========================================================

// ============================================================================

lazy val enso = (project in file("."))

.settings(version := "0.1")

.aggregate(

`core-definition`,

`interpreter-dsl`,

`json-rpc-server-test`,

`json-rpc-server`,

`language-server`,

`parser-service`,

`docs-generator`,

`polyglot-api`,

`project-manager`,

`syntax-definition`.jvm,

`text-buffer`,

flexer.jvm,

graph,

logger.jvm,

pkg,

cli,

`task-progress-notifications`,

`logging-utils`,

`logging-service`,

`logging-truffle-connector`,

`locking-test-helper`,

`akka-native`,

`version-output`,

`engine-runner`,

runtime,

searcher,

launcher,

downloader,

`runtime-version-manager`,

`runtime-version-manager-test`,

editions,

`distribution-manager`,

`edition-updater`,

`edition-uploader`,

`library-manager`,

`library-manager-test`,

`connected-lock-manager`,

`stdlib-version-updater`,

syntax.jvm,

testkit

)

.settings(Global / concurrentRestrictions += Tags.exclusive(Exclusive))

.settings(

commands ++= Seq(packageBuilder.makePackages, packageBuilder.makeBundles)

)

// ============================================================================

// === Dependency Versions ====================================================

// ============================================================================

/* Note [Dependency Versions]

* ~~~~~~~~~~~~~~~~~~~~~~~~~~

* Please maintain the following section in alphabetical order for the bundles

* of dependencies. Additionally, please keep the 'Other' subsection in

* alphabetical order.

*

* Furthermore, please keep the following in mind:

* - Wherever possible, we should use the same version of a dependency

* throughout the project.

* - If you need to include a new dependency, please define its version in this

* section.

* - If that version is not the latest, please include a note explaining why

* this is the case.

* - If, for some reason, you need to use a dependency version other than the

* global one, please include a note explaining why this is the case, and the

* circumstances under which the dependency could be upgraded to use the

* global version

*/

// === Akka ===================================================================

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.6.6"

val akkaHTTPVersion = "10.2.0-RC1"

val akkaMockSchedulerVersion = "0.5.5"

val logbackClassicVersion = "1.2.3"

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 akkaTest = Seq(

"ch.qos.logback" % "logback-classic" % logbackClassicVersion % Test

)

val akka =

Seq(

akkaActor,

akkaStream,

akkaHttp,

akkaSpray,

akkaTyped

)

// === Cats ===================================================================

val catsVersion = "2.2.0-M3"

val kittensVersion = "2.1.0"

val cats = {

Seq(

"org.typelevel" %% "cats-core" % catsVersion,

"org.typelevel" %% "cats-effect" % catsVersion,

"org.typelevel" %% "cats-free" % catsVersion,

"org.typelevel" %% "cats-macros" % catsVersion,

"org.typelevel" %% "kittens" % kittensVersion

)

}

// === Circe ==================================================================

val circeVersion = "0.14.0-M1"

val circeYamlVersion = "0.13.1"

val enumeratumCirceVersion = "1.6.1"

val circeGenericExtrasVersion = "0.13.0"

val circe = Seq("circe-core", "circe-generic", "circe-parser")

.map("io.circe" %% _ % circeVersion)

// === Commons ================================================================

val commonsCollectionsVersion = "4.4"

val commonsLangVersion = "3.10"

val commonsIoVersion = "2.7"

val commonsTextVersion = "1.8"

val commonsMathVersion = "3.6.1"

val commonsCompressVersion = "1.20"

val commonsCliVersion = "1.4"

val commons = Seq(

"org.apache.commons" % "commons-collections4" % commonsCollectionsVersion,

"org.apache.commons" % "commons-lang3" % commonsLangVersion,

"commons-io" % "commons-io" % commonsIoVersion,

"org.apache.commons" % "commons-text" % commonsTextVersion,

"org.apache.commons" % "commons-math3" % commonsMathVersion,

"commons-cli" % "commons-cli" % commonsCliVersion

)

// === Jackson ================================================================

val jacksonVersion = "2.11.1"

val jackson = Seq(

"com.fasterxml.jackson.dataformat" % "jackson-dataformat-cbor" % jacksonVersion,

"com.fasterxml.jackson.core" % "jackson-databind" % jacksonVersion,

"com.fasterxml.jackson.module" %% "jackson-module-scala" % jacksonVersion

)

// === JAXB ================================================================

val jaxbVersion = "2.3.3"

val jaxb = Seq(

"jakarta.xml.bind" % "jakarta.xml.bind-api" % jaxbVersion % Benchmark,

"com.sun.xml.bind" % "jaxb-impl" % jaxbVersion % Benchmark

)

// === JMH ====================================================================

val jmhVersion = "1.23"

val jmh = Seq(

"org.openjdk.jmh" % "jmh-core" % jmhVersion % Benchmark,

"org.openjdk.jmh" % "jmh-generator-annprocess" % jmhVersion % Benchmark

)

// === Monocle ================================================================

val monocleVersion = "2.0.5"

val monocle = {

Seq(

"com.github.julien-truffaut" %% "monocle-core" % monocleVersion,

"com.github.julien-truffaut" %% "monocle-macro" % monocleVersion,

"com.github.julien-truffaut" %% "monocle-law" % monocleVersion % "test"

)

}

// === Scala Compiler =========================================================

val scalaCompiler = Seq(

"org.scala-lang" % "scala-reflect" % scalacVersion,

"org.scala-lang" % "scala-compiler" % scalacVersion

)

// === std-lib ================================================================

val icuVersion = "67.1"

// === ZIO ====================================================================

val zioVersion = "1.0.1"

val zioInteropCatsVersion = "2.1.4.0"

val zio = Seq(

"dev.zio" %% "zio" % zioVersion,

"dev.zio" %% "zio-interop-cats" % zioInteropCatsVersion

)

// === Other ==================================================================

val bcpkixJdk15Version = "1.65"

val bumpVersion = "0.1.3"

val declineVersion = "1.2.0"

val directoryWatcherVersion = "0.9.10"

val flatbuffersVersion = "1.12.0"

val guavaVersion = "29.0-jre"

val jlineVersion = "3.19.0"

val kindProjectorVersion = "0.13.0"

val mockitoScalaVersion = "1.14.8"

val newtypeVersion = "0.4.4"

val pprintVersion = "0.5.9"

val pureconfigVersion = "0.15.0"

val refinedVersion = "0.9.14"

val scalacheckVersion = "1.14.3"

val scalacticVersion = "3.3.0-SNAP2"

val scalaLoggingVersion = "3.9.2"

val scalameterVersion = "0.19"

val scalatagsVersion = "0.9.1"

val scalatestVersion = "3.3.0-SNAP2"

val shapelessVersion = "2.4.0-M1"

val slf4jVersion = "1.7.30"

val slickVersion = "3.3.2"

val sqliteVersion = "3.36.0.1"

val tikaVersion = "1.24.1"

val typesafeConfigVersion = "1.4.1"

// ============================================================================

// === Internal Libraries =====================================================

// ============================================================================

lazy val logger = crossProject(JVMPlatform, JSPlatform)

.withoutSuffixFor(JVMPlatform)

.crossType(CrossType.Pure)

.in(file("lib/scala/logger"))

.settings(

version := "0.1",

libraryDependencies ++= scalaCompiler

)

.jsSettings(jsSettings)

lazy val flexer = crossProject(JVMPlatform, JSPlatform)

.withoutSuffixFor(JVMPlatform)

.crossType(CrossType.Pure)

.in(file("lib/scala/flexer"))

.dependsOn(logger)

.settings(

version := "0.1",

resolvers += Resolver.sonatypeRepo("releases"),

libraryDependencies ++= scalaCompiler ++ Seq(

"com.google.guava" % "guava" % guavaVersion exclude ("com.google.code.findbugs", "jsr305"),

"org.typelevel" %%% "cats-core" % catsVersion,

"org.typelevel" %%% "kittens" % kittensVersion

)

)

.jsSettings(jsSettings)

lazy val `syntax-definition` = crossProject(JVMPlatform, JSPlatform)

.withoutSuffixFor(JVMPlatform)

.crossType(CrossType.Pure)

.in(file("lib/scala/syntax/definition"))

.dependsOn(logger, flexer)

.settings(

scalacOptions ++= Seq("-Ypatmat-exhaust-depth", "off"),

libraryDependencies ++= monocle ++ scalaCompiler ++ Seq(

"org.typelevel" %%% "cats-core" % catsVersion,

"org.typelevel" %%% "kittens" % kittensVersion,

"com.lihaoyi" %%% "scalatags" % scalatagsVersion,

"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("lib/scala/syntax/specialization"))

.dependsOn(logger, flexer, `syntax-definition`)

.configs(Test)

.configs(Benchmark)

.settings(

commands += WithDebugCommand.withDebug,

Test / fork := true,

testFrameworks := Nil,

scalacOptions ++= Seq("-Ypatmat-exhaust-depth", "off"),

Compile / run / mainClass := Some("org.enso.syntax.text.Main"),

version := "0.1",

logBuffered := false,

libraryDependencies ++= Seq(

"org.scalatest" %%% "scalatest" % scalatestVersion % Test,

"com.lihaoyi" %%% "pprint" % pprintVersion,

"io.circe" %%% "circe-core" % circeVersion,

"io.circe" %%% "circe-generic" % circeVersion,

"io.circe" %%% "circe-parser" % circeVersion

),

(Compile / compile) := (Compile / compile)

.dependsOn(RecompileParser.run(`syntax-definition`))

.value,

(Test / compile) := (Test / compile)

.dependsOn(RecompileParser.run(`syntax-definition`))

.value,

(Benchmark / compile) := (Benchmark / compile)

.dependsOn(RecompileParser.run(`syntax-definition`))

.value

)

.jvmSettings(

inConfig(Benchmark)(Defaults.testSettings),

Benchmark / unmanagedSourceDirectories +=

baseDirectory.value.getParentFile / "shared/src/bench/scala",

libraryDependencies +=

"com.storm-enroute" %% "scalameter" % scalameterVersion % "bench",

testFrameworks := List(

new TestFramework("org.scalatest.tools.Framework"),

new TestFramework("org.scalameter.ScalaMeterFramework")

),

bench := (Benchmark / test).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 `lexer-bench` =

(project in file("lib/scala/syntax/specialization/lexer-bench"))

.settings(

commands += WithDebugCommand.withDebug,

inConfig(Compile)(truffleRunOptionsSettings),

inConfig(Benchmark)(Defaults.testSettings),

Test / parallelExecution := false,

Test / logBuffered := false,

Test / fork := true,

libraryDependencies ++= jmh

)

.configs(Test)

.configs(Benchmark)

.dependsOn(syntax.jvm)

.dependsOn(flexer.jvm)

.settings(

javaOptions ++= Seq(

"-Xms4096m",

"-Xmx4096m",

"-XX:+FlightRecorder"

),

Benchmark / mainClass := Some("org.openjdk.jmh.Main"),

bench := Def.task {

(Benchmark / run).toTask("").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 {

(Benchmark / testOnly).toTask(" -- -z " + name).value

}

}.evaluated,

Benchmark / parallelExecution := false

)

lazy val `parser-service` = (project in file("lib/scala/parser-service"))

.dependsOn(syntax.jvm)

.settings(

libraryDependencies ++= akka ++ akkaTest,

mainClass := Some("org.enso.ParserServiceMain")

)

lazy val `docs-generator` = (project in file("lib/scala/docs-generator"))

.dependsOn(syntax.jvm)

.dependsOn(cli)

.dependsOn(`version-output`)

.configs(Benchmark)

.settings(

libraryDependencies ++= Seq(

"commons-cli" % "commons-cli" % commonsCliVersion

),

mainClass := Some("org.enso.docs.generator.Main"),

inConfig(Benchmark)(Defaults.testSettings),

Benchmark / unmanagedSourceDirectories +=

baseDirectory.value.getParentFile / "bench" / "scala",

libraryDependencies +=

"com.storm-enroute" %% "scalameter" % scalameterVersion % "bench",

testFrameworks := List(

new TestFramework("org.scalatest.tools.Framework"),

new TestFramework("org.scalameter.ScalaMeterFramework")

),

bench := (Benchmark / test).tag(Exclusive).value

)

lazy val `text-buffer` = project

.in(file("lib/scala/text-buffer"))

.configs(Test)

.settings(

libraryDependencies ++= Seq(

"org.typelevel" %% "cats-core" % catsVersion,

"org.bouncycastle" % "bcpkix-jdk15on" % bcpkixJdk15Version,

"org.scalatest" %% "scalatest" % scalatestVersion % Test,

"org.scalacheck" %% "scalacheck" % scalacheckVersion % Test

)

)

lazy val graph = (project in file("lib/scala/graph/"))

.dependsOn(logger.jvm)

.configs(Test)

.settings(

version := "0.1",

resolvers ++= Seq(

Resolver.sonatypeRepo("releases"),

Resolver.sonatypeRepo("snapshots")

),

scalacOptions += "-Ymacro-annotations",

libraryDependencies ++= scalaCompiler ++ Seq(

"com.chuusai" %% "shapeless" % shapelessVersion,

"io.estatico" %% "newtype" % newtypeVersion,

"org.scalatest" %% "scalatest" % scalatestVersion % Test,

"org.scalacheck" %% "scalacheck" % scalacheckVersion % Test,

"com.github.julien-truffaut" %% "monocle-core" % monocleVersion,

"org.apache.commons" % "commons-lang3" % commonsLangVersion

),

addCompilerPlugin(

"org.typelevel" %% "kind-projector" % kindProjectorVersion cross CrossVersion.full

)

)

lazy val pkg = (project in file("lib/scala/pkg"))

.settings(

Compile / run / mainClass := Some("org.enso.pkg.Main"),

version := "0.1",

libraryDependencies ++= circe ++ Seq(

"org.scalatest" %% "scalatest" % scalatestVersion % Test,

"io.circe" %% "circe-yaml" % circeYamlVersion, // separate from other circe deps because its independent project with its own versioning

"commons-io" % "commons-io" % commonsIoVersion

)

)

.dependsOn(editions)

lazy val `akka-native` = project

.in(file("lib/scala/akka-native"))

.configs(Test)

.settings(

version := "0.1",

libraryDependencies ++= Seq(

akkaActor

),

// Note [Native Image Workaround for GraalVM 20.2]

libraryDependencies += "org.graalvm.nativeimage" % "svm" % graalVersion % "provided"

)

lazy val `logging-utils` = project

.in(file("lib/scala/logging-utils"))

.configs(Test)

.settings(

version := "0.1",

libraryDependencies ++= Seq(

"org.scalatest" %% "scalatest" % scalatestVersion % Test

)

)

lazy val `logging-service` = project

.in(file("lib/scala/logging-service"))

.configs(Test)

.settings(

version := "0.1",

libraryDependencies ++= Seq(

"org.slf4j" % "slf4j-api" % slf4jVersion,

"com.typesafe" % "config" % typesafeConfigVersion,

"com.typesafe.scala-logging" %% "scala-logging" % scalaLoggingVersion,

akkaStream,

akkaHttp,

"io.circe" %%% "circe-core" % circeVersion,

"io.circe" %%% "circe-parser" % circeVersion,

"org.scalatest" %% "scalatest" % scalatestVersion % Test,

"org.graalvm.nativeimage" % "svm" % graalVersion % "provided"

)

)

.settings(

if (Platform.isWindows)

(Compile / unmanagedSourceDirectories) += (Compile / sourceDirectory).value / "java-windows"

else

(Compile / unmanagedSourceDirectories) += (Compile / sourceDirectory).value / "java-unix"

)

.dependsOn(`akka-native`)

.dependsOn(`logging-utils`)

lazy val `logging-truffle-connector` = project

.in(file("lib/scala/logging-truffle-connector"))

.settings(

version := "0.1",

libraryDependencies ++= Seq(

"org.slf4j" % "slf4j-api" % slf4jVersion,

"org.graalvm.truffle" % "truffle-api" % graalVersion % "provided"

)

)

.dependsOn(`logging-utils`)

.dependsOn(`polyglot-api`)

lazy val cli = project

.in(file("lib/scala/cli"))

.configs(Test)

.settings(

version := "0.1",

libraryDependencies ++= circe ++ Seq(

"com.typesafe.scala-logging" %% "scala-logging" % scalaLoggingVersion,

"org.scalatest" %% "scalatest" % scalatestVersion % Test,

"org.typelevel" %% "cats-core" % catsVersion

),

Test / parallelExecution := false

)

lazy val `task-progress-notifications` = project

.in(file("lib/scala/task-progress-notifications"))

.configs(Test)

.settings(

version := "0.1",

libraryDependencies ++= Seq(

"com.beachape" %% "enumeratum-circe" % enumeratumCirceVersion,

"org.scalatest" %% "scalatest" % scalatestVersion % Test

),

Test / parallelExecution := false

)

.dependsOn(cli)

.dependsOn(`json-rpc-server`)

lazy val `version-output` = (project in file("lib/scala/version-output"))

.settings(

version := "0.1"

)

.settings(

Compile / sourceGenerators += Def.task {

val file = (Compile / sourceManaged).value / "buildinfo" / "Info.scala"

BuildInfo

.writeBuildInfoFile(

file = file,

log = state.value.log,

ensoVersion = ensoVersion,

scalacVersion = scalacVersion,

graalVersion = graalVersion,

currentEdition = currentEdition,

stdLibVersion = stdLibVersion

)

}.taskValue

)

lazy val `project-manager` = (project in file("lib/scala/project-manager"))

.settings(

(Compile / mainClass) := Some("org.enso.projectmanager.boot.ProjectManager")

)

.settings(

(Compile / run / fork) := true,

(Test / fork) := true,

(Compile / run / connectInput) := true,

libraryDependencies ++= akka ++ Seq(akkaTestkit % Test),

libraryDependencies ++= circe,

libraryDependencies ++= Seq(

"com.typesafe" % "config" % typesafeConfigVersion,

"com.github.pureconfig" %% "pureconfig" % pureconfigVersion,

"com.typesafe.scala-logging" %% "scala-logging" % scalaLoggingVersion,

"dev.zio" %% "zio" % zioVersion,

"dev.zio" %% "zio-interop-cats" % zioInteropCatsVersion,

"commons-cli" % "commons-cli" % commonsCliVersion,

"commons-io" % "commons-io" % commonsIoVersion,

"org.apache.commons" % "commons-lang3" % commonsLangVersion,

"com.beachape" %% "enumeratum-circe" % enumeratumCirceVersion,

"com.miguno.akka" %% "akka-mock-scheduler" % akkaMockSchedulerVersion % Test,

"org.mockito" %% "mockito-scala" % mockitoScalaVersion % Test

),

addCompilerPlugin(

"org.typelevel" %% "kind-projector" % kindProjectorVersion cross CrossVersion.full

)

)

.settings(

assembly / assemblyJarName := "project-manager.jar",

assembly / test := {},

assembly / assemblyOutputPath := file("project-manager.jar"),

assembly / assemblyMergeStrategy := {

case PathList("META-INF", file, xs @ _*) if file.endsWith(".DSA") =>

MergeStrategy.discard

case PathList("META-INF", file, xs @ _*) if file.endsWith(".SF") =>

MergeStrategy.discard

case PathList("META-INF", "MANIFEST.MF", xs @ _*) =>

MergeStrategy.discard

case "application.conf" => MergeStrategy.concat

case "reference.conf" => MergeStrategy.concat

case _ => MergeStrategy.first

},

(Test / test) := (Test / test).dependsOn(`engine-runner` / assembly).value,

rebuildNativeImage := NativeImage

.buildNativeImage(

"project-manager",

staticOnLinux = true,

initializeAtRuntime = Seq("scala.util.Random")

)

.dependsOn(VerifyReflectionSetup.run)

.dependsOn(assembly)

.value,

buildNativeImage := NativeImage

.incrementalNativeImageBuild(

rebuildNativeImage,

"project-manager"

)

.value

)

.dependsOn(`akka-native`)

.dependsOn(`version-output`)

.dependsOn(editions)

.dependsOn(`edition-updater`)

.dependsOn(cli)

.dependsOn(`task-progress-notifications`)

.dependsOn(`polyglot-api`)

.dependsOn(`runtime-version-manager`)

.dependsOn(`library-manager`)

.dependsOn(pkg)

.dependsOn(`json-rpc-server`)

.dependsOn(`json-rpc-server-test` % Test)

.dependsOn(testkit % Test)

.dependsOn(`runtime-version-manager-test` % Test)

/* Note [Classpath Separation]

* ~~~~~~~~~~~~~~~~~~~~~~~~~~

* Projects using the language runtime do not depend on it directly, but instead

* the language runtime is put on the Truffle classpath, rather than the

* standard classpath. This is the recommended way of handling this and we

* strive to use such structure everywhere.

* See

* https://www.graalvm.org/docs/graalvm-as-a-platform/implement-language#graalvm

*

* Currently the only exception to this are the tests of the runtime project

* which have classpath separation disabled, because they need direct access to

* the runtime's instruments.

*

* To ensure correct handling of dependencies by sbt, the classpath appended to

* Java options, should be based on `(runtime / Compile / fullClasspath).value`

* wherever possible. Using a key from the runtime project enables sbt to see

* the dependency.

*

* Assembly tasks that build JAR files which need `runtime.jar` to run should

* also add a dependency on `runtime / assembly`.

*/

lazy val `json-rpc-server` = project

.in(file("lib/scala/json-rpc-server"))

.settings(

libraryDependencies ++= akka ++ akkaTest,

libraryDependencies ++= circe,

libraryDependencies ++= Seq(

"io.circe" %% "circe-literal" % circeVersion,

akkaTestkit % Test,

"org.scalatest" %% "scalatest" % scalatestVersion % Test

)

)

lazy val `json-rpc-server-test` = project

.in(file("lib/scala/json-rpc-server-test"))

.settings(

libraryDependencies ++= akka,

libraryDependencies ++= circe,

libraryDependencies ++= Seq(

"io.circe" %% "circe-literal" % circeVersion,

akkaTestkit,

"org.scalatest" %% "scalatest" % scalatestVersion

)

)

.dependsOn(`json-rpc-server`)

lazy val testkit = project

.in(file("lib/scala/testkit"))

.settings(

libraryDependencies ++= Seq(

"org.apache.commons" % "commons-lang3" % commonsLangVersion,

"commons-io" % "commons-io" % commonsIoVersion,

"org.scalatest" %% "scalatest" % scalatestVersion

)

)

lazy val `core-definition` = (project in file("lib/scala/core-definition"))

.configs(Benchmark)

.settings(

version := "0.1",

inConfig(Compile)(truffleRunOptionsSettings),

inConfig(Benchmark)(Defaults.testSettings),

Test / parallelExecution := false,

Test / logBuffered := false,

scalacOptions += "-Ymacro-annotations",

libraryDependencies ++= jmh ++ Seq(

"com.chuusai" %% "shapeless" % shapelessVersion,

"org.scalacheck" %% "scalacheck" % scalacheckVersion % Test,

"org.scalactic" %% "scalactic" % scalacticVersion % Test,

"org.scalatest" %% "scalatest" % scalatestVersion % Test,

"org.typelevel" %% "cats-core" % catsVersion,

"com.github.julien-truffaut" %% "monocle-core" % monocleVersion

),

addCompilerPlugin(

"org.typelevel" %% "kind-projector" % kindProjectorVersion cross CrossVersion.full

)

)

.dependsOn(graph)

.dependsOn(syntax.jvm)

lazy val searcher = project

.in(file("lib/scala/searcher"))

.configs(Test)

.settings(

libraryDependencies ++= jmh ++ Seq(

"com.typesafe.slick" %% "slick" % slickVersion,

"org.xerial" % "sqlite-jdbc" % sqliteVersion,

"ch.qos.logback" % "logback-classic" % logbackClassicVersion % Test,

"org.scalatest" %% "scalatest" % scalatestVersion % Test

)

)

.configs(Benchmark)

.settings(

inConfig(Benchmark)(Defaults.testSettings),

Benchmark / fork := true

)

.dependsOn(testkit % Test)

.dependsOn(`polyglot-api`)

.dependsOn(`docs-generator`)

lazy val `interpreter-dsl` = (project in file("lib/scala/interpreter-dsl"))

.settings(

version := "0.1",

libraryDependencies += "com.google.auto.service" % "auto-service" % "1.0-rc7" exclude ("com.google.code.findbugs", "jsr305")

)

// ============================================================================

// === Sub-Projects ===========================================================

// ============================================================================

val truffleRunOptions = Seq(

"-Dpolyglot.engine.IterativePartialEscape=true",

"-Dpolyglot.engine.BackgroundCompilation=false"

)

val truffleRunOptionsSettings = Seq(

fork := true,

javaOptions ++= truffleRunOptions

)

lazy val `polyglot-api` = project

.in(file("engine/polyglot-api"))

.settings(

Test / fork := true,

commands += WithDebugCommand.withDebug,

Test / envVars ++= distributionEnvironmentOverrides,

Test / javaOptions ++= {

// Note [Classpath Separation]

val runtimeClasspath =

(LocalProject("runtime") / Compile / fullClasspath).value

.map(_.data)

.mkString(File.pathSeparator)

Seq(s"-Dtruffle.class.path.append=$runtimeClasspath")

},

libraryDependencies ++= Seq(

"org.graalvm.sdk" % "polyglot-tck" % graalVersion % "provided",

"com.google.flatbuffers" % "flatbuffers-java" % flatbuffersVersion,

"org.scalatest" %% "scalatest" % scalatestVersion % Test,

"org.scalacheck" %% "scalacheck" % scalacheckVersion % Test

),

libraryDependencies ++= jackson,

addCompilerPlugin(

"org.typelevel" %% "kind-projector" % kindProjectorVersion cross CrossVersion.full

),

GenerateFlatbuffers.flatcVersion := flatbuffersVersion,

Compile / sourceGenerators += GenerateFlatbuffers.task

)

.dependsOn(pkg)

.dependsOn(`text-buffer`)

.dependsOn(`logging-utils`)

.dependsOn(testkit % Test)

lazy val `language-server` = (project in file("engine/language-server"))

.settings(

libraryDependencies ++= akka ++ circe ++ Seq(

"com.typesafe.scala-logging" %% "scala-logging" % scalaLoggingVersion,

"io.circe" %% "circe-generic-extras" % circeGenericExtrasVersion,

"io.circe" %% "circe-literal" % circeVersion,

"dev.zio" %% "zio" % zioVersion,

"io.methvin" % "directory-watcher" % directoryWatcherVersion,

"com.beachape" %% "enumeratum-circe" % enumeratumCirceVersion,

"com.google.flatbuffers" % "flatbuffers-java" % flatbuffersVersion,

"commons-io" % "commons-io" % commonsIoVersion,

akkaTestkit % Test,

"com.typesafe.akka" %% "akka-http-testkit" % akkaHTTPVersion % Test,

"org.scalatest" %% "scalatest" % scalatestVersion % Test,

"org.scalacheck" %% "scalacheck" % scalacheckVersion % Test,

"org.graalvm.sdk" % "polyglot-tck" % graalVersion % "provided"

),