Update scala settings

Author: rochala

Test.scala

@@ -0,0 +1 @@
+@main def hello = println("Hello, world!")

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -823,7 +823,7 @@ trait BCodeHelpers extends BCodeIdiomatic {
     // without it.  This is particularly bad because the availability of
     // generic information could disappear as a consequence of a seemingly
     // unrelated change.
-      ctx.base.settings.YnoGenericSig.value
+      ctx.base.settings.XnoGenericSig.value
     || sym.is(Artifact)
     || sym.isAllOf(LiftedMethod)
     || sym.is(Bridge)

compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala

@@ -121,10 +121,10 @@ object PostProcessorFrontendAccess {
           case (None, None) => "8" // least supported version by default
 
       override val debug: Boolean = ctx.debug
-      override val dumpClassesDirectory: Option[String] = s.Ydumpclasses.valueSetByUser
+      override val dumpClassesDirectory: Option[String] = s.Xdumpclasses.valueSetByUser
       override val outputDirectory: AbstractFile = s.outputDir.value
       override val mainClass: Option[String] = s.XmainClass.valueSetByUser
-      override val jarCompressionLevel: Int = s.YjarCompressionLevel.value
+      override val jarCompressionLevel: Int = s.XjarCompressionLevel.value
       override val backendParallelism: Int = s.YbackendParallelism.value
       override val backendMaxWorkerQueue: Option[Int] = s.YbackendWorkerQueue.valueSetByUser
       override val outputOnlyTasty: Boolean = s.YoutputOnlyTasty.value

compiler/src/dotty/tools/dotc/Driver.scala

@@ -82,7 +82,7 @@ class Driver {
     Positioned.init(using ictx)
 
     inContext(ictx) {
-      if !ctx.settings.YdropComments.value || ctx.settings.YreadComments.value then
+      if !ctx.settings.XdropComments.value || ctx.settings.XreadComments.value then
         ictx.setProperty(ContextDoc, new ContextDocstrings)
       val fileNamesOrNone = command.checkUsage(summary, sourcesRequired)(using ctx.settings)(using ctx.settingsState)
       fileNamesOrNone.map { fileNames =>

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -349,15 +349,15 @@ object Phases {
     def subPhases: List[Run.SubPhase] = Nil
     final def traversals: Int = if subPhases.isEmpty then 1 else subPhases.length
 
-    /** skip the phase for a Java compilation unit, may depend on -Yjava-tasty */
+    /** skip the phase for a Java compilation unit, may depend on -Xjava-tasty */
     def skipIfJava(using Context): Boolean = true
 
     final def isAfterLastJavaPhase(using Context): Boolean =
-      // With `-Yjava-tasty` nominally the final phase is expected be ExtractAPI,
+      // With `-Xjava-tasty` nominally the final phase is expected be ExtractAPI,
       // otherwise drop Java sources at the end of TyperPhase.
       // Checks if the last Java phase is before this phase,
       // which always fails if the terminal phase is before lastJavaPhase.
-      val lastJavaPhase = if ctx.settings.YjavaTasty.value then sbtExtractAPIPhase else typerPhase
+      val lastJavaPhase = if ctx.settings.XjavaTasty.value then sbtExtractAPIPhase else typerPhase
       lastJavaPhase <= this
 
     /** @pre `isRunnable` returns true */

compiler/src/dotty/tools/dotc/config/Settings.scala

@@ -79,12 +79,12 @@ object SymbolLoaders {
       // offer a setting to resolve the conflict one way or the other.
       // This was motivated by the desire to use YourKit probes, which
       // require yjp.jar at runtime. See SI-2089.
-      if (ctx.settings.YtermConflict.value == "package" || ctx.mode.is(Mode.Interactive)) {
+      if (ctx.settings.XtermConflict.value == "package" || ctx.mode.is(Mode.Interactive)) {
         report.warning(
           s"Resolving package/object name conflict in favor of package ${preExisting.fullName}. The object will be inaccessible.")
         owner.asClass.delete(preExisting)
       }
-      else if (ctx.settings.YtermConflict.value == "object") {
+      else if (ctx.settings.XtermConflict.value == "object") {
         report.warning(
           s"Resolving package/object name conflict in favor of object ${preExisting.fullName}.  The package will be inaccessible.")
         return NoSymbol
@@ -457,7 +457,7 @@ class TastyLoader(val tastyFile: AbstractFile) extends SymbolLoader {
       new ClassfileTastyUUIDParser(classfile)(ctx).checkTastyUUID(tastyUUID)
     else
       // This will be the case in any of our tests that compile with `-Youtput-only-tasty`, or when
-      // tasty file compiled by `-Yearly-tasty-output-write` comes from an early output jar.
+      // tasty file compiled by `-Xearly-tasty-output-write` comes from an early output jar.
       report.inform(s"No classfiles found for $tastyFile when checking TASTy UUID")
 
   private def mayLoadTreesFromTasty(using Context): Boolean =

compiler/src/dotty/tools/dotc/core/Phases.scala

@@ -101,7 +101,7 @@ extends TypeError:
     em"""Recursion limit exceeded.
         |Maybe there is an illegal cyclic reference?
         |If that's not the case, you could also try to increase the stacksize using the -Xss JVM option.
-        |For the unprocessed stack trace, compile with -Yno-decode-stacktraces.
+        |For the unprocessed stack trace, compile with -Xno-decode-stacktraces.
         |A recurring operation is (inner to outer):
         |${opsString(mostCommon).stripMargin}"""
 
@@ -121,7 +121,7 @@ object handleRecursive:
     e
 
   def apply(op: String, details: => String, exc: Throwable, weight: Int = 1)(using Context): Nothing =
-    if ctx.settings.YnoDecodeStacktraces.value then
+    if ctx.settings.XnoDecodeStacktraces.value then
       throw exc
     else exc match
       case _: RecursionOverflow =>

compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala

@@ -358,7 +358,7 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
       }
     catch
       case ex: Throwable =>
-        if !ctx.settings.YnoDecodeStacktraces.value
+        if !ctx.settings.XnoDecodeStacktraces.value
           && handleRecursive.underlyingStackOverflowOrNull(ex) != null then
           throw StackSizeExceeded(mdef)
         else
@@ -866,7 +866,7 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
           em"""Recursion limit exceeded while pickling ${ex.mdef}
               |in ${ex.mdef.symbol.showLocated}.
               |You could try to increase the stacksize using the -Xss JVM option.
-              |For the unprocessed stack trace, compile with -Yno-decode-stacktraces.""",
+              |For the unprocessed stack trace, compile with -Xno-decode-stacktraces.""",
           ex.mdef.srcPos)
 
     def missing = forwardSymRefs.keysIterator

compiler/src/dotty/tools/dotc/core/TypeErrors.scala

@@ -981,8 +981,8 @@ class TreeUnpickler(reader: TastyReader,
       if !sym.isType && !sym.is(ParamAccessor) then
         sym.info = ta.avoidPrivateLeaks(sym)
 
-      if (ctx.settings.YreadComments.value) {
-        assert(ctx.docCtx.isDefined, "`-Yread-docs` enabled, but no `docCtx` is set.")
+      if (ctx.settings.XreadComments.value) {
+        assert(ctx.docCtx.isDefined, "`-Xread-docs` enabled, but no `docCtx` is set.")
         commentUnpicklerOpt.foreach { commentUnpickler =>
           val comment = commentUnpickler.commentAt(start)
           ctx.docCtx.get.addDocstring(tree.symbol, comment)

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -19,7 +19,7 @@ class IDEDecompilerDriver(val settings: List[String]) extends dotc.Driver {
 
   private val myInitCtx: Context = {
     val rootCtx = initCtx.fresh.addMode(Mode.Interactive | Mode.ReadPositions)
-    rootCtx.setSetting(rootCtx.settings.YreadComments, true)
+    rootCtx.setSetting(rootCtx.settings.XreadComments, true)
     rootCtx.setSetting(rootCtx.settings.YretainTrees, true)
     rootCtx.setSetting(rootCtx.settings.fromTasty, true)
     val ctx = setup(settings.toArray :+ "dummy.scala", rootCtx).get._2

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -48,11 +48,11 @@ class ReadTasty extends Phase {
               if (cls.rootTree.isEmpty) None
               else {
                 val attributes = unpickler.tastyAttributes
-                if attributes.isJava && !ctx.settings.YjavaTasty.value then
-                  // filter out Java compilation units if -Yjava-tasty is not set
+                if attributes.isJava && !ctx.settings.XjavaTasty.value then
+                  // filter out Java compilation units if -Xjava-tasty is not set
                   None
-                else if attributes.isOutline && !ctx.settings.YallowOutlineFromTasty.value then
-                  cannotUnpickle("it contains outline signatures and -Yallow-outline-from-tasty is not set.")
+                else if attributes.isOutline && !ctx.settings.XallowOutlineFromTasty.value then
+                  cannotUnpickle("it contains outline signatures and -Xallow-outline-from-tasty is not set.")
                 else
                   val unit = CompilationUnit(cls, cls.rootTree, forceTrees = true)
                   unit.pickled += (cls -> (() => unpickler.unpickler.bytes))

compiler/src/dotty/tools/dotc/decompiler/IDEDecompilerDriver.scala

@@ -33,8 +33,8 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   private val myInitCtx: Context = {
     val rootCtx = initCtx.fresh.addMode(Mode.ReadPositions).addMode(Mode.Interactive)
     rootCtx.setSetting(rootCtx.settings.YretainTrees, true)
-    rootCtx.setSetting(rootCtx.settings.YcookComments, true)
-    rootCtx.setSetting(rootCtx.settings.YreadComments, true)
+    rootCtx.setSetting(rootCtx.settings.XcookComments, true)
+    rootCtx.setSetting(rootCtx.settings.XreadComments, true)
     val ctx = setup(settings.toArray, rootCtx) match
       case Some((_, ctx)) => ctx
       case None => rootCtx

compiler/src/dotty/tools/dotc/fromtasty/ReadTasty.scala

@@ -1614,7 +1614,7 @@ object Parsers {
               imods &~= Given
               syntaxError(em"context function types require at least one parameter", paramSpan)
             FunctionWithMods(params, resultType, imods, erasedArgs.toList)
-          else if !ctx.settings.YkindProjector.isDefault then
+          else if !ctx.settings.XkindProjector.isDefault then
             val (newParams :+ newResultType, tparams) = replaceKindProjectorPlaceholders(params :+ resultType): @unchecked
             lambdaAbstract(tparams, Function(newParams, newResultType))
           else
@@ -1741,7 +1741,7 @@ object Parsers {
       val isVarianceAnnotated = name.startsWith("+") || name.startsWith("-")
       // We remove the variance marker from the name without passing along the specified variance at all
       // The real variance will be inferred at a later stage but may contradict the variance specified,
-      // This is ok, because `-Ykind-projector` is for cross-compiling existing Scala 2 code, not for writing new code,
+      // This is ok, because `-Xkind-projector` is for cross-compiling existing Scala 2 code, not for writing new code,
       // we may assume that variance annotations have already been checked by the Scala 2 compiler.
       val unannotatedName = if (isVarianceAnnotated) name.mapLast(_.drop(1)) else name
       TypeDef(unannotatedName, WildcardTypeBoundsTree()).withFlags(Param)
@@ -1758,7 +1758,7 @@ object Parsers {
         Ident(name)
       }
 
-      val uscores = ctx.settings.YkindProjector.value == "underscores"
+      val uscores = ctx.settings.XkindProjector.value == "underscores"
       val newParams = params.mapConserve {
         case param @ Ident(tpnme.raw.STAR | tpnme.raw.MINUS_STAR | tpnme.raw.PLUS_STAR) => addParam()
         case param @ Ident(tpnme.USCOREkw | tpnme.raw.MINUS_USCORE | tpnme.raw.PLUS_USCORE) if uscores => addParam()
@@ -1944,7 +1944,7 @@ object Parsers {
       if isSimpleLiteral then
         SingletonTypeTree(simpleLiteral())
       else if in.token == USCORE then
-        if ctx.settings.YkindProjector.value == "underscores" then
+        if ctx.settings.XkindProjector.value == "underscores" then
           val start = in.skipToken()
           Ident(tpnme.USCOREkw).withSpan(Span(start, in.lastOffset, start))
         else
@@ -1960,7 +1960,7 @@ object Parsers {
           typeBounds().withSpan(Span(start, in.lastOffset, start))
       // Allow symbols -_ and +_ through for compatibility with code written using kind-projector in Scala 3 underscore mode.
       // While these signify variant type parameters in Scala 2 + kind-projector, we ignore their variance markers since variance is inferred.
-      else if (isIdent(nme.MINUS) || isIdent(nme.PLUS)) && in.lookahead.token == USCORE && ctx.settings.YkindProjector.value == "underscores" then
+      else if (isIdent(nme.MINUS) || isIdent(nme.PLUS)) && in.lookahead.token == USCORE && ctx.settings.XkindProjector.value == "underscores" then
         val identName = in.name.toTypeName ++ nme.USCOREkw
         val start = in.skipToken()
         in.nextToken()
@@ -2012,7 +2012,7 @@ object Parsers {
         val applied = rejectWildcardType(t)
         val args = typeArgs(namedOK = false, wildOK = true)
 
-        if (!ctx.settings.YkindProjector.isDefault) {
+        if (!ctx.settings.XkindProjector.isDefault) {
           def fail(): Tree = {
             syntaxError(
               em"λ requires a single argument of the form X => ... or (X, Y) => ...",
@@ -2044,7 +2044,7 @@ object Parsers {
         }
       })
       case _ =>
-        if (!ctx.settings.YkindProjector.isDefault) {
+        if (!ctx.settings.XkindProjector.isDefault) {
           t match {
             case Tuple(params) =>
               val (newParams, tparams) = replaceKindProjectorPlaceholders(params)

compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala

@@ -174,7 +174,7 @@ object Scanners {
   }
 
   class Scanner(source: SourceFile, override val startFrom: Offset = 0, profile: Profile = NoProfile, allowIndent: Boolean = true)(using Context) extends ScannerCommon(source) {
-    val keepComments = !ctx.settings.YdropComments.value
+    val keepComments = !ctx.settings.XdropComments.value
 
     /** A switch whether operators at the start of lines can be infix operators */
     private[Scanners] var allowLeadingInfixOperators = true

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -130,7 +130,7 @@ object report:
 
   // Should only be called from Run#enrichErrorMessage.
   def enrichErrorMessage(errorMessage: String)(using Context): String =
-    if ctx.settings.YnoEnrichErrorMessages.value then errorMessage
+    if ctx.settings.XnoEnrichErrorMessages.value then errorMessage
     else try enrichErrorMessage1(errorMessage)
     catch case _: Throwable => errorMessage // don't introduce new errors trying to report errors, so swallow exceptions
 
@@ -155,7 +155,7 @@ object report:
        |  An unhandled exception was thrown in the compiler.
        |  Please file a crash report here:
        |  https://github.com/scala/scala3/issues/new/choose
-       |  For non-enriched exceptions, compile with -Yno-enrich-error-messages.
+       |  For non-enriched exceptions, compile with -Xno-enrich-error-messages.
        |
        |$info1
        |""".stripMargin

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -52,13 +52,13 @@ class ExtractAPI extends Phase {
   override def description: String = ExtractAPI.description
 
   override def isRunnable(using Context): Boolean = {
-    super.isRunnable && (ctx.runZincPhases || ctx.settings.YjavaTasty.value)
+    super.isRunnable && (ctx.runZincPhases || ctx.settings.XjavaTasty.value)
   }
 
   // Check no needed. Does not transform trees
   override def isCheckable: Boolean = false
 
-  // when `-Yjava-tasty` is set we actually want to run this phase on Java sources
+  // when `-Xjava-tasty` is set we actually want to run this phase on Java sources
   override def skipIfJava(using Context): Boolean = false
 
   // SuperAccessors need to be part of the API (see the scripted test
@@ -70,7 +70,7 @@ class ExtractAPI extends Phase {
 
   override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] =
     val doZincCallback = ctx.runZincPhases
-    val sigWriter: Option[Pickler.EarlyFileWriter] = ctx.settings.YearlyTastyOutput.value match
+    val sigWriter: Option[Pickler.EarlyFileWriter] = ctx.settings.XearlyTastyOutput.value match
       case earlyOut if earlyOut.isDirectory && earlyOut.exists =>
         Some(Pickler.EarlyFileWriter(earlyOut))
       case _ =>
@@ -81,12 +81,12 @@ class ExtractAPI extends Phase {
         val ctx0 = ctx.withProperty(NonLocalClassSymbolsInCurrentUnits, Some(nonLocalClassSymbols))
         super.runOn(units)(using ctx0)
       else
-        units // still run the phase for the side effects (writing TASTy files to -Yearly-tasty-output)
+        units // still run the phase for the side effects (writing TASTy files to -Xearly-tasty-output)
     sigWriter.foreach(writeSigFiles(units0, _))
     if doZincCallback then
       ctx.withIncCallback(recordNonLocalClasses(nonLocalClassSymbols, _))
-    if ctx.settings.YjavaTasty.value then
-      units0.filterNot(_.typedAsJava) // remove java sources, this is the terminal phase when `-Yjava-tasty` is set
+    if ctx.settings.XjavaTasty.value then
+      units0.filterNot(_.typedAsJava) // remove java sources, this is the terminal phase when `-Xjava-tasty` is set
     else
       units0
   end runOn

compiler/src/dotty/tools/dotc/report.scala

@@ -64,7 +64,7 @@ class ExtractDependencies extends Phase {
   // Check no needed. Does not transform trees
   override def isCheckable: Boolean = false
 
-  // when `-Yjava-tasty` is set we actually want to run this phase on Java sources
+  // when `-Xjava-tasty` is set we actually want to run this phase on Java sources
   override def skipIfJava(using Context): Boolean = false
 
   // This phase should be run directly after `Frontend`, if it is run after

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -12,7 +12,7 @@ class CookComments extends MegaPhase.MiniPhase {
   override def description: String = CookComments.description
 
   override def transformTypeDef(tree: tpd.TypeDef)(using Context): tpd.Tree = {
-    if (ctx.settings.YcookComments.value && tree.isClassDef) {
+    if (ctx.settings.XcookComments.value && tree.isClassDef) {
       val cls = tree.symbol
       val cookingCtx = ctx.localContext(tree, cls).setNewScope
       val template = tree.rhs.asInstanceOf[tpd.Template]

compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala

@@ -445,7 +445,7 @@ object GenericSignatures {
     }
   }
 
-  private def needsJavaSig(tp: Type, throwsArgs: List[Type])(using Context): Boolean = !ctx.settings.YnoGenericSig.value && {
+  private def needsJavaSig(tp: Type, throwsArgs: List[Type])(using Context): Boolean = !ctx.settings.XnoGenericSig.value && {
       def needs(tp: Type) = (new NeedsSigCollector).apply(false, tp)
       needs(tp) || throwsArgs.exists(needs)
   }

compiler/src/dotty/tools/dotc/transform/CookComments.scala

@@ -58,7 +58,7 @@ class Pickler extends Phase {
   override def isRunnable(using Context): Boolean =
     super.isRunnable && !ctx.settings.fromTasty.value
 
-  // when `-Yjava-tasty` is set we actually want to run this phase on Java sources
+  // when `-Xjava-tasty` is set we actually want to run this phase on Java sources
   override def skipIfJava(using Context): Boolean = false
 
   private def output(name: String, msg: String) = {
@@ -116,8 +116,8 @@ class Pickler extends Phase {
         util.SourceFile.relativePath(unit.source, reference)
       val isJavaAttr = unit.isJava // we must always set JAVAattr when pickling Java sources
       if isJavaAttr then
-        // assert that Java sources didn't reach Pickler without `-Yjava-tasty`.
-        assert(ctx.settings.YjavaTasty.value, "unexpected Java source file without -Yjava-tasty")
+        // assert that Java sources didn't reach Pickler without `-Xjava-tasty`.
+        assert(ctx.settings.XjavaTasty.value, "unexpected Java source file without -Xjava-tasty")
       val isOutline = isJavaAttr // TODO: later we may want outline for Scala sources too
       val attributes = Attributes(
         sourceFile = sourceRelativePath,
@@ -147,7 +147,7 @@ class Pickler extends Phase {
                 unit.source, tree :: Nil, positionWarnings,
                 scratch.positionBuffer, scratch.pickledIndices)
 
-          if !ctx.settings.YdropComments.value then
+          if !ctx.settings.XdropComments.value then
             CommentPickler.pickleComments(
                 pickler, treePkl.buf.addrOfTree, treePkl.docString, tree,
                 scratch.commentBuffer)
@@ -203,7 +203,7 @@ class Pickler extends Phase {
         super.runOn(units)
     if ctx.settings.YtestPickler.value then
       val ctx2 = ctx.fresh
-        .setSetting(ctx.settings.YreadComments, true)
+        .setSetting(ctx.settings.XreadComments, true)
         .setSetting(ctx.settings.YshowPrintErrors, true)
       testUnpickler(
         using ctx2

compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala

@@ -59,7 +59,7 @@ class TyperPhase(addRootImports: Boolean = true) extends Phase {
   }
 
   protected def discardAfterTyper(unit: CompilationUnit)(using Context): Boolean =
-    (unit.isJava && !ctx.settings.YjavaTasty.value) || unit.suspended
+    (unit.isJava && !ctx.settings.XjavaTasty.value) || unit.suspended
 
   override val subPhases: List[SubPhase] = List(
     SubPhase("indexing"), SubPhase("typechecking"), SubPhase("checkingJava"))