/
ScalaSettings.scala
544 lines (486 loc) · 37 KB
/
ScalaSettings.scala
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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
/*
* Scala (https://www.scala-lang.org)
*
* Copyright EPFL and Lightbend, Inc.
*
* Licensed under Apache License 2.0
* (http://www.apache.org/licenses/LICENSE-2.0).
*
* See the NOTICE file distributed with this work for
* additional information regarding copyright ownership.
*/
// $Id$
package scala
package tools
package nsc
package settings
import java.util.zip.Deflater
import scala.language.existentials
import scala.annotation.elidable
import scala.tools.util.PathResolver.Defaults
import scala.collection.mutable
import scala.reflect.internal.util.StringContextStripMarginOps
import scala.tools.nsc.util.DefaultJarFactory
trait ScalaSettings extends StandardScalaSettings with Warnings {
self: MutableSettings =>
/** Set of settings */
protected[scala] lazy val allSettings = mutable.HashSet[Setting]()
/** The user class path, specified by `-classpath` or `-cp`,
* defaults to the value of CLASSPATH env var if it is set, as in Java,
* or else to `"."` for the current user directory.
*/
protected def defaultClasspath = Option(System.getenv("CLASSPATH")).getOrElse(".")
/** If any of these settings is enabled, the compiler should print a message and exit. */
def infoSettings = List[Setting](version, help, Vhelp, Whelp, Xhelp, Yhelp, showPlugins, showPhases, genPhaseGraph, printArgs)
/** Is an info setting set? Any -option:help? */
def isInfo = infoSettings.exists(_.isSetByUser) || allSettings.exists(_.isHelping)
/** Disable a setting */
def disable(s: Setting) = allSettings -= s
val jvmargs = PrefixSetting("-J<flag>", "-J", "Pass <flag> directly to the runtime system.")
val defines = PrefixSetting("-Dproperty=value", "-D", "Pass -Dproperty=value directly to the runtime system.")
/*val toolcp =*/ PathSetting("-toolcp", "Add to the runner classpath.", "") withAbbreviation "--tool-class-path"
val nobootcp = BooleanSetting("-nobootcp", "Do not use the boot classpath for the scala jars.") withAbbreviation "--no-boot-class-path"
/**
* Standard settings
*/
// argfiles is only for the help message
/*val argfiles = */ BooleanSetting ("@<file>", "A text file containing compiler arguments (options and source files)")
val classpath = PathSetting ("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp" withAbbreviation "--class-path"
val d = OutputSetting (outputDirs, ".")
val nospecialization = BooleanSetting ("-no-specialization", "Ignore @specialize annotations.") withAbbreviation "--no-specialization"
// Would be nice to build this dynamically from scala.languageFeature.
// The two requirements: delay error checking until you have symbols, and let compiler command build option-specific help.
object languageFeatures extends MultiChoiceEnumeration {
val dynamics = Choice("dynamics", "Allow direct or indirect subclasses of scala.Dynamic")
val existentials = Choice("existentials", "Existential types (besides wildcard types) can be written and inferred")
val higherKinds = Choice("higherKinds", "Allow higher-kinded types")
val implicitConversions = Choice("implicitConversions", "Allow definition of implicit functions called views")
val postfixOps = Choice("postfixOps", "Allow postfix operator notation, such as `1 to 10 toList` (not recommended)")
val reflectiveCalls = Choice("reflectiveCalls", "Allow reflective access to members of structural types")
val macros = Choice("experimental.macros", "Allow macro definition (besides implementation and application)")
}
val language = {
val description = "Enable or disable language features"
MultiChoiceSetting(
name = "-language",
helpArg = "feature",
descr = description,
domain = languageFeatures
) withAbbreviation "--language"
}
val release = StringSetting("-release", "release", "Compile for a specific version of the Java platform. Supported targets: 6, 7, 8, 9", "").withPostSetHook { (value: StringSetting) =>
if (value.value != "" && !scala.util.Properties.isJavaAtLeast("9")) {
errorFn.apply("-release is only supported on Java 9 and higher")
} else {
// TODO validate numeric value
// TODO validate release <= java.specification.version
}
} withAbbreviation "--release"
def releaseValue: Option[String] = Option(release.value).filter(_ != "")
/*
* The previous "-source" option is intended to be used mainly
* though this helper.
*/
private[this] val version212 = ScalaVersion("2.12.0")
def isScala212: Boolean = source.value >= version212
private[this] val version213 = ScalaVersion("2.13.0")
def isScala213: Boolean = source.value >= version213
private[this] val version214 = ScalaVersion("2.14.0")
def isScala214: Boolean = source.value >= version214
private[this] val version300 = ScalaVersion("3.0.0")
def isScala300: Boolean = source.value >= version300
/**
* -X "Advanced" settings
*/
val Xhelp = BooleanSetting ("-X", "Print a synopsis of advanced options.")
val checkInit = BooleanSetting ("-Xcheckinit", "Wrap field accessors to throw an exception on uninitialized access.")
val developer = BooleanSetting ("-Xdev", "Issue warnings about anything which seems amiss in compiler internals. Intended for compiler developers")
val noassertions = BooleanSetting ("-Xdisable-assertions", "Generate no assertions or assumptions.") andThen (flag =>
if (flag) elidebelow.value = elidable.ASSERTION + 1)
val elidebelow = IntSetting ("-Xelide-below", "Calls to @elidable methods are omitted if method priority is lower than argument",
elidable.MINIMUM, None, elidable.byName get _)
val noForwarders = BooleanSetting ("-Xno-forwarders", "Do not generate static forwarders in mirror classes.")
val genPhaseGraph = StringSetting ("-Xgenerate-phase-graph", "file", "Generate the phase graphs (outputs .dot files) to fileX.dot.", "")
val maxerrs = IntSetting ("-Xmaxerrs", "Maximum errors to print", 100, None, _ => None)
val maxwarns = IntSetting ("-Xmaxwarns", "Maximum warnings to print", 100, None, _ => None)
val Xmigration = ScalaVersionSetting ("-Xmigration", "version", "Warn about constructs whose behavior may have changed since version.", initial = NoScalaVersion, default = Some(AnyScalaVersion))
val Xnojline = BooleanSetting ("-Xnojline", "Do not use JLine for editing.")
val Xverify = BooleanSetting ("-Xverify", "Verify generic signatures in generated bytecode.")
val plugin = MultiStringSetting ("-Xplugin", "paths", "Load a plugin from each classpath.")
val disable = MultiStringSetting ("-Xplugin-disable", "plugin", "Disable plugins by name.")
val showPlugins = BooleanSetting ("-Xplugin-list", "Print a synopsis of loaded plugins.")
val require = MultiStringSetting ("-Xplugin-require", "plugin", "Abort if a named plugin is not loaded.")
val pluginsDir = StringSetting ("-Xpluginsdir", "path", "Path to search for plugin archives.", Defaults.scalaPluginPath)
val prompt = BooleanSetting ("-Xprompt", "Display a prompt after each error (debugging option).")
val resident = BooleanSetting ("-Xresident", "Compiler stays resident: read source filenames from standard input.")
val script = StringSetting ("-Xscript", "object", "Treat the source file as a script and wrap it in a main method.", "")
val mainClass = StringSetting ("-Xmain-class", "path", "Class for manifest's Main-Class entry (only useful with -d <jar>)", "")
val sourceReader = StringSetting ("-Xsource-reader", "classname", "Specify a custom method for reading source files.", "")
val reporter = StringSetting ("-Xreporter", "classname", "Specify a custom subclass of FilteringReporter for compiler messages.", "scala.tools.nsc.reporters.ConsoleReporter")
val source = ScalaVersionSetting ("-Xsource", "version", "Treat compiler input as Scala source for the specified version, see scala/bug#8126.", initial = ScalaVersion("2.13"))
val XnoPatmatAnalysis = BooleanSetting ("-Xno-patmat-analysis", "Don't perform exhaustivity/unreachability analysis. Also, ignore @switch annotation.")
val XmixinForceForwarders = ChoiceSetting(
name = "-Xmixin-force-forwarders",
helpArg = "mode",
descr = "Generate forwarder methods in classes inhering concrete methods from traits.",
choices = List("true", "junit", "false"),
default = "true",
choicesHelp = List(
"Always generate mixin forwarders.",
"Generate mixin forwarders for JUnit-annotated methods (JUnit 4 does not support default methods).",
"Only generate mixin forwarders required for program correctness."))
object mixinForwarderChoices {
def isTruthy = XmixinForceForwarders.value == "true"
def isAtLeastJunit = isTruthy || XmixinForceForwarders.value == "junit"
}
// XML parsing options
object XxmlSettings extends MultiChoiceEnumeration {
val coalescing = Choice("coalescing", "Convert PCData to Text and coalesce sibling nodes")
def isCoalescing = Xxml contains coalescing
}
val Xxml = MultiChoiceSetting(
name = "-Xxml",
helpArg = "property",
descr = "Configure XML parsing.",
domain = XxmlSettings
)
/** Compatibility stubs for options whose value name did
* not previously match the option name.
*/
def debuginfo = g
def dependenciesFile = dependencyfile
def nowarnings = nowarn
def outdir = d
def printLate = print
/**
* -Y "Private" settings
*/
val Yhelp = BooleanSetting ("-Y", "Print a synopsis of private options.")
val breakCycles = BooleanSetting ("-Ybreak-cycles", "Attempt to break cycles encountered during typing")
val check = PhasesSetting ("-Ycheck", "Check the tree at the end of")
val Ycompacttrees = BooleanSetting ("-Ycompact-trees", "Use compact tree printer when displaying trees.")
val noCompletion = BooleanSetting ("-Yno-completion", "Disable tab-completion in the REPL.")
val termConflict = ChoiceSetting ("-Yresolve-term-conflict", "strategy", "Resolve term conflicts.", List("package", "object", "error"), "error")
val Ynogenericsig = BooleanSetting ("-Yno-generic-signatures", "Suppress generation of generic signatures for Java.")
val noimports = BooleanSetting ("-Yno-imports", "Compile without importing scala.*, java.lang.*, or Predef.")
.withPostSetHook(bs => if (bs) imports.value = Nil)
val nopredef = BooleanSetting ("-Yno-predef", "Compile without importing Predef.")
.withPostSetHook(bs => if (bs && !noimports) imports.value = "java.lang" :: "scala" :: Nil)
val imports = MultiStringSetting(name="-Yimports", arg="import", descr="Custom root imports, default is `java.lang,scala,scala.Predef`.", helpText=Some(
sm"""|Specify a list of packages and objects to import from as "root" imports.
|Root imports form the root context in which all Scala source is evaluated.
|The names supplied to `-Yimports` must be fully-qualified.
|
|For example, the default scala.Predef results in an `import scala.Predef._`.
|Ordinary access and scoping rules apply. Root imports increase the scoping
|depth, so that later root imports shadow earlier ones. In addition,
|names bound by root imports have lowest binding precedence, so that they
|cannot induce ambiguities in user code, where definitions and imports
|always have a higher precedence. Root imports are imports of last resort.
|
|By convention, an explicit import from a root import object such as
|Predef disables that root import for the current source file. The import
|is disabled when the import expression is compiled, so, also by convention,
|the import should be placed early in source code order. The textual name
|in the import does not need to match the value of `-Yimports`; the import
|works in the usual way, subject to renames and name binding precedence.
|
"""
))
val Yrecursion = IntSetting ("-Yrecursion", "Set recursion depth used when locking symbols.", 0, Some((0, Int.MaxValue)), (_: String) => None)
val YprintTrees = ChoiceSetting(
name = "-Yprint-trees",
helpArg = "style",
descr = "How to print trees when -Vprint is enabled.",
choices = List("text", "compact", "format", "text+format"),
default = "text"
).withPostSetHook(pt => pt.value match {
case "text" =>
case "compact" => XshowtreesCompact.value = true
case "format" => Xshowtrees.value = true
case "text+format" => XshowtreesStringified.value = true
})
val Xshowtrees = BooleanSetting ("-Yshow-trees", "(Requires -Vprint:) Print detailed ASTs in formatted form.").internalOnly()
val XshowtreesCompact
= BooleanSetting ("-Yshow-trees-compact", "(Requires -Vprint:) Print detailed ASTs in compact form.").internalOnly()
val XshowtreesStringified
= BooleanSetting ("-Yshow-trees-stringified", "(Requires -Vprint:) Print stringifications along with detailed ASTs.").internalOnly()
val skip = PhasesSetting ("-Yskip", "Skip")
val Ygenasmp = StringSetting ("-Ygen-asmp", "dir", "Generate a parallel output directory of .asmp files (ie ASM Textifier output).", "")
val Ydumpclasses = StringSetting ("-Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", "")
val stopAfter = PhasesSetting ("-Ystop-after", "Stop after") withAbbreviation ("-stop") // backward compat
val stopBefore = PhasesSetting ("-Ystop-before", "Stop before")
val Yrangepos = BooleanSetting ("-Yrangepos", "Use range positions for syntax trees.")
val Yvalidatepos = PhasesSetting ("-Yvalidate-pos", s"Validate positions after the given phases (implies ${Yrangepos.name})") withPostSetHook (_ => Yrangepos.value = true)
val Yreifycopypaste = BooleanSetting ("-Yreify-copypaste", "Dump the reified trees in copypasteable representation.")
val Ymacroexpand = ChoiceSetting ("-Ymacro-expand", "policy", "Control expansion of macros, useful for scaladoc and presentation compiler.", List(MacroExpand.Normal, MacroExpand.None, MacroExpand.Discard), MacroExpand.Normal)
val YmacroFresh = BooleanSetting ("-Ymacro-global-fresh-names", "Should fresh names in macros be unique across all compilation units")
val YmacroAnnotations = BooleanSetting ("-Ymacro-annotations", "Enable support for macro annotations, formerly in macro paradise.")
val Yreplclassbased = BooleanSetting ("-Yrepl-class-based", "Use classes to wrap REPL snippets instead of objects")
val Yreploutdir = StringSetting ("-Yrepl-outdir", "path", "Write repl-generated classfiles to given output directory (use \"\" to generate a temporary dir)" , "")
@deprecated("Unused setting will be removed", since="2.13")
val Yreplsync = new BooleanSetting ("-Yrepl-sync", "Legacy setting for sbt compatibility, unused.").internalOnly()
val Yscriptrunner = StringSetting ("-Yscriptrunner", "classname", "Specify a scala.tools.nsc.ScriptRunner (default, resident, shutdown, or a class name).", "default")
val YdisableFlatCpCaching = BooleanSetting ("-Yno-flat-classpath-cache", "Do not cache flat classpath representation of classpath elements from jars across compiler instances.") withAbbreviation "-YdisableFlatCpCaching"
val YcachePluginClassLoader = CachePolicy.setting("plugin", "compiler plugins")
val YcacheMacroClassLoader = CachePolicy.setting("macro", "macros")
val YmacroClasspath = PathSetting ("-Ymacro-classpath", "The classpath used to reflectively load macro implementations, default is the compilation classpath.", "")
val Youtline = BooleanSetting ("-Youtline", "Don't compile method bodies. Use together with `-Ystop-afer:pickler to generate the pickled signatures for all source files.").internalOnly()
val exposeEmptyPackage = BooleanSetting ("-Yexpose-empty-package", "Internal only: expose the empty package.").internalOnly()
val Ydelambdafy = ChoiceSetting ("-Ydelambdafy", "strategy", "Strategy used for translating lambdas into JVM code.", List("inline", "method"), "method")
// Allows a specialised jar to be written. For instance one that provides stable hashing of content, or customisation of the file storage
val YjarFactory = StringSetting ("-YjarFactory", "classname", "factory for jar files", classOf[DefaultJarFactory].getName)
val YaddBackendThreads = IntSetting ("-Ybackend-parallelism", "maximum worker threads for backend", 1, Some((1,16)), (x: String) => None )
val YmaxQueue = IntSetting ("-Ybackend-worker-queue", "backend threads worker queue size", 0, Some((0,1000)), (x: String) => None )
val YjarCompressionLevel = IntSetting("-Yjar-compression-level", "compression level to use when writing jar files",
Deflater.DEFAULT_COMPRESSION, Some((Deflater.DEFAULT_COMPRESSION,Deflater.BEST_COMPRESSION)), (x: String) => None)
val YpickleJava = BooleanSetting("-Ypickle-java", "Pickler phase should compute pickles for .java defined symbols for use by build tools").internalOnly()
val YpickleWrite = StringSetting("-Ypickle-write", "directory|jar", "destination for generated .sig files containing type signatures.", "", None).internalOnly()
sealed abstract class CachePolicy(val name: String, val help: String)
object CachePolicy {
def setting(style: String, styleLong: String) = ChoiceSetting(s"-Ycache-$style-class-loader", "policy", s"Policy for caching class loaders for $styleLong that are dynamically loaded.", values.map(_.name), None.name, values.map(_.help))
object None extends CachePolicy("none", "Don't cache class loader")
object LastModified extends CachePolicy("last-modified", "Cache class loader, using file last-modified time to invalidate")
object Always extends CachePolicy("always", "Cache class loader with no invalidation")
// TODO Jorge to add new policy. Think about whether there is a benefit to the user on offering this as a separate policy or unifying with the previous one.
// object ZipMetadata extends CachePolicy("zip-metadata", "Cache classloade, using file last-modified time, then ZIP file metadata to invalidate")
def values: List[CachePolicy] = List(None, LastModified, Always)
}
object optChoices extends MultiChoiceEnumeration {
val unreachableCode = Choice("unreachable-code", "Eliminate unreachable code, exception handlers guarding no instructions, redundant metadata (debug information, line numbers).")
val simplifyJumps = Choice("simplify-jumps", "Simplify branching instructions, eliminate unnecessary ones.")
val compactLocals = Choice("compact-locals", "Eliminate empty slots in the sequence of local variables.")
val copyPropagation = Choice("copy-propagation", "Eliminate redundant local variables and unused values (including closures). Enables unreachable-code.")
val redundantCasts = Choice("redundant-casts", "Eliminate redundant casts using a type propagation analysis.")
val boxUnbox = Choice("box-unbox", "Eliminate box-unbox pairs within the same method (also tuples, xRefs, value class instances). Enables unreachable-code.")
val nullnessTracking = Choice("nullness-tracking", "Track nullness / non-nullness of local variables and apply optimizations.")
val closureInvocations = Choice("closure-invocations" , "Rewrite closure invocations to the implementation method.")
val allowSkipCoreModuleInit = Choice("allow-skip-core-module-init", "Allow eliminating unused module loads for core modules of the standard library (e.g., Predef, ClassTag).")
val assumeModulesNonNull = Choice("assume-modules-non-null", "Assume loading a module never results in null (happens if the module is accessed in its super constructor).")
val allowSkipClassLoading = Choice("allow-skip-class-loading", "Allow optimizations that can skip or delay class loading.")
val inline = Choice("inline", "Inline method invocations according to -Yopt-inline-heuristics and -opt-inline-from.")
// note: unlike the other optimizer levels, "l:none" appears up in the `opt.value` set because it's not an expanding option (expandsTo is empty)
val lNone = Choice("l:none",
"Disable optimizations. Takes precedence: `-opt:l:none,+box-unbox` / `-opt:l:none -opt:box-unbox` don't enable box-unbox.")
private val defaultChoices = List(unreachableCode)
val lDefault = Choice(
"l:default",
"Enable default optimizations: " + defaultChoices.mkString("", ",", "."),
expandsTo = defaultChoices)
private val methodChoices = List(unreachableCode, simplifyJumps, compactLocals, copyPropagation, redundantCasts, boxUnbox, nullnessTracking, closureInvocations, allowSkipCoreModuleInit, assumeModulesNonNull, allowSkipClassLoading)
val lMethod = Choice(
"l:method",
"Enable intra-method optimizations: " + methodChoices.mkString("", ",", "."),
expandsTo = methodChoices)
private val inlineChoices = List(lMethod, inline)
val lInline = Choice("l:inline",
"Enable cross-method optimizations (note: inlining requires -opt-inline-from): " + inlineChoices.mkString("", ",", "."),
expandsTo = inlineChoices)
}
// We don't use the `default` parameter of `MultiChoiceSetting`: it specifies the default values
// when `-opt` is passed without explicit choices. When `-opt` is not explicitly specified, the
// set `opt.value` is empty.
val opt = MultiChoiceSetting(
name = "-opt",
helpArg = "optimization",
descr = "Enable optimizations",
domain = optChoices)
private def optEnabled(choice: optChoices.Choice) = {
!opt.contains(optChoices.lNone) && {
opt.contains(choice) ||
!opt.isSetByUser && optChoices.lDefault.expandsTo.contains(choice)
}
}
def optNone = opt.contains(optChoices.lNone)
def optUnreachableCode = optEnabled(optChoices.unreachableCode)
def optSimplifyJumps = optEnabled(optChoices.simplifyJumps)
def optCompactLocals = optEnabled(optChoices.compactLocals)
def optCopyPropagation = optEnabled(optChoices.copyPropagation)
def optRedundantCasts = optEnabled(optChoices.redundantCasts)
def optBoxUnbox = optEnabled(optChoices.boxUnbox)
def optNullnessTracking = optEnabled(optChoices.nullnessTracking)
def optClosureInvocations = optEnabled(optChoices.closureInvocations)
def optAllowSkipCoreModuleInit = optEnabled(optChoices.allowSkipCoreModuleInit)
def optAssumeModulesNonNull = optEnabled(optChoices.assumeModulesNonNull)
def optAllowSkipClassLoading = optEnabled(optChoices.allowSkipClassLoading)
def optInlinerEnabled = optEnabled(optChoices.inline)
def optBuildCallGraph = optInlinerEnabled || optClosureInvocations
def optAddToBytecodeRepository = optBuildCallGraph || optInlinerEnabled || optClosureInvocations
def optUseAnalyzerCache = opt.isSetByUser && !optNone && (optBuildCallGraph || opt.value.size > 1)
val optInlineFrom = MultiStringSetting(
"-opt-inline-from",
"patterns",
"Patterns for classfile names from which to allow inlining, `help` for details.",
helpText = Some(
"""Patterns for classfile names from which the inliner is allowed to pull in code.
| * Matches classes in the empty package
| ** All classes
| a.C Class a.C
| a.* Classes in package a
| a.** Classes in a and in sub-packages of a
| **.Util Classes named Util in any package (including the empty package)
| a.**.*Util* Classes in a and sub-packages with Util in their name (including a.Util)
| a.C$D The nested class D defined in class a.C
| scala.Predef$ The scala.Predef object
| <sources> Classes defined in source files compiled in the current compilation, either
| passed explicitly to the compiler or picked up from the `-sourcepath`
|
|The setting accepts a list of patterns: `-opt-inline-from:p1,p2`. The setting can be passed
|multiple times, the list of patterns gets extended. A leading `!` marks a pattern excluding.
|The last matching pattern defines whether a classfile is included or excluded (default: excluded).
|For example, `a.**,!a.b.**` includes classes in a and sub-packages, but not in a.b and sub-packages.
|
|Note: on the command-line you might need to quote patterns containing `*` to prevent the shell
|from expanding it to a list of files in the current directory.""".stripMargin))
val YoptInlineHeuristics = ChoiceSetting(
name = "-Yopt-inline-heuristics",
helpArg = "strategy",
descr = "Set the heuristics for inlining decisions.",
choices = List("at-inline-annotated", "everything", "default"),
default = "default")
object optWarningsChoices extends MultiChoiceEnumeration {
val none = Choice("none" , "No optimizer warnings.")
val atInlineFailedSummary = Choice("at-inline-failed-summary" , "One-line summary if there were @inline method calls that could not be inlined.")
val atInlineFailed = Choice("at-inline-failed" , "A detailed warning for each @inline method call that could not be inlined.")
val anyInlineFailed = Choice("any-inline-failed" , "A detailed warning for every callsite that was chosen for inlining by the heuristics, but could not be inlined.")
val noInlineMixed = Choice("no-inline-mixed" , "In mixed compilation, warn at callsites methods defined in java sources (the inlining decision cannot be made without bytecode).")
val noInlineMissingBytecode = Choice("no-inline-missing-bytecode" , "Warn if an inlining decision cannot be made because a the bytecode of a class or member cannot be found on the compilation classpath.")
val noInlineMissingScalaInlineInfoAttr = Choice("no-inline-missing-attribute", "Warn if an inlining decision cannot be made because a Scala classfile does not have a ScalaInlineInfo attribute.")
}
val optWarnings = MultiChoiceSetting(
name = "-opt-warnings",
helpArg = "warning",
descr = "Enable optimizer warnings",
domain = optWarningsChoices,
default = Some(List(optWarningsChoices.atInlineFailed.name)))
def optWarningsSummaryOnly = optWarnings.value subsetOf Set(optWarningsChoices.none, optWarningsChoices.atInlineFailedSummary)
def optWarningEmitAtInlineFailed =
!optWarnings.isSetByUser ||
optWarnings.contains(optWarningsChoices.atInlineFailedSummary) ||
optWarnings.contains(optWarningsChoices.atInlineFailed) ||
optWarnings.contains(optWarningsChoices.anyInlineFailed)
def optWarningNoInlineMixed = optWarnings.contains(optWarningsChoices.noInlineMixed)
def optWarningNoInlineMissingBytecode = optWarnings.contains(optWarningsChoices.noInlineMissingBytecode)
def optWarningNoInlineMissingScalaInlineInfoAttr = optWarnings.contains(optWarningsChoices.noInlineMissingScalaInlineInfoAttr)
val YprofileEnabled = BooleanSetting("-Yprofile-enabled", "Enable profiling.")
val YprofileDestination = StringSetting("-Yprofile-destination", "file", "Profiling output - specify a file or `-` for console.", "").
withPostSetHook( _ => YprofileEnabled.value = true )
val YprofileTrace = StringSetting("-Yprofile-trace", "file", "Capture trace of compilation in Chrome Trace format", "profile.trace").
withPostSetHook( _ => YprofileEnabled.value = true )
val YprofileExternalTool = PhasesSetting("-Yprofile-external-tool", "Enable profiling for a phase using an external tool hook. Generally only useful for a single phase", "typer").
withPostSetHook( _ => YprofileEnabled.value = true )
val YprofileRunGcBetweenPhases = PhasesSetting("-Yprofile-run-gc", "Run a GC between phases - this allows heap size to be accurate at the expense of more time. Specify a list of phases, or all", "_").
withPostSetHook( _ => YprofileEnabled.value = true )
val YpatmatExhaustdepth = IntSetting("-Ypatmat-exhaust-depth", "off", 20, Some((10, Int.MaxValue)),
str => Some(if(str.equalsIgnoreCase("off")) Int.MaxValue else str.toInt))
/**
* -V "Verbose" settings
*/
val Vhelp = BooleanSetting("-V", "Print a synopsis of verbose options.")
val browse = PhasesSetting("-Vbrowse", "Browse the abstract syntax tree after") withAbbreviation "-Ybrowse"
val debug = BooleanSetting("-Vdebug", "Increase the quantity of debugging output.") withAbbreviation "-Ydebug"
val Ydocdebug = BooleanSetting("-Vdoc", "Trace scaladoc activity.") withAbbreviation "-Ydoc-debug"
val Yidedebug = BooleanSetting("-Vide", "Generate, validate and output trees using the interactive compiler.") withAbbreviation "-Yide-debug"
val Yissuedebug = BooleanSetting("-Vissue", "Print stack traces when a context issues an error.") withAbbreviation "-Yissue-debug"
val log = PhasesSetting("-Vlog", "Log operations during") withAbbreviation "-Ylog"
val Ylogcp = BooleanSetting("-Vclasspath", "Output information about what classpath is being applied.") withAbbreviation "-Ylog-classpath"
val YmacrodebugLite = BooleanSetting("-Vmacro-lite", "Trace macro activities with less output.") withAbbreviation "-Ymacro-debug-lite"
val YmacrodebugVerbose = BooleanSetting("-Vmacro", "Trace macro activities: compilation, generation of synthetics, classloading, expansion, exceptions.") withAbbreviation "-Ymacro-debug-verbose"
val YoptTrace = StringSetting("-Vopt", "package/Class.method", "Trace the optimizer progress for methods; `_` to print all, prefix match to select.", "")
.withAbbreviation("-Yopt-trace")
val YoptLogInline = StringSetting("-Vinline", "package/Class.method", "Print a summary of inliner activity; `_` to print all, prefix match to select.", "")
.withAbbreviation("-Yopt-log-inline")
val Ypatmatdebug = BooleanSetting("-Vpatmat", "Trace pattern matching translation.") withAbbreviation "-Ypatmat-debug"
val showPhases = BooleanSetting("-Vphases", "Print a synopsis of compiler phases.")
.withAbbreviation("-Xshow-phases")
val Yposdebug = BooleanSetting("-Vpos", "Trace position validation.") withAbbreviation "-Ypos-debug"
val Xprint = PhasesSetting("-Vprint", "Print out program after")
.withAbbreviation("-Xprint")
val Xprintpos = BooleanSetting("-Vprint-pos", "Print tree positions, as offsets.")
.withAbbreviation("-Xprint-pos")
val printtypes = BooleanSetting("-Vprint-types", "Print tree types (debugging option).")
.withAbbreviation("-Xprint-types")
val printArgs = StringSetting("-Vprint-args", "file", "Print all compiler arguments to the specified location. Use - to echo to the reporter.", "-")
.withAbbreviation("-Xprint-args")
val Yquasiquotedebug = BooleanSetting("-Vquasiquote", "Trace quasiquotations.") withAbbreviation "-Yquasiquote-debug"
val Yreifydebug = BooleanSetting("-Vreify", "Trace reification.") withAbbreviation "-Yreify-debug"
val Yshow = PhasesSetting ("-Vshow", "(Requires -Xshow-class or -Xshow-object) Show after")
.withAbbreviation("-Yshow")
val Xshowcls = StringSetting("-Vshow-class", "class", "Show internal representation of class.", "")
.withAbbreviation("-Xshow-class")
val Xshowobj = StringSetting("-Vshow-object", "object", "Show internal representation of object.", "")
.withAbbreviation("-Xshow-object")
val Ymemberpos = StringSetting("-Vshow-member-pos", "output style", s"Show start and end positions of members (implies ${Yrangepos.name})", "")
.withPostSetHook(_ => Yrangepos.value = true)
.withAbbreviation("-Yshow-member-pos")
val Yshowsymkinds = BooleanSetting ("-Vshow-symkinds", "Print abbreviated symbol kinds next to symbol names.")
.withAbbreviation("-Yshow-symkinds")
val Yshowsymowners = BooleanSetting ("-Vshow-symowners", "Print owner identifiers next to symbol names.")
.withAbbreviation("-Yshow-symowners")
val Ystatistics = PhasesSetting("-Vstatistics", "Print compiler statistics for specific phases", "parser,typer,patmat,erasure,cleanup,jvm")
.withPostSetHook(s => YstatisticsEnabled.value = s.value.nonEmpty)
.withAbbreviation("-Ystatistics")
val YstatisticsEnabled = BooleanSetting("-Ystatistics-enabled", "Internal setting, indicating that statistics are enabled for some phase.").internalOnly()
val YhotStatisticsEnabled = BooleanSetting("-Vhot-statistics", s"Enable `${Ystatistics.name}` to also print hot statistics.")
.withAbbreviation("-Yhot-statistics")
val Yshowsyms = BooleanSetting("-Vsymbols", "Print the AST symbol hierarchy after each phase.") withAbbreviation "-Yshow-syms"
val Ytyperdebug = BooleanSetting("-Vtyper", "Trace type assignments.") withAbbreviation "-Ytyper-debug"
val XlogImplicits = BooleanSetting("-Vimplicits", "Show more detail on why some implicits are not applicable.")
.withAbbreviation("-Xlog-implicits")
val logImplicitConv = BooleanSetting("-Vimplicit-conversions", "Print a message whenever an implicit conversion is inserted.")
.withAbbreviation("-Xlog-implicit-conversions")
val logReflectiveCalls = BooleanSetting("-Vreflective-calls", "Print a message when a reflective method call is generated")
.withAbbreviation("-Xlog-reflective-calls")
val logFreeTerms = BooleanSetting("-Vfree-terms", "Print a message when reification creates a free term.")
.withAbbreviation("-Xlog-free-terms")
val logFreeTypes = BooleanSetting("-Vfree-types", "Print a message when reification resorts to generating a free type.")
.withAbbreviation("-Xlog-free-types")
/** Groups of Settings.
*/
val future = BooleanSetting("-Xfuture", "Replaced by -Xsource.").withDeprecationMessage("Not used since 2.13.")
val optimise = BooleanSetting("-optimize", "Enables optimizations.")
.withAbbreviation("-optimise")
.withDeprecationMessage("Since 2.12, enables -opt:l:inline -opt-inline-from:**. See -opt:help.")
.withPostSetHook(_ => {
opt.enable(optChoices.lInline)
optInlineFrom.value = List("**")
})
val Xexperimental = BooleanSetting("-Xexperimental", "Former graveyard for language-forking extensions.")
.withDeprecationMessage("Not used since 2.13.")
// Feature extensions
val XmacroSettings = MultiStringSetting("-Xmacro-settings", "option", "Custom settings for macros.")
/**
* IDE-specific settings
*/
val YpresentationVerbose = BooleanSetting("-Ypresentation-verbose", "Print information about presentation compiler tasks.")
val YpresentationDebug = BooleanSetting("-Ypresentation-debug", "Enable debugging output for the presentation compiler.")
val YpresentationAnyThread = BooleanSetting("-Ypresentation-any-thread", "Allow use of the presentation compiler from any thread")
val YpresentationStrict = BooleanSetting("-Ypresentation-strict", "Do not report type errors in sources with syntax errors.")
val YpresentationLog = StringSetting("-Ypresentation-log", "file", "Log presentation compiler events into file", "")
val YpresentationReplay = StringSetting("-Ypresentation-replay", "file", "Replay presentation compiler events from file", "")
val YpresentationDelay = IntSetting("-Ypresentation-delay", "Wait number of ms after typing before starting typechecking", 0, Some((0, 999)), str => Some(str.toInt))
val YpresentationLocateSourceFile = BooleanSetting("-Ypresentation-locate-source-file", "Enables legacy code in the classfile parser to locate a .scala file in the output directories corresponding to the SourceFile attribute .class file.")
/**
* -P "Plugin" settings
*/
val pluginOptions = MultiStringSetting("-P", "plugin:opt", "Pass an option to a plugin") .
withHelpSyntax("-P:<plugin>:<opt>")
/** Test whether this is scaladoc we're looking at */
def isScaladoc = false
object MacroExpand {
val None = "none"
val Normal = "normal"
val Discard = "discard"
}
def conflictWarning: Option[String] = {
// See cd878232b5 for an example how to warn about conflicting settings
/*
def checkSomeConflict: Option[String] = ...
List(/* checkSomeConflict, ... */).flatten match {
case Nil => None
case warnings => Some("Conflicting compiler settings were detected. Some settings will be ignored.\n" + warnings.mkString("\n"))
}
*/
None
}
}