Merge branch 'pr/26985' into merge-26985-27004

# Conflicts:
#	compiler/src/dotty/tools/dotc/core/Types.scala
#	compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

Author: olhotak

community-build/src/scala/dotty/communitybuild/projects.scala

@@ -127,8 +127,6 @@ object SbtCommunityProject:
   def scalacOptions = List(
     "-Xcheck-macros",
     "-Wsafe-init",
-    "-Yexplicit-nulls",
-    "-language:unsafeNulls",
   )
 
 object projects:

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

@@ -615,7 +615,7 @@ extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo {
       .setTyper(new Typer)
       .addMode(Mode.ImplicitsEnabled)
       .setTyperState(ctx.typerState.fresh(ctx.reporter))
-    if ctx.settings.YexplicitNulls.value && !Feature.enabledBySetting(nme.unsafeNulls) then
+    if ctx.settings.YexplicitNulls.value || Feature.enabledBySetting(nme.safeNulls) then
       start = start.addMode(Mode.SafeNulls)
     ctx.initialize()(using start) // re-initialize the base context with start
 

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

@@ -62,6 +62,7 @@ object Feature:
     (nme.noAutoTupling, "Disable automatic tupling"),
     (nme.dynamics, "Allow direct or indirect subclasses of scala.Dynamic"),
     (nme.unsafeNulls, "Enable unsafe nulls for explicit nulls"),
+    (nme.safeNulls, "Enable safe nulls for explicit nulls"),
     (nme.postfixOps, "Allow postfix operators (not recommended)"),
     (nme.strictEquality, "Enable strict equality (disable canEqualAny)"),
     (nme.implicitConversions, "Allow implicit conversions without warnings"),

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

@@ -561,7 +561,8 @@ private sealed trait YSettings:
   val YmagicOffsetHeader: Setting[String] = StringSetting(ForkSetting, "Ymagic-offset-header", "header", "Specify the magic header comment that marks the start of the actual code in generated wrapper scripts. Example: -Ymagic-offset-header:SOURCE_CODE_START. Then, in the source, the magic comment `///SOURCE_CODE_START:<ORIGINAL_FILE_PATH>` marks the start of user code. The comment should be suffixed by `:<ORIGINAL_FILE_PATH>` to indicate the original file.", "")
 
   // Experimental language features
-  val YexplicitNulls: Setting[Boolean] = BooleanSetting(ForkSetting, "Yexplicit-nulls", "Make reference types non-nullable. Nullable types can be expressed with unions: e.g. String|Null.")
+  val YexplicitNulls: Setting[Boolean] = BooleanSetting(ForkSetting, "Yexplicit-nulls", "Since explicit nulls is enabled by default, this flag now enables safe nulls for explicit-nulls")
+  val YnoExplicitNulls: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-explicit-nulls", "Make reference types implictly nullable.")
   val YnoFlexibleTypes: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-flexible-types", "Disable turning nullable Java return types and parameter types into flexible types, which behave like abstract types with a nullable lower bound and non-nullable upper bound.")
   val YflexifyTasty: Setting[Boolean] = BooleanSetting(ForkSetting, "Yflexify-tasty", "Apply flexification to Scala code compiled without -Yexplicit-nulls, when reading from tasty.")
   val YsafeInitGlobal: Setting[Boolean] = BooleanSetting(ForkSetting, "Ysafe-init-global", "Check safe initialization of global objects.")
@@ -577,6 +578,7 @@ private sealed trait YSettings:
   val YexplainLowlevel: Setting[Boolean] = BooleanSetting(ForkSetting, "Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")
   val YnoDoubleBindings: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-double-bindings", "Assert no namedtype is bound twice (should be enabled only if program is error-free).")
   val YshowVarBounds: Setting[Boolean] = BooleanSetting(ForkSetting, "Yshow-var-bounds", "Print type variables with their bounds.")
+  val YhideFlexibleTypes: Setting[Boolean] = BooleanSetting(ForkSetting, "Yhide-flexible-types", "Print flexible types as their base type. (T instead of (T)?)")
 
   val Yinstrument: Setting[Boolean] = BooleanSetting(ForkSetting, "Yinstrument", "Add instrumentation code that counts allocations and closure creations.")
   val YinstrumentDefs: Setting[Boolean] = BooleanSetting(ForkSetting, "Yinstrument-defs", "Add instrumentation code that counts method calls; needs -Yinstrument to be set, too.")

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

@@ -489,13 +489,13 @@ object Contexts {
       fresh.setSetting(ctx.settings.color, "never")
 
     /** Is the explicit nulls option set? */
-    def explicitNulls: Boolean = base.settings.YexplicitNulls.value
+    def explicitNulls: Boolean = !base.settings.YnoExplicitNulls.value
 
     /** Is the flexible types option set? */
-    def flexibleTypes: Boolean = base.settings.YexplicitNulls.value && !base.settings.YnoFlexibleTypes.value
+    def flexibleTypes: Boolean = explicitNulls && !base.settings.YnoFlexibleTypes.value
 
     /** Is the flexify tasty option set? */
-    def flexifyTasty: Boolean = base.settings.YexplicitNulls.value && base.settings.YflexifyTasty.value
+    def flexifyTasty: Boolean = explicitNulls && base.settings.YflexifyTasty.value
 
     /** Is the best-effort option set? */
     def isBestEffort: Boolean = base.settings.YbestEffort.value
@@ -771,7 +771,9 @@ object Contexts {
       importInfo.mentionsFeature(nme.unsafeNulls) match
         case Some(true) =>
           setMode(this.mode &~ Mode.SafeNulls)
-        case Some(false) if ctx.settings.YexplicitNulls.value =>
+        case _ =>
+      importInfo.mentionsFeature(nme.safeNulls) match
+        case Some(true) if explicitNulls =>
           setMode(this.mode | Mode.SafeNulls)
         case _ =>
       updateStore(importInfoLoc, importInfo)

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

@@ -668,6 +668,7 @@ object StdNames {
     val unbox: N                = "unbox"
     val universe: N             = "universe"
     val unsafeNulls: N          = "unsafeNulls"
+    val safeNulls: N            = "safeNulls"
     val update: N               = "update"
     val updateDynamic: N        = "updateDynamic"
     val uses: N                 = "uses"

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

@@ -384,6 +384,8 @@ object Types extends TypeUtils {
     final def isNotNull(using Context): Boolean = this match {
       case tp: ConstantType => tp.value.value != null
       case FlexibleType(_) => false
+      case tp: ThisType => true
+      case tp: SuperType => true
       case tp: ClassInfo => !tp.cls.isNullableClass && !tp.isNothingType
       case tp: AppliedType => tp.superType.isNotNull
       case tp: TypeBounds => tp.hi.isNotNull

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

@@ -420,7 +420,10 @@ class TreeUnpickler(reader: TastyReader,
               if nothingButMods(end) then AliasingBounds(readVariances(lo))
               else
                 val hi = readVariances(readType())
-                createNullableTypeBounds(lo, hi)
+                if (ctx.flexifyTasty && !explicitNulls)
+                  createNullableTypeBounds(lo, hi)
+                else
+                  TypeBounds(lo, hi)
             case ANNOTATEDtype =>
               val parent = readType()
               val ann =
@@ -1716,7 +1719,10 @@ class TreeUnpickler(reader: TastyReader,
               val lo = readTpt()
               val hi = if currentAddr == end then lo else readTpt()
               val alias = if currentAddr == end then EmptyTree else readTpt()
-              createNullableTypeBoundsTree(lo, hi, alias)
+              if (ctx.flexifyTasty && !explicitNulls)
+                createNullableTypeBoundsTree(lo, hi, alias)
+              else
+                TypeBoundsTree(lo, hi, alias)
             case QUOTE =>
               Quote(readTree(), Nil).withBodyType(readType())
             case SPLICE =>

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -244,7 +244,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case tp: SingletonType =>
         toTextSingleton(tp)
       case FlexibleType(tpe) =>
-        "(" ~ toText(tpe) ~ ")?"
+        if (ctx.settings.YhideFlexibleTypes.value) then
+          toText(tpe)
+        else
+          "(" ~ toText(tpe) ~ ")?"
       case AppliedType(tycon, args) =>
         (toTextLocal(tycon) ~ "[" ~ argsText(args) ~ "]").close
       case tp: RefinedType =>

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

@@ -438,7 +438,7 @@ class Pickler extends Phase {
       val attributes = Attributes(
         sourceFile = unit.source.pathRelativeToSourceRoot,
         scala2StandardLibrary = Feature.shouldBehaveAsScala2,
-        explicitNulls = ctx.settings.YexplicitNulls.value,
+        explicitNulls = ctx.explicitNulls,
         captureChecked = Feature.ccEnabled,
         withPureFuns = Feature.pureFunsEnabled,
         isJava = isJavaAttr,