import LibraryManifestGenerator.BundledLibrary

import org.enso.build.BenchTasks._

import org.enso.build.WithDebugCommand

import org.apache.commons.io.FileUtils

import sbt.Keys.{libraryDependencies, scalacOptions}

import sbt.addCompilerPlugin

import sbt.complete.DefaultParsers._

import sbt.complete.Parser

import sbt.nio.file.FileTreeView

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

import src.main.scala.licenses.{

DistributionDescription,

SBTDistributionComponent

}

import java.io.File

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

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

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

val scalacVersion = "2.13.8"

val graalVersion = "21.3.0"

val javaVersion = "11"

val defaultDevEnsoVersion = "0.0.0-dev"

val ensoVersion = sys.env.getOrElse(

"ENSO_VERSION",

defaultDevEnsoVersion

) // Note [Engine And Launcher Version]

val currentEdition = sys.env.getOrElse(

"ENSO_EDITION",

defaultDevEnsoVersion

) // Note [Default Editions]

// Note [Stdlib Version]

val stdLibVersion = defaultDevEnsoVersion

val targetStdlibVersion = 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.

*/

/* Note [Stdlib Version]

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

* The `stdlibVersion` variable stores the version at which standard library is

* stored within the source tree, which is currently set to a constant of

* `0.0.0-dev`.

*

* When distributions are built, the library versions are updated to match the

* current Enso version.

*/

ThisBuild / organization := "org.enso"

ThisBuild / scalaVersion := scalacVersion

/* Tag limiting the concurrent access to tools/simple-library-server in tests.

*/

val simpleLibraryServerTag = Tags.Tag("simple-library-server")

Global / concurrentRestrictions += Tags.limit(simpleLibraryServerTag, 1)

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

Global / excludeLintKeys += logManager

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

// === 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

"-g", // Include debugging information

"-Xlint:unchecked" // Enable additional warnings

)

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.

)

ThisBuild / Test / testOptions ++=

Seq(Tests.Argument("-oI")) ++

sys.env

.get("ENSO_TEST_JUNIT_DIR")

.map { junitDir =>

Tests.Argument(TestFrameworks.ScalaTest, "-u", junitDir)

}

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(

`interpreter-dsl`,

`json-rpc-server-test`,

`json-rpc-server`,

`language-server`,

`parser-service`,

`docs-generator`,

`polyglot-api`,

`project-manager`,

`syntax-definition`.jvm,

`syntax-rust-definition`,

`text-buffer`,

flexer.jvm,

graph,

logger.jvm,

pkg,

cli,

`task-progress-notifications`,

`profiling-utils`,

`logging-utils`,

`logging-service`,

`logging-truffle-connector`,

`locking-test-helper`,

`akka-native`,

`version-output`,

`engine-runner`,

runtime,

searcher,

launcher,

downloader,

`runtime-language-epb`,

`runtime-instrument-id-execution`,

`runtime-instrument-repl-debugger`,

`runtime-instrument-runtime-server`,

`runtime-with-instruments`,

`runtime-version-manager`,

`runtime-version-manager-test`,

editions,

`distribution-manager`,

`edition-updater`,

`edition-uploader`,

`library-manager`,

`library-manager-test`,

`connected-lock-manager`,

syntax.jvm,

testkit,

`std-base`,

`std-database`,

`std-google-api`,

`std-image`,

`std-table`

)

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

val akkaHTTPVersion = "10.2.9"

val akkaMockSchedulerVersion = "0.5.5"

val logbackClassicVersion = "1.2.11"

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

val kittensVersion = "2.3.2"

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

val circeYamlVersion = "0.14.1"

val enumeratumCirceVersion = "1.7.0"

val circeGenericExtrasVersion = "0.14.2"

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

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

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

val commonsCollectionsVersion = "4.4"

val commonsLangVersion = "3.12.0"

val commonsIoVersion = "2.11.0"

val commonsTextVersion = "1.8"

val commonsMathVersion = "3.6.1"

val commonsCompressVersion = "1.21"

val commonsCliVersion = "1.5.0"

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

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 = "4.0.0"

val jaxb = Seq(

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

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

)

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

val jmhVersion = "1.35"

val jmh = Seq(

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

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

)

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

val monocleVersion = "2.1.0"

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 = "71.1"

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

val zioVersion = "1.0.12"

val zioInteropCatsVersion = "3.2.9.0"

val zio = Seq(

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

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

)

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

val bcpkixJdk15Version = "1.70"

val bumpVersion = "0.1.3"

val declineVersion = "2.3.0"

val directoryWatcherVersion = "0.9.10"

val flatbuffersVersion = "1.12.0"

val guavaVersion = "31.1-jre"

val jlineVersion = "3.21.0"

val kindProjectorVersion = "0.13.2"

val mockitoScalaVersion = "1.17.12"

val newtypeVersion = "0.4.4"

val pprintVersion = "0.7.3"

val pureconfigVersion = "0.17.1"

val scalacheckVersion = "1.16.0"

val scalacticVersion = "3.3.0-SNAP3"

val scalaLoggingVersion = "3.9.4"

val scalameterVersion = "0.19"

val scalatagsVersion = "0.11.1"

val scalatestVersion = "3.3.0-SNAP3"

val shapelessVersion = "2.4.0-M1"

val slf4jVersion = "1.7.36"

val slickVersion = "3.3.3"

val sqliteVersion = "3.36.0.3"

val tikaVersion = "2.4.1"

val typesafeConfigVersion = "1.4.2"

val junitVersion = "4.13.2"

val netbeansApiVersion = "RELEASE140"

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

// === 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.sonatypeOssRepos("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"),

libraryDependencies +=

"org.scala-js" %%% "scalajs-java-securerandom" % "1.0.0"

)

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

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

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

),

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

)

)

val generateRustParserLib =

TaskKey[Seq[File]]("generateRustParserLib", "Generates parser native library")

`syntax-rust-definition` / generateRustParserLib := {

import sys.process._

val libGlob = target.value.toGlob / "rust" / * / "libenso_parser.so"

val allLibs = FileTreeView.default.list(Seq(libGlob)).map(_._1)

if (

sys.env.get("CI").isDefined ||

allLibs.isEmpty ||

(`syntax-rust-definition` / generateRustParserLib).inputFileChanges.hasChanges

) {

Seq("cargo", "build", "-p", "enso-parser-jni") !

}

FileTreeView.default.list(Seq(libGlob)).map(_._1.toFile)

}

`syntax-rust-definition` / generateRustParserLib / fileInputs +=

(`syntax-rust-definition` / baseDirectory).value.toGlob / "jni" / "src" / "*.rs"

val generateParserJavaSources = TaskKey[Seq[File]](

"generateParserJavaSources",

"Generates Java sources for Rust parser"

)

`syntax-rust-definition` / generateParserJavaSources := {

generateRustParser(

(`syntax-rust-definition` / Compile / sourceManaged).value,

(`syntax-rust-definition` / generateParserJavaSources).inputFileChanges

)

}

`syntax-rust-definition` / generateParserJavaSources / fileInputs +=

(`syntax-rust-definition` / baseDirectory).value.toGlob / "generate-java" / "src" / ** / "*.rs"

`syntax-rust-definition` / generateParserJavaSources / fileInputs +=

(`syntax-rust-definition` / baseDirectory).value.toGlob / "src" / ** / "*.rs"

def generateRustParser(base: File, changes: sbt.nio.FileChanges): Seq[File] = {

}

lazy val `syntax-rust-definition` = project

.in(file("lib/rust/parser"))

.configs(Test)

.settings(

Compile / sourceGenerators += generateParserJavaSources,

Compile / resourceGenerators += generateRustParserLib,

Compile / javaSource := baseDirectory.value / "generate-java" / "java",

frgaalJavaCompilerSetting

)

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

.dependsOn(logger.jvm)

.configs(Test)

.settings(

version := "0.1",

resolvers ++= (

Resolver.sonatypeOssRepos("releases") ++

Resolver.sonatypeOssRepos("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 `profiling-utils` = project

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

.configs(Test)

.settings(

version := "0.1",

libraryDependencies ++= Seq(

"org.netbeans.api" % "org-netbeans-modules-sampler" % netbeansApiVersion

exclude ("org.netbeans.api", "org-openide-loaders")

exclude ("org.netbeans.api", "org-openide-nodes")

exclude ("org.netbeans.api", "org-netbeans-api-progress-nb")

exclude ("org.netbeans.api", "org-netbeans-api-progress")

exclude ("org.netbeans.api", "org-openide-util-lookup")

exclude ("org.netbeans.api", "org-openide-util")

exclude ("org.netbeans.api", "org-openide-dialogs")

exclude ("org.netbeans.api", "org-openide-filesystems")

exclude ("org.netbeans.api", "org-openide-util-ui")

exclude ("org.netbeans.api", "org-openide-awt")

exclude ("org.netbeans.api", "org-openide-modules")

exclude ("org.netbeans.api", "org-netbeans-api-annotations-common")

)

)

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,

defaultDevEnsoVersion = defaultDevEnsoVersion,

ensoVersion = ensoVersion,

scalacVersion = scalacVersion,

graalVersion = graalVersion,

currentEdition = currentEdition

)

}.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(