Make everything available under experimental.errorHandling

Author: odersky

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

@@ -82,9 +82,12 @@ class CompilationUnit protected (val source: SourceFile, val info: CompilationUn
   /** Will be set to true if unit was compiled with `magic` language import. */
   var magic: Boolean = false
 
+  /** Will be set to true if unit was compiled with `errorHandling` language import. */
+  var newErrorHandling: Boolean = false
+
   /** Will be set to true if the unit contains a pureFunctions language import */
   var knowsPureFuns: Boolean = false
-  
+
   /** Will be set to true if the unit contains an inlineTrait language import */
   var knowsInlineTraits: Boolean = false
 

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -2425,7 +2425,7 @@ object desugar {
               AppliedTypeTree(ref(defn.SeqType), t),
               New(ref(defn.RepeatedAnnot.typeRef), Nil :: Nil))
         else if isOp(tpnme.?) then
-          AppliedTypeTree(ref(defn.MagicMaybeClass.typeRef), t :: ref(defn.UnitClass.typeRef) :: Nil)
+          AppliedTypeTree(ref(defn.MaybeClass.typeRef), t :: ref(defn.UnitClass.typeRef) :: Nil)
         else
           assert(ctx.mode.isExpr || ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), ctx.mode)
           Select(t, op.name)

compiler/src/dotty/tools/dotc/cc/Setup.scala

@@ -313,7 +313,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         CapturingType(OrType(tp1, parent2, tp.isSoft), refs2, tp2.isBoxed)
       case tp @ AppliedType(tycon, args) if tp.dealias eq tp =>
         val sym = tycon.typeSymbol
-        if !defn.isFunctionClass(sym) && sym != defn.MagicMaybeClass
+        if !defn.isFunctionClass(sym) && sym != defn.MaybeClass
         then tp.derivedAppliedType(tycon, args.mapConserve(_.boxDeeply))
         else tp
       case tp: RealTypeBounds =>

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

@@ -45,7 +45,7 @@ object Feature:
   val magic = experimental("magic")
   val inlineTraits = experimental("inlineTraits")
   val specializedTraits = experimental("specializedTraits")
-  val maybe = experimental("maybe")
+  val errorHandling = experimental("errorHandling")
 
   val nonViralExperimentalFeatures: Set[TermName] =
     Set(captureChecking, separationChecking, safe, magic)
@@ -87,7 +87,7 @@ object Feature:
     (magic, "Enable extensions for working with coding agents"),
     (inlineTraits, "Allow inline traits"),
     (specializedTraits, "Allow specialized traits"),
-    (maybe, "Allow T? and T ? E types"),
+    (errorHandling, "Allow error handling using T? and T ? E types"),
   )
 
   /** Features that are now standard; the language import / -language choice is
@@ -195,8 +195,10 @@ object Feature:
     || enabledBySetting(specializedTraits)
     || ctx.compilationUnit.knowsInlineTraits
 
-  def maybeEnabled(using Context) =
-    enabled(maybe) || magicEnabled
+  def errorHandlingEnabled(using Context) =
+    ctx.originalCompilationUnit.newErrorHandling
+    || enabledBySetting(errorHandling)
+    || enabledBySetting(magic)
 
   /** Is pureFunctions enabled for this compilation unit? */
   def pureFunsEnabled(using Context) =
@@ -283,7 +285,7 @@ object Feature:
       || sym.exists && defn.ccExperimental.contains(sym.owner))
 
   private def magicException(sym: Symbol)(using Context): Boolean =
-    Feature.magicEnabled && sym.isContainedIn(defn.MagicPackageClass)
+    Feature.magicEnabled // magic enables all experimental definitions
 
   def checkExperimentalDef(sym: Symbol, srcPos: SrcPos)(using Context) =
     val experimentalSym =
@@ -354,12 +356,16 @@ object Feature:
       case `magic` =>
         enableCC()
         ctx.compilationUnit.magic = true
+        ctx.compilationUnit.newErrorHandling = true
         ctx.compilationUnit.sourceVersion = Some(SourceVersion.future)
         true
       case `inlineTraits` =>
         ctx.compilationUnit.knowsInlineTraits = true
         if ctx.run != null then ctx.run.nn.inlineTraitsImportEncountered = true
         true
+      case `errorHandling` =>
+        ctx.compilationUnit.newErrorHandling = true
+        true
       case _ =>
         false
 

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

@@ -484,26 +484,29 @@ class Definitions {
   // Magic stuff
   @tu lazy val MagicPackage: Symbol = requiredPackage("scala.magic")
   @tu lazy val MagicPackageClass: ClassSymbol = MagicPackage.moduleClass.asClass
-  @tu lazy val MagicMaybeClass: ClassSymbol = requiredClass("scala.magic.compiletime.Maybe")
-  @tu lazy val MagicValidClass: ClassSymbol = requiredClass("scala.magic.runtime.Valid")
-  @tu lazy val MagicFailClass: ClassSymbol = requiredClass("scala.magic.runtime.Fail")
-    @tu lazy val Magic_provided1: Symbol = MagicPackage.info.member(termName("provided")).suchThat(_.info.isInstanceOf[MethodType]).symbol
-    @tu lazy val Magic_provided2: Symbol = MagicPackage.info.member(termName("provided")).suchThat(_.info.isInstanceOf[PolyType]).symbol
-    @tu lazy val Magic_CanErr: Symbol = MagicPackageClass.requiredType("CanErr")
-
-  @tu lazy val MagicOkModule: Symbol = requiredModule("scala.magic.Ok")
-    @tu lazy val Magic_OkApply: Symbol = MagicOkModule.requiredMethod(nme.apply)
-    @tu lazy val Magic_OkUnapply: Symbol = MagicOkModule.requiredMethod(nme.unapply)
-
-  @tu lazy val MagicErrModule: Symbol = requiredModule("scala.magic.Err")
-    @tu lazy val Magic_ErrUnapply: Symbol = MagicErrModule.requiredMethod(nme.unapply)
 
   @tu lazy val MagicCompiletimePackage: Symbol = requiredPackage("scala.magic.compiletime")
     @tu lazy val Magic_spec: Symbol = MagicCompiletimePackage.requiredMethod("$spec")
     @tu lazy val Magic_wrappedType: Symbol = MagicCompiletimePackage.requiredMethod("$wrappedType")
 
   @tu lazy val MagicRuntimePackageClass = requiredPackage("scala.magic.runtime").moduleClass.asClass
 
+  // Maybe-related
+  @tu lazy val MaybeClass: ClassSymbol = requiredClass("scala.compiletime.Maybe")
+  @tu lazy val ValidClass: ClassSymbol = requiredClass("scala.runtime.Valid")
+  @tu lazy val FailClass: ClassSymbol = requiredClass("scala.runtime.Fail")
+  @tu lazy val maybeModule: Symbol = requiredModule("scala.maybe")
+    @tu lazy val maybe_provided1: Symbol = maybeModule.info.member(termName("provided")).suchThat(_.info.isInstanceOf[MethodType]).symbol
+    @tu lazy val maybe_provided2: Symbol = maybeModule.info.member(termName("provided")).suchThat(_.info.isInstanceOf[PolyType]).symbol
+    @tu lazy val maybe_CanErr: Symbol = maybeModule.requiredType("CanErr")
+
+  @tu lazy val OkModule: Symbol = requiredModule("scala.util.Ok")
+    @tu lazy val Ok_apply: Symbol = OkModule.requiredMethod(nme.apply)
+    @tu lazy val Ok_unapply: Symbol = OkModule.requiredMethod(nme.unapply)
+
+  @tu lazy val ErrModule: Symbol = requiredModule("scala.util.Err")
+    @tu lazy val Err_unapply: Symbol = ErrModule.requiredMethod(nme.unapply)
+
   // More synthetic symbols
   @tu lazy val andType: TypeSymbol = enterBinaryAlias(tpnme.AND, AndType(_, _))
   @tu lazy val orType: TypeSymbol = enterBinaryAlias(tpnme.OR, OrType(_, _, soft = false))
@@ -2240,7 +2243,7 @@ class Definitions {
     m(TupleClass) = ProductClass
     m(NonEmptyTupleClass) = ProductClass
     m(PairClass) = ObjectClass
-    m(MagicMaybeClass) = ObjectClass
+    m(MaybeClass) = ObjectClass
     m
 
   // ----- Initialization ---------------------------------------------------

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

@@ -857,7 +857,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         tp2 match
           case OrNull(tp2a) =>
             tp1w match
-              case MagicMaybeType(tp1a, errArg, _) =>
+              case MaybeType(tp1a, errArg, _) =>
                 if errArg.isRef(defn.UnitClass) && tp1a.isNotNullNorMaybe then
                   return recur(tp1a, tp2a)
               case _ =>
@@ -1050,7 +1050,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
                 // Same as above; this.type is also a singleton type in spec language
                 !ctx.explicitNulls && isNullable(tp.underlying)
               case tp: RefinedOrRecType => isNullable(tp.parent)
-              case AppliedType(tycon, _ :: errArg :: Nil) if tycon.isRef(defn.MagicMaybeClass) =>
+              case AppliedType(tycon, _ :: errArg :: Nil) if tycon.isRef(defn.MaybeClass) =>
                 isSubType(defn.UnitType, errArg)
               case tp: AppliedType => isNullable(tp.tycon)
               case AndType(tp1, tp2) => isNullable(tp1) && isNullable(tp2)
@@ -1518,7 +1518,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
 
       /** T <: T? if T is not null */
       def byMaybeWidening: Boolean = tp2 match
-        case MagicMaybeType(res2, err2, _) if tp1.isNotNullNorMaybe =>
+        case MaybeType(res2, err2, _) if tp1.isNotNullNorMaybe =>
           recur(tp1, res2)
         case _ => false
 

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

@@ -84,7 +84,7 @@ object TypeErasure:
   private def erasureDependsOnArgs(sym: Symbol)(using Context) =
     sym == defn.ArrayClass
     || sym == defn.PairClass
-    || sym == defn.MagicMaybeClass
+    || sym == defn.MaybeClass
     || sym.isDerivedValueClass
     || sym.isSpecializedTrait
 
@@ -809,7 +809,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         else if (tycon.isRef(defn.PairClass)) erasePair(tp)
         else if (tp.isRepeatedParam) apply(tp.translateFromRepeated(toArray = sourceLanguage.isJava))
         else if (semiEraseVCs && tycon.classSymbol.isDerivedValueClass) eraseDerivedValueClass(tp)
-        else if tycon.isRef(defn.MagicMaybeClass) then eraseMaybe(tp)
+        else if tycon.isRef(defn.MaybeClass) then eraseMaybe(tp)
         else this(checkedSuperType(tp))
       case tp: TermRef =>
         this(underlyingOfTermRef(tp))

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

@@ -385,7 +385,7 @@ object Types extends TypeUtils {
       case tp: ConstantType => tp.value.value != null
       case tp: FlexibleType => false
       case tp: ClassInfo => !tp.cls.isNullableClass && !tp.isNothingType
-      case MagicMaybeType(_, _, nullable) => !norMaybe && !nullable
+      case MaybeType(_, _, nullable) => !norMaybe && !nullable
       case tp: TypeBounds => tp.hi.isNotNull(norMaybe)
       case tp: TypeProxy => tp.underlying.isNotNull(norMaybe)
       case AndType(tp1, tp2) => tp1.isNotNull(norMaybe) || tp2.isNotNull(norMaybe)
@@ -5795,14 +5795,14 @@ object Types extends TypeUtils {
     def unapply(tp: MatchAlias): Option[Type] = Some(tp.alias)
   }
 
-  object MagicMaybeType {
+  object MaybeType {
     /** The maybe type `resTp ? errTp` */
     def apply(resTp: Type, errTp: Type)(using Context) =
-      defn.MagicMaybeClass.typeRef.appliedTo(resTp, errTp)
+      defn.MaybeClass.typeRef.appliedTo(resTp, errTp)
 
     /** Matches types T ? E, returns (T, E, E >: Unit) */
     def unapply(tp: Type)(using Context): Option[(Type, Type, Boolean)] = tp.dealias match
-      case AppliedType(tycon, resArg :: errArg :: Nil) if tycon.isRef(defn.MagicMaybeClass) =>
+      case AppliedType(tycon, resArg :: errArg :: Nil) if tycon.isRef(defn.MaybeClass) =>
         Some((resArg, errArg, defn.unitSuperClasses.contains(errArg.classSymbol)))
       case _ =>
         None

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -731,7 +731,7 @@ object Inlines:
             return unitLiteral.withSpan(call.span)
           else if inlinedMethod == defn.Compiletime_codeOf then
             return Intrinsics.codeOf(arg, call.srcPos)
-          else if inlinedMethod == defn.Magic_OkApply && arg.tpe.isNotNullNorMaybe then
+          else if inlinedMethod == defn.Ok_unapply && arg.tpe.isNotNullNorMaybe then
             return arg
         case _ =>
 

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

@@ -2116,7 +2116,7 @@ object Parsers {
           if in.token == LBRACE
           then makeRetaining(t, captureSet(), tpnme.retains)
           else makeRetaining(t, Nil, tpnme.retainsCap)
-      else if in.isIdent(nme.?) && Feature.maybeEnabled && isPostfixQmark(isType = true) then
+      else if in.isIdent(nme.?) && Feature.errorHandlingEnabled && isPostfixQmark(isType = true) then
         atSpan(t.span.start):
           PostfixOp(t, typeIdent())
       else
@@ -2678,7 +2678,7 @@ object Parsers {
 
     def expr1(location: Location = Location.Elsewhere): Tree = in.token match
       case IF =>
-        ifExpr(in.offset, If, canOmitThen = Feature.maybeEnabled && location == Location.InBlock)
+        ifExpr(in.offset, If, canOmitThen = Feature.errorHandlingEnabled && location == Location.InBlock)
       case WHILE =>
         atSpan(in.skipToken()) {
           val cond = condExpr(DO)
@@ -3127,7 +3127,7 @@ object Parsers {
         case USCORE =>
           atSpan(startOffset(t), in.skipToken()) { PostfixOp(t, Ident(nme.WILDCARD)) }
         case _ =>
-          if in.isIdent(nme.?) && Feature.maybeEnabled && isPostfixQmark(isType = false) then
+          if in.isIdent(nme.?) && Feature.errorHandlingEnabled && isPostfixQmark(isType = false) then
             atSpan(t.span.start):
               PostfixOp(t, termIdent())
           else if in.isColon && location == Location.InParens && followingIsLambdaParams() then