Drop TreeInfo.isLeftAssoc

Use NameOps#isRightAssocOperatorName instead

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -899,7 +899,7 @@ object desugar {
           name = mdef.name.toExtensionName,
           tparams = ext.tparams ++ mdef.tparams,
           vparamss = mdef.vparamss match
-            case vparams1 :: vparamss1 if !isLeftAssoc(mdef.name) =>
+            case vparams1 :: vparamss1 if mdef.name.isRightAssocOperatorName =>
               vparams1 :: ext.vparamss ::: vparamss1
             case _ =>
               ext.vparamss ++ mdef.vparamss
@@ -1204,10 +1204,10 @@ object desugar {
         case _ =>
           Apply(sel, arg :: Nil)
 
-    if (isLeftAssoc(op.name))
-      makeOp(left, right, Span(left.span.start, op.span.end, op.span.start))
-    else
+    if op.name.isRightAssocOperatorName then
       makeOp(right, left, Span(op.span.start, right.span.end))
+    else
+      makeOp(left, right, Span(left.span.start, op.span.end, op.span.start))
   }
 
   /** Translate tuple expressions of arity <= 22

compiler/src/dotty/tools/dotc/ast/Positioned.scala

@@ -208,7 +208,7 @@ abstract class Positioned(implicit @constructorOnly src: SourceFile) extends Src
         check(tree.vparamss)
       case tree: DefDef if tree.mods.is(ExtensionMethod) =>
         tree.vparamss match {
-          case vparams1 :: vparams2 :: rest if !isLeftAssoc(tree.name) =>
+          case vparams1 :: vparams2 :: rest if tree.name.isRightAssocOperatorName =>
             check(tree.tparams)
             check(vparams2)
             check(vparams1)

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -185,9 +185,6 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case _ => false
   }
 
-  /** Is name a left-associative operator? */
-  def isLeftAssoc(operator: Name): Boolean = !operator.isEmpty && (operator.toSimpleName.last != ':')
-
   /** Is this argument node of the form <expr> : _*, or is it a reference to
    *  such an argument ? The latter case can happen when an argument is lifted.
    */

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

@@ -927,7 +927,7 @@ object Parsers {
     var opStack: List[OpInfo] = Nil
 
     def checkAssoc(offset: Token, op1: Name, op2: Name, op2LeftAssoc: Boolean): Unit =
-      if (isLeftAssoc(op1) != op2LeftAssoc)
+      if (op1.isRightAssocOperatorName == op2LeftAssoc)
         syntaxError(MixedLeftAndRightAssociativeOps(op1, op2, op2LeftAssoc), offset)
 
     def reduceStack(base: List[OpInfo], top: Tree, prec: Int, leftAssoc: Boolean, op2: Name, isType: Boolean): Tree = {
@@ -967,7 +967,7 @@ object Parsers {
       def recur(top: Tree): Tree =
         if (isIdent && isOperator) {
           val op = if (isType) typeIdent() else termIdent()
-          val top1 = reduceStack(base, top, precedence(op.name), isLeftAssoc(op.name), op.name, isType)
+          val top1 = reduceStack(base, top, precedence(op.name), !op.name.isRightAssocOperatorName, op.name, isType)
           opStack = OpInfo(top1, op, in.offset) :: opStack
           colonAtEOLOpt()
           newLineOptWhenFollowing(canStartOperand)
@@ -3316,7 +3316,7 @@ object Parsers {
             typeParamClause(ParamOwner.Def)
           else leadingTparams
         val vparamss = paramClauses() match
-          case rparams :: rparamss if leadingVparamss.nonEmpty && !isLeftAssoc(ident.name) =>
+          case rparams :: rparamss if leadingVparamss.nonEmpty && ident.name.isRightAssocOperatorName =>
             rparams :: leadingVparamss ::: rparamss
           case rparamss =>
             leadingVparamss ::: rparamss

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

@@ -795,7 +795,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         val (prefix, vparamss) =
           if isExtension then
             val (leadingParams, otherParamss) = (tree.vparamss: @unchecked) match
-              case vparams1 :: vparams2 :: rest if !isLeftAssoc(tree.name) =>
+              case vparams1 :: vparams2 :: rest if tree.name.isRightAssocOperatorName =>
                 (vparams2, vparams1 :: rest)
               case vparams1 :: rest =>
                 (vparams1, rest)

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

@@ -1620,7 +1620,7 @@ class RefChecks extends MiniPhase { thisPhase =>
     private def checkByNameRightAssociativeDef(tree: DefDef) {
       tree match {
         case DefDef(_, name, _, params :: _, _, _) =>
-          if (settings.lint && !treeInfo.isLeftAssoc(name.decodedName) && params.exists(p => isByName(p.symbol)))
+          if (settings.lint && name.decodedName.isRightAssocOperatorName && params.exists(p => isByName(p.symbol)))
             unit.warning(tree.pos,
               "by-name parameters will be evaluated eagerly when called as a right-associative infix operator. For more details, see SI-1980.")
         case _ =>

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

@@ -446,7 +446,7 @@ class Typer extends Namer
     // cyclic references.
     if (name == nme.ROOTPKG)
       return tree.withType(defn.RootPackage.termRef)
-      
+
     val rawType = {
       val saved1 = unimported
       val saved2 = foundUnderScala2
@@ -2342,20 +2342,18 @@ class Typer extends Namer
         typedUnApply(cpy.Apply(tree)(op, l :: r :: Nil), pt)
       else {
         val app = typedApply(desugar.binop(l, op, r), pt)
-        if (untpd.isLeftAssoc(op.name)) app
-        else {
+        if op.name.isRightAssocOperatorName then
           val defs = new mutable.ListBuffer[Tree]
-          def lift(app: Tree): Tree = (app: @unchecked) match {
+          def lift(app: Tree): Tree = (app: @unchecked) match
             case Apply(fn, args) =>
               if (app.tpe.isError) app
               else tpd.cpy.Apply(app)(fn, LiftImpure.liftArgs(defs, fn.tpe, args))
             case Assign(lhs, rhs) =>
               tpd.cpy.Assign(app)(lhs, lift(rhs))
             case Block(stats, expr) =>
               tpd.cpy.Block(app)(stats, lift(expr))
-          }
           wrapDefs(defs, lift(app))
-        }
+        else app
       }
     checkValidInfix(tree, result.symbol)
     result