1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
package mill.contrib.bsp
import java.util.Collections
import scala.collection.JavaConverters._
import ch.epfl.scala.bsp4j._
import mill.api.Result.Success
import mill.api.{Loose, Strict}
import mill.define.{Discover, Task}
import mill.eval._
import mill.eval.Evaluator
import mill.scalajslib.ScalaJSModule
import mill.scalalib.api.Util
import mill.scalanativelib._
import mill.scalalib.{JavaModule, ScalaModule, TestModule}
import mill.util.DummyLogger
object ModuleUtils {
object dummyModule extends mill.define.ExternalModule {
lazy val millDiscover: Discover[dummyModule.this.type] = Discover[this.type]
}
val dummyEvalautor: Evaluator = new Evaluator(os.pwd / "contrib" / "bsp" / "mill-bs",
os.pwd / "contrib" / "bsp" / "mill-out-bs",
os.pwd / "contrib" / "bsp" / "mill-external-bs",
dummyModule, DummyLogger)
def millModulesToBspTargets(modules: Seq[JavaModule],
evaluator: Evaluator,
supportedLanguages: List[String]): Predef.Map[JavaModule, BuildTarget] = {
val moduleIdMap = getModuleTargetIdMap(modules)
var moduleToTarget = Predef.Map[JavaModule, BuildTarget]()
for ( module <- modules ) {
val dataBuildTarget = computeScalaBuildTarget(module, evaluator)
val capabilities = getModuleCapabilities(module, evaluator)
val buildTargetTag: String = module match {
case m: TestModule => BuildTargetTag.TEST
case m: JavaModule => "-"
}
val dependencies = module match {
case m: JavaModule => m.moduleDeps.map(dep => moduleIdMap(dep)).toList.asJava
}
val buildTarget = new BuildTarget(moduleIdMap(module),
Collections.singletonList(buildTargetTag),
supportedLanguages.asJava,
dependencies,
capabilities)
if (module.isInstanceOf[ScalaModule]) {
buildTarget.setDataKind("scala")
}
buildTarget.setData(dataBuildTarget)
buildTarget.setDisplayName(module.millModuleSegments.last.value.toList.head.pathSegments.head)
buildTarget.setBaseDirectory(module.millSourcePath.toNIO.toAbsolutePath.toUri.toString)
moduleToTarget ++= Map(module -> buildTarget)
}
moduleToTarget
}
def getModuleCapabilities(module: JavaModule, evaluator: Evaluator): BuildTargetCapabilities = {
val canTest = module match {
case module: TestModule => true
case default => false
}
new BuildTargetCapabilities(true, canTest, true)
}
//TODO: I think here I need to look at scalaLibraryIvyDeps, ivyDeps that contain
// "scala-compiler" and "scala-reflect" and at scalacPluginIvyDeps
def computeScalaBuildTarget(module: JavaModule, evaluator: Evaluator): Any = {
module match {
case m: ScalaModule =>
val scalaVersion = evaluateInformativeTask(evaluator, m.scalaVersion, "")
new ScalaBuildTarget(
evaluateInformativeTask(evaluator, m.scalaOrganization, ""),
scalaVersion,
Util.scalaBinaryVersion(scalaVersion),
getScalaTargetPlatform(m),
computeScalaLangDependencies(m, evaluator).
map(pathRef => pathRef.path.toNIO.toAbsolutePath.toUri.toString).
toList.asJava)
case m: JavaModule => "This is just a test or java target"
}
}
def getTaskResult[T](evaluator: Evaluator, task: Task[T]): Result[Any] = {
evaluator.evaluate(Strict.Agg(task)).results(task)
}
def evaluateInformativeTask[T](evaluator: Evaluator, task: Task[T], defaultValue: T): T = {
val evaluated = evaluator.evaluate(Strict.Agg(task)).results(task)
evaluated match {
case Success(value) => evaluated.asSuccess.get.value.asInstanceOf[T]
case default => defaultValue
}
}
def computeScalaLangDependencies(module: ScalaModule, evaluator: Evaluator): Loose.Agg[PathRef] = {
evaluateInformativeTask(evaluator, module.scalacPluginClasspath, Loose.Agg.empty[PathRef]) ++
evaluateInformativeTask(evaluator, module.resolveDeps(module.ivyDeps), Loose.Agg.empty[PathRef]).
filter(pathRef => pathRef.path.toNIO.toAbsolutePath.toUri.toString.contains("scala-compiler") ||
pathRef.path.toNIO.toAbsolutePath.toUri.toString.contains("scala-reflect") ||
pathRef.path.toNIO.toAbsolutePath.toUri.toString.contains("scala-library"))
}
def getScalaTargetPlatform(module: ScalaModule): ScalaPlatform = {
module match {
case m: ScalaNativeModule => ScalaPlatform.NATIVE
case m: ScalaJSModule => ScalaPlatform.JS
case m: ScalaModule => ScalaPlatform.JVM
}
}
def getModuleTargetIdMap(modules: Seq[JavaModule]): Predef.Map[JavaModule, BuildTargetIdentifier] = {
var moduleToTarget = Map[JavaModule, BuildTargetIdentifier]()
for ( module <- modules ) {
moduleToTarget ++= Map(module -> new BuildTargetIdentifier(
module.millSourcePath.toNIO.toAbsolutePath.toUri.toString
))
}
moduleToTarget
}
}
|
