Allow with in refinements

Author: odersky

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

@@ -1566,33 +1566,32 @@ object Parsers {
     def infixTypeRest(t: Tree): Tree =
       infixOps(t, canStartTypeTokens, refinedType, isType = true, isOperator = !isPostfixStar)
 
-    /** RefinedType   ::=  WithType {[nl] Refinement}
+    /** RefinedType   ::=  WithType {[nl | ‘with’] Refinement}
      */
     val refinedType: () => Tree = () => refinedTypeRest(withType())
 
-    def refinedTypeRest(t: Tree): Tree = {
+    def refinedTypeRest(t: Tree): Tree =
       argumentStart()
-      if (in.isNestedStart)
+      if isTemplateBodyStart then
+        if in.token == WITH then in.nextToken()
         refinedTypeRest(atSpan(startOffset(t)) {
           RefinedTypeTree(rejectWildcardType(t), refinement(indentOK = true))
         })
       else t
-    }
 
     /** WithType ::= AnnotType {`with' AnnotType}    (deprecated)
      */
     def withType(): Tree = withTypeRest(annotType())
 
     def withTypeRest(t: Tree): Tree =
-      if in.token == WITH then
-        val withOffset = in.offset
+      def isRefinementStart =
+        val la = in.lookahead
+        la.isAfterLineEnd || la.token == LBRACE
+      if in.token == WITH && !isRefinementStart then
         in.nextToken()
-        if in.token == LBRACE || in.token == INDENT then
-          t
-        else
-          if sourceVersion.isAtLeast(`3.1`) then
-            deprecationWarning(DeprecatedWithOperator(), withOffset)
-          atSpan(startOffset(t)) { makeAndType(t, withType()) }
+        if sourceVersion.isAtLeast(`3.1`) then
+          deprecationWarning(DeprecatedWithOperator())
+        atSpan(startOffset(t)) { makeAndType(t, withType()) }
       else t
 
     /** AnnotType ::= SimpleType {Annotation}

tests/pos/abstract-givens.scala

@@ -0,0 +1,9 @@
+class C { type T }
+trait A with
+  given C with {}   // concrete
+  given c0: C {}    // concrete
+  given c1: C {}    // concrete
+  given c2: (C {type T <: Int})  // abstract with refinement
+
+object B extends A with
+  override given c2: C with { type T = Int }

tests/pos/refinements.scala

@@ -10,6 +10,10 @@ trait UU {
   type UX
   val u: UX
   val x: this.type & { type UX = Int }
+  val x1: this.type { type UX = Int }
+  val x2: this.type with { type UX = Int }
+  val x3: this.type with
+    type UX = Int
   val y: Int = x.u
   val z: x.UX = y
 }