From 342ffa6f65ce3e1420599a8fa97aff5f678679e0 Mon Sep 17 00:00:00 2001
From: Albert Meltzer <7529386+kitbellew@users.noreply.github.com>
Date: Fri, 15 Mar 2024 10:32:53 -0700
Subject: [PATCH] FormatTokens: import TokenOps._

---
 .../org/scalafmt/internal/FormatTokens.scala  | 30 ++++++++++---------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/scalafmt-core/shared/src/main/scala/org/scalafmt/internal/FormatTokens.scala b/scalafmt-core/shared/src/main/scala/org/scalafmt/internal/FormatTokens.scala
index d75eb2b41d..decdc7ba5d 100644
--- a/scalafmt-core/shared/src/main/scala/org/scalafmt/internal/FormatTokens.scala
+++ b/scalafmt-core/shared/src/main/scala/org/scalafmt/internal/FormatTokens.scala
@@ -9,19 +9,21 @@ import org.scalafmt.config.ScalafmtConfig
 import org.scalafmt.rewrite.FormatTokensRewrite
 import org.scalafmt.util._
 
-class FormatTokens(leftTok2tok: Map[TokenOps.TokenHash, Int])(
+import TokenOps._
+
+class FormatTokens(leftTok2tok: Map[TokenHash, Int])(
     val arr: Array[FormatToken]
 ) extends IndexedSeq[FormatToken] {
 
   private def this(arr: Array[FormatToken]) = this {
-    val result = Map.newBuilder[TokenOps.TokenHash, Int]
+    val result = Map.newBuilder[TokenHash, Int]
     result.sizeHint(arr.length)
     arr.foreach(t => result += FormatTokens.thash(t.left) -> t.meta.idx)
     result += FormatTokens.thash(arr.last.right) -> arr.last.meta.idx
     result.result()
   }(arr)
 
-  private lazy val matchingParentheses: Map[TokenOps.TokenHash, Token] =
+  private lazy val matchingParentheses: Map[TokenHash, Token] =
     TreeOps.getMatchingParentheses(arr.view.map(_.right))
 
   override def length: Int = arr.length
@@ -71,15 +73,15 @@ class FormatTokens(leftTok2tok: Map[TokenOps.TokenHash, Int])(
 
   @inline def matching(token: Token): Token =
     matchingParentheses.getOrElse(
-      TokenOps.hash(token),
+      FormatTokens.thash(token),
       throw new NoSuchElementException(
         s"Missing matching token index [${token.start}:${token.end}]: `$token`"
       )
     )
   @inline def matchingOpt(token: Token): Option[Token] =
-    matchingParentheses.get(TokenOps.hash(token))
+    matchingParentheses.get(FormatTokens.thash(token))
   @inline def hasMatching(token: Token): Boolean =
-    matchingParentheses.contains(TokenOps.hash(token))
+    matchingParentheses.contains(FormatTokens.thash(token))
   @inline def areMatching(t1: Token)(t2: => Token): Boolean =
     matchingOpt(t1) match {
       case Some(x) => x eq t2
@@ -212,28 +214,28 @@ class FormatTokens(leftTok2tok: Map[TokenOps.TokenHash, Int])(
     getHeadOpt(tree.tokens, tree)
 
   private def getLast(tokens: Tokens): FormatToken =
-    apply(TokenOps.findLastVisibleToken(tokens))
+    apply(findLastVisibleToken(tokens))
   def getLast(tokens: Tokens, tree: Tree): FormatToken =
     getOnOrAfterOwned(getLast(tokens), tree)
   @inline def getLast(tree: Tree): FormatToken =
     getLast(tree.tokens, tree)
 
   private def getLastOpt(tokens: Tokens): Option[FormatToken] =
-    TokenOps.findLastVisibleTokenOpt(tokens).map(apply)
+    findLastVisibleTokenOpt(tokens).map(apply)
   def getLastOpt(tokens: Tokens, tree: Tree): Option[FormatToken] =
     getLastOpt(tokens).map(getOnOrAfterOwned(_, tree))
   @inline def getLastOpt(tree: Tree): Option[FormatToken] =
     getLastOpt(tree.tokens, tree)
 
   private def getLastNonTrivial(tokens: Tokens): FormatToken =
-    apply(TokenOps.findLastNonTrivialToken(tokens))
+    apply(findLastNonTrivialToken(tokens))
   def getLastNonTrivial(tokens: Tokens, tree: Tree): FormatToken =
     getOnOrAfterOwned(getLastNonTrivial(tokens), tree)
   def getLastNonTrivial(tree: Tree): FormatToken =
     getLastNonTrivial(tree.tokens, tree)
 
   private def getLastNonTrivialOpt(tokens: Tokens): Option[FormatToken] =
-    TokenOps.findLastNonTrivialTokenOpt(tokens).map(apply)
+    findLastNonTrivialTokenOpt(tokens).map(apply)
   def getLastNonTrivialOpt(tokens: Tokens, tree: Tree): Option[FormatToken] =
     getLastNonTrivialOpt(tokens).map(getOnOrAfterOwned(_, tree))
   def getLastNonTrivialOpt(tree: Tree): Option[FormatToken] =
@@ -319,11 +321,11 @@ object FormatTokens {
     def process(right: Token): Unit = {
       val rmeta = FormatToken.TokenMeta(owner(right), right.syntax)
       if (left eq null) {
-        fmtWasOff = TokenOps.isFormatOff(right)
+        fmtWasOff = isFormatOff(right)
       } else {
         val between = arr.slice(wsIdx, tokIdx)
-        val fmtIsOff = fmtWasOff || TokenOps.isFormatOff(right)
-        fmtWasOff = if (fmtWasOff) !TokenOps.isFormatOn(right) else fmtIsOff
+        val fmtIsOff = fmtWasOff || isFormatOff(right)
+        fmtWasOff = if (fmtWasOff) !isFormatOn(right) else fmtIsOff
         val meta = FormatToken.Meta(between, ftIdx, fmtIsOff, lmeta, rmeta)
         result += FormatToken(left, right, meta)
         ftIdx += 1
@@ -348,6 +350,6 @@ object FormatTokens {
   }
 
   @inline
-  def thash(token: Token): TokenOps.TokenHash = TokenOps.hash(token)
+  def thash(token: Token): TokenHash = hash(token)
 
 }