Convert -Ycc to language import

Two new experimental language imports:

 - captureChecking: replaces -Ycc
 - pureFunctions: Enables pure function syntax A -> B

Author: odersky

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

@@ -81,8 +81,8 @@ class Compiler {
          new PatternMatcher) ::      // Compile pattern matches
     List(new TestRecheck.Pre) ::     // Test only: run rechecker, enabled under -Yrecheck-test
     List(new TestRecheck) ::         // Test only: run rechecker, enabled under -Yrecheck-test
-    List(new CheckCaptures.Pre) ::   // Preparations for check captures phase, enabled under -Ycc
-    List(new CheckCaptures) ::       // Check captures, enabled under -Ycc
+    List(new CheckCaptures.Pre) ::   // Preparations for check captures phase, enabled under captureChecking
+    List(new CheckCaptures) ::       // Check captures, enabled under captureChecking
     List(new ElimOpaque,             // Turn opaque into normal aliases
          new sjs.ExplicitJSClasses,  // Make all JS classes explicit (Scala.js only)
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.

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

@@ -195,11 +195,11 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case arg => arg.typeOpt.widen.isRepeatedParam
   }
 
-  /** Is tree a type tree of the form `=> T` or (under -Ycc) `{refs}-> T`? */
+  /** Is tree a type tree of the form `=> T` or (under pureFunctions) `{refs}-> T`? */
   def isByNameType(tree: Tree)(using Context): Boolean =
     stripByNameType(tree) ne tree
 
-  /** Strip `=> T` to `T` and (under -Ycc) `{refs}-> T` to `T` */
+  /** Strip `=> T` to `T` and (under pureFunctions) `{refs}-> T` to `T` */
   def stripByNameType(tree: Tree)(using Context): Tree = unsplice(tree) match
     case ByNameTypeTree(t1) => t1
     case untpd.CapturingTypeTree(_, parent) =>
@@ -400,12 +400,12 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     }
   }
 
-  /** Under -Ycc: A builder and extractor for `=> T`, which is an alias for `{*}-> T`.
+  /** Under pureFunctions: A builder and extractor for `=> T`, which is an alias for `{*}-> T`.
    *  Only trees of the form `=> T` are matched; trees written directly as `{*}-> T`
    *  are ignored by the extractor.
    */
   object ImpureByNameTypeTree:
-  
+
     def apply(tp: ByNameTypeTree)(using Context): untpd.CapturingTypeTree =
       untpd.CapturingTypeTree(
         Ident(nme.CAPTURE_ROOT).withSpan(tp.span.startPos) :: Nil, tp)

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

@@ -217,7 +217,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     case class Infix()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Infix)
 
-    /** Used under -Ycc to mark impure function types `A => B` in `FunctionWithMods` */
+    /** Used under pureFunctions to mark impure function types `A => B` in `FunctionWithMods` */
     case class Impure()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Impure)
   }
 

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

@@ -9,6 +9,7 @@ import Decorators.*, NameOps.*
 import config.Printers.capt
 import util.Property.Key
 import tpd.*
+import config.Feature
 
 private val Captures: Key[CaptureSet] = Key()
 private val BoxedType: Key[BoxedTypeCache] = Key()
@@ -120,11 +121,11 @@ extension (tp: Type)
     case _ =>
       tp
 
-  /** Under -Ycc, map regular function type to impure function type
+  /** Under pureFunctions, map regular function type to impure function type
    */
-  def adaptFunctionTypeUnderCC(using Context): Type = tp match
+  def adaptFunctionTypeUnderPureFuns(using Context): Type = tp match
     case AppliedType(fn, args)
-    if ctx.settings.Ycc.value && defn.isFunctionClass(fn.typeSymbol) =>
+    if Feature.pureFunsEnabled && defn.isFunctionClass(fn.typeSymbol) =>
       val fname = fn.typeSymbol.name
       defn.FunctionType(
         fname.functionArity,

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

@@ -7,7 +7,7 @@ import Phases.*, DenotTransformers.*, SymDenotations.*
 import Contexts.*, Names.*, Flags.*, Symbols.*, Decorators.*
 import Types.*, StdNames.*, Denotations.*
 import config.Printers.{capt, recheckr}
-import config.Config
+import config.{Config, Feature}
 import ast.{tpd, untpd, Trees}
 import Trees.*
 import typer.RefChecks.{checkAllOverrides, checkParents}
@@ -26,7 +26,7 @@ object CheckCaptures:
 
   class Pre extends PreRecheck, SymTransformer:
 
-    override def isEnabled(using Context) = ctx.settings.Ycc.value
+    override def isEnabled(using Context) = Feature.ccEnabled
 
   	/** Reset `private` flags of parameter accessors so that we can refine them
      *  in Setup if they have non-empty capture sets. Special handling of some
@@ -133,7 +133,7 @@ class CheckCaptures extends Recheck, SymTransformer:
   import CheckCaptures.*
 
   def phaseName: String = "cc"
-  override def isEnabled(using Context) = ctx.settings.Ycc.value
+  override def isEnabled(using Context) = Feature.ccEnabled
 
   def newRechecker()(using Context) = CaptureChecker(ctx)
 
@@ -148,7 +148,7 @@ class CheckCaptures extends Recheck, SymTransformer:
   /** Check overrides again, taking capture sets into account.
    *  TODO: Can we avoid doing overrides checks twice?
    *  We need to do them here since only at this phase CaptureTypes are relevant
-   *  But maybe we can then elide the check during the RefChecks phase if -Ycc is set?
+   *  But maybe we can then elide the check during the RefChecks phase under captureChecking?
    */
   def checkOverrides = new TreeTraverser:
     def traverse(t: Tree)(using Context) =

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

@@ -240,7 +240,7 @@ object Config {
    */
   inline val printCaptureSetsAsPrefix = true
 
-  /** If true, allow mappping capture set variables under -Ycc with maps that are neither
+  /** If true, allow mappping capture set variables under captureChecking with maps that are neither
    *  bijective nor idempotent. We currently do now know how to do this correctly in all
    *  cases, though.
    */

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

@@ -28,6 +28,8 @@ object Feature:
   val symbolLiterals = deprecated("symbolLiterals")
   val fewerBraces = experimental("fewerBraces")
   val saferExceptions = experimental("saferExceptions")
+  val pureFunctions = experimental("pureFunctions")
+  val captureChecking = experimental("captureChecking")
 
   /** Is `feature` enabled by by a command-line setting? The enabling setting is
    *
@@ -75,6 +77,11 @@ object Feature:
 
   def scala2ExperimentalMacroEnabled(using Context) = enabled(scala2macros)
 
+  def pureFunsEnabled(using Context) =
+    enabled(pureFunctions) || ccEnabled
+
+  def ccEnabled(using Context) = enabled(captureChecking)
+
   def sourceVersionSetting(using Context): SourceVersion =
     SourceVersion.valueOf(ctx.settings.source.value)
 

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

@@ -328,9 +328,8 @@ private sealed trait YSettings:
   val YcheckInit: Setting[Boolean] = BooleanSetting("-Ysafe-init", "Ensure safe initialization of objects")
   val YrequireTargetName: Setting[Boolean] = BooleanSetting("-Yrequire-targetName", "Warn if an operator is defined without a @targetName annotation")
   val YrecheckTest: Setting[Boolean] = BooleanSetting("-Yrecheck-test", "Run basic rechecking (internal test only)")
-  val Ycc: Setting[Boolean] = BooleanSetting("-Ycc", "Check captured references (warning: extremely experimental and unstable)")
-  val YccDebug: Setting[Boolean] = BooleanSetting("-Ycc-debug", "Used in conjunction with -Ycc, debug info for captured references")
-  val YccNoAbbrev: Setting[Boolean] = BooleanSetting("-Ycc-no-abbrev", "Used in conjunction with -Ycc, suppress type abbreviations")
+  val YccDebug: Setting[Boolean] = BooleanSetting("-Ycc-debug", "Used in conjunction with captureChecking language import, debug info for captured references")
+  val YccNoAbbrev: Setting[Boolean] = BooleanSetting("-Ycc-no-abbrev", "Used in conjunction with captureChecking language import, suppress type abbreviations")
 
   /** Area-specific debug output */
   val YexplainLowlevel: Setting[Boolean] = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")

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

@@ -14,6 +14,7 @@ import typer.ImportInfo.RootRef
 import Comments.CommentsContext
 import Comments.Comment
 import util.Spans.NoSpan
+import config.Feature
 import Symbols.requiredModuleRef
 import cc.{CapturingType, CaptureSet, EventuallyCapturingType}
 
@@ -976,7 +977,6 @@ class Definitions {
   @tu lazy val BooleanBeanPropertyAnnot: ClassSymbol = requiredClass("scala.beans.BooleanBeanProperty")
   @tu lazy val BodyAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Body")
   @tu lazy val CapabilityAnnot: ClassSymbol = requiredClass("scala.annotation.capability")
-  @tu lazy val CaptureCheckedAnnot: ClassSymbol = requiredClass("scala.annotation.internal.CaptureChecked")
   @tu lazy val ChildAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Child")
   @tu lazy val ContextResultCountAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ContextResultCount")
   @tu lazy val ProvisionalSuperClassAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ProvisionalSuperClass")
@@ -1012,6 +1012,7 @@ class Definitions {
   @tu lazy val UncheckedStableAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedStable")
   @tu lazy val UncheckedVarianceAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedVariance")
   @tu lazy val VolatileAnnot: ClassSymbol = requiredClass("scala.volatile")
+  @tu lazy val WithPureFunsAnnot: ClassSymbol = requiredClass("scala.annotation.internal.WithPureFuns")
   @tu lazy val FieldMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.field")
   @tu lazy val GetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.getter")
   @tu lazy val ParamMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.param")
@@ -1160,7 +1161,7 @@ class Definitions {
 
   /** Extractor for context function types representing by-name parameters, of the form
    *  `() ?=> T`.
-   *  Under -Ycc, this becomes `() ?-> T` or `{r1, ..., rN} () ?-> T`.
+   *  Under purefunctions, this becomes `() ?-> T` or `{r1, ..., rN} () ?-> T`.
    */
   object ByNameFunction:
     def apply(tp: Type)(using Context): Type = tp match
@@ -1984,7 +1985,7 @@ class Definitions {
     if (!isInitialized) {
       // force initialization of every symbol that is synthesized or hijacked by the compiler
       val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses()
-        ++ (JavaEnumClass :: (if ctx.settings.Ycc.value then captureRoot :: Nil else Nil))
+        ++ (JavaEnumClass :: (if Feature.ccEnabled then captureRoot :: Nil else Nil))
 
       isInitialized = true
     }

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

@@ -8,6 +8,7 @@ import scala.io.Codec
 import Int.MaxValue
 import Names._, StdNames._, Contexts._, Symbols._, Flags._, NameKinds._, Types._
 import util.Chars.{isOperatorPart, digit2int}
+import config.Feature
 import Decorators.*
 import Definitions._
 import nme._
@@ -208,14 +209,14 @@ object NameOps {
             if str == mustHave then found = true
             idx + str.length
           else idx
-        val start = if ctx.settings.Ycc.value then skip(0, "Impure") else 0
+        val start = if Feature.pureFunsEnabled then skip(0, "Impure") else 0
         skip(skip(start, "Erased"), "Context") == suffixStart
         && found
       }
 
     /** Same as `funArity`, except that it returns -1 if the prefix
      *  is not one of a (possibly empty) concatenation of a subset of
-     *  "Impure" (only under -Ycc), "Erased" and "Context" (in that order).
+     *  "Impure" (only under pureFunctions), "Erased" and "Context" (in that order).
      */
     private def checkedFunArity(suffixStart: Int)(using Context): Int =
       if isFunctionPrefix(suffixStart) then funArity(suffixStart) else -1