TokenRange: use FormatToken instead of Token

scalafmt-core/shared/src/main/scala/org/scalafmt/internal/FormatOps.scala

@@ -170,9 +170,9 @@ class FormatOps(
     optimizationEntities.statementStarts.get(meta.idx + 1),
   )
 
-  def parensTuple(token: T): TokenRanges = matchingOpt(token)
-    .fold(TokenRanges.empty)(other => TokenRanges(TokenRange(token, other.left)))
-  def parensTuple(tree: Tree): TokenRanges = parensTuple(getLast(tree).left)
+  def parensTuple(ft: FormatToken): TokenRanges = matchingOpt(ft.left)
+    .fold(TokenRanges.empty)(other => TokenRanges(TokenRange(ft, other)))
+  def parensTuple(tree: Tree): TokenRanges = parensTuple(getLast(tree))
 
   def insideBlock[A](start: FormatToken, end: T)(implicit
       classifier: Classifier[T, A],
@@ -198,11 +198,9 @@ class FormatOps(
     @tailrec
     def run(tok: FormatToken): Unit = if (tok.left.start < end.start) {
       val nextTokOpt = matches(tok).flatMap { closeFt =>
-        val open = tok.left
-        val close = closeFt.left
-        if (open.start >= close.end) None
+        if (tok.left.start >= closeFt.left.end) None
         else {
-          result = result.append(TokenRange(open, close))
+          result = result.append(TokenRange(tok, closeFt))
           Some(closeFt)
         }
       }
@@ -1569,8 +1567,7 @@ class FormatOps(
             _: Term.NewAnonymous => getSplits(getSpaceSplit(1))
         case t: Term.ForYield => getDelimsIfEnclosed(t.enumsBlock) match {
             case Some((forEnumHead, forEnumLast)) =>
-              val exclude =
-                TokenRanges(TokenRange(forEnumHead.left, forEnumLast.left))
+              val exclude = TokenRanges(TokenRange(forEnumHead, forEnumLast))
               val afterYield = (t.body match {
                 case b: Term.Block => getHeadAndLastIfEnclosed(b)
                     .map { case (forBodyHead, forBodyLastOpt) =>

scalafmt-core/shared/src/main/scala/org/scalafmt/internal/Router.scala

@@ -1029,7 +1029,8 @@ class Router(formatOps: FormatOps) {
               singleArgument && isTreeEndingInArgumentClause(onlyArgument)
             }
           )
-            if (onlyArgument eq leftOwner) TokenRanges(TokenRange(open, close))
+            if (onlyArgument eq leftOwner)
+              TokenRanges(TokenRange(ft, afterClose))
             else parensTuple(onlyArgument)
           else insideBracesBlock(ft, close)
 
@@ -1103,7 +1104,7 @@ class Router(formatOps: FormatOps) {
                   needDifferentFromOneArgPerLine
                 val noOptimal = style.newlines.keep && !useOneArgPerLineSplit ||
                   singleArgument && !excludeBlocks.isEmpty &&
-                  excludeBlocks.ranges.forall(_.lt.is[T.LeftParen])
+                  excludeBlocks.ranges.forall(_.lt.left.is[T.LeftParen])
                 val okIndent = rightIsComment || handleImplicit
                 Split(noSplitMod, 0, policy = noSplitPolicy).withOptimalToken(
                   optimal,

scalafmt-core/shared/src/main/scala/org/scalafmt/internal/TokenRange.scala

@@ -2,9 +2,9 @@ package org.scalafmt.internal
 
 import scala.meta.tokens.Token
 
-class TokenRange private (val lt: Token, val rt: Token) {
+class TokenRange private (val lt: FormatToken, val rt: FormatToken) {
 
-  def validateAfter(other: TokenRange): Unit = require(lt.start >= other.rt.end)
+  def validateAfter(other: TokenRange): Unit = require(lt.idx > other.rt.idx)
 
 }
 
@@ -20,13 +20,13 @@ class TokenRanges private (val ranges: Seq[TokenRange]) extends AnyVal {
     new TokenRanges(range +: ranges)
   }
 
-  def startOfFirstRange(): Option[Token] = ranges.lastOption.map(_.lt)
+  def startOfFirstRange(): Option[Token] = ranges.lastOption.map(_.lt.left)
 }
 
 object TokenRange {
 
-  def apply(lt: Token, rt: Token): TokenRange =
-    if (lt.start < rt.start) new TokenRange(lt, rt) else new TokenRange(rt, lt)
+  def apply(lt: FormatToken, rt: FormatToken): TokenRange =
+    if (lt.idx < rt.idx) new TokenRange(lt, rt) else new TokenRange(rt, lt)
 
 }
 

scalafmt-core/shared/src/main/scala/org/scalafmt/util/PolicyOps.scala

@@ -155,7 +155,7 @@ object PolicyOps {
       endRt: T => Policy.End.WithPos,
   )(lastPolicy: Policy)(implicit fileLine: FileLine): Policy = exclude.ranges
     .foldLeft(lastPolicy) { case (policy, range) =>
-      (lastPolicy <== endLt(range.lt)) ==> (endRt(range.rt) ==> policy)
+      (lastPolicy <== endLt(range.lt.left)) ==> (endRt(range.rt.left) ==> policy)
     }
 
   def delayedBreakPolicy(
@@ -228,17 +228,18 @@ object PolicyOps {
   def unindentAtExclude(exclude: TokenRanges, indent: Length): Policy = exclude
     .ranges.foldLeft(Policy.noPolicy) { case (policy, range) =>
       val (lt, rt) = (range.lt, range.rt)
-      val trigger = rt
-      val unindent = Indent(indent, rt, ExpiresOn.After)
+      val ltl = lt.left
+      val rtl = rt.left
+      val trigger = rtl
+      val unindent = Indent(indent, rtl, ExpiresOn.After)
       val triggeredIndent = Indent.before(unindent, trigger)
-      val triggerUnindent = Policy.on(rt, prefix = "UNIND{") {
-        case Decision(FormatToken(`lt`, _, _), s) => s
-            .map(_.withIndent(triggeredIndent))
-      }
-      val cancelUnindent = delayedBreakPolicy(Policy.End == lt) {
-        Policy.after(lt, rank = 1, prefix = "UNIND}") { // use rank to apply after policy above
-          case Decision(FormatToken(`lt`, _, _), s) => s
-              .map(_.switch(trigger, false))
+      val triggerUnindent = Policy
+        .on(rtl, prefix = "UNIND{") { case Decision(`lt`, s) =>
+          s.map(_.withIndent(triggeredIndent))
+        }
+      val cancelUnindent = delayedBreakPolicy(Policy.End == ltl) {
+        Policy.after(ltl, rank = 1, prefix = "UNIND}") { // use rank to apply after policy above
+          case Decision(`lt`, s) => s.map(_.switch(trigger, false))
         }
       }
       policy ==> triggerUnindent & cancelUnindent