Lower precedence of qualified types' with

Author: mbovel

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

@@ -1653,6 +1653,7 @@ object Parsers {
      *                   |  TypTypeParamClause ‘=>>’ Type
      *                   |  FunParamClause ‘=>>’ Type
      *                   |  MatchType
+     *                   |  QualifiedType2                              -- under qualifiedTypes
      *                   |  InfixType
      *  FunType        ::=  (MonoFunType | PolyFunType)
      *  MonoFunType    ::=  FunTypeArgs (‘=>’ | ‘?=>’) Type
@@ -1663,6 +1664,11 @@ object Parsers {
      *                   |  `(' [ FunArgType {`,' FunArgType } ] `)'
      *                   |  '(' [ TypedFunParam {',' TypedFunParam } ')'
      *  MatchType      ::=  InfixType `match` <<< TypeCaseClauses >>>
+     *  QualifiedType2 ::=  InfixType `with` PostfixExprf
+     *  IntoType       ::=  [‘into’] IntoTargetType
+     *                   |  ‘( IntoType ‘)’
+     *  IntoTargetType ::=  Type
+     *                   |  FunTypeArgs (‘=>’ | ‘?=>’) IntoType
      */
     def typ(inContextBound: Boolean = false): Tree =
       val start = in.offset
@@ -1722,6 +1728,8 @@ object Parsers {
           functionRest(t :: Nil)
         case MATCH =>
           matchType(t)
+        case WITH if in.featureEnabled(Feature.qualifiedTypes) =>
+          qualifiedTypeShort(t)
         case FORSOME =>
           syntaxError(ExistentialTypesNoLongerSupported())
           t
@@ -1856,6 +1864,7 @@ object Parsers {
     def funParamClauses(): List[List[ValDef]] =
       if in.token == LPAREN then funParamClause() :: funParamClauses() else Nil
 
+
     /** InfixType ::= RefinedType {id [nl] RefinedType}
      *             |  RefinedType `^`   -- under captureChecking
      */
@@ -1910,22 +1919,12 @@ object Parsers {
         t
     }
 
-    /** With qualifiedTypes enabled:
-      * WithType ::= AnnotType [`with' PostfixExpr]
-      *
-      * Otherwise:
-      * WithType ::= AnnotType {`with' AnnotType}    (deprecated)
-      */
+    /** WithType ::= AnnotType {`with' AnnotType}    (deprecated)
+     */
     def withType(): Tree = withTypeRest(annotType())
 
     def withTypeRest(t: Tree): Tree =
-      if in.featureEnabled(Feature.qualifiedTypes) && in.token == WITH then
-        if inQualifiedType then t
-        else
-          in.nextToken()
-          val qualifier = postfixExpr()
-          QualifiedTypeTree(t, None, qualifier).withSpan(Span(t.span.start, qualifier.span.end))
-      else if in.token == WITH then
+      if in.token == WITH && !in.featureEnabled(Feature.qualifiedTypes) then
         val withOffset = in.offset
         in.nextToken()
         if in.token == LBRACE || in.token == INDENT then
@@ -2268,6 +2267,17 @@ object Parsers {
       accept(RBRACE)
       QualifiedTypeTree(tp, Some(id), qualifier).withSpan(Span(startOffset, qualifier.span.end))
 
+    /** `with` PostfixExpr
+     */
+    def qualifiedTypeShort(t: Tree): Tree =
+      if inQualifiedType then
+        t
+      else
+        accept(WITH)
+        val qualifier = postfixExpr()
+        QualifiedTypeTree(t, None, qualifier).withSpan(Span(t.span.start, qualifier.span.end))
+
+
     /** TypeBounds ::= [`>:' TypeBound ] [`<:' TypeBound ]
      *  TypeBound  ::= Type
      *               | CaptureSet -- under captureChecking
@@ -2344,7 +2354,12 @@ object Parsers {
 
     def typeDependingOn(location: Location): Tree =
       if location.inParens then typ()
-      else if location.inPattern then rejectWildcardType(refinedType())
+      else if location.inPattern then
+        val t = rejectWildcardType(refinedType())
+        if in.featureEnabled(Feature.qualifiedTypes) && in.token == WITH then
+          qualifiedTypeShort(t)
+        else
+          t
       else infixType()
 
 /* ----------- EXPRESSIONS ------------------------------------------------ */
@@ -3253,10 +3268,11 @@ object Parsers {
       if (isIdent(nme.raw.BAR)) { in.nextToken(); pattern1(location) :: patternAlts(location) }
       else Nil
 
-    /**  Pattern1     ::= PatVar `:` RefinedType
-     *                  | [‘-’] integerLiteral `:` RefinedType
-     *                  | [‘-’] floatingPointLiteral `:` RefinedType
-     *                  | Pattern2
+    /**  Pattern1       ::= PatVar `:` QualifiedType3
+     *                    | [‘-’] integerLiteral `:` QualifiedType3
+     *                    | [‘-’] floatingPointLiteral `:` QualifiedType3
+     *                    | Pattern2
+     *   QualifiedType3 ::= RefinedType [`with` PostfixExpr]
      */
     def pattern1(location: Location = Location.InPattern): Tree =
       val p = pattern2(location)

tests/printing/qualified-types.check

@@ -60,10 +60,13 @@ package example {
             Int @qualified[Int]((x3: Int) => x3 < 10)
          = ???
         val x4:
-          Int @qualified[Int]((x4: Int) => x4 > 0) &
-            Int @qualified[Int]((x4: Int) => x4 < 10)
+          (Int @qualified[Int]((x4: Int) => x4 > 0) & Int) @qualified[
+            Int @qualified[Int]((x4: Int) => x4 > 0) & Int]((
+            x4: Int @qualified[Int]((x4: Int) => x4 > 0) & Int) => x4 < 10)
          = ???
-        val x5: Int & String @qualified[String]((x5: String) => false) = ???
+        val x5:
+          (Int & String) @qualified[Int & String]((x5: Int & String) => false)
+           = ???
         val x6:
           (Int @qualified[Int]((x6: Int) => x6 > 0) & Int) @qualified[
             Int @qualified[Int]((x6: Int) => x6 > 0) & Int]((