Refactor: distinguish type- and term- level priority

Encapsulate the precedence rules in `parsing.precedence` while allowing for
different precedence between term- and type-level operators, as mandated by the
spec.

This is just a refactoring, the actual priority changes are separate.

* Add an `isType` flag to `parsing.precedence` and add
  constants for `AndTypePrec` and `OrTypePrec` (distinct from `OrPrec` and
  `AndPrec`, which is now unused and dropped).
* In the parser, consider `isType` to decide priority.
* In the pretty-printer, use `AndTypePrec` and `OrTypePrec` where appropriate.

Author: Blaisorblade

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

@@ -471,13 +471,13 @@ object Parsers {
         syntaxError(MixedLeftAndRightAssociativeOps(op1, op2, op2LeftAssoc), offset)
 
     def reduceStack(base: List[OpInfo], top: Tree, prec: Int, leftAssoc: Boolean, op2: Name, isType: Boolean): Tree = {
-      if (opStack != base && precedence(opStack.head.operator.name) == prec)
+      if (opStack != base && precedence(opStack.head.operator.name, isType) == prec)
         checkAssoc(opStack.head.offset, opStack.head.operator.name, op2, leftAssoc)
       def recur(top: Tree): Tree = {
         if (opStack == base) top
         else {
           val opInfo = opStack.head
-          val opPrec = precedence(opInfo.operator.name)
+          val opPrec = precedence(opInfo.operator.name, isType)
           if (prec < opPrec || leftAssoc && prec == opPrec) {
             opStack = opStack.tail
             recur {
@@ -514,7 +514,7 @@ object Parsers {
       var top = first
       while (isIdent && isOperator) {
         val op = if (isType) typeIdent() else termIdent()
-        top = reduceStack(base, top, precedence(op.name), isLeftAssoc(op.name), op.name, isType)
+        top = reduceStack(base, top, precedence(op.name, isType), isLeftAssoc(op.name), op.name, isType)
         opStack = OpInfo(top, op, in.offset) :: opStack
         newLineOptWhenFollowing(canStartOperand)
         if (maybePostfix && !canStartOperand(in.token)) {

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

@@ -7,7 +7,7 @@ import core.NameOps._
 
 package object parsing {
 
-  def precedence(operator: Name): Int =
+  def precedence(operator: Name, isType: Boolean = false): Int =
     if (operator eq nme.ERROR) -1
     else {
       val firstCh = operator.firstPart.head

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

@@ -161,9 +161,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
         }
         finally openRecs = openRecs.tail
       case AndType(tp1, tp2) =>
-        changePrec(AndPrec) { toText(tp1) ~ " & " ~ toText(tp2) }
+        changePrec(AndTypePrec) { toText(tp1) ~ " & " ~ toText(tp2) }
       case OrType(tp1, tp2) =>
-        changePrec(OrPrec) { toText(tp1) ~ " | " ~ toText(tp2) }
+        changePrec(OrTypePrec) { toText(tp1) ~ " | " ~ toText(tp2) }
       case tp: ErrorType =>
         s"<error ${tp.msg.msg}>"
       case tp: WildcardType =>

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

@@ -375,9 +375,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case SingletonTypeTree(ref) =>
         toTextLocal(ref) ~ "." ~ keywordStr("type")
       case AndTypeTree(l, r) =>
-        changePrec(AndPrec) { toText(l) ~ " & " ~ toText(r) }
+        changePrec(AndTypePrec) { toText(l) ~ " & " ~ toText(r) }
       case OrTypeTree(l, r) =>
-        changePrec(OrPrec) { toText(l) ~ " | " ~ toText(r) }
+        changePrec(OrTypePrec) { toText(l) ~ " | " ~ toText(r) }
       case RefinedTypeTree(tpt, refines) =>
         toTextLocal(tpt) ~ " " ~ blockText(refines)
       case AppliedTypeTree(tpt, args) =>

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

@@ -1,6 +1,6 @@
 package dotty.tools.dotc
 
-import core.StdNames.nme
+import core.StdNames.{nme,tpnme}
 import parsing.{precedence, minPrec, maxPrec, minInfixPrec}
 import util.Property.Key
 
@@ -9,7 +9,8 @@ package object printing {
   type Precedence = Int
 
   val DotPrec       = parsing.maxPrec
-  val AndPrec       = parsing.precedence(nme.raw.AMP)
+  val AndTypePrec   = parsing.precedence(tpnme.raw.AMP, true)
+  val OrTypePrec    = parsing.precedence(tpnme.raw.BAR, true)
   val OrPrec        = parsing.precedence(nme.raw.BAR)
   val InfixPrec     = parsing.minInfixPrec
   val GlobalPrec    = parsing.minPrec