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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
package mill.scalalib.worker
import java.io.File
import java.util.Optional
import ammonite.ops.{Path, exists, ls, mkdir}
import ammonite.util.Colors
import mill.Agg
import mill.eval.PathRef
import mill.scalalib.{CompilationResult, Lib, TestRunner}
import xsbti.compile.{CompilerCache => _, FileAnalysisStore => _, ScalaInstance => _, _}
import mill.scalalib.Dep.isDotty
import mill.scalalib.Lib.{grepJar, scalaBinaryVersion}
import mill.util.{Ctx, PrintLogger}
import sbt.internal.inc._
import sbt.internal.util.{ConsoleOut, MainAppender}
import sbt.util.LogExchange
case class MockedLookup(am: File => Optional[CompileAnalysis]) extends PerClasspathEntryLookup {
override def analysis(classpathEntry: File): Optional[CompileAnalysis] =
am(classpathEntry)
override def definesClass(classpathEntry: File): DefinesClass =
Locate.definesClass(classpathEntry)
}
class ScalaWorkerImpl(ctx0: mill.util.Ctx,
compilerBridgeClasspath: Array[String]) extends mill.scalalib.ScalaWorkerApi{
@volatile var compilersCache = Option.empty[(Long, Compilers)]
/** Compile the bridge if it doesn't exist yet and return the output directory.
* TODO: Proper invalidation, see #389
*/
def compileZincBridgeIfNeeded(scalaVersion: String,
sourcesJar: Path,
compilerJars: Array[File]): Path = {
val workingDir = ctx0.dest / scalaVersion
val compiledDest = workingDir / 'compiled
if (!exists(workingDir)) {
ctx0.log.info("Compiling compiler interface...")
mkdir(workingDir)
mkdir(compiledDest)
val sourceFolder = mill.modules.Util.unpackZip(sourcesJar)(workingDir)
val classloader = mill.util.ClassLoader.create(compilerJars.map(_.toURI.toURL), null)(ctx0)
val compilerMain = classloader.loadClass(
if (isDotty(scalaVersion))
"dotty.tools.dotc.Main"
else
"scala.tools.nsc.Main"
)
val argsArray = Array[String](
"-d", compiledDest.toString,
"-classpath", (compilerJars ++ compilerBridgeClasspath).mkString(File.pathSeparator)
) ++ ls.rec(sourceFolder.path).filter(_.ext == "scala").map(_.toString)
compilerMain.getMethod("process", classOf[Array[String]])
.invoke(null, argsArray)
}
compiledDest
}
def discoverMainClasses(compilationResult: CompilationResult)(implicit ctx: mill.util.Ctx): Seq[String] = {
def toScala[A](o: Optional[A]): Option[A] = if (o.isPresent) Some(o.get) else None
toScala(FileAnalysisStore.binary(compilationResult.analysisFile.toIO).get())
.map(_.getAnalysis)
.flatMap{
case analysis: Analysis =>
Some(analysis.infos.allInfos.values.map(_.getMainClasses).flatten.toSeq.sorted)
case _ =>
None
}
.getOrElse(Seq.empty[String])
}
def compileScala(scalaVersion: String,
sources: Agg[Path],
compilerBridgeSources: Path,
compileClasspath: Agg[Path],
compilerClasspath: Agg[Path],
scalacOptions: Seq[String],
scalacPluginClasspath: Agg[Path],
javacOptions: Seq[String],
upstreamCompileOutput: Seq[CompilationResult])
(implicit ctx: mill.util.Ctx): mill.eval.Result[CompilationResult] = {
val compileClasspathFiles = compileClasspath.map(_.toIO).toArray
val compilerJars = compilerClasspath.toArray.map(_.toIO)
val compilerBridge = compileZincBridgeIfNeeded(scalaVersion, compilerBridgeSources, compilerJars)
val ic = new sbt.internal.inc.IncrementalCompilerImpl()
val compilerBridgeSig = compilerBridge.mtime.toMillis
val compilersSig = compilerBridgeSig + compilerClasspath.map(p => p.toString().hashCode + p.mtime.toMillis).sum
val compilers = compilersCache match {
case Some((k, v)) if k == compilersSig => v
case _ =>
val compilerName =
if (isDotty(scalaVersion))
s"dotty-compiler_${scalaBinaryVersion(scalaVersion)}"
else
"scala-compiler"
val scalaInstance = new ScalaInstance(
version = scalaVersion,
loader = mill.util.ClassLoader.create(compilerJars.map(_.toURI.toURL), null),
libraryJar = grepJar(compilerClasspath, "scala-library", scalaVersion).toIO,
compilerJar = grepJar(compilerClasspath, compilerName, scalaVersion).toIO,
allJars = compilerJars,
explicitActual = None
)
val compilers = ic.compilers(
scalaInstance,
ClasspathOptionsUtil.boot,
None,
ZincUtil.scalaCompiler(scalaInstance, compilerBridge.toIO)
)
compilersCache = Some((compilersSig, compilers))
compilers
}
mkdir(ctx.dest)
val logger = {
val consoleAppender = MainAppender.defaultScreen(ConsoleOut.printStreamOut(
ctx.log.outputStream
))
val l = LogExchange.logger("Hello")
LogExchange.unbindLoggerAppenders("Hello")
LogExchange.bindLoggerAppenders("Hello", (consoleAppender -> sbt.util.Level.Info) :: Nil)
l
}
def analysisMap(f: File): Optional[CompileAnalysis] = {
if (f.isFile) {
Optional.empty[CompileAnalysis]
} else {
upstreamCompileOutput.collectFirst {
case CompilationResult(zincPath, classFiles) if classFiles.path.toNIO == f.toPath =>
FileAnalysisStore.binary(zincPath.toIO).get().map[CompileAnalysis](_.getAnalysis)
}.getOrElse(Optional.empty[CompileAnalysis])
}
}
val lookup = MockedLookup(analysisMap)
val zincFile = ctx.dest / 'zinc
val classesDir = ctx.dest / 'classes
val zincIOFile = zincFile.toIO
val classesIODir = classesDir.toIO
val store = FileAnalysisStore.binary(zincIOFile)
try {
val newResult = ic.compile(
ic.inputs(
classpath = classesIODir +: compileClasspathFiles,
sources = sources.toArray.map(_.toIO),
classesDirectory = classesIODir,
scalacOptions = (scalacPluginClasspath.map(jar => s"-Xplugin:${jar}") ++ scalacOptions).toArray,
javacOptions = javacOptions.toArray,
maxErrors = 10,
sourcePositionMappers = Array(),
order = CompileOrder.Mixed,
compilers = compilers,
setup = ic.setup(
lookup,
skip = false,
zincIOFile,
new FreshCompilerCache,
IncOptions.of(),
new ManagedLoggedReporter(10, logger),
None,
Array()
),
pr = {
val prev = store.get()
PreviousResult.of(prev.map(_.getAnalysis), prev.map(_.getMiniSetup))
}
),
logger = logger
)
store.set(
AnalysisContents.create(
newResult.analysis(),
newResult.setup()
)
)
mill.eval.Result.Success(CompilationResult(zincFile, PathRef(classesDir)))
}catch{case e: CompileFailed => mill.eval.Result.Failure(e.toString)}
}
}
|
