Allow paper syntax to parse capturing types

# Conflicts:
#	compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
#	compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
#	compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
#	tests/pos-custom-args/captures/boxmap.scala
#	tests/pos-custom-args/captures/cc-expand.scala

Author: odersky

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

@@ -476,6 +476,7 @@ class Definitions {
     @tu lazy val Predef_identity : Symbol = ScalaPredefModule.requiredMethod(nme.identity)
     @tu lazy val Predef_undefined: Symbol = ScalaPredefModule.requiredMethod(nme.???)
     @tu lazy val Predef_retainsType: Symbol = ScalaPredefModule.requiredType(tpnme.retains)
+    @tu lazy val Predef_capturing: Symbol = ScalaPredefModule.requiredType(tpnme.CAPTURING)
   @tu lazy val ScalaPredefModuleClass: ClassSymbol = ScalaPredefModule.moduleClass.asClass
 
   @tu lazy val SubTypeClass: ClassSymbol = requiredClass("scala.<:<")

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

@@ -119,6 +119,7 @@ object StdNames {
     val BITMAP_TRANSIENT: N           = s"${BITMAP_PREFIX}trans$$"    // initialization bitmap for transient lazy vals
     val BITMAP_CHECKINIT: N           = s"${BITMAP_PREFIX}init$$"      // initialization bitmap for checkinit values
     val BITMAP_CHECKINIT_TRANSIENT: N = s"${BITMAP_PREFIX}inittrans$$" // initialization bitmap for transient checkinit values
+    val CAPTURING                     = "|>"
     val DEFAULT_GETTER: N             = str.DEFAULT_GETTER
     val DEFAULT_GETTER_INIT: N        = "$lessinit$greater"
     val DO_WHILE_PREFIX: N            = "doWhile$"

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

@@ -361,7 +361,8 @@ class TreeUnpickler(reader: TastyReader,
               val args = until(end)(readType())
               tycon match
                 case tycon: TypeRef if tycon.symbol == defn.Predef_retainsType =>
-                  CapturingType(args(0), CaptureSet.fromRetainsTypeArg(args(1)))
+                  if ctx.settings.Ycc.value then CapturingType(args(0), CaptureSet.fromRetainsTypeArg(args(1)))
+                  else args(0)
                 case _ =>
                   tycon.appliedTo(args)
             case TYPEBOUNDS =>

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

@@ -890,6 +890,24 @@ object Parsers {
            }
       }
 
+    def followingIsCaptureSet(): Boolean =
+      val lookahead = in.LookaheadScanner()
+      def recur(): Boolean =
+        lookahead.isIdent && {
+          lookahead.nextToken()
+          if lookahead.token == COMMA then
+            lookahead.nextToken()
+            recur()
+          else
+            lookahead.token == RBRACE && {
+              lookahead.nextToken()
+              canStartInfixTypeTokens.contains(lookahead.token)
+              || lookahead.token == LBRACKET
+            }
+        }
+      lookahead.nextToken()
+      recur()
+
   /* --------- OPERAND/OPERATOR STACK --------------------------------------- */
 
     var opStack: List[OpInfo] = Nil
@@ -1329,17 +1347,27 @@ object Parsers {
       case _ => false
     }
 
+    def captureRef(): Tree =
+      atSpan(in.offset) {
+        val name = ident()
+        if name.isVarPattern then SingletonTypeTree(Ident(name))
+        else Ident(name.toTypeName)
+      }
+
     /** Type           ::=  FunType
      *                   |  HkTypeParamClause ‘=>>’ Type
      *                   |  FunParamClause ‘=>>’ Type
      *                   |  MatchType
      *                   |  InfixType
+     *                   |  CaptureSet Type
      *  FunType        ::=  (MonoFunType | PolyFunType)
      *  MonoFunType    ::=  FunTypeArgs (‘=>’ | ‘?=>’) Type
      *  PolyFunType    ::=  HKTypeParamClause '=>' Type
      *  FunTypeArgs    ::=  InfixType
      *                   |  `(' [ [ ‘[using]’ ‘['erased']  FunArgType {`,' FunArgType } ] `)'
      *                   |  '(' [ ‘[using]’ ‘['erased'] TypedFunParam {',' TypedFunParam } ')'
+     *  CaptureSet     ::=  `{` CaptureRef {`,` CaptureRef} `}`
+     *  CaptureRef     ::=  Ident
      */
     def typ(): Tree = {
       val start = in.offset
@@ -1445,6 +1473,11 @@ object Parsers {
           }
           else { accept(TLARROW); typ() }
         }
+        else if in.token == LBRACE && followingIsCaptureSet() then
+          val refs = inBraces { commaSeparated(captureRef) }
+          val t = typ()
+          val captured = refs.reduce(InfixOp(_, Ident(tpnme.raw.BAR), _))
+          AppliedTypeTree(TypeTree(defn.Predef_capturing.typeRef), captured :: t :: Nil)
         else if (in.token == INDENT) enclosed(INDENT, typ())
         else infixType()
 
@@ -1513,7 +1546,7 @@ object Parsers {
     def infixType(): Tree = infixTypeRest(refinedType())
 
     def infixTypeRest(t: Tree): Tree =
-      infixOps(t, canStartTypeTokens, refinedTypeFn, Location.ElseWhere,
+      infixOps(t, canStartInfixTypeTokens, refinedTypeFn, Location.ElseWhere,
         isType = true,
         isOperator = !followingIsVararg())
 
@@ -3154,7 +3187,7 @@ object Parsers {
         ImportSelector(
           atSpan(in.skipToken()) { Ident(nme.EMPTY) },
           bound =
-            if canStartTypeTokens.contains(in.token) then rejectWildcardType(infixType())
+            if canStartInfixTypeTokens.contains(in.token) then rejectWildcardType(infixType())
             else EmptyTree)
 
       /** id [‘as’ (id | ‘_’) */

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

@@ -230,8 +230,8 @@ object Tokens extends TokensCommon {
 
   final val canStartExprTokens2: TokenSet = canStartExprTokens3 | BitSet(DO)
 
-  final val canStartTypeTokens: TokenSet = literalTokens | identifierTokens | BitSet(
-    THIS, SUPER, USCORE, LPAREN, AT)
+  final val canStartInfixTypeTokens: TokenSet = literalTokens | identifierTokens | BitSet(
+    THIS, SUPER, USCORE, LPAREN, LBRACE, AT)
 
   final val templateIntroTokens: TokenSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
 

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

@@ -191,9 +191,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case CapturingType(parent, refs) =>
         if refs.isConst then
           if Config.printCaptureSetsAsPrefix then
-            changePrec(GlobalPrec)("{" ~ toTextCaptureRef(ref) ~ "} " ~ toText(parent))
+            changePrec(GlobalPrec)("{" ~ Text(refs.elems.toList.map(toTextCaptureRef), ", ") ~ "} " ~ toText(parent))
           else
-            changePrec(InfixPrec)(toText(parent) ~ " retains " ~ toTextCaptureRef(ref))
+            changePrec(InfixPrec)(toText(parent) ~ " retains " ~ toText(refs.toRetainsTypeArg))
         else
           s"$refs " ~ toText(parent) // ^^^ improve
       case tp: PreviousErrorType if ctx.settings.XprintTypes.value =>
@@ -283,7 +283,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   /** If -uniqid is set, the unique id of symbol, after a # */
   protected def idString(sym: Symbol): String =
-    if (showUniqueIds || Printer.debugPrintUnique) "#" + sym.id else ""
+    if showUniqueIds then "#" + sym.id else ""
 
   def nameString(sym: Symbol): String =
     simpleNameString(sym) + idString(sym) // + "<" + (if (sym.exists) sym.owner else "") + ">"
@@ -323,7 +323,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case tp @ ConstantType(value) =>
         toText(value)
       case pref: TermParamRef =>
-        nameString(pref.binder.paramNames(pref.paramNum))
+        nameString(pref.binder.paramNames(pref.paramNum)) ~ lambdaHash(pref.binder)
       case tp: RecThis =>
         val idx = openRecs.reverse.indexOf(tp.binder)
         if (idx >= 0) selfRecName(idx + 1)

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

@@ -532,6 +532,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           changePrec(OrTypePrec) { toText(args(0)) ~ " | " ~ atPrec(OrTypePrec + 1) { toText(args(1)) } }
         else if (tpt.symbol == defn.andType && args.length == 2)
           changePrec(AndTypePrec) { toText(args(0)) ~ " & " ~ atPrec(AndTypePrec + 1) { toText(args(1)) } }
+        else if tpt.symbol == defn.Predef_retainsType && args.length == 2 then
+          changePrec(InfixPrec) { toText(args(0)) ~ " retains " ~ toText(args(1)) }
+        else if tpt.symbol == defn.Predef_capturing && args.length == 2 then
+          changePrec(GlobalPrec) { "{" ~ toText(args(0)) ~ "}" ~ toText(args(1)) }
         else if defn.isFunctionClass(tpt.symbol)
             && tpt.isInstanceOf[TypeTree] && tree.hasType && !printDebug
         then changePrec(GlobalPrec) { toText(tree.typeOpt) }

compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -218,6 +218,10 @@ trait TypeAssigner {
           if ctx.settings.Ycc.value
           then CapturingType(args(0), include(CaptureSet.empty, args(1)))
           else args(0)
+        else if constr == defn.Predef_capturing then
+          if ctx.settings.Ycc.value
+          then CapturingType(args(1), include(CaptureSet.empty, args(0)))
+          else args(1)
         else tp
       case _ => tp
   end processAppliedType

library/src/scala/runtime/stdLibPatches/Predef.scala

@@ -51,4 +51,6 @@ object Predef:
   /** type `A` with capture set `B` */
   infix type retains[A, B]
 
+  /** An alternative notation for capturing types. TODO: needed? Or maybe mangle the name? */
+  infix type |> [A, B]
 end Predef

tests/pos-custom-args/captures/cc-expand.scala

@@ -0,0 +1,21 @@
+object Test:
+
+  class A
+  class B
+  class C
+  class CTC
+  type CT = CTC retains *
+
+  def test(ct: CT, dt: CT) =
+
+    def x0: A => {ct} B = ???
+
+    def x1: A => B retains ct.type = ???
+    def x2: A => B => C retains ct.type = ???
+    def x3: A => () => B => C retains ct.type = ???
+
+    def x4: (x: A retains ct.type) => B => C = ???
+
+    def x5: A => (x: B retains ct.type) => () => C retains dt.type = ???
+    def x6: A => (x: B retains ct.type) => (() => C retains dt.type) retains x.type | dt.type = ???
+    def x7: A => (x: B retains ct.type) => (() => C retains dt.type) retains x.type = ???