Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

FormatOps: swtich to the shorthand T for Token #2999

Merged
merged 1 commit into from
Dec 26, 2021
Merged

FormatOps: swtich to the shorthand T for Token #2999

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
113 changes: 56 additions & 57 deletions scalafmt-core/shared/src/main/scala/org/scalafmt/internal/FormatOps.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,7 +37,6 @@ import scala.meta.{
Type,
TypeCase
}
import scala.meta.tokens.Token
import scala.meta.tokens.{Token => T}

/** Helper functions for generating splits/policies for a given tree.
Expand Down Expand Up @@ -94,8 +93,8 @@ class FormatOps(
private[internal] val statementStarts =
getStatementStarts(topSourceTree, tokens.after(_).left, soft)
// Maps token to number of non-whitespace bytes before the token's position.
private final val nonWhitespaceOffset: Map[Token, Int] = {
val resultB = Map.newBuilder[Token, Int]
private final val nonWhitespaceOffset: Map[T, Int] = {
val resultB = Map.newBuilder[T, Int]
var curr = 0
usedTokens.foreach { t =>
resultB += (t -> curr)
Expand All @@ -107,7 +106,7 @@ class FormatOps(
val (forceConfigStyle, emptyQueueSpots) = getForceConfigStyle

@inline
def owners(token: Token): Tree = ownersMap(hash(token))
def owners(token: T): Tree = ownersMap(hash(token))
/*
* The tokens on the left hand side of Pkg
*
Expand Down Expand Up @@ -154,7 +153,7 @@ class FormatOps(
}

@inline
final def findFirst(start: FormatToken, end: Token)(
final def findFirst(start: FormatToken, end: T)(
f: FormatToken => Boolean
): Option[FormatToken] = {
findFirst(start, end.end)(f)
Expand All @@ -173,15 +172,15 @@ class FormatOps(
}
}

def findFirstOnRight[A](start: FormatToken, end: Token)(implicit
classifier: Classifier[Token, A]
): Option[Token] =
def findFirstOnRight[A](start: FormatToken, end: T)(implicit
classifier: Classifier[T, A]
): Option[T] =
findFirst(start, end.start)(x => classifier(x.right)).map(_.right)

final def rhsOptimalToken(
start: FormatToken,
end: Int = Int.MaxValue
)(implicit style: ScalafmtConfig): Token =
)(implicit style: ScalafmtConfig): T =
findTokenWith(start, next) { start =>
start.right match {
case t if t.end >= end => Some(start.left)
Expand All @@ -205,7 +204,7 @@ class FormatOps(
@tailrec
final def endOfSingleLineBlock(
start: FormatToken
)(implicit style: ScalafmtConfig): Token = {
)(implicit style: ScalafmtConfig): T = {
lazy val isInfix = isInfixRhs(start)
val endFound = start.right match {
case _: T.Comma | _: T.LeftParen | _: T.Semicolon | _: T.RightArrow |
Expand Down Expand Up @@ -257,25 +256,25 @@ class FormatOps(
final def startsStatement(tok: FormatToken): Option[Tree] =
startsStatement(tok.right)
@inline
final def startsStatement(token: Token): Option[Tree] =
final def startsStatement(token: T): Option[Tree] =
statementStarts.get(hash(token))
val StartsStatementRight = new ExtractFromMeta[Tree](startsStatement)

def parensTuple(token: Token): TokenRanges =
def parensTuple(token: T): TokenRanges =
matchingOpt(token).fold(TokenRanges.empty) { other =>
TokenRanges(TokenRange(token, other))
}

def getExcludeIf(
end: Token,
cond: Token => Boolean = _.is[T.RightBrace]
end: T,
cond: T => Boolean = _.is[T.RightBrace]
): TokenRanges =
if (cond(end)) // allow newlines in final {} block
parensTuple(end)
else TokenRanges.empty

def insideBlock[A](start: FormatToken, end: Token)(implicit
classifier: Classifier[Token, A]
def insideBlock[A](start: FormatToken, end: T)(implicit
classifier: Classifier[T, A]
): TokenRanges =
insideBlock(start, end, x => classifier(x.left))

Expand Down Expand Up @@ -320,7 +319,7 @@ class FormatOps(
TokenRanges(result.result())
}

def defnSiteLastToken(close: FormatToken, tree: Tree): Token = {
def defnSiteLastToken(close: FormatToken, tree: Tree): T = {
tree match {
// TODO(olafur) scala.meta should make this easier.
case procedure: Defn.Def if procedure.decltpe.exists(_.tokens.isEmpty) =>
Expand All @@ -341,7 +340,7 @@ class FormatOps(
}.getOrElse(getLastToken(tree))

@inline
def splitOneArgOneLine(close: Token, owner: Tree)(implicit
def splitOneArgOneLine(close: T, owner: Tree)(implicit
fileLine: FileLine,
style: ScalafmtConfig
): Policy = {
Expand Down Expand Up @@ -387,20 +386,20 @@ class FormatOps(
}
}

private def getOneArgPerLineSplitsAfterComma(r: Token, s: Seq[Split]) =
private def getOneArgPerLineSplitsAfterComma(r: T, s: Seq[Split]) =
if (r.is[T.LeftBrace]) SplitTag.OneArgPerLine.activateOnly(s)
else Decision.onlyNewlineSplits(s)

def UnindentAtExclude(
exclude: Set[Token],
exclude: Set[T],
indent: Length
): Policy.Pf = {
case Decision(t, s) if exclude.contains(t.left) =>
val close = matching(t.left)
s.map(_.withIndent(indent, close, ExpiresOn.After))
}

def penalizeNewlineByNesting(from: Token, to: Token)(implicit
def penalizeNewlineByNesting(from: T, to: T)(implicit
fileLine: FileLine
): Policy = {
Policy.before(to) {
Expand All @@ -423,15 +422,15 @@ class FormatOps(
def templateCurlyFt(template: Template): Option[FormatToken] =
getStartOfTemplateBody(template).map(tokenBefore)

def templateCurly(template: Template): Option[Token] =
def templateCurly(template: Template): Option[T] =
templateCurlyFt(template).map(_.left)

def templateCurlyOrLastNonTrivial(template: Template): Token =
def templateCurlyOrLastNonTrivial(template: Template): T =
templateCurly(template).getOrElse(getLastNonTrivialToken(template))

def templateDerivesOrCurlyOrLastNonTrivial(
template: Template
)(implicit ft: FormatToken): Token =
)(implicit ft: FormatToken): T =
findTemplateGroupOnRight(_.getExpireToken())(template)
.getOrElse(templateCurlyOrLastNonTrivial(template))

Expand Down Expand Up @@ -481,10 +480,10 @@ class FormatOps(
}
}

def getOptimalTokenFor(token: Token): Token =
def getOptimalTokenFor(token: T): T =
getOptimalTokenFor(tokens(token))

def getOptimalTokenFor(ft: FormatToken): Token =
def getOptimalTokenFor(ft: FormatToken): T =
if (isAttachedSingleLineComment(ft)) ft.right else ft.left

def insideInfixSplit(
Expand Down Expand Up @@ -527,7 +526,7 @@ class FormatOps(
new InfixSplits(app, ft, fullInfix, leftInfix)
}

private def switch(splits: Seq[Split], triggers: Token*): Seq[Split] =
private def switch(splits: Seq[Split], triggers: T*): Seq[Split] =
splits.map { x =>
triggers.foldLeft(x) { case (y, trigger) => y.switch(trigger, false) }
}
Expand Down Expand Up @@ -615,7 +614,7 @@ class FormatOps(
}

val (nlIndent, nlPolicy) = {
def policy(triggers: Token*)(implicit fileLine: FileLine) =
def policy(triggers: T*)(implicit fileLine: FileLine) =
if (triggers.isEmpty) Policy.NoPolicy
else
Policy.on(fullExpire) {
Expand Down Expand Up @@ -785,19 +784,19 @@ class FormatOps(

}

def getSingleLineInfixPolicy(end: Token) =
def getSingleLineInfixPolicy(end: T) =
Policy.on(end) {
case Decision(t: FormatToken, s) if isInfixOp(t.meta.leftOwner) =>
SplitTag.InfixChainNoNL.activateOnly(s)
}

def getMidInfixToken(app: InfixApp): Token = {
def getMidInfixToken(app: InfixApp): T = {
val opToken = app.op.tokens.head
val opFollowsComment = tokens(opToken, -1).left.is[T.Comment]
if (opFollowsComment) getLastNonTrivialToken(app.lhs) else opToken
}

private def getLastEnclosedToken(tree: Tree): Token = {
private def getLastEnclosedToken(tree: Tree): T = {
val tokens = tree.tokens
val slice = if (isEnclosedInMatching(tree)) tokens.dropRight(1) else tokens
findLastNonTrivialToken(slice)
Expand Down Expand Up @@ -873,17 +872,17 @@ class FormatOps(
case _ => false
}

def functionExpire(function: Term.FunctionTerm): (Token, ExpiresOn) = {
def dropWS(rtoks: Seq[Token]): Seq[Token] =
def functionExpire(function: Term.FunctionTerm): (T, ExpiresOn) = {
def dropWS(rtoks: Seq[T]): Seq[T] =
rtoks.dropWhile(_.is[Whitespace])
def orElse(rtoks: Seq[Token]) = {
def orElse(rtoks: Seq[T]) = {
val last = rtoks.head
if (last.is[T.RightParen] && matchingOpt(last).contains(rtoks.last))
rtoks.tail.find(!_.is[Whitespace]).get -> ExpiresOn.After
else
last -> ExpiresOn.After
}
def dropComment(rtoks: Seq[Token]) =
def dropComment(rtoks: Seq[T]) =
if (rtoks.head.is[T.Comment]) dropWS(rtoks.tail) else rtoks

def getRToks = dropWS(function.tokens.reverse)
Expand All @@ -897,9 +896,9 @@ class FormatOps(
}
}

def noOptimizationZones(): Set[Token] = {
val result = Set.newBuilder[Token]
var expire: Token = null
def noOptimizationZones(): Set[T] = {
val result = Set.newBuilder[T]
var expire: T = null
tokens.foreach {
case FormatToken(x, _, _) if expire ne null =>
if (x eq expire) expire = null else result += x
Expand Down Expand Up @@ -972,7 +971,7 @@ class FormatOps(
}
}

def distance(left: Token, right: Token): Int = {
def distance(left: T, right: T): Int = {
nonWhitespaceOffset(right) - nonWhitespaceOffset(left)
}

Expand Down Expand Up @@ -1025,7 +1024,7 @@ class FormatOps(

def ctorWithChain(
ownerSet: Set[Tree],
lastToken: Token
lastToken: T
)(implicit style: ScalafmtConfig): Policy =
if (style.binPack.parentConstructors eq BinPack.ParentCtors.Always) NoPolicy
else if (ownerSet.isEmpty) NoPolicy
Expand All @@ -1043,7 +1042,7 @@ class FormatOps(
isFirstCtor: Boolean,
owners: => Set[Tree],
rhs: => Option[Tree],
lastToken: Token,
lastToken: T,
indentLen: Int,
extendsThenWith: => Boolean = false
)(implicit
Expand Down Expand Up @@ -1131,7 +1130,7 @@ class FormatOps(
val isBracket = open.is[T.LeftBracket]

@tailrec
def loop(token: Token): FormatToken = {
def loop(token: T): FormatToken = {
val f = tokens.after(token)
f.right match {
case x: T.LeftParen => loop(matching(x))
Expand Down Expand Up @@ -1350,7 +1349,7 @@ class FormatOps(
new ExtractFromMeta(getLambdaAtSingleArgCallSite)

def findArgsFor[A <: Tree](
token: Token,
token: T,
argss: Seq[Seq[A]]
): Option[Seq[A]] =
TokenOps.findArgsFor(token, argss, matchingOpt)
Expand Down Expand Up @@ -1537,13 +1536,13 @@ class FormatOps(
@tailrec
final def findXmlLastLineIndent(ft: FormatToken): Int =
ft.left match {
case _: Token.Xml.Start => 0
case t: Token.Xml.Part =>
case _: T.Xml.Start => 0
case t: T.Xml.Part =>
TokenOps.getXmlLastLineIndent(t) match {
case Some(x) => x
case None => findXmlLastLineIndent(prev(ft))
}
case t: Token.Xml.SpliceEnd =>
case t: T.Xml.SpliceEnd =>
findXmlLastLineIndent(tokens(matching(t), -1))
case _ =>
findXmlLastLineIndent(prev(ft))
Expand Down Expand Up @@ -1661,10 +1660,10 @@ class FormatOps(
spaceSplit.withIndents(spaceIndents),
getNlSplit(1)(spaceSplit.fileLine)
)
def getSlb(end: Token, excl: TokenRanges)(implicit fileLine: FileLine) =
def getSlb(end: T, excl: TokenRanges)(implicit fileLine: FileLine) =
SingleLineBlock(end, exclude = excl, noSyntaxNL = true)
def getSlbSplit(
end: Token,
end: T,
exclude: TokenRanges = TokenRanges.empty,
policy: Policy = Policy.NoPolicy
)(implicit fileLine: FileLine) =
Expand Down Expand Up @@ -1745,14 +1744,14 @@ class FormatOps(
slbOnly: Boolean
): Split = {
val expire = nextNonCommentSameLine(tokens.getLastNonTrivial(body)).left
def slbSplit(end: Token)(implicit fileLine: FileLine) =
def slbSplit(end: T)(implicit fileLine: FileLine) =
Split(Space, 0).withSingleLine(end, noSyntaxNL = true)
body match {
case _: Term.ForYield =>
// unfold policy on yield forces a break
// revert it if we are attempting a single line
val noBreakOnYield = Policy.before(expire) {
case Decision(ft, s) if s.isEmpty && ft.right.is[Token.KwYield] =>
case Decision(ft, s) if s.isEmpty && ft.right.is[T.KwYield] =>
Seq(Split(Space, 0))
}
slbSplit(expire).andPolicy(noBreakOnYield)
Expand Down Expand Up @@ -1874,7 +1873,7 @@ class FormatOps(
}) && {
val btoks = body.tokens
btoks.headOption.exists { head =>
head.is[Token.LeftParen] && tokens.areMatching(head)(btoks.last)
head.is[T.LeftParen] && tokens.areMatching(head)(btoks.last)
}
}
}
Expand Down Expand Up @@ -2479,7 +2478,7 @@ class FormatOps(

def indentAndBreakBeforeCtrl[A](tree: Tree, split: Split)(implicit
style: ScalafmtConfig,
classifier: Classifier[Token, A]
classifier: Classifier[T, A]
): Split =
if (!style.dialect.allowSignificantIndentation) split
else {
Expand Down Expand Up @@ -2720,8 +2719,8 @@ class FormatOps(
})
}

def rightIsCloseDelimToAddTrailingComma(left: Token, ft: => FormatToken)(
implicit style: ScalafmtConfig
def rightIsCloseDelimToAddTrailingComma(left: T, ft: => FormatToken)(implicit
style: ScalafmtConfig
): Boolean =
style.getTrailingCommas match {
case TrailingCommas.keep =>
Expand Down Expand Up @@ -2760,12 +2759,12 @@ class FormatOps(
object FormatOps {
case class TreeArgs(tree: Tree, args: Seq[Tree])

class SelectLike(val tree: Term, val qual: Term, val nameToken: Token)
class SelectLike(val tree: Term, val qual: Term, val nameToken: T)

object SelectLike {
def apply(tree: Term.Select): SelectLike =
new SelectLike(tree, tree.qual, tree.name.tokens.head)
def apply(tree: Term.Match, kw: Token.KwMatch): SelectLike =
def apply(tree: Term.Match, kw: T.KwMatch): SelectLike =
new SelectLike(tree, tree.expr, kw)
}

Expand All @@ -2790,7 +2789,7 @@ object FormatOps {
}

def getOpenParenAlignIndents(
end: Token
end: T
)(implicit style: ScalafmtConfig): Seq[Indent] =
if (style.align.closeParenSite)
Seq(
Expand Down
Loading