Complete the language import functionality

odersky · odersky · commit 010633bcdc4b · 2022-10-25T12:30:35.000+02:00
Complete the functionality of allowing language imports for pureFunctions
and captureChecking:

 - make parser work with them
 - make printer to recognize them
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -145,7 +145,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     case Floating
   }
 
-  /** {x1, ..., xN} T   (only relevant under -Ycc) */
+  /** {x1, ..., xN} T   (only relevant under captureChecking) */
   case class CapturingTypeTree(refs: List[Tree], parent: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
 
   /** Short-lived usage in typer, does not need copy/transform/fold infrastructure */
diff --git a/compiler/src/dotty/tools/dotc/core/Mode.scala b/compiler/src/dotty/tools/dotc/core/Mode.scala
@@ -78,7 +78,7 @@ object Mode {
   /** Use Scala2 scheme for overloading and implicit resolution */
   val OldOverloadingResolution: Mode = newMode(15, "OldOverloadingResolution")
 
-  /** Treat CapturingTypes as plain AnnotatedTypes even in phase =Ycc.
+  /** Treat CapturingTypes as plain AnnotatedTypes even in phase CheckCaptures.
    *  Reuses the value of OldOverloadingResolution to save Mode bits.
    *  This is OK since OldOverloadingResolution only affects implicit search, which
    *  is done during phases Typer and Inlinig, and IgnoreCaptures only has an
diff --git a/compiler/src/dotty/tools/dotc/core/NameOps.scala b/compiler/src/dotty/tools/dotc/core/NameOps.scala
@@ -209,8 +209,7 @@ object NameOps {
             if str == mustHave then found = true
             idx + str.length
           else idx
-        val start = if Feature.pureFunsEnabled then skip(0, "Impure") else 0
-        skip(skip(start, "Erased"), "Context") == suffixStart
+        skip(skip(skip(0, "Impure"), "Erased"), "Context") == suffixStart
         && found
       }
 
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -196,7 +196,7 @@ object Parsers {
 
     def isIdent = in.isIdent
     def isIdent(name: Name) = in.isIdent(name)
-    def isPureArrow(name: Name): Boolean = Feature.pureFunsEnabled && isIdent(name)
+    def isPureArrow(name: Name): Boolean = in.pureFunsEnabled && isIdent(name)
     def isPureArrow: Boolean = isPureArrow(nme.PUREARROW) || isPureArrow(nme.PURECTXARROW)
     def isErased = isIdent(nme.erased) && in.erasedEnabled
     def isSimpleLiteral =
@@ -972,7 +972,7 @@ object Parsers {
      *  capture set `{ref1, ..., refN}` followed by a token that can start a type?
      */
     def followingIsCaptureSet(): Boolean =
-      Feature.ccEnabled && {
+      in.featureEnabled(Feature.captureChecking) && {
         val lookahead = in.LookaheadScanner()
         def followingIsTypeStart() =
           lookahead.nextToken()
@@ -1485,7 +1485,7 @@ object Parsers {
             if !imods.flags.isEmpty || params.isEmpty then
               syntaxError(em"illegal parameter list for type lambda", start)
               token = ARROW
-          else if Feature.pureFunsEnabled then
+          else if in.pureFunsEnabled then
             // `=>` means impure function under pureFunctions or captureChecking
             // language imports, whereas `->` is then a regular function.
             imods |= Impure
@@ -1891,7 +1891,7 @@ object Parsers {
       if in.token == ARROW || isPureArrow(nme.PUREARROW) then
         val isImpure = in.token == ARROW
         val tp = atSpan(in.skipToken()) { ByNameTypeTree(core()) }
-        if isImpure && Feature.pureFunsEnabled then ImpureByNameTypeTree(tp) else tp
+        if isImpure && in.pureFunsEnabled then ImpureByNameTypeTree(tp) else tp
       else if in.token == LBRACE && followingIsCaptureSet() then
         val start = in.offset
         val cs = captureSet()
diff --git a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
@@ -230,6 +230,15 @@ object Scanners {
         postfixOpsEnabledCtx = myLanguageImportContext
       postfixOpsEnabledCache
 
+    private var pureFunsEnabledCache = false
+    private var pureFunsEnabledCtx: Context = NoContext
+
+    def pureFunsEnabled =
+      if pureFunsEnabledCtx ne myLanguageImportContext then
+        pureFunsEnabledCache = featureEnabled(Feature.pureFunctions) || featureEnabled(Feature.captureChecking)
+        pureFunsEnabledCtx = myLanguageImportContext
+      pureFunsEnabledCache
+
     /** All doc comments kept by their end position in a `Map`.
       *
       * Note: the map is necessary since the comments are looked up after an
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -58,6 +58,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     try op finally myCtx = savedCtx
   }
 
+  inline def inContextBracket(inline op: Text): Text =
+    val savedCtx = myCtx
+    try op finally myCtx = savedCtx
+
   def withoutPos(op: => Text): Text = {
     val savedPrintPos = printPos
     printPos = false
@@ -308,7 +312,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     blockText(block.stats :+ block.expr)
 
   protected def blockText[T >: Untyped](trees: List[Tree[T]]): Text =
-    ("{" ~ toText(trees, "\n") ~ "}").close
+    inContextBracket {
+      ("{" ~ toText(trees, "\n") ~ "}").close
+    }
 
   protected def typeApplyText[T >: Untyped](tree: TypeApply[T]): Text = {
     val funText = toTextLocal(tree.fun)
@@ -598,7 +604,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
             typeDefText(tparamsTxt, optText(rhs)(" = " ~ _))
         }
         recur(rhs, "", true)
-      case Import(expr, selectors) =>
+      case tree @ Import(expr, selectors) =>
+        myCtx = myCtx.importContext(tree, tree.symbol)
         keywordText("import ") ~ importText(expr, selectors)
       case Export(expr, selectors) =>
         keywordText("export ") ~ importText(expr, selectors)
@@ -965,7 +972,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     }
     else impl.body
 
-    val bodyText = " {" ~~ selfText ~ toTextGlobal(primaryConstrs ::: body, "\n") ~ "}"
+    val bodyText = inContextBracket(
+      " {" ~~ selfText ~ toTextGlobal(primaryConstrs ::: body, "\n") ~ "}")
 
     prefix ~
     keywordText(" extends").provided(!ofNew && impl.parents.nonEmpty) ~~ parentsText ~
@@ -988,7 +996,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   protected def packageDefText(tree: PackageDef): Text = {
     val statsText = tree.stats match {
       case (pdef: PackageDef) :: Nil => toText(pdef)
-      case _ => toTextGlobal(tree.stats, "\n")
+      case _ => inContextBracket(toTextGlobal(tree.stats, "\n"))
     }
     val bodyText =
       if (currentPrecedence == TopLevelPrec) "\n" ~ statsText else " {" ~ statsText ~ "}"
diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
@@ -78,6 +78,9 @@ i2797a
 # allows to simplify a type that was already computed
 i13842.scala
 
+# Position change under captureChecking
+boxmap-paper.scala
+
 # GADT cast applied to singleton type difference
 i4176-gadt.scala
 
diff --git a/library/src/scala/runtime/stdLibPatches/language.scala b/library/src/scala/runtime/stdLibPatches/language.scala
@@ -64,12 +64,14 @@ object language:
      *
      *  @see [[https://dotty.epfl.ch/docs/reference/experimental/purefuns]]
      */
+    @compileTimeOnly("`pureFunctions` can only be used at compile time in import statements")
     object pureFunctions
 
     /** Experimental support for capture checking; implies support for pureFunctions
      *
      *  @see [[https://dotty.epfl.ch/docs/reference/experimental/cc]]
      */
+    @compileTimeOnly("`captureChecking` can only be used at compile time in import statements")
     object captureChecking
   end experimental
 
diff --git a/tests/neg/cc-only-defs.scala b/tests/neg/cc-only-defs.scala
@@ -5,7 +5,7 @@ trait Test {
 
   val z: *.type // error
 
-  val b: ImpureFunction1[Int, Int] // error
+  val b: ImpureFunction1[Int, Int] // now OK
 
   val a: {z} String // error
 }  // error
diff --git a/tests/pos-custom-args/captures/caps-universal.scala b/tests/pos-custom-args/captures/caps-universal.scala
@@ -1,7 +1,7 @@
-import annotation.retainsUniversal
+import annotation.retains
 
 val foo: Int => Int = x => x
-val bar: (Int -> Int) @retainsUniversal = foo
+val bar: (Int -> Int) @retains(caps.*) = foo
 val baz: {*} Int -> Int = bar
 
 
diff --git a/tests/pos/boxmap-paper.scala b/tests/pos/boxmap-paper.scala
@@ -0,0 +1,38 @@
+import language.experimental.captureChecking
+
+type Cell[+T] = [K] -> (T => K) -> K
+
+def cell[T](x: T): Cell[T] =
+  [K] => (k: T => K) => k(x)
+
+def get[T](c: Cell[T]): T = c[T](identity)
+
+def map[A, B](c: Cell[A])(f: A => B): Cell[B]
+  = c[Cell[B]]((x: A) => cell(f(x)))
+
+def pureMap[A, B](c: Cell[A])(f: A -> B): Cell[B]
+  = c[Cell[B]]((x: A) => cell(f(x)))
+
+def lazyMap[A, B](c: Cell[A])(f: A => B): {f} () -> Cell[B]
+  = () => c[Cell[B]]((x: A) => cell(f(x)))
+
+trait IO:
+  def print(s: String): Unit
+
+def test(io: {*} IO) =
+
+  val loggedOne: {io} () -> Int = () => { io.print("1"); 1 }
+
+  val c: Cell[{io} () -> Int]
+      = cell[{io} () -> Int](loggedOne)
+
+  val g = (f: {io} () -> Int) =>
+    val x = f(); io.print(" + ")
+    val y = f(); io.print(s" = ${x + y}")
+
+  val r = lazyMap[{io} () -> Int, Unit](c)(f => g(f))
+  val r2 = lazyMap[{io} () -> Int, Unit](c)(g)
+  val r3 = lazyMap(c)(g)
+  val _ = r()
+  val _ = r2()
+  val _ = r3()
diff --git a/tests/pos/caps-universal.scala b/tests/pos/caps-universal.scala
@@ -0,0 +1,10 @@
+import language.experimental.pureFunctions
+import annotation.retains
+
+val id: Int -> Int = (x: Int) => x
+val foo: Int => Int = id
+val bar: (Int -> Int) @retains(caps.*) = foo
+
+
+
+

Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {`
`145`	`145`	`case Floating`
`146`	`146`	`}`
`147`	`147`
`148`		`- /** {x1, ..., xN} T (only relevant under -Ycc) */`
	`148`	`+ /** {x1, ..., xN} T (only relevant under captureChecking) */`
`149`	`149`	`case class CapturingTypeTree(refs: List[Tree], parent: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree`
`150`	`150`
`151`	`151`	`/** Short-lived usage in typer, does not need copy/transform/fold infrastructure */`
Original file line number	Diff line number	Diff line change
`@@ -209,8 +209,7 @@ object NameOps {`
`209`	`209`	`if str == mustHave then found = true`
`210`	`210`	`idx + str.length`
`211`	`211`	`else idx`
`212`		`- val start = if Feature.pureFunsEnabled then skip(0, "Impure") else 0`
`213`		`- skip(skip(start, "Erased"), "Context") == suffixStart`
	`212`	`+ skip(skip(skip(0, "Impure"), "Erased"), "Context") == suffixStart`
`214`	`213`	`&& found`
`215`	`214`	`}`
`216`	`215`
Original file line number	Diff line number	Diff line change
`@@ -64,12 +64,14 @@ object language:`
`64`	`64`	`*`
`65`	`65`	`* @see [[https://dotty.epfl.ch/docs/reference/experimental/purefuns]]`
`66`	`66`	`*/`
	`67`	+ @compileTimeOnly("`pureFunctions` can only be used at compile time in import statements")
`67`	`68`	`object pureFunctions`
`68`	`69`
`69`	`70`	`/** Experimental support for capture checking; implies support for pureFunctions`
`70`	`71`	`*`
`71`	`72`	`* @see [[https://dotty.epfl.ch/docs/reference/experimental/cc]]`
`72`	`73`	`*/`
	`74`	+ @compileTimeOnly("`captureChecking` can only be used at compile time in import statements")
`73`	`75`	`object captureChecking`
`74`	`76`	`end experimental`
`75`	`77`